From dd45ad246a96826360e1a0e70c7a4b6007a1278b Mon Sep 17 00:00:00 2001 From: Andreas Tolfsen Date: Thu, 23 Feb 2017 14:12:29 +0000 Subject: [PATCH] Bug 1340775 - Allow window position to be set to negative coordinates. r=maja_zf, a=test-only It should be possible to set a window's position to a pair of negative coordinates, since the user may move the window off-screen. The window may also be situated off-screen by default: for example a maximised window on Windows will report window.screenX to be -8px. Relevant change to the specification: https://github.com/w3c/webdriver/pull/805 MozReview-Commit-ID: FdReDi8pLL0 --HG-- extra : source : 78b008fb7d12ac75b2ad06d06ab65e6bc4ae8bb5 extra : intermediate-source : e0563eeab4043e203614bd505773b2396e4a2e30 --- testing/marionette/driver.js | 4 +- .../tests/unit/test_window_position.py | 60 +++++++++++++++++-- 2 files changed, 56 insertions(+), 8 deletions(-) diff --git a/testing/marionette/driver.js b/testing/marionette/driver.js index 53af7ba2e9f31..8008672973c31 100644 --- a/testing/marionette/driver.js +++ b/testing/marionette/driver.js @@ -1251,8 +1251,8 @@ GeckoDriver.prototype.setWindowPosition = function* (cmd, resp) { assert.firefox() let {x, y} = cmd.parameters; - assert.positiveInteger(x); - assert.positiveInteger(y); + assert.integer(x); + assert.integer(y); let win = this.getCurrentWindow(); let orig = {screenX: win.screenX, screenY: win.screenY}; diff --git a/testing/marionette/harness/marionette_harness/tests/unit/test_window_position.py b/testing/marionette/harness/marionette_harness/tests/unit/test_window_position.py index e8e7a8d461438..48bbaf9517e2e 100644 --- a/testing/marionette/harness/marionette_harness/tests/unit/test_window_position.py +++ b/testing/marionette/harness/marionette_harness/tests/unit/test_window_position.py @@ -8,6 +8,16 @@ class TestWindowPosition(MarionetteTestCase): + + def setUp(self): + MarionetteTestCase.setUp(self) + self.original_position = self.marionette.get_window_position() + + def tearDown(self): + x, y = self.original_position["x"], self.original_position["y"] + self.marionette.set_window_position(x, y) + MarionetteTestCase.tearDown(self) + def test_get_types(self): position = self.marionette.get_window_position() self.assertIsInstance(position["x"], int) @@ -19,12 +29,6 @@ def test_set_types(self): with self.assertRaises(InvalidArgumentException): self.marionette.set_window_position(x, y) - def test_out_of_bounds_arguments(self): - for x, y in [(-1,0), (0,-1), (-1,-1)]: - print("testing out of bounds position ({},{})".format(x, y)) - with self.assertRaises(InvalidArgumentException): - self.marionette.set_window_position(x, y) - def test_move_to_new_position(self): old_position = self.marionette.get_window_position() new_position = {"x": old_position["x"] + 10, "y": old_position["y"] + 10} @@ -38,3 +42,47 @@ def test_move_to_existing_position(self): new_position = self.marionette.get_window_position() self.assertEqual(old_position["x"], new_position["x"]) self.assertEqual(old_position["y"], new_position["y"]) + + def test_move_to_negative_coordinates(self): + print("Current position: {}".format( + self.marionette.get_window_position())) + self.marionette.set_window_position(-8, -8) + position = self.marionette.get_window_position() + print("Position after requesting move to negative coordinates: {}".format(position)) + + # Different systems will report more or less than (-8,-8) + # depending on the characteristics of the window manager, since + # the screenX/screenY position measures the chrome boundaries, + # including any WM decorations. + # + # This makes this hard to reliably test across different + # environments. Generally we are happy when calling + # marionette.set_window_position with negative coordinates does + # not throw. + # + # Because we have to cater to an unknown set of environments, + # the following assertions are the most common denominator that + # make this test pass, irregardless of system characteristics. + + os = self.marionette.session_capabilities["platformName"] + + # Certain WMs prohibit windows from being moved off-screen, + # but we don't have this information. It should be safe to + # assume a window can be moved to (0,0) or less. + if os == "linux": + # certain WMs prohibit windows from being moved off-screen + self.assertLessEqual(position["x"], 0) + self.assertLessEqual(position["y"], 0) + + # On macOS, windows can only be moved off the screen on the + # horizontal axis. The system menu bar also blocks windows from + # being moved to (0,0). + elif os == "darwin": + self.assertEqual(-8, position["x"]) + self.assertEqual(23, position["y"]) + + # It turns out that Windows is the only platform on which the + # window can be reliably positioned off-screen. + elif os == "windows_nt": + self.assertEqual(-8, position["x"]) + self.assertEqual(-8, position["y"])