yukijoou/kwin
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
kwin/autotests/integration/outputchanges_test.cpp

735 lines
29 KiB
C++
Raw Normal View History

autotests: Replace output management test with a more useful test The output management test checks the implementation of output management capabilities in the virtual backend, which is not helpful. This change replaces it with a more useful test that verifies how windows are placed after an output change.
2021-12-10 10:22:19 +00:00
/*
SPDX-FileCopyrightText: 2021 Vlad Zahorodnii <vlad.zahorodnii@kde.org>
SPDX-License-Identifier: GPL-2.0-or-later
*/
#include "kwin_wayland_test.h"
Move multi-purpose code in its own directory Things such as Output, InputDevice and so on are made to be multi-purpose. In order to make this separation more clear, this change moves that code in the core directory. Some things still link to the abstraction level above (kwin), they can be tackled in future refactors. Ideally code in core/ should depend either on other code in core/ or system libs.
2022-08-29 07:55:49 +00:00
#include "core/output.h"
core: Rename Platform to OutputBackend
2022-11-05 10:43:41 +00:00
#include "core/outputbackend.h"
Move multi-purpose code in its own directory Things such as Output, InputDevice and so on are made to be multi-purpose. In order to make this separation more clear, this change moves that code in the core directory. Some things still link to the abstraction level above (kwin), they can be tackled in future refactors. Ideally code in core/ should depend either on other code in core/ or system libs.
2022-08-29 07:55:49 +00:00
#include "core/outputconfiguration.h"
Port away from Cursor::setPos() Use input device specific apis to change the position of the cursor. The main reason to do so is to break the assumption that Cursor position is the same as pointer position, which I would like to rely on later to merge tablet and pointer cursors.
2023-02-09 13:07:56 +00:00
#include "pointer_input.h"
autotests: Replace output management test with a more useful test The output management test checks the implementation of output management capabilities in the virtual backend, which is not helpful. This change replaces it with a more useful test that verifies how windows are placed after an output change.
2021-12-10 10:22:19 +00:00
#include "wayland_server.h"
Rename AbstractClient to Window
2022-04-22 17:39:12 +00:00
#include "window.h"
autotests: Replace output management test with a more useful test The output management test checks the implementation of output management capabilities in the virtual backend, which is not helpful. This change replaces it with a more useful test that verifies how windows are placed after an output change.
2021-12-10 10:22:19 +00:00
#include "workspace.h"
#include <KWayland/Client/surface.h>
handle laptop lid closing in KWin Instead of KScreen turning the display off, do that in KWin directly
2023-05-08 08:48:30 +00:00
using namespace std::chrono_literals;
autotests: Replace output management test with a more useful test The output management test checks the implementation of output management capabilities in the virtual backend, which is not helpful. This change replaces it with a more useful test that verifies how windows are placed after an output change.
2021-12-10 10:22:19 +00:00
namespace KWin
{
static const QString s_socketName = QStringLiteral("wayland_test_output_changes-0");
class OutputChangesTest : public QObject
{
Q_OBJECT
private Q_SLOTS:
void initTestCase();
void init();
void cleanup();
void testWindowSticksToOutputAfterOutputIsDisabled();
void testWindowSticksToOutputAfterAnotherOutputIsDisabled();
void testWindowSticksToOutputAfterOutputIsMoved();
autotests: Add more test cases in OutputChangesTest It adds more test cases in OutputChangesTest, particularly swapping outputs. Swapping outputs is an interesting case because outputs can temporarily overlap so workspace()->outputAt() can return wrong output and the window is going to stick to wrong output.
2022-09-13 07:43:17 +00:00
void testWindowSticksToOutputAfterOutputsAreSwappedLeftToRight();
void testWindowSticksToOutputAfterOutputsAreSwappedRightToLeft();
autotests: Add basic test cases for testing placement tracker
2022-09-13 08:13:37 +00:00
void testWindowRestoredAfterEnablingOutput();
autotests: Extend OutputChangesTest with more cases This change extends the OutputChangesTest so it also covers the cases where a maximized and a fullscreen window is moved back to its original output when it's hotplugged.
2022-10-04 09:40:54 +00:00
void testMaximizedWindowRestoredAfterEnablingOutput();
void testFullScreenWindowRestoredAfterEnablingOutput();
autotests/integration: add more cases to OutputChangesTest
2022-11-01 13:39:23 +00:00
void testWindowRestoredAfterChangingScale();
void testMaximizeStateRestoredAfterEnablingOutput();
autotests/integration/outputchanges: add geometry restore test
2023-11-06 14:01:44 +00:00
void testInvalidGeometryRestoreAfterEnablingOutput();
autotests: Add basic test cases for testing placement tracker
2022-09-13 08:13:37 +00:00
void testWindowNotRestoredAfterMovingWindowAndEnablingOutput();
handle laptop lid closing in KWin Instead of KScreen turning the display off, do that in KWin directly
2023-05-08 08:48:30 +00:00
void testLaptopLidClosed();
autotests: Replace output management test with a more useful test The output management test checks the implementation of output management capabilities in the virtual backend, which is not helpful. This change replaces it with a more useful test that verifies how windows are placed after an output change.
2021-12-10 10:22:19 +00:00
};
void OutputChangesTest::initTestCase()
{
Rename AbstractClient to Window
2022-04-22 17:39:12 +00:00
qRegisterMetaType<Window *>();
autotests: Replace output management test with a more useful test The output management test checks the implementation of output management capabilities in the virtual backend, which is not helpful. This change replaces it with a more useful test that verifies how windows are placed after an output change.
2021-12-10 10:22:19 +00:00
QSignalSpy applicationStartedSpy(kwinApp(), &Application::started);
QVERIFY(waylandServer()->init(s_socketName));
autotests: directly call setVirtualOutputs
2023-05-08 10:16:00 +00:00
Test::setOutputConfig({
QRect(0, 0, 1280, 1024),
QRect(1280, 0, 1280, 1024),
});
autotests: Replace output management test with a more useful test The output management test checks the implementation of output management capabilities in the virtual backend, which is not helpful. This change replaces it with a more useful test that verifies how windows are placed after an output change.
2021-12-10 10:22:19 +00:00
kwinApp()->start();
QVERIFY(applicationStartedSpy.wait());
Make Workspace track managed outputs This change adjusts the window management abstractions in kwin for the drm backend providing more than just "desktop" outputs. Besides that, it has other potential benefits - for example, the Workspace could start managing allocation of the placeholder output by itself, thus leading to some simplifications in the drm backend. Another is that it lets us move wayland code from the drm backend.
2022-07-11 10:41:15 +00:00
const auto outputs = workspace()->outputs();
autotests: Replace output management test with a more useful test The output management test checks the implementation of output management capabilities in the virtual backend, which is not helpful. This change replaces it with a more useful test that verifies how windows are placed after an output change.
2021-12-10 10:22:19 +00:00
QCOMPARE(outputs.count(), 2);
QCOMPARE(outputs[0]->geometry(), QRect(0, 0, 1280, 1024));
QCOMPARE(outputs[1]->geometry(), QRect(1280, 0, 1280, 1024));
}
void OutputChangesTest::init()
{
autotests: directly call setVirtualOutputs
2023-05-08 10:16:00 +00:00
Test::setOutputConfig({
QRect(0, 0, 1280, 1024),
QRect(1280, 0, 1280, 1024),
});
autotests: Replace output management test with a more useful test The output management test checks the implementation of output management capabilities in the virtual backend, which is not helpful. This change replaces it with a more useful test that verifies how windows are placed after an output change.
2021-12-10 10:22:19 +00:00
QVERIFY(Test::setupWaylandConnection());
workspace()->setActiveOutput(QPoint(640, 512));
Port away from Cursor::setPos() Use input device specific apis to change the position of the cursor. The main reason to do so is to break the assumption that Cursor position is the same as pointer position, which I would like to rely on later to merge tablet and pointer cursors.
2023-02-09 13:07:56 +00:00
input()->pointer()->warp(QPoint(640, 512));
autotests: Replace output management test with a more useful test The output management test checks the implementation of output management capabilities in the virtual backend, which is not helpful. This change replaces it with a more useful test that verifies how windows are placed after an output change.
2021-12-10 10:22:19 +00:00
}
void OutputChangesTest::cleanup()
{
Test::destroyWaylandConnection();
}
void OutputChangesTest::testWindowSticksToOutputAfterOutputIsDisabled()
{
core: Rename Platform to OutputBackend
2022-11-05 10:43:41 +00:00
auto outputs = kwinApp()->outputBackend()->outputs();
autotests: Replace output management test with a more useful test The output management test checks the implementation of output management capabilities in the virtual backend, which is not helpful. This change replaces it with a more useful test that verifies how windows are placed after an output change.
2021-12-10 10:22:19 +00:00
// Create a window.
replace all uses of QScopedPointer with std::unique_ptr
2022-08-01 21:29:02 +00:00
std::unique_ptr<KWayland::Client::Surface> surface(Test::createSurface());
std::unique_ptr<Test::XdgToplevel> shellSurface(Test::createXdgToplevelSurface(surface.get()));
auto window = Test::renderAndWaitForShown(surface.get(), QSize(100, 50), Qt::blue);
autotests: client -> window
2022-04-23 19:51:16 +00:00
QVERIFY(window);
autotests: Replace output management test with a more useful test The output management test checks the implementation of output management capabilities in the virtual backend, which is not helpful. This change replaces it with a more useful test that verifies how windows are placed after an output change.
2021-12-10 10:22:19 +00:00
// Move the window to some predefined position so the test is more robust.
autotests: client -> window
2022-04-23 19:51:16 +00:00
window->move(QPoint(42, 67));
QCOMPARE(window->frameGeometry(), QRect(42, 67, 100, 50));
autotests: Replace output management test with a more useful test The output management test checks the implementation of output management capabilities in the virtual backend, which is not helpful. This change replaces it with a more useful test that verifies how windows are placed after an output change.
2021-12-10 10:22:19 +00:00
// Disable the output where the window is on.
Rename WaylandOutputConfig to OutputConfiguration
2022-04-14 10:51:20 +00:00
OutputConfiguration config;
autotests: Replace output management test with a more useful test The output management test checks the implementation of output management capabilities in the virtual backend, which is not helpful. This change replaces it with a more useful test that verifies how windows are placed after an output change.
2021-12-10 10:22:19 +00:00
{
Merge AbstractWaylandOutput with AbstractOutput
2022-04-14 08:32:51 +00:00
auto changeSet = config.changeSet(outputs[0]);
autotests: Replace output management test with a more useful test The output management test checks the implementation of output management capabilities in the virtual backend, which is not helpful. This change replaces it with a more useful test that verifies how windows are placed after an output change.
2021-12-10 10:22:19 +00:00
changeSet->enabled = false;
}
Make Workspace process batched output updates Currently the Workspace processes output updates as they occur, e.g. when the drm backend scans connectors, the Workspace will handle hotplugged outputs one by one or if an output configuration changes the mode of several outputs, the workspace will process output layout updates one by one instead of handling it in one pass. The main reason for the current behavior is simplicity. However, that can create issues because it's possible that the output layout will be temporarily in degenerate state and features such as sticking windows to their outputs will be broken. In order to fix that, this change makes the Workspace process batched output updates. There are several challenges - disconnected outputs have to be alive when the outputsQueried signal is emitted, the workspace needs to determine what outputs have been added or removed on its own.
2022-09-05 07:31:57 +00:00
workspace()->applyOutputConfiguration(config);
autotests: Replace output management test with a more useful test The output management test checks the implementation of output management capabilities in the virtual backend, which is not helpful. This change replaces it with a more useful test that verifies how windows are placed after an output change.
2021-12-10 10:22:19 +00:00
// The window will be sent to the second output, which is at (1280, 0).
autotests: client -> window
2022-04-23 19:51:16 +00:00
QCOMPARE(window->frameGeometry(), QRect(1280 + 42, 0 + 67, 100, 50));
autotests: Replace output management test with a more useful test The output management test checks the implementation of output management capabilities in the virtual backend, which is not helpful. This change replaces it with a more useful test that verifies how windows are placed after an output change.
2021-12-10 10:22:19 +00:00
}
void OutputChangesTest::testWindowSticksToOutputAfterAnotherOutputIsDisabled()
{
core: Rename Platform to OutputBackend
2022-11-05 10:43:41 +00:00
auto outputs = kwinApp()->outputBackend()->outputs();
autotests: Replace output management test with a more useful test The output management test checks the implementation of output management capabilities in the virtual backend, which is not helpful. This change replaces it with a more useful test that verifies how windows are placed after an output change.
2021-12-10 10:22:19 +00:00
// Create a window.
replace all uses of QScopedPointer with std::unique_ptr
2022-08-01 21:29:02 +00:00
std::unique_ptr<KWayland::Client::Surface> surface(Test::createSurface());
std::unique_ptr<Test::XdgToplevel> shellSurface(Test::createXdgToplevelSurface(surface.get()));
auto window = Test::renderAndWaitForShown(surface.get(), QSize(100, 50), Qt::blue);
autotests: client -> window
2022-04-23 19:51:16 +00:00
QVERIFY(window);
autotests: Replace output management test with a more useful test The output management test checks the implementation of output management capabilities in the virtual backend, which is not helpful. This change replaces it with a more useful test that verifies how windows are placed after an output change.
2021-12-10 10:22:19 +00:00
// Move the window to the second output.
autotests: client -> window
2022-04-23 19:51:16 +00:00
window->move(QPoint(1280 + 42, 67));
QCOMPARE(window->frameGeometry(), QRect(1280 + 42, 67, 100, 50));
autotests: Replace output management test with a more useful test The output management test checks the implementation of output management capabilities in the virtual backend, which is not helpful. This change replaces it with a more useful test that verifies how windows are placed after an output change.
2021-12-10 10:22:19 +00:00
// Disable the first output.
Rename WaylandOutputConfig to OutputConfiguration
2022-04-14 10:51:20 +00:00
OutputConfiguration config;
autotests: Replace output management test with a more useful test The output management test checks the implementation of output management capabilities in the virtual backend, which is not helpful. This change replaces it with a more useful test that verifies how windows are placed after an output change.
2021-12-10 10:22:19 +00:00
{
Merge AbstractWaylandOutput with AbstractOutput
2022-04-14 08:32:51 +00:00
auto changeSet = config.changeSet(outputs[0]);
autotests: Replace output management test with a more useful test The output management test checks the implementation of output management capabilities in the virtual backend, which is not helpful. This change replaces it with a more useful test that verifies how windows are placed after an output change.
2021-12-10 10:22:19 +00:00
changeSet->enabled = false;
}
{
Merge AbstractWaylandOutput with AbstractOutput
2022-04-14 08:32:51 +00:00
auto changeSet = config.changeSet(outputs[1]);
autotests: Replace output management test with a more useful test The output management test checks the implementation of output management capabilities in the virtual backend, which is not helpful. This change replaces it with a more useful test that verifies how windows are placed after an output change.
2021-12-10 10:22:19 +00:00
changeSet->pos = QPoint(0, 0);
}
Make Workspace process batched output updates Currently the Workspace processes output updates as they occur, e.g. when the drm backend scans connectors, the Workspace will handle hotplugged outputs one by one or if an output configuration changes the mode of several outputs, the workspace will process output layout updates one by one instead of handling it in one pass. The main reason for the current behavior is simplicity. However, that can create issues because it's possible that the output layout will be temporarily in degenerate state and features such as sticking windows to their outputs will be broken. In order to fix that, this change makes the Workspace process batched output updates. There are several challenges - disconnected outputs have to be alive when the outputsQueried signal is emitted, the workspace needs to determine what outputs have been added or removed on its own.
2022-09-05 07:31:57 +00:00
workspace()->applyOutputConfiguration(config);
autotests: Replace output management test with a more useful test The output management test checks the implementation of output management capabilities in the virtual backend, which is not helpful. This change replaces it with a more useful test that verifies how windows are placed after an output change.
2021-12-10 10:22:19 +00:00
// The position of the window relative to its output should remain the same.
autotests: client -> window
2022-04-23 19:51:16 +00:00
QCOMPARE(window->frameGeometry(), QRect(42, 67, 100, 50));
autotests: Replace output management test with a more useful test The output management test checks the implementation of output management capabilities in the virtual backend, which is not helpful. This change replaces it with a more useful test that verifies how windows are placed after an output change.
2021-12-10 10:22:19 +00:00
}
void OutputChangesTest::testWindowSticksToOutputAfterOutputIsMoved()
{
core: Rename Platform to OutputBackend
2022-11-05 10:43:41 +00:00
auto outputs = kwinApp()->outputBackend()->outputs();
autotests: Replace output management test with a more useful test The output management test checks the implementation of output management capabilities in the virtual backend, which is not helpful. This change replaces it with a more useful test that verifies how windows are placed after an output change.
2021-12-10 10:22:19 +00:00
// Create a window.
replace all uses of QScopedPointer with std::unique_ptr
2022-08-01 21:29:02 +00:00
std::unique_ptr<KWayland::Client::Surface> surface(Test::createSurface());
std::unique_ptr<Test::XdgToplevel> shellSurface(Test::createXdgToplevelSurface(surface.get()));
auto window = Test::renderAndWaitForShown(surface.get(), QSize(100, 50), Qt::blue);
autotests: client -> window
2022-04-23 19:51:16 +00:00
QVERIFY(window);
autotests: Replace output management test with a more useful test The output management test checks the implementation of output management capabilities in the virtual backend, which is not helpful. This change replaces it with a more useful test that verifies how windows are placed after an output change.
2021-12-10 10:22:19 +00:00
// Move the window to some predefined position so the test is more robust.
autotests: client -> window
2022-04-23 19:51:16 +00:00
window->move(QPoint(42, 67));
QCOMPARE(window->frameGeometry(), QRect(42, 67, 100, 50));
autotests: Replace output management test with a more useful test The output management test checks the implementation of output management capabilities in the virtual backend, which is not helpful. This change replaces it with a more useful test that verifies how windows are placed after an output change.
2021-12-10 10:22:19 +00:00
// Disable the first output.
Rename WaylandOutputConfig to OutputConfiguration
2022-04-14 10:51:20 +00:00
OutputConfiguration config;
autotests: Replace output management test with a more useful test The output management test checks the implementation of output management capabilities in the virtual backend, which is not helpful. This change replaces it with a more useful test that verifies how windows are placed after an output change.
2021-12-10 10:22:19 +00:00
{
Merge AbstractWaylandOutput with AbstractOutput
2022-04-14 08:32:51 +00:00
auto changeSet = config.changeSet(outputs[0]);
autotests: Replace output management test with a more useful test The output management test checks the implementation of output management capabilities in the virtual backend, which is not helpful. This change replaces it with a more useful test that verifies how windows are placed after an output change.
2021-12-10 10:22:19 +00:00
changeSet->pos = QPoint(-10, 20);
}
Make Workspace process batched output updates Currently the Workspace processes output updates as they occur, e.g. when the drm backend scans connectors, the Workspace will handle hotplugged outputs one by one or if an output configuration changes the mode of several outputs, the workspace will process output layout updates one by one instead of handling it in one pass. The main reason for the current behavior is simplicity. However, that can create issues because it's possible that the output layout will be temporarily in degenerate state and features such as sticking windows to their outputs will be broken. In order to fix that, this change makes the Workspace process batched output updates. There are several challenges - disconnected outputs have to be alive when the outputsQueried signal is emitted, the workspace needs to determine what outputs have been added or removed on its own.
2022-09-05 07:31:57 +00:00
workspace()->applyOutputConfiguration(config);
autotests: Replace output management test with a more useful test The output management test checks the implementation of output management capabilities in the virtual backend, which is not helpful. This change replaces it with a more useful test that verifies how windows are placed after an output change.
2021-12-10 10:22:19 +00:00
// The position of the window relative to its output should remain the same.
autotests: client -> window
2022-04-23 19:51:16 +00:00
QCOMPARE(window->frameGeometry(), QRect(-10 + 42, 20 + 67, 100, 50));
autotests: Replace output management test with a more useful test The output management test checks the implementation of output management capabilities in the virtual backend, which is not helpful. This change replaces it with a more useful test that verifies how windows are placed after an output change.
2021-12-10 10:22:19 +00:00
}
autotests: Add more test cases in OutputChangesTest It adds more test cases in OutputChangesTest, particularly swapping outputs. Swapping outputs is an interesting case because outputs can temporarily overlap so workspace()->outputAt() can return wrong output and the window is going to stick to wrong output.
2022-09-13 07:43:17 +00:00
void OutputChangesTest::testWindowSticksToOutputAfterOutputsAreSwappedLeftToRight()
{
// This test verifies that a window placed on the left monitor sticks
// to that monitor even after the monitors are swapped horizontally.
core: Rename Platform to OutputBackend
2022-11-05 10:43:41 +00:00
const auto outputs = kwinApp()->outputBackend()->outputs();
autotests: Add more test cases in OutputChangesTest It adds more test cases in OutputChangesTest, particularly swapping outputs. Swapping outputs is an interesting case because outputs can temporarily overlap so workspace()->outputAt() can return wrong output and the window is going to stick to wrong output.
2022-09-13 07:43:17 +00:00
// Create a window.
std::unique_ptr<KWayland::Client::Surface> surface(Test::createSurface());
std::unique_ptr<Test::XdgToplevel> shellSurface(Test::createXdgToplevelSurface(surface.get()));
auto window = Test::renderAndWaitForShown(surface.get(), QSize(100, 50), Qt::blue);
QVERIFY(window);
// Move the window to the left output.
window->move(QPointF(0, 0));
QCOMPARE(window->output(), outputs[0]);
QCOMPARE(window->frameGeometry(), QRectF(0, 0, 100, 50));
// Swap outputs.
OutputConfiguration config;
{
auto changeSet1 = config.changeSet(outputs[0]);
changeSet1->pos = QPoint(1280, 0);
auto changeSet2 = config.changeSet(outputs[1]);
changeSet2->pos = QPoint(0, 0);
}
workspace()->applyOutputConfiguration(config);
// The window should be still on its original output.
QCOMPARE(window->output(), outputs[0]);
QCOMPARE(window->frameGeometry(), QRectF(1280, 0, 100, 50));
autotests: Replace output management test with a more useful test The output management test checks the implementation of output management capabilities in the virtual backend, which is not helpful. This change replaces it with a more useful test that verifies how windows are placed after an output change.
2021-12-10 10:22:19 +00:00
}
autotests: Add more test cases in OutputChangesTest It adds more test cases in OutputChangesTest, particularly swapping outputs. Swapping outputs is an interesting case because outputs can temporarily overlap so workspace()->outputAt() can return wrong output and the window is going to stick to wrong output.
2022-09-13 07:43:17 +00:00
void OutputChangesTest::testWindowSticksToOutputAfterOutputsAreSwappedRightToLeft()
{
// This test verifies that a window placed on the right monitor sticks
// to that monitor even after the monitors are swapped horizontally.
core: Rename Platform to OutputBackend
2022-11-05 10:43:41 +00:00
const auto outputs = kwinApp()->outputBackend()->outputs();
autotests: Add more test cases in OutputChangesTest It adds more test cases in OutputChangesTest, particularly swapping outputs. Swapping outputs is an interesting case because outputs can temporarily overlap so workspace()->outputAt() can return wrong output and the window is going to stick to wrong output.
2022-09-13 07:43:17 +00:00
// Create a window.
std::unique_ptr<KWayland::Client::Surface> surface(Test::createSurface());
std::unique_ptr<Test::XdgToplevel> shellSurface(Test::createXdgToplevelSurface(surface.get()));
auto window = Test::renderAndWaitForShown(surface.get(), QSize(100, 50), Qt::blue);
QVERIFY(window);
// Move the window to the right output.
window->move(QPointF(1280, 0));
QCOMPARE(window->output(), outputs[1]);
QCOMPARE(window->frameGeometry(), QRectF(1280, 0, 100, 50));
// Swap outputs.
OutputConfiguration config;
{
auto changeSet1 = config.changeSet(outputs[0]);
changeSet1->pos = QPoint(1280, 0);
auto changeSet2 = config.changeSet(outputs[1]);
changeSet2->pos = QPoint(0, 0);
}
workspace()->applyOutputConfiguration(config);
// The window should be still on its original output.
QCOMPARE(window->output(), outputs[1]);
QCOMPARE(window->frameGeometry(), QRectF(0, 0, 100, 50));
}
autotests: Add basic test cases for testing placement tracker
2022-09-13 08:13:37 +00:00
void OutputChangesTest::testWindowRestoredAfterEnablingOutput()
{
// This test verifies that a window will be moved back to its original output when it's hotplugged.
core: Rename Platform to OutputBackend
2022-11-05 10:43:41 +00:00
const auto outputs = kwinApp()->outputBackend()->outputs();
autotests: Add basic test cases for testing placement tracker
2022-09-13 08:13:37 +00:00
// Create a window.
std::unique_ptr<KWayland::Client::Surface> surface(Test::createSurface());
std::unique_ptr<Test::XdgToplevel> shellSurface(Test::createXdgToplevelSurface(surface.get()));
auto window = Test::renderAndWaitForShown(surface.get(), QSize(100, 50), Qt::blue);
QVERIFY(window);
// Move the window to the right output.
window->move(QPointF(1280 + 50, 100));
QCOMPARE(window->output(), outputs[1]);
QCOMPARE(window->frameGeometry(), QRectF(1280 + 50, 100, 100, 50));
// Disable the right output.
OutputConfiguration config1;
{
auto changeSet = config1.changeSet(outputs[1]);
changeSet->enabled = false;
}
workspace()->applyOutputConfiguration(config1);
// The window will be moved to the left monitor.
QCOMPARE(window->output(), outputs[0]);
QCOMPARE(window->frameGeometry(), QRectF(50, 100, 100, 50));
// Enable the right monitor.
OutputConfiguration config2;
{
auto changeSet = config2.changeSet(outputs[1]);
changeSet->enabled = true;
}
workspace()->applyOutputConfiguration(config2);
// The window will be moved back to the right monitor.
QCOMPARE(window->output(), outputs[1]);
QCOMPARE(window->frameGeometry(), QRectF(1280 + 50, 100, 100, 50));
}
void OutputChangesTest::testWindowNotRestoredAfterMovingWindowAndEnablingOutput()
{
// This test verifies that a window won't be moved to its original output when it's
// hotplugged because the window was moved manually by the user.
core: Rename Platform to OutputBackend
2022-11-05 10:43:41 +00:00
const auto outputs = kwinApp()->outputBackend()->outputs();
autotests: Add basic test cases for testing placement tracker
2022-09-13 08:13:37 +00:00
// Create a window.
std::unique_ptr<KWayland::Client::Surface> surface(Test::createSurface());
std::unique_ptr<Test::XdgToplevel> shellSurface(Test::createXdgToplevelSurface(surface.get()));
auto window = Test::renderAndWaitForShown(surface.get(), QSize(100, 50), Qt::blue);
QVERIFY(window);
// Move the window to the right output.
window->move(QPointF(1280 + 50, 100));
QCOMPARE(window->output(), outputs[1]);
QCOMPARE(window->frameGeometry(), QRectF(1280 + 50, 100, 100, 50));
// Disable the right output.
OutputConfiguration config1;
{
auto changeSet = config1.changeSet(outputs[1]);
changeSet->enabled = false;
}
workspace()->applyOutputConfiguration(config1);
// The window will be moved to the left monitor.
QCOMPARE(window->output(), outputs[0]);
QCOMPARE(window->frameGeometry(), QRectF(50, 100, 100, 50));
// Pretend that the user moved the window.
workspace()->slotWindowMove();
QVERIFY(window->isInteractiveMove());
window->keyPressEvent(Qt::Key_Right);
window->keyPressEvent(Qt::Key_Enter);
QCOMPARE(window->frameGeometry(), QRectF(58, 100, 100, 50));
// Enable the right monitor.
OutputConfiguration config2;
{
auto changeSet = config2.changeSet(outputs[1]);
changeSet->enabled = true;
}
workspace()->applyOutputConfiguration(config2);
// The window is still on the left monitor because user manually moved it.
QCOMPARE(window->output(), outputs[0]);
QCOMPARE(window->frameGeometry(), QRectF(58, 100, 100, 50));
}
autotests: Extend OutputChangesTest with more cases This change extends the OutputChangesTest so it also covers the cases where a maximized and a fullscreen window is moved back to its original output when it's hotplugged.
2022-10-04 09:40:54 +00:00
void OutputChangesTest::testMaximizedWindowRestoredAfterEnablingOutput()
{
// This test verifies that a maximized window will be moved to its original
// output when it's re-enabled.
core: Rename Platform to OutputBackend
2022-11-05 10:43:41 +00:00
const auto outputs = kwinApp()->outputBackend()->outputs();
autotests: Extend OutputChangesTest with more cases This change extends the OutputChangesTest so it also covers the cases where a maximized and a fullscreen window is moved back to its original output when it's hotplugged.
2022-10-04 09:40:54 +00:00
// Create a window.
std::unique_ptr<KWayland::Client::Surface> surface(Test::createSurface());
std::unique_ptr<Test::XdgToplevel> shellSurface(Test::createXdgToplevelSurface(surface.get()));
auto window = Test::renderAndWaitForShown(surface.get(), QSize(100, 50), Qt::blue);
QVERIFY(window);
// kwin will send a configure event with the actived state.
QSignalSpy toplevelConfigureRequestedSpy(shellSurface.get(), &Test::XdgToplevel::configureRequested);
QSignalSpy surfaceConfigureRequestedSpy(shellSurface->xdgSurface(), &Test::XdgSurface::configureRequested);
QVERIFY(surfaceConfigureRequestedSpy.wait());
// Move the window to the right monitor and make it maximized.
QSignalSpy frameGeometryChangedSpy(window, &Window::frameGeometryChanged);
window->move(QPointF(1280 + 50, 100));
window->maximize(MaximizeFull);
QVERIFY(surfaceConfigureRequestedSpy.wait());
QCOMPARE(toplevelConfigureRequestedSpy.last().at(0).value<QSize>(), QSize(1280, 1024));
shellSurface->xdgSurface()->ack_configure(surfaceConfigureRequestedSpy.last().at(0).value<quint32>());
Test::render(surface.get(), QSize(1280, 1024), Qt::blue);
QVERIFY(frameGeometryChangedSpy.wait());
QCOMPARE(window->frameGeometry(), QRectF(1280, 0, 1280, 1024));
QCOMPARE(window->moveResizeGeometry(), QRectF(1280, 0, 1280, 1024));
QCOMPARE(window->output(), outputs[1]);
QCOMPARE(window->maximizeMode(), MaximizeFull);
QCOMPARE(window->requestedMaximizeMode(), MaximizeFull);
QCOMPARE(window->geometryRestore(), QRectF(1280 + 50, 100, 100, 50));
// Disable the right output.
OutputConfiguration config1;
{
auto changeSet = config1.changeSet(outputs[1]);
changeSet->enabled = false;
}
workspace()->applyOutputConfiguration(config1);
// The window will be moved to the left monitor, the geometry restore will be updated too.
QCOMPARE(window->frameGeometry(), QRectF(0, 0, 1280, 1024));
QCOMPARE(window->moveResizeGeometry(), QRectF(0, 0, 1280, 1024));
QCOMPARE(window->output(), outputs[0]);
QCOMPARE(window->maximizeMode(), MaximizeFull);
QCOMPARE(window->requestedMaximizeMode(), MaximizeFull);
QCOMPARE(window->geometryRestore(), QRectF(50, 100, 100, 50));
// Enable the right monitor.
OutputConfiguration config2;
{
auto changeSet = config2.changeSet(outputs[1]);
changeSet->enabled = true;
}
workspace()->applyOutputConfiguration(config2);
// The window will be moved back to the right monitor, the geometry restore will be updated too.
QCOMPARE(window->frameGeometry(), QRectF(1280, 0, 1280, 1024));
QCOMPARE(window->moveResizeGeometry(), QRectF(1280, 0, 1280, 1024));
QCOMPARE(window->output(), outputs[1]);
QCOMPARE(window->maximizeMode(), MaximizeFull);
QCOMPARE(window->requestedMaximizeMode(), MaximizeFull);
QCOMPARE(window->geometryRestore(), QRectF(1280 + 50, 100, 100, 50));
}
void OutputChangesTest::testFullScreenWindowRestoredAfterEnablingOutput()
{
// This test verifies that a fullscreen window will be moved to its original
// output when it's re-enabled.
core: Rename Platform to OutputBackend
2022-11-05 10:43:41 +00:00
const auto outputs = kwinApp()->outputBackend()->outputs();
autotests: Extend OutputChangesTest with more cases This change extends the OutputChangesTest so it also covers the cases where a maximized and a fullscreen window is moved back to its original output when it's hotplugged.
2022-10-04 09:40:54 +00:00
// Create a window.
std::unique_ptr<KWayland::Client::Surface> surface(Test::createSurface());
std::unique_ptr<Test::XdgToplevel> shellSurface(Test::createXdgToplevelSurface(surface.get()));
auto window = Test::renderAndWaitForShown(surface.get(), QSize(100, 50), Qt::blue);
QVERIFY(window);
// kwin will send a configure event with the actived state.
QSignalSpy toplevelConfigureRequestedSpy(shellSurface.get(), &Test::XdgToplevel::configureRequested);
QSignalSpy surfaceConfigureRequestedSpy(shellSurface->xdgSurface(), &Test::XdgSurface::configureRequested);
QVERIFY(surfaceConfigureRequestedSpy.wait());
// Move the window to the right monitor and make it fullscreen.
QSignalSpy frameGeometryChangedSpy(window, &Window::frameGeometryChanged);
window->move(QPointF(1280 + 50, 100));
window->setFullScreen(true);
QVERIFY(surfaceConfigureRequestedSpy.wait());
QCOMPARE(toplevelConfigureRequestedSpy.last().at(0).value<QSize>(), QSize(1280, 1024));
shellSurface->xdgSurface()->ack_configure(surfaceConfigureRequestedSpy.last().at(0).value<quint32>());
Test::render(surface.get(), QSize(1280, 1024), Qt::blue);
QVERIFY(frameGeometryChangedSpy.wait());
QCOMPARE(window->frameGeometry(), QRectF(1280, 0, 1280, 1024));
QCOMPARE(window->moveResizeGeometry(), QRectF(1280, 0, 1280, 1024));
QCOMPARE(window->output(), outputs[1]);
QCOMPARE(window->isFullScreen(), true);
QCOMPARE(window->isRequestedFullScreen(), true);
QCOMPARE(window->fullscreenGeometryRestore(), QRectF(1280 + 50, 100, 100, 50));
// Disable the right output.
OutputConfiguration config1;
{
auto changeSet = config1.changeSet(outputs[1]);
changeSet->enabled = false;
}
workspace()->applyOutputConfiguration(config1);
// The window will be moved to the left monitor, the geometry restore will be updated too.
QCOMPARE(window->frameGeometry(), QRectF(0, 0, 1280, 1024));
QCOMPARE(window->moveResizeGeometry(), QRectF(0, 0, 1280, 1024));
QCOMPARE(window->output(), outputs[0]);
QCOMPARE(window->isFullScreen(), true);
QCOMPARE(window->isRequestedFullScreen(), true);
QCOMPARE(window->fullscreenGeometryRestore(), QRectF(50, 100, 100, 50));
// Enable the right monitor.
OutputConfiguration config2;
{
auto changeSet = config2.changeSet(outputs[1]);
changeSet->enabled = true;
}
workspace()->applyOutputConfiguration(config2);
// The window will be moved back to the right monitor, the geometry restore will be updated too.
QCOMPARE(window->frameGeometry(), QRectF(1280, 0, 1280, 1024));
QCOMPARE(window->moveResizeGeometry(), QRectF(1280, 0, 1280, 1024));
QCOMPARE(window->output(), outputs[1]);
QCOMPARE(window->isFullScreen(), true);
QCOMPARE(window->isRequestedFullScreen(), true);
QCOMPARE(window->fullscreenGeometryRestore(), QRectF(1280 + 50, 100, 100, 50));
}
autotests/integration: add more cases to OutputChangesTest
2022-11-01 13:39:23 +00:00
void OutputChangesTest::testWindowRestoredAfterChangingScale()
{
// This test verifies that a window will be moved to its original position after changing the scale of an output
core: Rename Platform to OutputBackend
2022-11-05 10:43:41 +00:00
const auto output = kwinApp()->outputBackend()->outputs().front();
autotests/integration: add more cases to OutputChangesTest
2022-11-01 13:39:23 +00:00
// Create a window.
std::unique_ptr<KWayland::Client::Surface> surface(Test::createSurface());
std::unique_ptr<Test::XdgToplevel> shellSurface(Test::createXdgToplevelSurface(surface.get()));
auto window = Test::renderAndWaitForShown(surface.get(), QSize(100, 50), Qt::blue);
QVERIFY(window);
// Move the window to the bottom right
const QPointF originalPosition(output->geometry().width() - window->width(), output->geometry().height() - window->height());
window->move(originalPosition);
QCOMPARE(window->pos(), originalPosition);
QCOMPARE(window->output(), output);
// change the scale of the output
OutputConfiguration config1;
{
auto changeSet = config1.changeSet(output);
changeSet->scale = 2;
}
workspace()->applyOutputConfiguration(config1);
// The window will be moved to still be in the monitor
QCOMPARE(window->pos(), QPointF(output->geometry().width() - window->width(), output->geometry().height() - window->height()));
QCOMPARE(window->output(), output);
// Change scale back
OutputConfiguration config2;
{
auto changeSet = config2.changeSet(output);
changeSet->scale = 1;
}
workspace()->applyOutputConfiguration(config2);
// The window will be moved back to where it was before
QCOMPARE(window->pos(), originalPosition);
QCOMPARE(window->output(), output);
}
void OutputChangesTest::testMaximizeStateRestoredAfterEnablingOutput()
{
// This test verifies that the window state will get restored after disabling and enabling an output,
// even if its maximize state changed in the process
core: Rename Platform to OutputBackend
2022-11-05 10:43:41 +00:00
const auto outputs = kwinApp()->outputBackend()->outputs();
autotests/integration: add more cases to OutputChangesTest
2022-11-01 13:39:23 +00:00
// Disable the right output
{
OutputConfiguration config;
auto changeSet = config.changeSet(outputs[1]);
changeSet->enabled = false;
workspace()->applyOutputConfiguration(config);
}
// Create a window.
std::unique_ptr<KWayland::Client::Surface> surface(Test::createSurface());
std::unique_ptr<Test::XdgToplevel> shellSurface(Test::createXdgToplevelSurface(surface.get()));
auto window = Test::renderAndWaitForShown(surface.get(), QSize(100, 50), Qt::blue);
QVERIFY(window);
// kwin will send a configure event with the actived state.
QSignalSpy toplevelConfigureRequestedSpy(shellSurface.get(), &Test::XdgToplevel::configureRequested);
QSignalSpy surfaceConfigureRequestedSpy(shellSurface->xdgSurface(), &Test::XdgSurface::configureRequested);
QVERIFY(surfaceConfigureRequestedSpy.wait());
const QRectF originalGeometry = window->moveResizeGeometry();
// Enable the right output
{
OutputConfiguration config;
auto changeSet = config.changeSet(outputs[1]);
changeSet->enabled = true;
workspace()->applyOutputConfiguration(config);
}
// Move the window to the right monitor and make it maximized.
QSignalSpy frameGeometryChangedSpy(window, &Window::frameGeometryChanged);
window->move(QPointF(1280 + 50, 100));
window->maximize(MaximizeFull);
QVERIFY(surfaceConfigureRequestedSpy.wait());
QCOMPARE(toplevelConfigureRequestedSpy.last().at(0).value<QSize>(), QSize(1280, 1024));
shellSurface->xdgSurface()->ack_configure(surfaceConfigureRequestedSpy.last().at(0).value<quint32>());
Test::render(surface.get(), QSize(1280, 1024), Qt::blue);
QVERIFY(frameGeometryChangedSpy.wait());
QCOMPARE(window->frameGeometry(), QRectF(1280, 0, 1280, 1024));
QCOMPARE(window->moveResizeGeometry(), QRectF(1280, 0, 1280, 1024));
QCOMPARE(window->output(), outputs[1]);
QCOMPARE(window->maximizeMode(), MaximizeFull);
QCOMPARE(window->requestedMaximizeMode(), MaximizeFull);
QCOMPARE(window->geometryRestore(), QRectF(1280 + 50, 100, 100, 50));
// Disable the right output
{
OutputConfiguration config;
auto changeSet = config.changeSet(outputs[1]);
changeSet->enabled = false;
workspace()->applyOutputConfiguration(config);
}
// The window will be moved to its prior position on the left monitor and unmaximized
QVERIFY(surfaceConfigureRequestedSpy.wait());
QCOMPARE(toplevelConfigureRequestedSpy.last().at(0).value<QSize>(), originalGeometry.size().toSize());
shellSurface->xdgSurface()->ack_configure(surfaceConfigureRequestedSpy.last().at(0).value<quint32>());
Test::render(surface.get(), originalGeometry.size().toSize(), Qt::blue);
QVERIFY(frameGeometryChangedSpy.wait());
QCOMPARE(window->frameGeometry(), originalGeometry);
QCOMPARE(window->moveResizeGeometry(), originalGeometry);
QCOMPARE(window->output(), outputs[0]);
QCOMPARE(window->maximizeMode(), MaximizeRestore);
QCOMPARE(window->requestedMaximizeMode(), MaximizeRestore);
// Enable the right output again
{
OutputConfiguration config;
auto changeSet = config.changeSet(outputs[1]);
changeSet->enabled = true;
workspace()->applyOutputConfiguration(config);
}
// The window will be moved back to the right monitor, maximized and the geometry restore will be updated
QVERIFY(surfaceConfigureRequestedSpy.wait());
QCOMPARE(toplevelConfigureRequestedSpy.last().at(0).value<QSize>(), outputs[1]->geometry().size());
shellSurface->xdgSurface()->ack_configure(surfaceConfigureRequestedSpy.last().at(0).value<quint32>());
Test::render(surface.get(), outputs[1]->geometry().size(), Qt::blue);
QVERIFY(frameGeometryChangedSpy.wait());
QCOMPARE(window->frameGeometry(), QRectF(1280, 0, 1280, 1024));
QCOMPARE(window->moveResizeGeometry(), QRectF(1280, 0, 1280, 1024));
QCOMPARE(window->output(), outputs[1]);
QCOMPARE(window->maximizeMode(), MaximizeFull);
QCOMPARE(window->requestedMaximizeMode(), MaximizeFull);
QCOMPARE(window->geometryRestore(), QRectF(1280 + 50, 100, 100, 50));
}
autotests/integration/outputchanges: add geometry restore test
2023-11-06 14:01:44 +00:00
void OutputChangesTest::testInvalidGeometryRestoreAfterEnablingOutput()
{
// This test verifies that the geometry restore gets restore correctly, even if it's invalid
const auto outputs = kwinApp()->outputBackend()->outputs();
// Disable the right output
{
OutputConfiguration config;
auto changeSet = config.changeSet(outputs[1]);
changeSet->enabled = false;
workspace()->applyOutputConfiguration(config);
}
// Create a window.
std::unique_ptr<KWayland::Client::Surface> surface(Test::createSurface());
std::unique_ptr<Test::XdgToplevel> shellSurface(Test::createXdgToplevelSurface(surface.get(), Test::CreationSetup::CreateOnly));
shellSurface->set_maximized();
{
QSignalSpy surfaceConfigureRequestedSpy(shellSurface->xdgSurface(), &Test::XdgSurface::configureRequested);
shellSurface->xdgSurface()->surface()->commit(KWayland::Client::Surface::CommitFlag::None);
QVERIFY(surfaceConfigureRequestedSpy.wait());
shellSurface->xdgSurface()->ack_configure(surfaceConfigureRequestedSpy.last().first().toUInt());
}
auto window = Test::renderAndWaitForShown(surface.get(), QSize(1280, 1024), Qt::blue);
QVERIFY(window);
QCOMPARE(window->maximizeMode(), MaximizeFull);
const QRectF originalGeometry = window->moveResizeGeometry();
const QRectF originalGeometryRestore = window->geometryRestore();
// Enable the right output
{
OutputConfiguration config;
auto changeSet = config.changeSet(outputs[1]);
changeSet->enabled = true;
workspace()->applyOutputConfiguration(config);
}
// Move the window to the right monitor
window->sendToOutput(outputs[1]);
surface->commit(KWayland::Client::Surface::CommitFlag::None);
QCOMPARE(window->frameGeometry(), QRectF(1280, 0, 1280, 1024));
QCOMPARE(window->moveResizeGeometry(), QRectF(1280, 0, 1280, 1024));
QCOMPARE(window->output(), outputs[1]);
QCOMPARE(window->requestedMaximizeMode(), MaximizeFull);
QVERIFY(outputs[1]->geometry().contains(window->geometryRestore().topLeft().toPoint()));
QCOMPARE(window->geometryRestore().size(), QSizeF(0, 0));
const QRectF rightGeometryRestore = window->geometryRestore();
// Disable the right output
{
OutputConfiguration config;
auto changeSet = config.changeSet(outputs[1]);
changeSet->enabled = false;
workspace()->applyOutputConfiguration(config);
}
QSignalSpy toplevelConfigureRequestedSpy(shellSurface.get(), &Test::XdgToplevel::configureRequested);
QSignalSpy surfaceConfigureRequestedSpy(shellSurface->xdgSurface(), &Test::XdgSurface::configureRequested);
QSignalSpy frameGeometryChangedSpy(window, &Window::frameGeometryChanged);
// The window will be moved to its prior position on the left monitor, and still maximized
QCOMPARE(window->frameGeometry(), originalGeometry);
QCOMPARE(window->moveResizeGeometry(), originalGeometry);
QCOMPARE(window->output(), outputs[0]);
QCOMPARE(window->maximizeMode(), MaximizeFull);
QCOMPARE(window->requestedMaximizeMode(), MaximizeFull);
QVERIFY(outputs[0]->geometry().contains(window->geometryRestore().topLeft().toPoint()));
QCOMPARE(window->geometryRestore(), originalGeometryRestore);
// Enable the right output again
{
OutputConfiguration config;
auto changeSet = config.changeSet(outputs[1]);
changeSet->enabled = true;
workspace()->applyOutputConfiguration(config);
}
// The window will be moved back to the right monitor, maximized and the geometry restore will be updated
QVERIFY(surfaceConfigureRequestedSpy.wait());
QCOMPARE(toplevelConfigureRequestedSpy.last().at(0).value<QSize>(), outputs[1]->geometry().size());
shellSurface->xdgSurface()->ack_configure(surfaceConfigureRequestedSpy.last().at(0).value<quint32>());
Test::render(surface.get(), outputs[1]->geometry().size(), Qt::blue);
QCOMPARE(window->frameGeometry(), QRectF(1280, 0, 1280, 1024));
QCOMPARE(window->moveResizeGeometry(), QRectF(1280, 0, 1280, 1024));
QCOMPARE(window->output(), outputs[1]);
QCOMPARE(window->maximizeMode(), MaximizeFull);
QCOMPARE(window->requestedMaximizeMode(), MaximizeFull);
QCOMPARE(window->geometryRestore(), rightGeometryRestore);
}
handle laptop lid closing in KWin Instead of KScreen turning the display off, do that in KWin directly
2023-05-08 08:48:30 +00:00
void OutputChangesTest::testLaptopLidClosed()
{
Test::setOutputConfig({
Test::OutputInfo{
.geometry = QRect(0, 0, 1280, 1024),
.internal = true,
},
Test::OutputInfo{
.geometry = QRect(1280, 0, 1280, 1024),
.internal = false,
},
});
const auto outputs = kwinApp()->outputBackend()->outputs();
const auto internal = outputs.front();
QVERIFY(internal->isInternal());
const auto external = outputs.back();
QVERIFY(!external->isInternal());
auto lidSwitch = std::make_unique<Test::VirtualInputDevice>();
lidSwitch->setLidSwitch(true);
lidSwitch->setName("virtual lid switch");
input()->addInputDevice(lidSwitch.get());
auto timestamp = 1ms;
Q_EMIT lidSwitch->switchToggledOff(timestamp++, lidSwitch.get());
QVERIFY(internal->isEnabled());
QVERIFY(external->isEnabled());
Q_EMIT lidSwitch->switchToggledOn(timestamp++, lidSwitch.get());
QVERIFY(!internal->isEnabled());
QVERIFY(external->isEnabled());
Q_EMIT lidSwitch->switchToggledOff(timestamp++, lidSwitch.get());
QVERIFY(internal->isEnabled());
QVERIFY(external->isEnabled());
input()->removeInputDevice(lidSwitch.get());
}
autotests: Add more test cases in OutputChangesTest It adds more test cases in OutputChangesTest, particularly swapping outputs. Swapping outputs is an interesting case because outputs can temporarily overlap so workspace()->outputAt() can return wrong output and the window is going to stick to wrong output.
2022-09-13 07:43:17 +00:00
} // namespace KWin
autotests: Replace output management test with a more useful test The output management test checks the implementation of output management capabilities in the virtual backend, which is not helpful. This change replaces it with a more useful test that verifies how windows are placed after an output change.
2021-12-10 10:22:19 +00:00
WAYLANDTEST_MAIN(KWin::OutputChangesTest)
#include "outputchanges_test.moc"
Reference in a new issue Copy permalink