summaryrefslogtreecommitdiffstats
path: root/dom/events/test/test_moz_mouse_pixel_scroll_event.html
diff options
context:
space:
mode:
authorMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
committerMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
commit5f8de423f190bbb79a62f804151bc24824fa32d8 (patch)
tree10027f336435511475e392454359edea8e25895d /dom/events/test/test_moz_mouse_pixel_scroll_event.html
parent49ee0794b5d912db1f95dce6eb52d781dc210db5 (diff)
downloadUXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.gz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.lz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.xz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.zip
Add m-esr52 at 52.6.0
Diffstat (limited to 'dom/events/test/test_moz_mouse_pixel_scroll_event.html')
-rw-r--r--dom/events/test/test_moz_mouse_pixel_scroll_event.html1363
1 files changed, 1363 insertions, 0 deletions
diff --git a/dom/events/test/test_moz_mouse_pixel_scroll_event.html b/dom/events/test/test_moz_mouse_pixel_scroll_event.html
new file mode 100644
index 000000000..c2919ce44
--- /dev/null
+++ b/dom/events/test/test_moz_mouse_pixel_scroll_event.html
@@ -0,0 +1,1363 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+ <title>Test for MozMousePixelScroll events</title>
+ <script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
+ <script type="application/javascript" src="/tests/SimpleTest/EventUtils.js"></script>
+ <script type="application/javascript" src="/tests/SimpleTest/paint_listener.js"></script>
+ <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+ <style>
+ .scrollable {
+ overflow: auto;
+ line-height: 1;
+ margin: 15px;
+ }
+ .scrollable > div {
+ width: 1000px;
+ height: 1000px;
+ font-size: 1000px;
+ line-height: 1;
+ }
+ </style>
+</head>
+<body>
+<p id="display"></p>
+<div id="Scrollable128" class="scrollable" style="font-size: 128px; width: 100px; height: 100px;">
+ <div>
+ <div id="Scrollable96" class="scrollable" style="font-size: 96px; width: 150px; height: 150px;">
+ <div>
+ <div id="Scrollable64" class="scrollable" style="font-size: 64px; width: 200px; height: 200px;">
+ <div>
+ </div>
+ </div>
+ </div>
+ </div>
+ </div>
+</div>
+<div id="Scrollable32" class="scrollable" style="font-size: 32px; width: 50px; height: 50px;">
+ <div>
+ </div>
+</div>
+<div id="content" style="display: none">
+
+</div>
+<pre id="test">
+<script type="application/javascript">
+
+SimpleTest.waitForExplicitFinish();
+SimpleTest.waitForFocus(startTest, window);
+
+var gScrollable128 = document.getElementById("Scrollable128");
+var gScrollable96 = document.getElementById("Scrollable96");
+var gScrollable64 = document.getElementById("Scrollable64");
+var gScrollable32 = document.getElementById("Scrollable32");
+var gRoot = document.documentElement;
+
+function* prepareScrollUnits()
+{
+ var result = -1;
+ function handler(aEvent)
+ {
+ result = aEvent.detail;
+ aEvent.preventDefault();
+ setTimeout(runTest, 0);
+ }
+ window.addEventListener("MozMousePixelScroll", handler, true);
+
+ yield waitForAllPaints(function () { setTimeout(runTest, 0); });
+
+ yield synthesizeWheel(gScrollable128, 10, 10,
+ { deltaMode: WheelEvent.DOM_DELTA_LINE,
+ deltaY: 1.0, lineOrPageDeltaY: 1 });
+ gScrollable128.wheelLineHeight = result;
+ ok(result > 96 && result < 200, "prepareScrollUnits: gScrollable128.wheelLineHeight may be illegal value, got " + result);
+
+ result = -1;
+ yield synthesizeWheel(gScrollable96, 10, 10,
+ { deltaMode: WheelEvent.DOM_DELTA_LINE,
+ deltaY: 1.0, lineOrPageDeltaY: 1 });
+ gScrollable96.wheelLineHeight = result;
+ ok(result > 64 && result < gScrollable128.wheelLineHeight, "prepareScrollUnits: gScrollable96.wheelLineHeight may be illegal value, got " + result);
+
+ result = -1;
+ yield synthesizeWheel(gScrollable64, 10, 10,
+ { deltaMode: WheelEvent.DOM_DELTA_LINE,
+ deltaY: 1.0, lineOrPageDeltaY: 1 });
+ gScrollable64.wheelLineHeight = result;
+ ok(result > 32 && result < gScrollable96.wheelLineHeight, "prepareScrollUnits: gScrollable64.wheelLineHeight may be illegal value, got " + result);
+
+ result = -1;
+ yield synthesizeWheel(gScrollable32, 10, 10,
+ { deltaMode: WheelEvent.DOM_DELTA_LINE,
+ deltaY: 1.0, lineOrPageDeltaY: 1 });
+ gScrollable32.wheelLineHeight = result;
+ ok(result > 16 && result < gScrollable64.wheelLineHeight, "prepareScrollUnits: gScrollable32.wheelLineHeight may be illegal value, got " + result);
+
+ result = -1;
+ yield synthesizeWheel(gRoot, 10, 10,
+ { deltaMode: WheelEvent.DOM_DELTA_LINE,
+ deltaY: 1.0, lineOrPageDeltaY: 1 });
+ gRoot.wheelLineHeight = result;
+ ok(result > 10 && result < gScrollable32.wheelLineHeight, "prepareScrollUnits: gRoot.wheelLineHeight may be illegal value, got " + result);
+
+ result = -1;
+ yield synthesizeWheel(gScrollable128, 10, 10,
+ { deltaMode: WheelEvent.DOM_DELTA_LINE,
+ deltaX: 1.0, lineOrPageDeltaX: 1 });
+ gScrollable128.wheelHorizontalLine = result;
+ ok(result > 50 && result < 200, "prepareScrollUnits: gScrollable128.wheelHorizontalLine may be illegal value, got " + result);
+
+ result = -1;
+ yield synthesizeWheel(gScrollable96, 10, 10,
+ { deltaMode: WheelEvent.DOM_DELTA_LINE,
+ deltaX: 1.0, lineOrPageDeltaX: 1 });
+ gScrollable96.wheelHorizontalLine = result;
+ ok(result > 30 && result < gScrollable128.wheelHorizontalLine, "prepareScrollUnits: gScrollable96.wheelHorizontalLine may be illegal value, got " + result);
+
+ result = -1;
+ yield synthesizeWheel(gScrollable64, 10, 10,
+ { deltaMode: WheelEvent.DOM_DELTA_LINE,
+ deltaX: 1.0, lineOrPageDeltaX: 1 });
+ gScrollable64.wheelHorizontalLine = result;
+ ok(result > 20 && result < gScrollable96.wheelHorizontalLine, "prepareScrollUnits: gScrollable64.wheelHorizontalLine may be illegal value, got " + result);
+
+ result = -1;
+ yield synthesizeWheel(gScrollable32, 10, 10,
+ { deltaMode: WheelEvent.DOM_DELTA_LINE,
+ deltaX: 1.0, lineOrPageDeltaX: 1 });
+ gScrollable32.wheelHorizontalLine = result;
+ ok(result > 12 && result < gScrollable64.wheelHorizontalLine, "prepareScrollUnits: gScrollable32.wheelHorizontalLine may be illegal value, got " + result);
+
+ result = -1;
+ yield synthesizeWheel(gRoot, 10, 10,
+ { deltaMode: WheelEvent.DOM_DELTA_LINE,
+ deltaX: 1.0, lineOrPageDeltaX: 1 });
+ gRoot.wheelHorizontalLine = result;
+ ok(result > 5 && result < gScrollable32.wheelHorizontalLine, "prepareScrollUnits: gRoot.wheelHorizontalLine may be illegal value, got " + result);
+
+ result = -1;
+ yield synthesizeWheel(gScrollable128, 10, 10,
+ { deltaMode: WheelEvent.DOM_DELTA_PAGE,
+ deltaY: 1.0, lineOrPageDeltaY: 1 });
+ gScrollable128.wheelPageHeight = result;
+ ok(result >= (100 - gScrollable128.wheelLineHeight * 2) && result <= 100,
+ "prepareScrollUnits: gScrollable128.wheelLineHeight is strange value, got " + result);
+
+ result = -1;
+ yield synthesizeWheel(gScrollable96, 10, 10,
+ { deltaMode: WheelEvent.DOM_DELTA_PAGE,
+ deltaY: 1.0, lineOrPageDeltaY: 1 });
+ gScrollable96.wheelPageHeight = result;
+ ok(result >= (150 - gScrollable96.wheelLineHeight * 2) && result <= 150,
+ "prepareScrollUnits: gScrollable96.wheelLineHeight is strange value, got " + result);
+
+ result = -1;
+ yield synthesizeWheel(gScrollable64, 10, 10,
+ { deltaMode: WheelEvent.DOM_DELTA_PAGE,
+ deltaY: 1.0, lineOrPageDeltaY: 1 });
+ gScrollable64.wheelPageHeight = result;
+ ok(result >= (200 - gScrollable64.wheelLineHeight * 2) && result <= 200,
+ "prepareScrollUnits: gScrollable64.wheelLineHeight is strange value, got " + result);
+
+ result = -1;
+ yield synthesizeWheel(gScrollable32, 10, 10,
+ { deltaMode: WheelEvent.DOM_DELTA_PAGE,
+ deltaY: 1.0, lineOrPageDeltaY: 1 });
+ gScrollable32.wheelPageHeight = result;
+ ok(result >= (50 - gScrollable32.wheelLineHeight * 2) && result <= 50,
+ "prepareScrollUnits: gScrollable32.wheelLineHeight is strange value, got " + result);
+
+ result = -1;
+ yield synthesizeWheel(gRoot, 10, 10,
+ { deltaMode: WheelEvent.DOM_DELTA_PAGE,
+ deltaY: 1.0, lineOrPageDeltaY: 1 });
+ gRoot.wheelPageHeight = result;
+ ok(window.innerHeight - result < 100 && window.innerHeight - result > 0,
+ "prepareScrollUnits: gRoot.wheelLineHeight is strange value, got " + result);
+
+
+ result = -1;
+ yield synthesizeWheel(gScrollable128, 10, 10,
+ { deltaMode: WheelEvent.DOM_DELTA_PAGE,
+ deltaX: 1.0, lineOrPageDeltaX: 1 });
+ gScrollable128.wheelPageWidth = result;
+ ok(result >= (100 - gScrollable128.wheelLineHeight * 2) && result <= 100,
+ "prepareScrollUnits: gScrollable128.wheelPageWidth is strange value, got " + result);
+
+ result = -1;
+ yield synthesizeWheel(gScrollable96, 10, 10,
+ { deltaMode: WheelEvent.DOM_DELTA_PAGE,
+ deltaX: 1.0, lineOrPageDeltaX: 1 });
+ gScrollable96.wheelPageWidth = result;
+ ok(result >= (150 - gScrollable96.wheelLineHeight * 2) && result <= 150,
+ "prepareScrollUnits: gScrollable96.wheelPageWidth is strange value, got " + result);
+
+ result = -1;
+ yield synthesizeWheel(gScrollable64, 10, 10,
+ { deltaMode: WheelEvent.DOM_DELTA_PAGE,
+ deltaX: 1.0, lineOrPageDeltaX: 1 });
+ gScrollable64.wheelPageWidth = result;
+ ok(result >= (200 - gScrollable64.wheelLineHeight * 2) && result <= 200,
+ "prepareScrollUnits: gScrollable64.wheelPageWidth is strange value, got " + result);
+
+ result = -1;
+ yield synthesizeWheel(gScrollable32, 10, 10,
+ { deltaMode: WheelEvent.DOM_DELTA_PAGE,
+ deltaX: 1.0, lineOrPageDeltaX: 1 });
+ gScrollable32.wheelPageWidth = result;
+ ok(result >= (50 - gScrollable32.wheelLineHeight * 2) && result <= 50,
+ "prepareScrollUnits: gScrollable32.wheelPageWidth is strange value, got " + result);
+
+ result = -1;
+ yield synthesizeWheel(gRoot, 10, 10,
+ { deltaMode: WheelEvent.DOM_DELTA_PAGE,
+ deltaX: 1.0, lineOrPageDeltaX: 1 });
+ gRoot.wheelPageWidth = result;
+ ok(window.innerWidth - result < 100 && window.innerWidth - result > 0,
+ "prepareScrollUnits: gRoot.wheelPageWidth is strange value, got " + result);
+
+ window.removeEventListener("MozMousePixelScroll", handler, true);
+}
+
+function* doTests()
+{
+ const kTests = [
+ // DOM_DELTA_LINE
+ { description: "Should be computed from nearest scrollable element, 128",
+ target: gScrollable128,
+ event: {
+ deltaMode: WheelEvent.DOM_DELTA_LINE,
+ deltaX: 1.0, deltaY: 1.0, lineOrPageDeltaX: 1, lineOrPageDeltaY: 1 },
+ prepare: function () {
+ gScrollable128.scrollLeft = 0;
+ gScrollable128.scrollTop = 0;
+ },
+ cleanup: function () {
+ },
+ expected: {
+ x: gScrollable128, y: gScrollable128
+ }
+ },
+ { description: "Should be computed from nearest scrollable element, even if not scrollable to the direction",
+ target: gScrollable128,
+ event: {
+ deltaMode: WheelEvent.DOM_DELTA_LINE,
+ deltaX: -1.0, deltaY: -1.0, lineOrPageDeltaX: -1, lineOrPageDeltaY: -1 },
+ prepare: function () {
+ gScrollable128.scrollLeft = 0;
+ gScrollable128.scrollTop = 0;
+ },
+ cleanup: function () {
+ },
+ expected: {
+ x: gScrollable128, y: gScrollable128
+ }
+ },
+ { description: "Should be computed from nearest scrollable element, 96",
+ target: gScrollable96,
+ event: {
+ deltaMode: WheelEvent.DOM_DELTA_LINE,
+ deltaX: 1.0, deltaY: 1.0, lineOrPageDeltaX: 1, lineOrPageDeltaY: 1 },
+ prepare: function () {
+ gScrollable96.scrollLeft = 0;
+ gScrollable96.scrollTop = 0;
+ },
+ cleanup: function () {
+ },
+ expected: {
+ x: gScrollable96, y: gScrollable96
+ }
+ },
+ { description: "Should be computed from nearest scrollable element, even if not scrollable to the direction, 96",
+ target: gScrollable96,
+ event: {
+ deltaMode: WheelEvent.DOM_DELTA_LINE,
+ deltaX: -1.0, deltaY: -1.0, lineOrPageDeltaX: -1, lineOrPageDeltaY: -1 },
+ prepare: function () {
+ gScrollable96.scrollLeft = 0;
+ gScrollable96.scrollTop = 0;
+ },
+ cleanup: function () {
+ },
+ expected: {
+ x: gScrollable96, y: gScrollable96
+ }
+ },
+ { description: "Should be computed from nearest scrollable element, 64",
+ target: gScrollable64,
+ event: {
+ deltaMode: WheelEvent.DOM_DELTA_LINE,
+ deltaX: 1.0, deltaY: 1.0, lineOrPageDeltaX: 1, lineOrPageDeltaY: 1 },
+ prepare: function () {
+ gScrollable64.scrollLeft = 0;
+ gScrollable64.scrollTop = 0;
+ },
+ cleanup: function () {
+ },
+ expected: {
+ x: gScrollable64, y: gScrollable64
+ }
+ },
+ { description: "Should be computed from nearest scrollable element, even if not scrollable to the direction, 64",
+ target: gScrollable64,
+ event: {
+ deltaMode: WheelEvent.DOM_DELTA_LINE,
+ deltaX: -1.0, deltaY: -1.0, lineOrPageDeltaX: -1, lineOrPageDeltaY: -1 },
+ prepare: function () {
+ gScrollable64.scrollLeft = 0;
+ gScrollable64.scrollTop = 0;
+ },
+ cleanup: function () {
+ },
+ expected: {
+ x: gScrollable64, y: gScrollable64
+ }
+ },
+ { description: "Should be computed from nearest scrollable element, 32",
+ target: gScrollable32,
+ event: {
+ deltaMode: WheelEvent.DOM_DELTA_LINE,
+ deltaX: 1.0, deltaY: 1.0, lineOrPageDeltaX: 1, lineOrPageDeltaY: 1 },
+ prepare: function () {
+ gScrollable32.scrollLeft = 0;
+ gScrollable32.scrollTop = 0;
+ },
+ cleanup: function () {
+ },
+ expected: {
+ x: gScrollable32, y: gScrollable32
+ }
+ },
+ { description: "Should be computed from nearest scrollable element, even if not scrollable to the direction, 32",
+ target: gScrollable32,
+ event: {
+ deltaMode: WheelEvent.DOM_DELTA_LINE,
+ deltaX: -1.0, deltaY: -1.0, lineOrPageDeltaX: -1, lineOrPageDeltaY: -1 },
+ prepare: function () {
+ gScrollable32.scrollLeft = 0;
+ gScrollable32.scrollTop = 0;
+ },
+ cleanup: function () {
+ },
+ expected: {
+ x: gScrollable32, y: gScrollable32
+ }
+ },
+ { description: "Should be computed from root element if there is no scrollable element, root",
+ target: gRoot,
+ event: {
+ deltaMode: WheelEvent.DOM_DELTA_LINE,
+ deltaX: 1.0, deltaY: 1.0, lineOrPageDeltaX: 1, lineOrPageDeltaY: 1 },
+ prepare: function () {
+ },
+ cleanup: function () {
+ },
+ expected: {
+ x: gRoot, y: gRoot
+ }
+ },
+ { description: "Should be computed from root element, even if there is no scrollable element, root",
+ target: gRoot,
+ event: {
+ deltaMode: WheelEvent.DOM_DELTA_LINE,
+ deltaX: -1.0, deltaY: -1.0, lineOrPageDeltaX: -1, lineOrPageDeltaY: -1 },
+ prepare: function () {
+ },
+ cleanup: function () {
+ },
+ expected: {
+ x: gRoot, y: gRoot
+ }
+ },
+ { description: "Should be computed from nearest scrollable element, 128",
+ target: gScrollable128,
+ event: {
+ deltaMode: WheelEvent.DOM_DELTA_LINE,
+ deltaX: 0.0, deltaY: 1.0, lineOrPageDeltaX: 0, lineOrPageDeltaY: 1 },
+ prepare: function () {
+ gScrollable128.scrollLeft = 0;
+ gScrollable128.scrollTop = 0;
+ },
+ cleanup: function () {
+ },
+ expected: {
+ x: null, y: gScrollable128
+ }
+ },
+ { description: "Should be computed from nearest scrollable element, even if not scrollable to the direction",
+ target: gScrollable128,
+ event: {
+ deltaMode: WheelEvent.DOM_DELTA_LINE,
+ deltaX: 0.0, deltaY: -1.0, lineOrPageDeltaX: 0, lineOrPageDeltaY: -1 },
+ prepare: function () {
+ gScrollable128.scrollLeft = 0;
+ gScrollable128.scrollTop = 0;
+ },
+ cleanup: function () {
+ },
+ expected: {
+ x: null, y: gScrollable128
+ }
+ },
+ { description: "Should be computed from nearest scrollable element, 96",
+ target: gScrollable96,
+ event: {
+ deltaMode: WheelEvent.DOM_DELTA_LINE,
+ deltaX: 0.0, deltaY: 1.0, lineOrPageDeltaX: 0, lineOrPageDeltaY: 1 },
+ prepare: function () {
+ gScrollable96.scrollLeft = 0;
+ gScrollable96.scrollTop = 0;
+ },
+ cleanup: function () {
+ },
+ expected: {
+ x: null, y: gScrollable96
+ }
+ },
+ { description: "Should be computed from nearest scrollable element, even if not scrollable to the direction, 96",
+ target: gScrollable96,
+ event: {
+ deltaMode: WheelEvent.DOM_DELTA_LINE,
+ deltaX: 0.0, deltaY: -1.0, lineOrPageDeltaX: 0, lineOrPageDeltaY: -1 },
+ prepare: function () {
+ gScrollable96.scrollLeft = 0;
+ gScrollable96.scrollTop = 0;
+ },
+ cleanup: function () {
+ },
+ expected: {
+ x: null, y: gScrollable96
+ }
+ },
+ { description: "Should be computed from nearest scrollable element, 64",
+ target: gScrollable64,
+ event: {
+ deltaMode: WheelEvent.DOM_DELTA_LINE,
+ deltaX: 0.0, deltaY: 1.0, lineOrPageDeltaX: 0, lineOrPageDeltaY: 1 },
+ prepare: function () {
+ gScrollable64.scrollLeft = 0;
+ gScrollable64.scrollTop = 0;
+ },
+ cleanup: function () {
+ },
+ expected: {
+ x: null, y: gScrollable64
+ }
+ },
+ { description: "Should be computed from nearest scrollable element, even if not scrollable to the direction, 64",
+ target: gScrollable64,
+ event: {
+ deltaMode: WheelEvent.DOM_DELTA_LINE,
+ deltaX: 0.0, deltaY: -1.0, lineOrPageDeltaX: 0, lineOrPageDeltaY: -1 },
+ prepare: function () {
+ gScrollable64.scrollLeft = 0;
+ gScrollable64.scrollTop = 0;
+ },
+ cleanup: function () {
+ },
+ expected: {
+ x: null, y: gScrollable64
+ }
+ },
+ { description: "Should be computed from nearest scrollable element, 32",
+ target: gScrollable32,
+ event: {
+ deltaMode: WheelEvent.DOM_DELTA_LINE,
+ deltaX: 0.0, deltaY: 1.0, lineOrPageDeltaX: 0, lineOrPageDeltaY: 1 },
+ prepare: function () {
+ gScrollable32.scrollLeft = 0;
+ gScrollable32.scrollTop = 0;
+ },
+ cleanup: function () {
+ },
+ expected: {
+ x: null, y: gScrollable32
+ }
+ },
+ { description: "Should be computed from nearest scrollable element, even if not scrollable to the direction, 32",
+ target: gScrollable32,
+ event: {
+ deltaMode: WheelEvent.DOM_DELTA_LINE,
+ deltaX: 0.0, deltaY: -1.0, lineOrPageDeltaX: 0, lineOrPageDeltaY: -1 },
+ prepare: function () {
+ gScrollable32.scrollLeft = 0;
+ gScrollable32.scrollTop = 0;
+ },
+ cleanup: function () {
+ },
+ expected: {
+ x: null, y: gScrollable32
+ }
+ },
+ { description: "Should be computed from root element if there is no scrollable element, root",
+ target: gRoot,
+ event: {
+ deltaMode: WheelEvent.DOM_DELTA_LINE,
+ deltaX: 0.0, deltaY: 1.0, lineOrPageDeltaX: 0, lineOrPageDeltaY: 1 },
+ prepare: function () {
+ },
+ cleanup: function () {
+ },
+ expected: {
+ x: null, y: gRoot
+ }
+ },
+ { description: "Should be computed from root element, even if there is no scrollable element, root",
+ target: gRoot,
+ event: {
+ deltaMode: WheelEvent.DOM_DELTA_LINE,
+ deltaX: 0.0, deltaY: -1.0, lineOrPageDeltaX: 0, lineOrPageDeltaY: -1 },
+ prepare: function () {
+ },
+ cleanup: function () {
+ },
+ expected: {
+ x: null, y: gRoot
+ }
+ },
+ { description: "Should be computed from nearest scrollable element, 128",
+ target: gScrollable128,
+ event: {
+ deltaMode: WheelEvent.DOM_DELTA_LINE,
+ deltaX: 1.0, deltaY: 0.0, lineOrPageDeltaX: 1, lineOrPageDeltaY: 0 },
+ prepare: function () {
+ gScrollable128.scrollLeft = 0;
+ gScrollable128.scrollTop = 0;
+ },
+ cleanup: function () {
+ },
+ expected: {
+ x: gScrollable128, y: null
+ }
+ },
+ { description: "Should be computed from nearest scrollable element, even if not scrollable to the direction",
+ target: gScrollable128,
+ event: {
+ deltaMode: WheelEvent.DOM_DELTA_LINE,
+ deltaX: -1.0, deltaY: 0.0, lineOrPageDeltaX: -1, lineOrPageDeltaY: 0 },
+ prepare: function () {
+ gScrollable128.scrollLeft = 0;
+ gScrollable128.scrollTop = 0;
+ },
+ cleanup: function () {
+ },
+ expected: {
+ x: gScrollable128, y: null
+ }
+ },
+ { description: "Should be computed from nearest scrollable element, 96",
+ target: gScrollable96,
+ event: {
+ deltaMode: WheelEvent.DOM_DELTA_LINE,
+ deltaX: 1.0, deltaY: 0.0, lineOrPageDeltaX: 1, lineOrPageDeltaY: 0 },
+ prepare: function () {
+ gScrollable96.scrollLeft = 0;
+ gScrollable96.scrollTop = 0;
+ },
+ cleanup: function () {
+ },
+ expected: {
+ x: gScrollable96, y: null
+ }
+ },
+ { description: "Should be computed from nearest scrollable element, even if not scrollable to the direction, 96",
+ target: gScrollable96,
+ event: {
+ deltaMode: WheelEvent.DOM_DELTA_LINE,
+ deltaX: -1.0, deltaY: 0.0, lineOrPageDeltaX: -1, lineOrPageDeltaY: 0 },
+ prepare: function () {
+ gScrollable96.scrollLeft = 0;
+ gScrollable96.scrollTop = 0;
+ },
+ cleanup: function () {
+ },
+ expected: {
+ x: gScrollable96, y: null
+ }
+ },
+ { description: "Should be computed from nearest scrollable element, 64",
+ target: gScrollable64,
+ event: {
+ deltaMode: WheelEvent.DOM_DELTA_LINE,
+ deltaX: 1.0, deltaY: 0.0, lineOrPageDeltaX: 1, lineOrPageDeltaY: 0 },
+ prepare: function () {
+ gScrollable64.scrollLeft = 0;
+ gScrollable64.scrollTop = 0;
+ },
+ cleanup: function () {
+ },
+ expected: {
+ x: gScrollable64, y: null
+ }
+ },
+ { description: "Should be computed from nearest scrollable element, even if not scrollable to the direction, 64",
+ target: gScrollable64,
+ event: {
+ deltaMode: WheelEvent.DOM_DELTA_LINE,
+ deltaX: -1.0, deltaY: 0.0, lineOrPageDeltaX: -1, lineOrPageDeltaY: 0 },
+ prepare: function () {
+ gScrollable64.scrollLeft = 0;
+ gScrollable64.scrollTop = 0;
+ },
+ cleanup: function () {
+ },
+ expected: {
+ x: gScrollable64, y: null
+ }
+ },
+ { description: "Should be computed from nearest scrollable element, 32",
+ target: gScrollable32,
+ event: {
+ deltaMode: WheelEvent.DOM_DELTA_LINE,
+ deltaX: 1.0, deltaY: 0.0, lineOrPageDeltaX: 1, lineOrPageDeltaY: 0 },
+ prepare: function () {
+ gScrollable32.scrollLeft = 0;
+ gScrollable32.scrollTop = 0;
+ },
+ cleanup: function () {
+ },
+ expected: {
+ x: gScrollable32, y: null
+ }
+ },
+ { description: "Should be computed from nearest scrollable element, even if not scrollable to the direction, 32",
+ target: gScrollable32,
+ event: {
+ deltaMode: WheelEvent.DOM_DELTA_LINE,
+ deltaX: -1.0, deltaY: 0.0, lineOrPageDeltaX: -1, lineOrPageDeltaY: 0 },
+ prepare: function () {
+ gScrollable32.scrollLeft = 0;
+ gScrollable32.scrollTop = 0;
+ },
+ cleanup: function () {
+ },
+ expected: {
+ x: gScrollable32, y: null
+ }
+ },
+ { description: "Should be computed from root element if there is no scrollable element, root",
+ target: gRoot,
+ event: {
+ deltaMode: WheelEvent.DOM_DELTA_LINE,
+ deltaX: 1.0, deltaY: 0.0, lineOrPageDeltaX: 1, lineOrPageDeltaY: 0 },
+ prepare: function () {
+ },
+ cleanup: function () {
+ },
+ expected: {
+ x: gRoot, y: null
+ }
+ },
+ { description: "Should be computed from root element, even if there is no scrollable element, root",
+ target: gRoot,
+ event: {
+ deltaMode: WheelEvent.DOM_DELTA_LINE,
+ deltaX: -1.0, deltaY: 0.0, lineOrPageDeltaX: -1, lineOrPageDeltaY: 0 },
+ prepare: function () {
+ },
+ cleanup: function () {
+ },
+ expected: {
+ x: gRoot, y: null
+ }
+ },
+
+ // DOM_DELTA_PAGE
+ { description: "Should be computed from nearest scrollable element, 128",
+ target: gScrollable128,
+ event: {
+ deltaMode: WheelEvent.DOM_DELTA_PAGE,
+ deltaX: 1.0, deltaY: 1.0, lineOrPageDeltaX: 1, lineOrPageDeltaY: 1 },
+ prepare: function () {
+ gScrollable128.scrollLeft = 0;
+ gScrollable128.scrollTop = 0;
+ },
+ cleanup: function () {
+ },
+ expected: {
+ x: gScrollable128, y: gScrollable128
+ }
+ },
+ { description: "Should be computed from nearest scrollable element, even if not scrollable to the direction",
+ target: gScrollable128,
+ event: {
+ deltaMode: WheelEvent.DOM_DELTA_PAGE,
+ deltaX: -1.0, deltaY: -1.0, lineOrPageDeltaX: -1, lineOrPageDeltaY: -1 },
+ prepare: function () {
+ gScrollable128.scrollLeft = 0;
+ gScrollable128.scrollTop = 0;
+ },
+ cleanup: function () {
+ },
+ expected: {
+ x: gScrollable128, y: gScrollable128
+ }
+ },
+ { description: "Should be computed from nearest scrollable element, 96",
+ target: gScrollable96,
+ event: {
+ deltaMode: WheelEvent.DOM_DELTA_PAGE,
+ deltaX: 1.0, deltaY: 1.0, lineOrPageDeltaX: 1, lineOrPageDeltaY: 1 },
+ prepare: function () {
+ gScrollable96.scrollLeft = 0;
+ gScrollable96.scrollTop = 0;
+ },
+ cleanup: function () {
+ },
+ expected: {
+ x: gScrollable96, y: gScrollable96
+ }
+ },
+ { description: "Should be computed from nearest scrollable element, even if not scrollable to the direction, 96",
+ target: gScrollable96,
+ event: {
+ deltaMode: WheelEvent.DOM_DELTA_PAGE,
+ deltaX: -1.0, deltaY: -1.0, lineOrPageDeltaX: -1, lineOrPageDeltaY: -1 },
+ prepare: function () {
+ gScrollable96.scrollLeft = 0;
+ gScrollable96.scrollTop = 0;
+ },
+ cleanup: function () {
+ },
+ expected: {
+ x: gScrollable96, y: gScrollable96
+ }
+ },
+ { description: "Should be computed from nearest scrollable element, 64",
+ target: gScrollable64,
+ event: {
+ deltaMode: WheelEvent.DOM_DELTA_PAGE,
+ deltaX: 1.0, deltaY: 1.0, lineOrPageDeltaX: 1, lineOrPageDeltaY: 1 },
+ prepare: function () {
+ gScrollable64.scrollLeft = 0;
+ gScrollable64.scrollTop = 0;
+ },
+ cleanup: function () {
+ },
+ expected: {
+ x: gScrollable64, y: gScrollable64
+ }
+ },
+ { description: "Should be computed from nearest scrollable element, even if not scrollable to the direction, 64",
+ target: gScrollable64,
+ event: {
+ deltaMode: WheelEvent.DOM_DELTA_PAGE,
+ deltaX: -1.0, deltaY: -1.0, lineOrPageDeltaX: -1, lineOrPageDeltaY: -1 },
+ prepare: function () {
+ gScrollable64.scrollLeft = 0;
+ gScrollable64.scrollTop = 0;
+ },
+ cleanup: function () {
+ },
+ expected: {
+ x: gScrollable64, y: gScrollable64
+ }
+ },
+ { description: "Should be computed from nearest scrollable element, 32",
+ target: gScrollable32,
+ event: {
+ deltaMode: WheelEvent.DOM_DELTA_PAGE,
+ deltaX: 1.0, deltaY: 1.0, lineOrPageDeltaX: 1, lineOrPageDeltaY: 1 },
+ prepare: function () {
+ gScrollable32.scrollLeft = 0;
+ gScrollable32.scrollTop = 0;
+ },
+ cleanup: function () {
+ },
+ expected: {
+ x: gScrollable32, y: gScrollable32
+ }
+ },
+ { description: "Should be computed from nearest scrollable element, even if not scrollable to the direction, 32",
+ target: gScrollable32,
+ event: {
+ deltaMode: WheelEvent.DOM_DELTA_PAGE,
+ deltaX: -1.0, deltaY: -1.0, lineOrPageDeltaX: -1, lineOrPageDeltaY: -1 },
+ prepare: function () {
+ gScrollable32.scrollLeft = 0;
+ gScrollable32.scrollTop = 0;
+ },
+ cleanup: function () {
+ },
+ expected: {
+ x: gScrollable32, y: gScrollable32
+ }
+ },
+ { description: "Should be computed from root element if there is no scrollable element, root",
+ target: gRoot,
+ event: {
+ deltaMode: WheelEvent.DOM_DELTA_PAGE,
+ deltaX: 1.0, deltaY: 1.0, lineOrPageDeltaX: 1, lineOrPageDeltaY: 1 },
+ prepare: function () {
+ },
+ cleanup: function () {
+ },
+ expected: {
+ x: gRoot, y: gRoot
+ }
+ },
+ { description: "Should be computed from root element, even if there is no scrollable element, root",
+ target: gRoot,
+ event: {
+ deltaMode: WheelEvent.DOM_DELTA_PAGE,
+ deltaX: -1.0, deltaY: -1.0, lineOrPageDeltaX: -1, lineOrPageDeltaY: -1 },
+ prepare: function () {
+ },
+ cleanup: function () {
+ },
+ expected: {
+ x: gRoot, y: gRoot
+ }
+ },
+ { description: "Should be computed from nearest scrollable element, 128",
+ target: gScrollable128,
+ event: {
+ deltaMode: WheelEvent.DOM_DELTA_PAGE,
+ deltaX: 0.0, deltaY: 1.0, lineOrPageDeltaX: 0, lineOrPageDeltaY: 1 },
+ prepare: function () {
+ gScrollable128.scrollLeft = 0;
+ gScrollable128.scrollTop = 0;
+ },
+ cleanup: function () {
+ },
+ expected: {
+ x: null, y: gScrollable128
+ }
+ },
+ { description: "Should be computed from nearest scrollable element, even if not scrollable to the direction",
+ target: gScrollable128,
+ event: {
+ deltaMode: WheelEvent.DOM_DELTA_PAGE,
+ deltaX: 0.0, deltaY: -1.0, lineOrPageDeltaX: 0, lineOrPageDeltaY: -1 },
+ prepare: function () {
+ gScrollable128.scrollLeft = 0;
+ gScrollable128.scrollTop = 0;
+ },
+ cleanup: function () {
+ },
+ expected: {
+ x: null, y: gScrollable128
+ }
+ },
+ { description: "Should be computed from nearest scrollable element, 96",
+ target: gScrollable96,
+ event: {
+ deltaMode: WheelEvent.DOM_DELTA_PAGE,
+ deltaX: 0.0, deltaY: 1.0, lineOrPageDeltaX: 0, lineOrPageDeltaY: 1 },
+ prepare: function () {
+ gScrollable96.scrollLeft = 0;
+ gScrollable96.scrollTop = 0;
+ },
+ cleanup: function () {
+ },
+ expected: {
+ x: null, y: gScrollable96
+ }
+ },
+ { description: "Should be computed from nearest scrollable element, even if not scrollable to the direction, 96",
+ target: gScrollable96,
+ event: {
+ deltaMode: WheelEvent.DOM_DELTA_PAGE,
+ deltaX: 0.0, deltaY: -1.0, lineOrPageDeltaX: 0, lineOrPageDeltaY: -1 },
+ prepare: function () {
+ gScrollable96.scrollLeft = 0;
+ gScrollable96.scrollTop = 0;
+ },
+ cleanup: function () {
+ },
+ expected: {
+ x: null, y: gScrollable96
+ }
+ },
+ { description: "Should be computed from nearest scrollable element, 64",
+ target: gScrollable64,
+ event: {
+ deltaMode: WheelEvent.DOM_DELTA_PAGE,
+ deltaX: 0.0, deltaY: 1.0, lineOrPageDeltaX: 0, lineOrPageDeltaY: 1 },
+ prepare: function () {
+ gScrollable64.scrollLeft = 0;
+ gScrollable64.scrollTop = 0;
+ },
+ cleanup: function () {
+ },
+ expected: {
+ x: null, y: gScrollable64
+ }
+ },
+ { description: "Should be computed from nearest scrollable element, even if not scrollable to the direction, 64",
+ target: gScrollable64,
+ event: {
+ deltaMode: WheelEvent.DOM_DELTA_PAGE,
+ deltaX: 0.0, deltaY: -1.0, lineOrPageDeltaX: 0, lineOrPageDeltaY: -1 },
+ prepare: function () {
+ gScrollable64.scrollLeft = 0;
+ gScrollable64.scrollTop = 0;
+ },
+ cleanup: function () {
+ },
+ expected: {
+ x: null, y: gScrollable64
+ }
+ },
+ { description: "Should be computed from nearest scrollable element, 32",
+ target: gScrollable32,
+ event: {
+ deltaMode: WheelEvent.DOM_DELTA_PAGE,
+ deltaX: 0.0, deltaY: 1.0, lineOrPageDeltaX: 0, lineOrPageDeltaY: 1 },
+ prepare: function () {
+ gScrollable32.scrollLeft = 0;
+ gScrollable32.scrollTop = 0;
+ },
+ cleanup: function () {
+ },
+ expected: {
+ x: null, y: gScrollable32
+ }
+ },
+ { description: "Should be computed from nearest scrollable element, even if not scrollable to the direction, 32",
+ target: gScrollable32,
+ event: {
+ deltaMode: WheelEvent.DOM_DELTA_PAGE,
+ deltaX: 0.0, deltaY: -1.0, lineOrPageDeltaX: 0, lineOrPageDeltaY: -1 },
+ prepare: function () {
+ gScrollable32.scrollLeft = 0;
+ gScrollable32.scrollTop = 0;
+ },
+ cleanup: function () {
+ },
+ expected: {
+ x: null, y: gScrollable32
+ }
+ },
+ { description: "Should be computed from root element if there is no scrollable element, root",
+ target: gRoot,
+ event: {
+ deltaMode: WheelEvent.DOM_DELTA_PAGE,
+ deltaX: 0.0, deltaY: 1.0, lineOrPageDeltaX: 0, lineOrPageDeltaY: 1 },
+ prepare: function () {
+ },
+ cleanup: function () {
+ },
+ expected: {
+ x: null, y: gRoot
+ }
+ },
+ { description: "Should be computed from root element, even if there is no scrollable element, root",
+ target: gRoot,
+ event: {
+ deltaMode: WheelEvent.DOM_DELTA_PAGE,
+ deltaX: 0.0, deltaY: -1.0, lineOrPageDeltaX: 0, lineOrPageDeltaY: -1 },
+ prepare: function () {
+ },
+ cleanup: function () {
+ },
+ expected: {
+ x: null, y: gRoot
+ }
+ },
+ { description: "Should be computed from nearest scrollable element, 128",
+ target: gScrollable128,
+ event: {
+ deltaMode: WheelEvent.DOM_DELTA_PAGE,
+ deltaX: 1.0, deltaY: 0.0, lineOrPageDeltaX: 1, lineOrPageDeltaY: 0 },
+ prepare: function () {
+ gScrollable128.scrollLeft = 0;
+ gScrollable128.scrollTop = 0;
+ },
+ cleanup: function () {
+ },
+ expected: {
+ x: gScrollable128, y: null
+ }
+ },
+ { description: "Should be computed from nearest scrollable element, even if not scrollable to the direction",
+ target: gScrollable128,
+ event: {
+ deltaMode: WheelEvent.DOM_DELTA_PAGE,
+ deltaX: -1.0, deltaY: 0.0, lineOrPageDeltaX: -1, lineOrPageDeltaY: 0 },
+ prepare: function () {
+ gScrollable128.scrollLeft = 0;
+ gScrollable128.scrollTop = 0;
+ },
+ cleanup: function () {
+ },
+ expected: {
+ x: gScrollable128, y: null
+ }
+ },
+ { description: "Should be computed from nearest scrollable element, 96",
+ target: gScrollable96,
+ event: {
+ deltaMode: WheelEvent.DOM_DELTA_PAGE,
+ deltaX: 1.0, deltaY: 0.0, lineOrPageDeltaX: 1, lineOrPageDeltaY: 0 },
+ prepare: function () {
+ gScrollable96.scrollLeft = 0;
+ gScrollable96.scrollTop = 0;
+ },
+ cleanup: function () {
+ },
+ expected: {
+ x: gScrollable96, y: null
+ }
+ },
+ { description: "Should be computed from nearest scrollable element, even if not scrollable to the direction, 96",
+ target: gScrollable96,
+ event: {
+ deltaMode: WheelEvent.DOM_DELTA_PAGE,
+ deltaX: -1.0, deltaY: 0.0, lineOrPageDeltaX: -1, lineOrPageDeltaY: 0 },
+ prepare: function () {
+ gScrollable96.scrollLeft = 0;
+ gScrollable96.scrollTop = 0;
+ },
+ cleanup: function () {
+ },
+ expected: {
+ x: gScrollable96, y: null
+ }
+ },
+ { description: "Should be computed from nearest scrollable element, 64",
+ target: gScrollable64,
+ event: {
+ deltaMode: WheelEvent.DOM_DELTA_PAGE,
+ deltaX: 1.0, deltaY: 0.0, lineOrPageDeltaX: 1, lineOrPageDeltaY: 0 },
+ prepare: function () {
+ gScrollable64.scrollLeft = 0;
+ gScrollable64.scrollTop = 0;
+ },
+ cleanup: function () {
+ },
+ expected: {
+ x: gScrollable64, y: null
+ }
+ },
+ { description: "Should be computed from nearest scrollable element, even if not scrollable to the direction, 64",
+ target: gScrollable64,
+ event: {
+ deltaMode: WheelEvent.DOM_DELTA_PAGE,
+ deltaX: -1.0, deltaY: 0.0, lineOrPageDeltaX: -1, lineOrPageDeltaY: 0 },
+ prepare: function () {
+ gScrollable64.scrollLeft = 0;
+ gScrollable64.scrollTop = 0;
+ },
+ cleanup: function () {
+ },
+ expected: {
+ x: gScrollable64, y: null
+ }
+ },
+ { description: "Should be computed from nearest scrollable element, 32",
+ target: gScrollable32,
+ event: {
+ deltaMode: WheelEvent.DOM_DELTA_PAGE,
+ deltaX: 1.0, deltaY: 0.0, lineOrPageDeltaX: 1, lineOrPageDeltaY: 0 },
+ prepare: function () {
+ gScrollable32.scrollLeft = 0;
+ gScrollable32.scrollTop = 0;
+ },
+ cleanup: function () {
+ },
+ expected: {
+ x: gScrollable32, y: null
+ }
+ },
+ { description: "Should be computed from nearest scrollable element, even if not scrollable to the direction, 32",
+ target: gScrollable32,
+ event: {
+ deltaMode: WheelEvent.DOM_DELTA_PAGE,
+ deltaX: -1.0, deltaY: 0.0, lineOrPageDeltaX: -1, lineOrPageDeltaY: 0 },
+ prepare: function () {
+ gScrollable32.scrollLeft = 0;
+ gScrollable32.scrollTop = 0;
+ },
+ cleanup: function () {
+ },
+ expected: {
+ x: gScrollable32, y: null
+ }
+ },
+ { description: "Should be computed from root element if there is no scrollable element, root",
+ target: gRoot,
+ event: {
+ deltaMode: WheelEvent.DOM_DELTA_PAGE,
+ deltaX: 1.0, deltaY: 0.0, lineOrPageDeltaX: 1, lineOrPageDeltaY: 0 },
+ prepare: function () {
+ },
+ cleanup: function () {
+ },
+ expected: {
+ x: gRoot, y: null
+ }
+ },
+ { description: "Should be computed from root element, even if there is no scrollable element, root",
+ target: gRoot,
+ event: {
+ deltaMode: WheelEvent.DOM_DELTA_PAGE,
+ deltaX: -1.0, deltaY: 0.0, lineOrPageDeltaX: -1, lineOrPageDeltaY: 0 },
+ prepare: function () {
+ },
+ cleanup: function () {
+ },
+ expected: {
+ x: gRoot, y: null
+ }
+ },
+
+ // Overflow: hidden; boxes shouldn't be ignored.
+ { description: "Should be computed from nearest scrollable element even if it hides overflow content, 64",
+ target: gScrollable64,
+ event: {
+ deltaMode: WheelEvent.DOM_DELTA_LINE,
+ deltaX: 1.0, deltaY: 1.0, lineOrPageDeltaX: 1, lineOrPageDeltaY: 1 },
+ prepare: function () {
+ gScrollable64.style.overflow = "hidden";
+ gScrollable96.scrollLeft = 0;
+ gScrollable96.scrollTop = 0;
+ gScrollable64.scrollLeft = 0;
+ gScrollable64.scrollTop = 0;
+ },
+ cleanup: function () {
+ gScrollable64.style.overflow = "auto";
+ },
+ expected: {
+ x: gScrollable64, y: gScrollable64
+ }
+ },
+ { description: "Should be computed from nearest scrollable element even if it hides overflow content (X), 64",
+ target: gScrollable64,
+ event: {
+ deltaMode: WheelEvent.DOM_DELTA_LINE,
+ deltaX: 1.0, deltaY: 1.0, lineOrPageDeltaX: 1, lineOrPageDeltaY: 1 },
+ prepare: function () {
+ gScrollable64.style.overflowX = "hidden";
+ gScrollable96.scrollLeft = 0;
+ gScrollable96.scrollTop = 0;
+ gScrollable64.scrollLeft = 0;
+ gScrollable64.scrollTop = 0;
+ },
+ cleanup: function () {
+ gScrollable64.style.overflow = "auto";
+ },
+ expected: {
+ x: gScrollable64, y: gScrollable64
+ }
+ },
+ { description: "Should be computed from nearest scrollable element even if it hides overflow content (Y), 64",
+ target: gScrollable64,
+ event: {
+ deltaMode: WheelEvent.DOM_DELTA_LINE,
+ deltaX: 1.0, deltaY: 1.0, lineOrPageDeltaX: 1, lineOrPageDeltaY: 1 },
+ prepare: function () {
+ gScrollable64.style.overflowY = "hidden";
+ gScrollable96.scrollLeft = 0;
+ gScrollable96.scrollTop = 0;
+ gScrollable64.scrollLeft = 0;
+ gScrollable64.scrollTop = 0;
+ },
+ cleanup: function () {
+ gScrollable64.style.overflow = "auto";
+ },
+ expected: {
+ x: gScrollable64, y: gScrollable64
+ }
+ },
+ { description: "Should be computed from nearest scrollable element even if it hides overflow content (X), 64",
+ target: gScrollable64,
+ event: {
+ deltaMode: WheelEvent.DOM_DELTA_LINE,
+ deltaX: 0.0, deltaY: 1.0, lineOrPageDeltaX: 0, lineOrPageDeltaY: 1 },
+ prepare: function () {
+ gScrollable64.style.overflowX = "hidden";
+ gScrollable96.scrollLeft = 0;
+ gScrollable96.scrollTop = 0;
+ gScrollable64.scrollLeft = 0;
+ gScrollable64.scrollTop = 0;
+ },
+ cleanup: function () {
+ gScrollable64.style.overflow = "auto";
+ },
+ expected: {
+ x: null, y: gScrollable64
+ }
+ },
+ { description: "Should be computed from nearest scrollable element even if it hides overflow content (Y), 64",
+ target: gScrollable64,
+ event: {
+ deltaMode: WheelEvent.DOM_DELTA_LINE,
+ deltaX: 0.0, deltaY: 1.0, lineOrPageDeltaX: 0, lineOrPageDeltaY: 1 },
+ prepare: function () {
+ gScrollable64.style.overflowY = "hidden";
+ gScrollable96.scrollLeft = 0;
+ gScrollable96.scrollTop = 0;
+ gScrollable64.scrollLeft = 0;
+ gScrollable64.scrollTop = 0;
+ },
+ cleanup: function () {
+ gScrollable64.style.overflow = "auto";
+ },
+ expected: {
+ x: null, y: gScrollable64
+ }
+ },
+ { description: "Should be computed from nearest scrollable element even if it hides overflow content (X), 64",
+ target: gScrollable64,
+ event: {
+ deltaMode: WheelEvent.DOM_DELTA_LINE,
+ deltaX: 1.0, deltaY: 0.0, lineOrPageDeltaX: 1, lineOrPageDeltaY: 0 },
+ prepare: function () {
+ gScrollable64.style.overflowX = "hidden";
+ gScrollable96.scrollLeft = 0;
+ gScrollable96.scrollTop = 0;
+ gScrollable64.scrollLeft = 0;
+ gScrollable64.scrollTop = 0;
+ },
+ cleanup: function () {
+ gScrollable64.style.overflow = "auto";
+ },
+ expected: {
+ x: gScrollable64, y: null
+ }
+ },
+ { description: "Should be computed from nearest scrollable element even if it hides overflow content (Y), 64",
+ target: gScrollable64,
+ event: {
+ deltaMode: WheelEvent.DOM_DELTA_LINE,
+ deltaX: 1.0, deltaY: 0.0, lineOrPageDeltaX: 1, lineOrPageDeltaY: 0 },
+ prepare: function () {
+ gScrollable64.style.overflowY = "hidden";
+ gScrollable96.scrollLeft = 0;
+ gScrollable96.scrollTop = 0;
+ gScrollable64.scrollLeft = 0;
+ gScrollable64.scrollTop = 0;
+ },
+ cleanup: function () {
+ gScrollable64.style.overflow = "auto";
+ },
+ expected: {
+ x: gScrollable64, y: null
+ }
+ },
+ ];
+
+ var currentTest, description, firedX, firedY;
+ var expectedHandlerCalls;
+
+ function handler(aEvent)
+ {
+ aEvent.preventDefault();
+
+ if (aEvent.axis != MouseScrollEvent.HORIZONTAL_AXIS &&
+ aEvent.axis != MouseScrollEvent.VERTICAL_AXIS) {
+ ok(false,
+ description + "The event had invalid axis (" + aEvent.axis + ")");
+ if (--expectedHandlerCalls == 0) {
+ setTimeout(runTest, 0);
+ }
+ return;
+ }
+
+ var isHorizontal = (aEvent.axis == MouseScrollEvent.HORIZONTAL_AXIS);
+ if ((isHorizontal && !currentTest.expected.x) ||
+ (!isHorizontal && !currentTest.expected.y)) {
+ ok(false,
+ description + "The event fired unexpectedly (" +
+ (isHorizontal ? "Horizontal" : "Vertical") + ")");
+ if (--expectedHandlerCalls == 0) {
+ setTimeout(runTest, 0);
+ }
+ return;
+ }
+
+ if (isHorizontal) {
+ firedX = true;
+ } else {
+ firedY = true;
+ }
+
+ var expectedDetail =
+ (currentTest.event.deltaMode == WheelEvent.DOM_DELTA_LINE) ?
+ (isHorizontal ? currentTest.expected.x.wheelHorizontalLine :
+ currentTest.expected.y.wheelLineHeight) :
+ (isHorizontal ? currentTest.expected.x.wheelPageWidth :
+ currentTest.expected.y.wheelPageHeight);
+ is(Math.abs(aEvent.detail), expectedDetail,
+ description + ((isHorizontal) ? "horizontal" : "vertical") + " event detail is wrong");
+
+ if (--expectedHandlerCalls == 0) {
+ setTimeout(runTest, 0);
+ }
+ }
+
+ window.addEventListener("MozMousePixelScroll", handler, true);
+
+ for (var i = 0; i < kTests.length; i++) {
+ currentTest = kTests[i];
+ description = "doTests, " + currentTest.description + " (deltaMode: " +
+ (currentTest.event.deltaMode == WheelEvent.DOM_DELTA_LINE ?
+ "DOM_DELTA_LINE" : "DOM_DELTA_PAGE") +
+ ", deltaX: " + currentTest.event.deltaX +
+ ", deltaY: " + currentTest.event.deltaY + "): ";
+ currentTest.prepare();
+ firedX = firedY = false;
+ expectedHandlerCalls = (currentTest.expected.x ? 1 : 0)
+ + (currentTest.expected.y ? 1 : 0);
+ yield synthesizeWheel(currentTest.target, 10, 10, currentTest.event);
+ if (currentTest.expected.x) {
+ ok(firedX, description + "Horizontal MozMousePixelScroll event wasn't fired");
+ }
+ if (currentTest.expected.y) {
+ ok(firedY, description + "Vertical MozMousePixelScroll event wasn't fired");
+ }
+ currentTest.cleanup();
+ }
+
+ window.removeEventListener("MozMousePixelScroll", handler, true);
+}
+
+function* testBody()
+{
+ yield* prepareScrollUnits();
+ yield* doTests();
+}
+
+var gTestContinuation = null;
+
+function runTest()
+{
+ if (!gTestContinuation) {
+ gTestContinuation = testBody();
+ }
+ var ret = gTestContinuation.next();
+ if (ret.done) {
+ SimpleTest.finish();
+ }
+}
+
+function startTest() {
+ SpecialPowers.pushPrefEnv({"set": [["mousewheel.default.delta_multiplier_x", 100],
+ ["mousewheel.default.delta_multiplier_y", 100],
+ ["mousewheel.default.delta_multiplier_z", 100],
+ ["mousewheel.with_alt.delta_multiplier_x", 100],
+ ["mousewheel.with_alt.delta_multiplier_y", 100],
+ ["mousewheel.with_alt.delta_multiplier_z", 100],
+ ["mousewheel.with_control.delta_multiplier_x", 100],
+ ["mousewheel.with_control.delta_multiplier_y", 100],
+ ["mousewheel.with_control.delta_multiplier_z", 100],
+ ["mousewheel.with_meta.delta_multiplier_x", 100],
+ ["mousewheel.with_meta.delta_multiplier_y", 100],
+ ["mousewheel.with_meta.delta_multiplier_z", 100],
+ ["mousewheel.with_shift.delta_multiplier_x", 100],
+ ["mousewheel.with_shift.delta_multiplier_y", 100],
+ ["mousewheel.with_shift.delta_multiplier_z", 100],
+ ["mousewheel.with_win.delta_multiplier_x", 100],
+ ["mousewheel.with_win.delta_multiplier_y", 100],
+ ["mousewheel.with_win.delta_multiplier_z", 100],
+ // If APZ is enabled we should ensure the preventDefault calls work even
+ // if the test is running slowly.
+ ["apz.content_response_timeout", 2000],
+ ]}, runTest);
+}
+
+</script>
+</pre>
+</body>
+</html>