From 26a029d407be480d791972afb5975cf62c9360a6 Mon Sep 17 00:00:00 2001
From: Daniel Baumann <daniel.baumann@progress-linux.org>
Date: Fri, 19 Apr 2024 02:47:55 +0200
Subject: Adding upstream version 124.0.1.

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
---
 .../css/view-timeline-inset-animation.html         | 743 +++++++++++++++++++++
 1 file changed, 743 insertions(+)
 create mode 100644 testing/web-platform/tests/scroll-animations/css/view-timeline-inset-animation.html

(limited to 'testing/web-platform/tests/scroll-animations/css/view-timeline-inset-animation.html')
diff --git a/testing/web-platform/tests/scroll-animations/css/view-timeline-inset-animation.html b/testing/web-platform/tests/scroll-animations/css/view-timeline-inset-animation.html
new file mode 100644
index 0000000000..f9aa0f2918
--- /dev/null
+++ b/testing/web-platform/tests/scroll-animations/css/view-timeline-inset-animation.html
@@ -0,0 +1,743 @@
+<!DOCTYPE html>
+<title>Animations using view-timeline-inset</title>
+<meta name="viewport" content="width=device-width,initial-scale=1,minimum-scale=1">
+<link rel="help" src="https://drafts.csswg.org/scroll-animations-1/#propdef-view-timeline-inset">
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script src="/web-animations/testcommon.js"></script>
+<script src="support/testcommon.js"></script>
+<style>
+  @keyframes anim {
+    from { z-index: 0; }
+    to { z-index: 100; }
+  }
+  #scroller {
+    overflow: hidden;
+    width: 80px;
+    height: 100px;
+  }
+  #target {
+    margin: 150px;
+    width: 50px;
+    height: 50px;
+    z-index: -1;
+  }
+</style>
+<main id=main></main>
+<script>
+  setup(assert_implements_animation_timeline);
+
+  function inflate(t, template) {
+    t.add_cleanup(() => main.replaceChildren());
+    main.append(template.content.cloneNode(true));
+  }
+  async function scrollTop(e, value) {
+    e.scrollTop = value;
+    await waitForNextFrame();
+  }
+  async function scrollLeft(e, value) {
+    e.scrollLeft = value;
+    await waitForNextFrame();
+  }
+  async function assertValueAt(scroller, target, args) {
+    if (args.scrollTop !== undefined)
+      await scrollTop(scroller, args.scrollTop);
+    if (args.scrollLeft !== undefined)
+      await scrollLeft(scroller, args.scrollLeft);
+    assert_equals(getComputedStyle(target).zIndex, args.expected.toString());
+  }
+</script>
+
+<!--
+  Explanation of scroll positions
+  ===============================
+
+  Please note the following:
+
+   - The scroller has a width x height of 80x100px.
+   - The content is 50x50px with a 150px margin on all sides.
+     In other words, the size of the scroller content is 200x200px.
+
+  This means that, for vertical direction scrolling, assuming no insets:
+
+   - The start offset is 50px (scroller height + 50px is 150px, which consumes
+     exactly the margin of the content).
+   - The end offset is 200px (this is where the bottom edge of the scroller has
+     just cleared the content).
+   - The halfway point is (50px + 200px) / 2 = 125px.
+
+  For horizontal direction scrolling, assuming no insets:
+
+   - The start offset is 70px (scroller width + 70px is 150px, which consumes
+     exactly the margin of the content).
+   - The end offset is 200px (this is where the left edge of the scroller has
+     just cleared the content).
+   - The halfway point is (70px + 200px) / 2 = 135px.
+
+  The start and end insets will adjust the start and end offsets accordingly,
+  and the expectations in this file explicitly write out those adjustments.
+  For example, if the start offset is normally 50px, but there's an inset of
+  10px, we'll expect 50px + 10px rather than 60px.
+
+  Halfway-point expectations write out the adjustment from the "normal"
+  halfway-point, e.g. for start-inset:10px and end-inset:20px, we expect
+  "125px + 5px" since (20-10)/2 == 5.
+
+  Finally, note that for right-to-left and bottom-to-top scrolling directions
+  scroll offsets go the in the negative direction. This is why some expectations
+  negate all the offsets.
+-->
+
+<template id=test_one_value>
+  <style>
+    #target {
+      view-timeline: --t1;
+      view-timeline-inset: 10px;
+      animation: anim 1s linear forwards;
+      animation-timeline: --t1;
+    }
+  </style>
+  <div id=scroller class=vertical>
+    <div id=target></div>
+  </div>
+</template>
+<script>
+  promise_test(async (t) => {
+    inflate(t, test_one_value);
+    await assertValueAt(scroller, target, { scrollTop:50, expected:-1 });
+    await assertValueAt(scroller, target, { scrollTop:50 + 10, expected:0 }); // 0%
+    await assertValueAt(scroller, target, { scrollTop:125 + 0, expected:50 }); // 50%
+    await assertValueAt(scroller, target, { scrollTop:200 - 10, expected:100 }); // 100%
+  }, 'view-timeline-inset with one value');
+</script>
+<template id=test_two_values>
+  <style>
+    #target {
+      view-timeline: --t1;
+      view-timeline-inset: 10px 20px;
+      animation: anim 1s linear forwards;
+      animation-timeline: --t1;
+    }
+  </style>
+  <div id=scroller class=vertical>
+    <div id=target></div>
+  </div>
+</template>
+<script>
+  promise_test(async (t) => {
+    inflate(t, test_two_values);
+    await assertValueAt(scroller, target, { scrollTop:50, expected:-1 });
+    await assertValueAt(scroller, target, { scrollTop:50 + 20, expected:0 }); // 0%
+    await assertValueAt(scroller, target, { scrollTop:125 + 5, expected:50 }); // 50%
+    await assertValueAt(scroller, target, { scrollTop:200 - 10, expected:100 }); // 100%
+  }, 'view-timeline-inset with two values');
+</script>
+
+<template id=test_em_values>
+  <style>
+    #target {
+      font-size: 10px;
+      view-timeline: --t1;
+      view-timeline-inset: 10px 2em;
+      animation: anim 1s linear forwards;
+      animation-timeline: --t1;
+    }
+  </style>
+  <div id=scroller class=vertical>
+    <div id=target></div>
+  </div>
+</template>
+<script>
+  promise_test(async (t) => {
+    inflate(t, test_em_values);
+    await assertValueAt(scroller, target, { scrollTop:50, expected:-1 });
+    await assertValueAt(scroller, target, { scrollTop:50 + 20, expected:0 }); // 0%
+    await assertValueAt(scroller, target, { scrollTop:125 + 5, expected:50 }); // 50%
+    await assertValueAt(scroller, target, { scrollTop:200 - 10, expected:100 }); // 100%
+  }, 'view-timeline-inset with em values');
+</script>
+
+<template id=test_percentage_values>
+  <style>
+    #target {
+      font-size: 10px;
+      view-timeline: --t1;
+      view-timeline-inset: calc(5px + max(1%, 5%)) 20%;
+      animation: anim 1s linear forwards;
+      animation-timeline: --t1;
+    }
+  </style>
+  <div id=scroller class=vertical>
+    <div id=target></div>
+  </div>
+</template>
+<script>
+  promise_test(async (t) => {
+    inflate(t, test_percentage_values);
+    await assertValueAt(scroller, target, { scrollTop:50, expected:-1 });
+    await assertValueAt(scroller, target, { scrollTop:50 + 20, expected:0 }); // 0%
+    await assertValueAt(scroller, target, { scrollTop:125 + 5, expected:50 }); // 50%
+    await assertValueAt(scroller, target, { scrollTop:200 - 10, expected:100 }); // 100%
+  }, 'view-timeline-inset with percentage values');
+</script>
+
+<template id=test_outset>
+  <style>
+    #target {
+      view-timeline: --t1;
+      view-timeline-inset: -10px -20px;
+      animation: anim 1s linear forwards;
+      animation-timeline: --t1;
+    }
+  </style>
+  <div id=scroller class=vertical>
+    <div id=target></div>
+  </div>
+</template>
+<script>
+  promise_test(async (t) => {
+    inflate(t, test_outset);
+    await assertValueAt(scroller, target, { scrollTop:20, expected:-1 });
+    await assertValueAt(scroller, target, { scrollTop:50 - 20, expected:0 }); // 0%
+    await assertValueAt(scroller, target, { scrollTop:125 - 5, expected:50 }); // 50%
+    await assertValueAt(scroller, target, { scrollTop:200 + 10, expected:100 }); // 100%
+  }, 'view-timeline-inset with negative values');
+</script>
+
+<template id=test_horizontal>
+  <style>
+    #target {
+      view-timeline: --t1 x;
+      view-timeline-inset: 10px 20px;
+      animation: anim 1s linear forwards;
+      animation-timeline: --t1;
+    }
+  </style>
+  <div id=scroller>
+    <div id=target></div>
+  </div>
+</template>
+<script>
+  promise_test(async (t) => {
+    inflate(t, test_horizontal);
+    await assertValueAt(scroller, target, { scrollLeft:20, expected:-1 });
+    await assertValueAt(scroller, target, { scrollLeft:70 + 20, expected:0 }); // 0%
+    await assertValueAt(scroller, target, { scrollLeft:135 + 5, expected:50 }); // 50%
+    await assertValueAt(scroller, target, { scrollLeft:200 - 10, expected:100 }); // 100%
+  }, 'view-timeline-inset with horizontal scroller');
+</script>
+
+<template id=test_block>
+  <style>
+    #target {
+      view-timeline: --t1 block;
+      view-timeline-inset: 10px 20px;
+      animation: anim 1s linear forwards;
+      animation-timeline: --t1;
+    }
+  </style>
+  <div id=scroller>
+    <div id=target></div>
+  </div>
+</template>
+<script>
+  promise_test(async (t) => {
+    inflate(t, test_block);
+    await assertValueAt(scroller, target, { scrollTop:50, expected:-1 });
+    await assertValueAt(scroller, target, { scrollTop:50 + 20, expected:0 }); // 0%
+    await assertValueAt(scroller, target, { scrollTop:125 + 5, expected:50 }); // 50%
+    await assertValueAt(scroller, target, { scrollTop:200 - 10, expected:100 }); // 100%
+  }, 'view-timeline-inset with block scroller');
+</script>
+
+<template id=test_inline>
+  <style>
+    #target {
+      view-timeline: --t1 inline;
+      view-timeline-inset: 10px 20px;
+      animation: anim 1s linear forwards;
+      animation-timeline: --t1;
+    }
+  </style>
+  <div id=scroller>
+    <div id=target></div>
+  </div>
+</template>
+<script>
+  promise_test(async (t) => {
+    inflate(t, test_inline);
+    await assertValueAt(scroller, target, { scrollLeft:20, expected:-1 });
+    await assertValueAt(scroller, target, { scrollLeft:70 + 20, expected:0 }); // 0%
+    await assertValueAt(scroller, target, { scrollLeft:135 + 5, expected:50 }); // 50%
+    await assertValueAt(scroller, target, { scrollLeft:200 - 10, expected:100 }); // 100%
+  }, 'view-timeline-inset with inline scroller');
+</script>
+
+<template id=test_auto_block>
+  <style>
+    #scroller {
+      scroll-padding-block: 10px 20px;
+    }
+    #target {
+      view-timeline: --t1 block;
+      view-timeline-inset: auto auto;
+      animation: anim 1s linear forwards;
+      animation-timeline: --t1;
+    }
+  </style>
+  <div id=scroller>
+    <div id=target></div>
+  </div>
+</template>
+<script>
+  promise_test(async (t) => {
+    inflate(t, test_auto_block);
+    await assertValueAt(scroller, target, { scrollTop:50, expected:-1 });
+    await assertValueAt(scroller, target, { scrollTop:50 + 20, expected:0 }); // 0%
+    await assertValueAt(scroller, target, { scrollTop:125 + 5, expected:50 }); // 50%
+    await assertValueAt(scroller, target, { scrollTop:200 - 10, expected:100 }); // 100%
+  }, 'view-timeline-inset:auto, block');
+</script>
+
+<template id=test_auto_block_vertical_lr>
+  <style>
+    #scroller {
+      scroll-padding-block: 10px 20px;
+      writing-mode: vertical-lr;
+    }
+    #target {
+      view-timeline: --t1 block;
+      view-timeline-inset: auto auto;
+      animation: anim 1s linear forwards;
+      animation-timeline: --t1;
+    }
+  </style>
+  <div id=scroller>
+    <div id=target></div>
+  </div>
+</template>
+<script>
+  promise_test(async (t) => {
+    inflate(t, test_auto_block_vertical_lr);
+    await assertValueAt(scroller, target, { scrollLeft:20, expected:-1 });
+    await assertValueAt(scroller, target, { scrollLeft:70 + 20, expected:0 }); // 0%
+    await assertValueAt(scroller, target, { scrollLeft:135 + 5, expected:50 }); // 50%
+    await assertValueAt(scroller, target, { scrollLeft:200 - 10, expected:100 }); // 100%
+  }, 'view-timeline-inset:auto, block, vertical-lr');
+</script>
+
+<template id=test_auto_block_vertical_rl>
+  <style>
+    #scroller {
+      scroll-padding-block: 10px 20px;
+      writing-mode: vertical-rl;
+    }
+    #target {
+      view-timeline: --t1 block;
+      view-timeline-inset: auto auto;
+      animation: anim 1s linear forwards;
+      animation-timeline: --t1;
+    }
+  </style>
+  <div id=scroller>
+    <div id=target></div>
+  </div>
+</template>
+<script>
+  promise_test(async (t) => {
+    inflate(t, test_auto_block_vertical_rl);
+    // Note: this represents horizontal scrolling from right to left.
+    await assertValueAt(scroller, target, { scrollLeft:-20, expected:-1 });
+    await assertValueAt(scroller, target, { scrollLeft:-(70 + 20), expected:0 }); // 0%
+    await assertValueAt(scroller, target, { scrollLeft:-(135 + 5), expected:50 }); // 50%
+    await assertValueAt(scroller, target, { scrollLeft:-(200 - 10), expected:100 }); // 100%
+  }, 'view-timeline-inset:auto, block, vertical-rl');
+</script>
+
+<template id=test_auto_inline>
+  <style>
+    #scroller {
+      scroll-padding-inline: 10px 20px;
+    }
+    #target {
+      view-timeline: --t1 inline;
+      view-timeline-inset: auto auto;
+      animation: anim 1s linear forwards;
+      animation-timeline: --t1;
+    }
+  </style>
+  <div id=scroller>
+    <div id=target></div>
+  </div>
+</template>
+<script>
+  promise_test(async (t) => {
+    inflate(t, test_auto_inline);
+    await assertValueAt(scroller, target, { scrollLeft:20, expected:-1 });
+    await assertValueAt(scroller, target, { scrollLeft:70 + 20, expected:0 }); // 0%
+    await assertValueAt(scroller, target, { scrollLeft:135 + 5, expected:50 }); // 50%
+    await assertValueAt(scroller, target, { scrollLeft:200 - 10, expected:100 }); // 100%
+  }, 'view-timeline-inset:auto, inline');
+</script>
+
+<template id=test_auto_inline_vertical_rl>
+  <style>
+    #scroller {
+      scroll-padding-inline: 10px 20px;
+      writing-mode: vertical-rl;
+    }
+    #target {
+      view-timeline: --t1 inline;
+      view-timeline-inset: auto auto;
+      animation: anim 1s linear forwards;
+      animation-timeline: --t1;
+    }
+  </style>
+  <div id=scroller>
+    <div id=target></div>
+  </div>
+</template>
+<script>
+  promise_test(async (t) => {
+    inflate(t, test_auto_inline_vertical_rl);
+    await assertValueAt(scroller, target, { scrollTop:50, expected:-1 });
+    await assertValueAt(scroller, target, { scrollTop:50 + 20, expected:0 }); // 0%
+    await assertValueAt(scroller, target, { scrollTop:125 + 5, expected:50 }); // 50%
+    await assertValueAt(scroller, target, { scrollTop:200 - 10, expected:100 }); // 100%
+  }, 'view-timeline-inset:auto, inline, vertical-rl');
+</script>
+
+<template id=test_auto_inline_vertical_lr>
+  <style>
+    #scroller {
+      scroll-padding-inline: 10px 20px;
+      writing-mode: vertical-lr;
+    }
+    #target {
+      view-timeline: --t1 inline;
+      view-timeline-inset: auto auto;
+      animation: anim 1s linear forwards;
+      animation-timeline: --t1;
+    }
+  </style>
+  <div id=scroller>
+    <div id=target></div>
+  </div>
+</template>
+<script>
+  promise_test(async (t) => {
+    inflate(t, test_auto_inline_vertical_lr);
+    await assertValueAt(scroller, target, { scrollTop:50, expected:-1 });
+    await assertValueAt(scroller, target, { scrollTop:50 + 20, expected:0 }); // 0%
+    await assertValueAt(scroller, target, { scrollTop:125 + 5, expected:50 }); // 50%
+    await assertValueAt(scroller, target, { scrollTop:200 - 10, expected:100 }); // 100%
+  }, 'view-timeline-inset:auto, inline, vertical-lr');
+</script>
+
+<template id=test_auto_inline_rtl>
+  <style>
+    #scroller {
+      scroll-padding-inline: 10px 20px;
+      direction: rtl;
+    }
+    #target {
+      view-timeline: --t1 inline;
+      view-timeline-inset: auto auto;
+      animation: anim 1s linear forwards;
+      animation-timeline: --t1;
+    }
+  </style>
+  <div id=scroller>
+    <div id=target></div>
+  </div>
+</template>
+<script>
+  promise_test(async (t) => {
+    inflate(t, test_auto_inline_rtl);
+    await assertValueAt(scroller, target, { scrollLeft:-20, expected:-1 });
+    await assertValueAt(scroller, target, { scrollLeft:-(70 + 20), expected:0 }); // 0%
+    await assertValueAt(scroller, target, { scrollLeft:-(135 + 5), expected:50 }); // 50%
+    await assertValueAt(scroller, target, { scrollLeft:-(200 - 10), expected:100 }); // 100%
+  }, 'view-timeline-inset:auto, inline, rtl');
+</script>
+
+<template id=test_auto_inline_vertical_rl_rtl>
+  <style>
+    #scroller {
+      scroll-padding-inline: 10px 20px;
+      writing-mode: vertical-rl;
+      direction: rtl;
+    }
+    #target {
+      view-timeline: --t1 inline;
+      view-timeline-inset: auto auto;
+      animation: anim 1s linear forwards;
+      animation-timeline: --t1;
+    }
+  </style>
+  <div id=scroller>
+    <div id=target></div>
+  </div>
+</template>
+<script>
+  promise_test(async (t) => {
+    inflate(t, test_auto_inline_vertical_rl_rtl);
+    await assertValueAt(scroller, target, { scrollTop:-50, expected:-1 });
+    await assertValueAt(scroller, target, { scrollTop:-(50 + 20), expected:0 }); // 0%
+    await assertValueAt(scroller, target, { scrollTop:-(125 + 5), expected:50 }); // 50%
+    await assertValueAt(scroller, target, { scrollTop:-(200 - 10), expected:100 }); // 100%
+  }, 'view-timeline-inset:auto, inline, vertical-rl, rtl');
+</script>
+
+<template id=test_auto_inline_vertical_lr_rtl>
+  <style>
+    #scroller {
+      scroll-padding-inline: 10px 20px;
+      writing-mode: vertical-lr;
+      direction: rtl;
+    }
+    #target {
+      view-timeline: --t1 inline;
+      view-timeline-inset: auto auto;
+      animation: anim 1s linear forwards;
+      animation-timeline: --t1;
+    }
+  </style>
+  <div id=scroller>
+    <div id=target></div>
+  </div>
+</template>
+<script>
+  promise_test(async (t) => {
+    inflate(t, test_auto_inline_vertical_lr_rtl);
+    await assertValueAt(scroller, target, { scrollTop:-50, expected:-1 });
+    await assertValueAt(scroller, target, { scrollTop:-(50 + 20), expected:0 }); // 0%
+    await assertValueAt(scroller, target, { scrollTop:-(125 + 5), expected:50 }); // 50%
+    await assertValueAt(scroller, target, { scrollTop:-(200 - 10), expected:100 }); // 100%
+  }, 'view-timeline-inset:auto, inline, vertical-lr, rtl');
+</script>
+
+<template id=test_auto_vertical>
+  <style>
+    #scroller {
+      scroll-padding-block: 10px 20px;
+    }
+    #target {
+      view-timeline: --t1 y;
+      view-timeline-inset: auto auto;
+      animation: anim 1s linear forwards;
+      animation-timeline: --t1;
+    }
+  </style>
+  <div id=scroller>
+    <div id=target></div>
+  </div>
+</template>
+<script>
+  promise_test(async (t) => {
+    inflate(t, test_auto_vertical);
+    await assertValueAt(scroller, target, { scrollTop:50, expected:-1 });
+    await assertValueAt(scroller, target, { scrollTop:50 + 20, expected:0 }); // 0%
+    await assertValueAt(scroller, target, { scrollTop:125 + 5, expected:50 }); // 50%
+    await assertValueAt(scroller, target, { scrollTop:200 - 10, expected:100 }); // 100%
+  }, 'view-timeline-inset:auto, y');
+</script>
+
+<template id=test_auto_vertical_vertical_rl>
+  <style>
+    #scroller {
+      scroll-padding-inline: 10px 20px;
+      writing-mode: vertical-rl;
+    }
+    #target {
+      view-timeline: --t1 y;
+      view-timeline-inset: auto auto;
+      animation: anim 1s linear forwards;
+      animation-timeline: --t1;
+    }
+  </style>
+  <div id=scroller>
+    <div id=target></div>
+  </div>
+</template>
+<script>
+  promise_test(async (t) => {
+    inflate(t, test_auto_vertical_vertical_rl);
+    await assertValueAt(scroller, target, { scrollTop:50, expected:-1 });
+    await assertValueAt(scroller, target, { scrollTop:50 + 20, expected:0 }); // 0%
+    await assertValueAt(scroller, target, { scrollTop:125 + 5, expected:50 }); // 50%
+    await assertValueAt(scroller, target, { scrollTop:200 - 10, expected:100 }); // 100%
+  }, 'view-timeline-inset:auto, y, vertical-rl');
+</script>
+
+<template id=test_auto_vertical_vertical_rl_rtl>
+  <style>
+    #scroller {
+      scroll-padding-inline: 10px 20px;
+      writing-mode: vertical-rl;
+      direction: rtl;
+    }
+    #target {
+      view-timeline: --t1 y;
+      view-timeline-inset: auto auto;
+      animation: anim 1s linear forwards;
+      animation-timeline: --t1;
+    }
+  </style>
+  <div id=scroller>
+    <div id=target></div>
+  </div>
+</template>
+<script>
+  promise_test(async (t) => {
+    inflate(t, test_auto_vertical_vertical_rl_rtl);
+    await assertValueAt(scroller, target, { scrollTop:-50, expected:-1 });
+    await assertValueAt(scroller, target, { scrollTop:-(50 + 20), expected:0 }); // 0%
+    await assertValueAt(scroller, target, { scrollTop:-(125 + 5), expected:50 }); // 50%
+    await assertValueAt(scroller, target, { scrollTop:-(200 - 10), expected:100 }); // 100%
+  }, 'view-timeline-inset:auto, y, vertical-rl, rtl');
+</script>
+
+<template id=test_auto_horizontal>
+  <style>
+    #scroller {
+      scroll-padding-inline: 10px 20px;
+    }
+    #target {
+      view-timeline: --t1 x;
+      view-timeline-inset: auto auto;
+      animation: anim 1s linear forwards;
+      animation-timeline: --t1;
+    }
+  </style>
+  <div id=scroller>
+    <div id=target></div>
+  </div>
+</template>
+<script>
+  promise_test(async (t) => {
+    inflate(t, test_auto_horizontal);
+    await assertValueAt(scroller, target, { scrollLeft:20, expected:-1 });
+    await assertValueAt(scroller, target, { scrollLeft:70 + 20, expected:0 }); // 0%
+    await assertValueAt(scroller, target, { scrollLeft:135 + 5, expected:50 }); // 50%
+    await assertValueAt(scroller, target, { scrollLeft:200 - 10, expected:100 }); // 100%
+  }, 'view-timeline-inset:auto, x');
+</script>
+
+<template id=test_auto_horizontal_rtl>
+  <style>
+    #scroller {
+      scroll-padding-inline: 10px 20px;
+      direction: rtl;
+    }
+    #target {
+      view-timeline: --t1 x;
+      view-timeline-inset: auto auto;
+      animation: anim 1s linear forwards;
+      animation-timeline: --t1;
+    }
+  </style>
+  <div id=scroller>
+    <div id=target></div>
+  </div>
+</template>
+<script>
+  promise_test(async (t) => {
+    inflate(t, test_auto_horizontal_rtl);
+    await assertValueAt(scroller, target, { scrollLeft:-20, expected:-1 });
+    await assertValueAt(scroller, target, { scrollLeft:-(70 + 20), expected:0 }); // 0%
+    await assertValueAt(scroller, target, { scrollLeft:-(135 + 5), expected:50 }); // 50%
+    await assertValueAt(scroller, target, { scrollLeft:-(200 - 10), expected:100 }); // 100%
+  }, 'view-timeline-inset:auto, x, rtl');
+</script>
+
+<template id=test_auto_horizontal_vertical_lr>
+  <style>
+    #scroller {
+      scroll-padding-block: 10px 20px;
+      writing-mode: vertical-lr;
+    }
+    #target {
+      view-timeline: --t1 x;
+      view-timeline-inset: auto auto;
+      animation: anim 1s linear forwards;
+      animation-timeline: --t1;
+    }
+  </style>
+  <div id=scroller>
+    <div id=target></div>
+  </div>
+</template>
+<script>
+  promise_test(async (t) => {
+    inflate(t, test_auto_horizontal_vertical_lr);
+    await assertValueAt(scroller, target, { scrollLeft:20, expected:-1 });
+    await assertValueAt(scroller, target, { scrollLeft:70 + 20, expected:0 }); // 0%
+    await assertValueAt(scroller, target, { scrollLeft:135 + 5, expected:50 }); // 50%
+    await assertValueAt(scroller, target, { scrollLeft:200 - 10, expected:100 }); // 100%
+  }, 'view-timeline-inset:auto, x, vertical-lr');
+</script>
+
+<template id=test_auto_horizontal_vertical_rl>
+  <style>
+    #scroller {
+      scroll-padding-block: 10px 20px;
+      writing-mode: vertical-rl;
+    }
+    #target {
+      view-timeline: --t1 x;
+      view-timeline-inset: auto auto;
+      animation: anim 1s linear forwards;
+      animation-timeline: --t1;
+    }
+  </style>
+  <div id=scroller>
+    <div id=target></div>
+  </div>
+</template>
+<script>
+  promise_test(async (t) => {
+    inflate(t, test_auto_horizontal_vertical_rl);
+    await assertValueAt(scroller, target, { scrollLeft:-20, expected:-1 });
+    await assertValueAt(scroller, target, { scrollLeft:-(70 + 20), expected:0 }); // 0%
+    await assertValueAt(scroller, target, { scrollLeft:-(135 + 5), expected:50 }); // 50%
+    await assertValueAt(scroller, target, { scrollLeft:-(200 - 10), expected:100 }); // 100%
+  }, 'view-timeline-inset:auto, x, vertical-rl');
+</script>
+
+<template id=test_auto_mix>
+  <style>
+    #scroller {
+      font-size: 10px;
+      scroll-padding-block: 50px calc(10% + 1em);
+    }
+    #target {
+      view-timeline: --t1;
+      view-timeline-inset: 10% auto;
+      animation: anim 1s linear forwards;
+      animation-timeline: --t1;
+    }
+  </style>
+  <div id=scroller>
+    <div id=target></div>
+  </div>
+</template>
+<script>
+  promise_test(async (t) => {
+    inflate(t, test_auto_mix);
+    // Note: 10% of scroller height 100px is 10px, and 1em with font-size:10px
+    // is also 10px. Hence we expect the end inset specified as calc(10% + 1em)
+    // to be 20px.
+    await assertValueAt(scroller, target, { scrollTop:50, expected:-1 });
+    await assertValueAt(scroller, target, { scrollTop:50 + 20, expected:0 }); // 0%
+    await assertValueAt(scroller, target, { scrollTop:125 + 5, expected:50 }); // 50%
+    await assertValueAt(scroller, target, { scrollTop:200 - 10, expected:100 }); // 100%
+  }, 'view-timeline-inset:auto, mix');
+</script>
+
+<!--
+  TODO: How to test view-timeline:auto + scroll-padding:auto? The UA may
+  in theory use any value in that case.
+
+  https://drafts.csswg.org/css-scroll-snap-1/#valdef-scroll-padding-auto
+-->
-- 
cgit v1.2.3

