diff options
author | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-07 19:33:14 +0000 |
---|---|---|
committer | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-07 19:33:14 +0000 |
commit | 36d22d82aa202bb199967e9512281e9a53db42c9 (patch) | |
tree | 105e8c98ddea1c1e4784a60a5a6410fa416be2de /dom/tests/mochitest/bugs/test_resize_move_windows.html | |
parent | Initial commit. (diff) | |
download | firefox-esr-36d22d82aa202bb199967e9512281e9a53db42c9.tar.xz firefox-esr-36d22d82aa202bb199967e9512281e9a53db42c9.zip |
Adding upstream version 115.7.0esr.upstream/115.7.0esrupstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to '')
-rw-r--r-- | dom/tests/mochitest/bugs/test_resize_move_windows.html | 349 |
1 files changed, 349 insertions, 0 deletions
diff --git a/dom/tests/mochitest/bugs/test_resize_move_windows.html b/dom/tests/mochitest/bugs/test_resize_move_windows.html new file mode 100644 index 0000000000..11b2d90f21 --- /dev/null +++ b/dom/tests/mochitest/bugs/test_resize_move_windows.html @@ -0,0 +1,349 @@ +<!DOCTYPE HTML> +<html> +<!-- +https://bugzilla.mozilla.org/show_bug.cgi?id=565541 +--> +<head> + <title>Test for Bug 565541</title> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/> +</head> +<body> +<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=565541">Mozilla Bug 565541</a> +<p id="display"></p> +<div id="content" style="display: none"> + +</div> +<pre id="test"> +<script> + +/** Test for Bug 565541 **/ + +SimpleTest.waitForExplicitFinish(); + +var previousX, previousY, previousWidth, previousHeight; + +["innerWidth", "innerHeight", "screenX", "screenY", "outerWidth", + "outerHeight"].map(function(name) { + window[name+"Getter"] = Object.getOwnPropertyDescriptor(window, name).get; +}); + +function backValues() +{ + previousX = window.screenX; + previousY = window.screenY; + previousWidth = window.outerWidth; + previousHeight = window.outerHeight; +} + +function restoreValues() +{ + window.moveTo(previousX, previousY); + window.resizeTo(previousWidth, previousHeight); +} + +function getNewWidth(aWindow) +{ + return (aWindow.innerWidth > (screen.width / 2)) ? 100 : screen.width; +} + +function getNewHeight(aWindow) +{ + return (aWindow.innerHeight > (screen.height / 2)) ? 100 : screen.height; +} + +function getNewX(aWindow) +{ + return (aWindow.screenX > ((screen.width - aWindow.outerWidth) / 2)) + ? 0 : screen.width - aWindow.outerWidth; +} + +function getNewY(aWindow) +{ + return (aWindow.screenY > ((screen.height - aWindow.outerHeight) / 2)) + ? 0 : screen.height - aWindow.outerHeight; +} + +/** + * hitEventLoop is called when we want to check something but we can't rely on + * an event or a specific number of event loop hiting. + * This method can be called by specifying a condition, a test (using SimpleTest + * API), how many times the event loop has to be hit and what to call next. + * If times < 0, the event loop will be hit as long as the condition isn't + * true or the test doesn't time out. + */ +function hitEventLoop(condition, test, times) { + return new Promise(function(resolve, reject) { + function doMagic() { + if (condition() || times == 0) { + test(); + resolve(); + return; + } + + times--; + setTimeout(doMagic, 0); + } + + doMagic(); + }); +} + +function checkChangeIsDisabled(aWindow) { + // We want to check that nothing has changed. Having a high value would take + // too much time. Worse thing that could happen is random green. + var hits = 5; + + function getProp(propName) { + return window[propName + "Getter"].call(aWindow); + } + + var originalWidth = getProp("innerWidth"); + var originalHeight = getProp("innerHeight"); + + var originalX = getProp("screenX"); + var originalY = getProp("screenY"); + + var oWidth = getProp("outerWidth"); + var oHeight = getProp("outerHeight"); + + function changeCondition() { + return aWindow.innerWidth != originalWidth || + aWindow.innerHeight != originalHeight || + aWindow.screenX != originalX || aWindow.screenY != originalY || + aWindow.outerWidth != oWidth || aWindow.outerHeight != oHeight; + } + + function changeTest() { + is(getProp("innerWidth"), originalWidth, + "Window width shouldn't have changed"); + is(getProp("innerHeight"), originalHeight, + "Window height shouldn't have changed"); + is(getProp("screenX"), originalX, + "Window x position shouldn't have changed"); + is(getProp("screenY"), originalY, + "Window y position shouldn't have changed"); + is(getProp("outerWidth"), oWidth, + "Window outerWidth shouldn't have changed"); + is(getProp("outerHeight"), oHeight, + "Window outerHeight shouldn't have changed"); + } + + /** + * Size changes. + */ + var newWidth = getNewWidth(aWindow); + var newHeight = getNewHeight(aWindow); + + aWindow.resizeTo(newWidth, newHeight); + + aWindow.resizeBy(newWidth - aWindow.innerWidth, + newHeight - aWindow.innerHeight); + + aWindow.sizeToContent(); + + /** + * Position checks. + */ + var newX = getNewX(aWindow); + var newY = getNewY(aWindow); + + aWindow.moveTo(newX, newY); + + aWindow.moveBy(newX - aWindow.screenX, + newY - aWindow.screenY); + + /** + * Outer width/height checks. + */ + aWindow.resizeTo(aWindow.outerWidth * 2, aWindow.outerHeight * 2); + + // We did a lot of changes. Now, we are going to wait and see if something + // happens. + // NOTE: if this happens to fail, you will have to check manually which + // operation has been accepted. + return hitEventLoop(changeCondition, changeTest, hits); +} + +function checkChangeIsEnabled(aWindow, aNext) +{ + info(`checkChangeIsEnabled start`); + // Something should happen. We are not going to go to the next test until + // it does. + var hits = -1; + + var prevWidth; + var prevHeight; + + var prevX; + var prevY; + + var oWidth; + var oHeight; + + function sizeChangeCondition() { + return aWindow.outerWidth != prevWidth && aWindow.outerHeight != prevHeight; + } + + function sizeChangeTest() { + isnot(aWindow.outerWidth, prevWidth, "Window width should have changed"); + isnot(aWindow.outerHeight, prevHeight, "Window height should have changed"); + + prevWidth = aWindow.outerWidth; + prevHeight = aWindow.outerHeight; + } + + function posChangeCondition() { + // With GTK, sometimes, only one dimension changes. + if (navigator.platform.includes('Linux')) { + return aWindow.screenX != prevX || aWindow.screenY != prevY; + } + return aWindow.screenX != prevX && aWindow.screenY != prevY; + } + + function posChangeTest() { + // With GTK, sometimes, only one dimension changes. + if (navigator.platform.includes('Linux')) { + // With GTK, sometimes, aWindow.screenX changes during two calls. + // So we call it once and save the returned value. + var x = aWindow.screenX; + var y = aWindow.screenY; + if (x != prevX) { + isnot(x, prevX, "Window x position should have changed"); + } + if (y != prevY) { + isnot(y, prevY, "Window y position should have changed"); + } + } else { + isnot(aWindow.screenX, prevX, "Window x position should have changed"); + isnot(aWindow.screenY, prevY, "Window y position should have changed"); + } + + prevX = aWindow.screenX; + prevY = aWindow.screenY; + } + + function outerChangeCondition() { + return aWindow.outerWidth != oWidth && aWindow.outerHeight != oHeight; + } + + function outerChangeTest() { + isnot(aWindow.outerWidth, oWidth, "Window outerWidth should have changed"); + isnot(aWindow.outerHeight, oHeight, "Window outerHeight should have changed"); + } + + /** + * Size checks. + */ + prevWidth = aWindow.outerWidth; + prevHeight = aWindow.outerHeight; + + aWindow.resizeTo(getNewWidth(aWindow), getNewHeight(aWindow)); + hitEventLoop(sizeChangeCondition, sizeChangeTest, hits) + .then(function() { + aWindow.resizeTo(getNewWidth(aWindow), getNewHeight(aWindow)); + return hitEventLoop(sizeChangeCondition, sizeChangeTest, hits); + }) + .then(function () { + aWindow.resizeBy(getNewWidth(aWindow) - aWindow.innerWidth, + getNewHeight(aWindow) - aWindow.innerHeight); + return hitEventLoop(sizeChangeCondition, sizeChangeTest, hits); + }) + .then(function() { + aWindow.sizeToContent(); + return hitEventLoop(sizeChangeCondition, sizeChangeTest, hits); + }) + .then(function() { + /** + * Position checks. + */ + prevX = aWindow.screenX; + prevY = aWindow.screenY; + + aWindow.moveTo(getNewX(aWindow), getNewY(aWindow)); + return hitEventLoop(posChangeCondition, posChangeTest, hits); + }) + .then(function() { + prevX = aWindow.screenX; + prevY = aWindow.screenY; + + aWindow.moveBy(getNewX(aWindow) - aWindow.screenX, + getNewY(aWindow) - aWindow.screenY); + return hitEventLoop(posChangeCondition, posChangeTest, hits); + }) + .then(function() { + /** + * Outer width/height checks. + */ + oWidth = aWindow.outerWidth; + oHeight = aWindow.outerHeight; + + aWindow.resizeTo(oWidth * 2, oHeight * 2); + return hitEventLoop(outerChangeCondition, outerChangeTest, hits); + }) + .then(function() { + let origWidth = oWidth; + let origHeight = oHeight; + + oWidth = aWindow.outerWidth; + oHeight = aWindow.outerHeight; + + aWindow.resizeTo(origWidth, origHeight); + return hitEventLoop(outerChangeCondition, outerChangeTest, hits); + }) + .then(aNext); +} + +SpecialPowers.pushPrefEnv({ + "set": [["dom.disable_window_move_resize", false]]}, + function() { +SimpleTest.waitForFocus(function() { + if (screen.width <= 200 || screen.height <= 200) { + todo(false, "The screen needs to be bigger than 200px*200px to run this test."); + SimpleTest.finish(); + return; + } + + backValues(); + + // The current window can't change it's own size and position. + checkChangeIsDisabled(window).then(function() { + info(`Change was disabled`); + // We create a window and check that it can change its own size and position. + // However, passing size/position parameters to window.open should work. + var w = window.open("file_resize_move_windows_1.html", '', + 'width=170,height=170,screenX=65,screenY=65'); + + SimpleTest.waitForFocus(function() { + w.check(function() { + // The current window can change the size and position of the created one. + checkChangeIsEnabled(w, function() { + w.close(); + + // If we call window.open with an empty string as a third parameter, + // by default, it will create a new tab instead of a new window. + // In that case, we shouldn't allow the caller to change the size/position. + w = window.open("file_resize_move_windows_2.html", '', ''); + SimpleTest.waitForFocus(function() { + w.check(function() { + + // The current window can't change the size and position of the new tab. + checkChangeIsDisabled(w).then(function() { + w.close(); + + restoreValues(); + SimpleTest.finish(); + }); + }); + }, w, false); + }); + }) + }, w, false); + }); +}); +}); // SpecialPowers.pushPrefEnv() + +</script> +</pre> +</body> +</html> |