diff options
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.html | 1363 |
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> |