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

780 lines
25 KiB
C++
Raw Normal View History

Prettify license headers
2020-08-02 22:22:19 +00:00
/*
KWin - the KDE window manager
This file is part of the KDE project.
[autotest] Add a test for locking the screen First test case is to ensure that pointer motion events trigger a leave event on the surface the pointer is on. The test case shows errors in the input handling. More tests need to be added.
2016-02-01 14:10:00 +00:00
Prettify license headers
2020-08-02 22:22:19 +00:00
SPDX-FileCopyrightText: 2016 Martin Gräßlin <mgraesslin@kde.org>
[autotest] Add a test for locking the screen First test case is to ensure that pointer motion events trigger a leave event on the surface the pointer is on. The test case shows errors in the input handling. More tests need to be added.
2016-02-01 14:10:00 +00:00
Prettify license headers
2020-08-02 22:22:19 +00:00
SPDX-License-Identifier: GPL-2.0-or-later
*/
[autotest] Add a test for locking the screen First test case is to ensure that pointer motion events trigger a leave event on the surface the pointer is on. The test case shows errors in the input handling. More tests need to be added.
2016-02-01 14:10:00 +00:00
#include "kwin_wayland_test.h"
Run clang-format The .clang-format file is based on the one in ECM except the following style options: - AlwaysBreakBeforeMultilineStrings - BinPackArguments - BinPackParameters - ColumnLimit - BreakBeforeBraces - KeepEmptyLinesAtTheStartOfBlocks
2022-03-23 10:13:38 +00:00
[autotests] Don't check whether there is a /dev/dri/card0 Summary: With EGL_MESA_platform_surfaceless we don't need a dri device anymore. So we don't need to skip the tests if the device is missing. Instead the tests verify that OpenGL compositing is used if requested. Test Plan: ctest passes Reviewers: #kwin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D18014
2019-01-06 15:34:10 +00:00
#include "composite.h"
[autotest] Add a test for locking the screen First test case is to ensure that pointer motion events trigger a leave event on the surface the pointer is on. The test case shows errors in the input handling. More tests need to be added.
2016-02-01 14:10:00 +00:00
#include "cursor.h"
Rename AbstractOutput to Output AbstractOutput is not so Abstract and it's common to avoid the word "Abstract" in class names as it doesn't contribute any new information. It also significantly reduces the line width in some places.
2022-04-14 12:33:28 +00:00
#include "output.h"
Run clang-format The .clang-format file is based on the one in ECM except the following style options: - AlwaysBreakBeforeMultilineStrings - BinPackArguments - BinPackParameters - ColumnLimit - BreakBeforeBraces - KeepEmptyLinesAtTheStartOfBlocks
2022-03-23 10:13:38 +00:00
#include "platform.h"
Introduce explicit base render backend type The main idea behind the render backend is to decouple low level bits from scenes. The end goal is to make the render backend provide render targets where the scene can render. Design-wise, such a split is more flexible than the current state, for example we could start experimenting with using qtquick (assuming that the legacy scene is properly encapsulated) or creating multiple scenes, for example for each output layer, etc. So far, the RenderBackend class only contains one getter, more stuff will be moved from the Scene as it makes sense.
2021-11-10 10:34:18 +00:00
#include "renderbackend.h"
[autotest] Extend lockscreen test * verifies that pointer axis isn't passed to windows * verifies that screen edge is not activated while screen is locked
2016-02-02 12:50:13 +00:00
#include "screenedge.h"
Integrate kwaylandserver This makes KWin switch to in-tree copy of KWaylandServer codebase. KWaylandServer namespace has been left as is. It will be addressed later by renaming classes in order to fit in the KWin namespace.
2022-04-22 09:27:33 +00:00
#include "wayland/keyboard_interface.h"
#include "wayland/seat_interface.h"
[autotest] Add a test for locking the screen First test case is to ensure that pointer motion events trigger a leave event on the surface the pointer is on. The test case shows errors in the input handling. More tests need to be added.
2016-02-01 14:10:00 +00:00
#include "wayland_server.h"
Rename AbstractClient to Window
2022-04-22 17:39:12 +00:00
#include "window.h"
[autotest] Add a test for locking the screen First test case is to ensure that pointer motion events trigger a leave event on the surface the pointer is on. The test case shows errors in the input handling. More tests need to be added.
2016-02-01 14:10:00 +00:00
#include "workspace.h"
[autotests] Verify that Effects don't get pointer events on locked screen Interesting approach I would not have expected to work. A dummy Effect class is created in the test and an instance is passed to EffectsHandler's startMouseInterception. It doesn't verify whether it's an Effect it knows or has created, so it's totally happy with the dummy. It shows that motion and press/release are passed to the Effect when screen is not locked and doesn't while the screen is locked.
2016-02-02 13:41:28 +00:00
#include <kwineffects.h>
[autotest] Add a test for locking the screen First test case is to ensure that pointer motion events trigger a leave event on the surface the pointer is on. The test case shows errors in the input handling. More tests need to be added.
2016-02-01 14:10:00 +00:00
#include <KWayland/Client/compositor.h>
Run clang-format The .clang-format file is based on the one in ECM except the following style options: - AlwaysBreakBeforeMultilineStrings - BinPackArguments - BinPackParameters - ColumnLimit - BreakBeforeBraces - KeepEmptyLinesAtTheStartOfBlocks
2022-03-23 10:13:38 +00:00
#include <KWayland/Client/connection_thread.h>
[autotests] Test case for lock screen intercepts key events Our active client should lose keyboard focus when screen gets locked and re-gain after the screen unlocks.
2016-02-08 15:52:22 +00:00
#include <KWayland/Client/keyboard.h>
[autotest] Add a test for locking the screen First test case is to ensure that pointer motion events trigger a leave event on the surface the pointer is on. The test case shows errors in the input handling. More tests need to be added.
2016-02-01 14:10:00 +00:00
#include <KWayland/Client/pointer.h>
Run clang-format The .clang-format file is based on the one in ECM except the following style options: - AlwaysBreakBeforeMultilineStrings - BinPackArguments - BinPackParameters - ColumnLimit - BreakBeforeBraces - KeepEmptyLinesAtTheStartOfBlocks
2022-03-23 10:13:38 +00:00
#include <KWayland/Client/registry.h>
[autotest] Add a test for locking the screen First test case is to ensure that pointer motion events trigger a leave event on the surface the pointer is on. The test case shows errors in the input handling. More tests need to be added.
2016-02-01 14:10:00 +00:00
#include <KWayland/Client/seat.h>
#include <KWayland/Client/shm_pool.h>
#include <KWayland/Client/surface.h>
Implement lock screen security for touch events When the screen gets locked any existing sequence gets cancelled and the focused touch surface gets reset. While screen is locked touch events are filtered to only go to lock screen or input methods. Test case is added for touch event during lock screen. Reviewed-By: Bhushan Shah
2016-02-10 15:43:06 +00:00
#include <KWayland/Client/touch.h>
[autotest] Add a test for locking the screen First test case is to ensure that pointer motion events trigger a leave event on the surface the pointer is on. The test case shows errors in the input handling. More tests need to be added.
2016-02-01 14:10:00 +00:00
Run clang-format The .clang-format file is based on the one in ECM except the following style options: - AlwaysBreakBeforeMultilineStrings - BinPackArguments - BinPackParameters - ColumnLimit - BreakBeforeBraces - KeepEmptyLinesAtTheStartOfBlocks
2022-03-23 10:13:38 +00:00
// screenlocker
[autotest] Add a test for locking the screen First test case is to ensure that pointer motion events trigger a leave event on the surface the pointer is on. The test case shows errors in the input handling. More tests need to be added.
2016-02-01 14:10:00 +00:00
#include <KScreenLocker/KsldApp>
[autotests] Fix LockScreenTest::testKeyboardShortcut 32f4e115e2c68b75a5eea86e0a582388d5abadb9 broke the test. To my surprise there was a test using the kwin internal shortcut handling instead of using KGlobalAccel. This change adjusts the test to go through KGlobalAccel for testing the global shortcut.
2017-01-18 19:24:17 +00:00
#include <KGlobalAccel>
[autotest] Add a test for locking the screen First test case is to ensure that pointer motion events trigger a leave event on the surface the pointer is on. The test case shows errors in the input handling. More tests need to be added.
2016-02-01 14:10:00 +00:00
#include <linux/input.h>
[autotest] Fix build on build.kde.org (Try 3) Qt::Orientation seems not to be a declared metatype with Qt 5.4.
2016-03-03 15:26:55 +00:00
Q_DECLARE_METATYPE(Qt::Orientation)
[autotest] Add a test for locking the screen First test case is to ensure that pointer motion events trigger a leave event on the surface the pointer is on. The test case shows errors in the input handling. More tests need to be added.
2016-02-01 14:10:00 +00:00
namespace KWin
{
static const QString s_socketName = QStringLiteral("wayland_test_kwin_lock_screen-0");
class LockScreenTest : public QObject
{
Q_OBJECT
private Q_SLOTS:
void initTestCase();
void init();
void cleanup();
[wayland] Place lockscreen greeter above other windows Summary: BUG: 420802 Reviewers: #kwin, davidedmundson Reviewed By: #kwin, davidedmundson Subscribers: apol, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D29523
2020-05-08 08:26:27 +00:00
void testStackingOrder();
[autotest] Add a test for locking the screen First test case is to ensure that pointer motion events trigger a leave event on the surface the pointer is on. The test case shows errors in the input handling. More tests need to be added.
2016-02-01 14:10:00 +00:00
void testPointer();
[autotest] Add test case for pointer buttons on locked screen Extends the lock screen tests by verifying that pointer button press/release events will be intercepted by the lock screen.
2016-02-01 16:57:38 +00:00
void testPointerButton();
[autotest] Extend lockscreen test * verifies that pointer axis isn't passed to windows * verifies that screen edge is not activated while screen is locked
2016-02-02 12:50:13 +00:00
void testPointerAxis();
[autotests] Test case for lock screen intercepts key events Our active client should lose keyboard focus when screen gets locked and re-gain after the screen unlocks.
2016-02-08 15:52:22 +00:00
void testKeyboard();
[autotest] Extend lockscreen test * verifies that pointer axis isn't passed to windows * verifies that screen edge is not activated while screen is locked
2016-02-02 12:50:13 +00:00
void testScreenEdge();
[autotests] Verify that Effects don't get pointer events on locked screen Interesting approach I would not have expected to work. A dummy Effect class is created in the test and an instance is passed to EffectsHandler's startMouseInterception. It doesn't verify whether it's an Effect it knows or has created, so it's totally happy with the dummy. It shows that motion and press/release are passed to the Effect when screen is not locked and doesn't while the screen is locked.
2016-02-02 13:41:28 +00:00
void testEffects();
[autotests] Add test case for effects key handling during screen lock Verifies that no key events are forwarded to the Effects during a locked screen.
2016-02-08 11:36:39 +00:00
void testEffectsKeyboard();
Implement internal keyboard repeat As a Wayland server KWin does not have to emit additional key repeat events (unlike X11). The clients are responsible for handling this based on the provided key repeat information. Internally KWin needs key repeat, though. E.g. the effects need key repeat (filtering in Present Windows), window moving by keyboard needs repeat, etc. etc. This change introduces the internal key repeat. For each key press a QTimer is started which gets canceled again on the key release. If the timer fires it invoked processKey with a new KeyboardKeyAutoRepeat state. This is handled just like a KeyPress, but states are not updated and the QKeyEvent has autorepeat set to true. The event filters check for the autorepeat state and filter the event out if they are not interested in it. E.g. the filters passing the event to the Wayland client need to filter it out. Currently auto-repeat is bound to using libinput. This needs to be modified. The only backend sending repeated events is X11, thus for other backends it should be enabled. Whether creating a timer on each key event is a good idea is something to evaluate in future. Reviewed-By: Bhushan Shah
2016-02-19 06:53:20 +00:00
void testEffectsKeyboardAutorepeat();
[autotests] Extend LockScreenTest for locking while moving window Things which weren't possible on X11 are possible now.
2016-02-03 08:36:12 +00:00
void testMoveWindow();
[autotest] Extend LockScreen test for global pointer and axis shortcuts The global shortcuts may not be triggered while screen is locked.
2016-02-04 08:06:15 +00:00
void testPointerShortcut();
void testAxisShortcut_data();
void testAxisShortcut();
[autotest] Add test case for global shortcuts while screen is locked They shouldn't be triggered if the screen is locked.
2016-02-08 14:23:06 +00:00
void testKeyboardShortcut();
Implement lock screen security for touch events When the screen gets locked any existing sequence gets cancelled and the focused touch surface gets reset. While screen is locked touch events are filtered to only go to lock screen or input methods. Test case is added for touch event during lock screen. Reviewed-By: Bhushan Shah
2016-02-10 15:43:06 +00:00
void testTouch();
[autotest] Add a test for locking the screen First test case is to ensure that pointer motion events trigger a leave event on the surface the pointer is on. The test case shows errors in the input handling. More tests need to be added.
2016-02-01 14:10:00 +00:00
private:
void unlock();
Rename AbstractClient to Window
2022-04-22 17:39:12 +00:00
Window *showWindow();
[autotest] Add a test for locking the screen First test case is to ensure that pointer motion events trigger a leave event on the surface the pointer is on. The test case shows errors in the input handling. More tests need to be added.
2016-02-01 14:10:00 +00:00
KWayland::Client::ConnectionThread *m_connection = nullptr;
KWayland::Client::Compositor *m_compositor = nullptr;
KWayland::Client::Seat *m_seat = nullptr;
KWayland::Client::ShmPool *m_shm = nullptr;
};
[autotests] Verify that Effects don't get pointer events on locked screen Interesting approach I would not have expected to work. A dummy Effect class is created in the test and an instance is passed to EffectsHandler's startMouseInterception. It doesn't verify whether it's an Effect it knows or has created, so it's totally happy with the dummy. It shows that motion and press/release are passed to the Effect when screen is not locked and doesn't while the screen is locked.
2016-02-02 13:41:28 +00:00
class HelperEffect : public Effect
{
Q_OBJECT
public:
Run clang-format The .clang-format file is based on the one in ECM except the following style options: - AlwaysBreakBeforeMultilineStrings - BinPackArguments - BinPackParameters - ColumnLimit - BreakBeforeBraces - KeepEmptyLinesAtTheStartOfBlocks
2022-03-23 10:13:38 +00:00
HelperEffect()
{
}
~HelperEffect() override
{
}
[autotests] Verify that Effects don't get pointer events on locked screen Interesting approach I would not have expected to work. A dummy Effect class is created in the test and an instance is passed to EffectsHandler's startMouseInterception. It doesn't verify whether it's an Effect it knows or has created, so it's totally happy with the dummy. It shows that motion and press/release are passed to the Effect when screen is not locked and doesn't while the screen is locked.
2016-02-02 13:41:28 +00:00
Run clang-format The .clang-format file is based on the one in ECM except the following style options: - AlwaysBreakBeforeMultilineStrings - BinPackArguments - BinPackParameters - ColumnLimit - BreakBeforeBraces - KeepEmptyLinesAtTheStartOfBlocks
2022-03-23 10:13:38 +00:00
void windowInputMouseEvent(QEvent *) override
{
Run clazy with qt-keywords fixit In C++20, there will be emit() class member, which can conflict with the emit keyword. Given that, there are plans to enable QT_NO_KEYWORDS by default in the future. See also https://lists.qt-project.org/pipermail/development/2020-February/038812.html
2021-06-08 07:02:14 +00:00
Q_EMIT inputEvent();
[autotests] Verify that Effects don't get pointer events on locked screen Interesting approach I would not have expected to work. A dummy Effect class is created in the test and an instance is passed to EffectsHandler's startMouseInterception. It doesn't verify whether it's an Effect it knows or has created, so it's totally happy with the dummy. It shows that motion and press/release are passed to the Effect when screen is not locked and doesn't while the screen is locked.
2016-02-02 13:41:28 +00:00
}
Run clang-format The .clang-format file is based on the one in ECM except the following style options: - AlwaysBreakBeforeMultilineStrings - BinPackArguments - BinPackParameters - ColumnLimit - BreakBeforeBraces - KeepEmptyLinesAtTheStartOfBlocks
2022-03-23 10:13:38 +00:00
void grabbedKeyboardEvent(QKeyEvent *e) override
{
Run clazy with qt-keywords fixit In C++20, there will be emit() class member, which can conflict with the emit keyword. Given that, there are plans to enable QT_NO_KEYWORDS by default in the future. See also https://lists.qt-project.org/pipermail/development/2020-February/038812.html
2021-06-08 07:02:14 +00:00
Q_EMIT keyEvent(e->text());
[autotests] Add test case for effects key handling during screen lock Verifies that no key events are forwarded to the Effects during a locked screen.
2016-02-08 11:36:39 +00:00
}
[autotests] Verify that Effects don't get pointer events on locked screen Interesting approach I would not have expected to work. A dummy Effect class is created in the test and an instance is passed to EffectsHandler's startMouseInterception. It doesn't verify whether it's an Effect it knows or has created, so it's totally happy with the dummy. It shows that motion and press/release are passed to the Effect when screen is not locked and doesn't while the screen is locked.
2016-02-02 13:41:28 +00:00
Q_SIGNALS:
void inputEvent();
Run clang-format The .clang-format file is based on the one in ECM except the following style options: - AlwaysBreakBeforeMultilineStrings - BinPackArguments - BinPackParameters - ColumnLimit - BreakBeforeBraces - KeepEmptyLinesAtTheStartOfBlocks
2022-03-23 10:13:38 +00:00
void keyEvent(const QString &);
[autotests] Verify that Effects don't get pointer events on locked screen Interesting approach I would not have expected to work. A dummy Effect class is created in the test and an instance is passed to EffectsHandler's startMouseInterception. It doesn't verify whether it's an Effect it knows or has created, so it's totally happy with the dummy. It shows that motion and press/release are passed to the Effect when screen is not locked and doesn't while the screen is locked.
2016-02-02 13:41:28 +00:00
};
Run clang-format The .clang-format file is based on the one in ECM except the following style options: - AlwaysBreakBeforeMultilineStrings - BinPackArguments - BinPackParameters - ColumnLimit - BreakBeforeBraces - KeepEmptyLinesAtTheStartOfBlocks
2022-03-23 10:13:38 +00:00
#define LOCK \
do { \
QVERIFY(!waylandServer()->isScreenLocked()); \
QSignalSpy lockStateChangedSpy(ScreenLocker::KSldApp::self(), &ScreenLocker::KSldApp::lockStateChanged); \
QVERIFY(lockStateChangedSpy.isValid()); \
ScreenLocker::KSldApp::self()->lock(ScreenLocker::EstablishLock::Immediate); \
QCOMPARE(lockStateChangedSpy.count(), 1); \
QVERIFY(waylandServer()->isScreenLocked()); \
} while (false)
#define UNLOCK \
do { \
QSignalSpy lockStateChangedSpy(ScreenLocker::KSldApp::self(), &ScreenLocker::KSldApp::lockStateChanged); \
QVERIFY(lockStateChangedSpy.isValid()); \
unlock(); \
if (lockStateChangedSpy.count() != 1) { \
QVERIFY(lockStateChangedSpy.wait()); \
} \
QCOMPARE(lockStateChangedSpy.count(), 1); \
QVERIFY(!waylandServer()->isScreenLocked()); \
} while (false)
[autotest] Reduce code duplication in LockScreenTest
2016-02-02 15:11:21 +00:00
Migrate all autotest input simulation functions [5/6] Make autotests create fake input devices Migrate all input simulation functions from kwinApp()->platform()->... to the their counter part in the Test namespace.
2022-03-10 10:27:35 +00:00
#define MOTION(target) Test::pointerMotion(target, timestamp++)
[autotest] Reduce code duplication in LockScreenTest
2016-02-02 15:11:21 +00:00
Migrate all autotest input simulation functions [5/6] Make autotests create fake input devices Migrate all input simulation functions from kwinApp()->platform()->... to the their counter part in the Test namespace.
2022-03-10 10:27:35 +00:00
#define PRESS Test::pointerButtonPressed(BTN_LEFT, timestamp++)
[autotest] Reduce code duplication in LockScreenTest
2016-02-02 15:11:21 +00:00
Migrate all autotest input simulation functions [5/6] Make autotests create fake input devices Migrate all input simulation functions from kwinApp()->platform()->... to the their counter part in the Test namespace.
2022-03-10 10:27:35 +00:00
#define RELEASE Test::pointerButtonReleased(BTN_LEFT, timestamp++)
[autotests] Verify that Effects don't get pointer events on locked screen Interesting approach I would not have expected to work. A dummy Effect class is created in the test and an instance is passed to EffectsHandler's startMouseInterception. It doesn't verify whether it's an Effect it knows or has created, so it's totally happy with the dummy. It shows that motion and press/release are passed to the Effect when screen is not locked and doesn't while the screen is locked.
2016-02-02 13:41:28 +00:00
Migrate all autotest input simulation functions [5/6] Make autotests create fake input devices Migrate all input simulation functions from kwinApp()->platform()->... to the their counter part in the Test namespace.
2022-03-10 10:27:35 +00:00
#define KEYPRESS(key) Test::keyboardKeyPressed(key, timestamp++)
[autotests] Add test case for effects key handling during screen lock Verifies that no key events are forwarded to the Effects during a locked screen.
2016-02-08 11:36:39 +00:00
Migrate all autotest input simulation functions [5/6] Make autotests create fake input devices Migrate all input simulation functions from kwinApp()->platform()->... to the their counter part in the Test namespace.
2022-03-10 10:27:35 +00:00
#define KEYRELEASE(key) Test::keyboardKeyReleased(key, timestamp++)
[autotests] Add test case for effects key handling during screen lock Verifies that no key events are forwarded to the Effects during a locked screen.
2016-02-08 11:36:39 +00:00
[autotest] Add a test for locking the screen First test case is to ensure that pointer motion events trigger a leave event on the surface the pointer is on. The test case shows errors in the input handling. More tests need to be added.
2016-02-01 14:10:00 +00:00
void LockScreenTest::unlock()
{
using namespace ScreenLocker;
const auto children = KSldApp::self()->children();
for (auto it = children.begin(); it != children.end(); ++it) {
if (qstrcmp((*it)->metaObject()->className(), "LogindIntegration") != 0) {
continue;
}
QMetaObject::invokeMethod(*it, "requestUnlock");
break;
}
}
Rename AbstractClient to Window
2022-04-22 17:39:12 +00:00
Window *LockScreenTest::showWindow()
[autotest] Reduce code duplication in LockScreenTest
2016-02-02 15:11:21 +00:00
{
using namespace KWayland::Client;
Run clang-format The .clang-format file is based on the one in ECM except the following style options: - AlwaysBreakBeforeMultilineStrings - BinPackArguments - BinPackParameters - ColumnLimit - BreakBeforeBraces - KeepEmptyLinesAtTheStartOfBlocks
2022-03-23 10:13:38 +00:00
#define VERIFY(statement) \
if (!QTest::qVerify((statement), #statement, "", __FILE__, __LINE__)) \
[autotest] Reduce code duplication in LockScreenTest
2016-02-02 15:11:21 +00:00
return nullptr;
Run clang-format The .clang-format file is based on the one in ECM except the following style options: - AlwaysBreakBeforeMultilineStrings - BinPackArguments - BinPackParameters - ColumnLimit - BreakBeforeBraces - KeepEmptyLinesAtTheStartOfBlocks
2022-03-23 10:13:38 +00:00
#define COMPARE(actual, expected) \
if (!QTest::qCompare(actual, expected, #actual, #expected, __FILE__, __LINE__)) \
[autotest] Reduce code duplication in LockScreenTest
2016-02-02 15:11:21 +00:00
return nullptr;
autotests: Prepend KWayland::Client:: to Surface With a "Surface" type in kwin, KWayland::Client::Surface without fully specified namespace will conflict with kwin's Surface type. In some way, it also improves readability as it's clear where Surface comes from.
2021-09-03 17:54:03 +00:00
KWayland::Client::Surface *surface = Test::createSurface(m_compositor);
[autotest] Reduce code duplication in LockScreenTest
2016-02-02 15:11:21 +00:00
VERIFY(surface);
autotests: Port the tests to new xdg-shell helpers
2021-05-11 05:26:51 +00:00
Test::XdgToplevel *shellSurface = Test::createXdgToplevelSurface(surface, surface);
[autotest] Reduce code duplication in LockScreenTest
2016-02-02 15:11:21 +00:00
VERIFY(shellSurface);
// let's render
[autotest/integration] Add helper for waiting for a shown ShellClient Summary: Many tests create a Wayland window, render it and then wait till it's created in KWin as a ShellClient. To reduce code duplication the test helper provides helper methods to wait for the next ShellClient to be shown and to directly render and wait for the window for that to be shown. Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D2057
2016-07-01 07:54:44 +00:00
auto c = Test::renderAndWaitForShown(surface, QSize(100, 50), Qt::blue);
[autotest] Reduce code duplication in LockScreenTest
2016-02-02 15:11:21 +00:00
VERIFY(c);
[autotest/integration] Add helper for waiting for a shown ShellClient Summary: Many tests create a Wayland window, render it and then wait till it's created in KWin as a ShellClient. To reduce code duplication the test helper provides helper methods to wait for the next ShellClient to be shown and to directly render and wait for the window for that to be shown. Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D2057
2016-07-01 07:54:44 +00:00
COMPARE(workspace()->activeClient(), c);
[autotest] Reduce code duplication in LockScreenTest
2016-02-02 15:11:21 +00:00
#undef VERIFY
#undef COMPARE
return c;
}
[autotest] Add a test for locking the screen First test case is to ensure that pointer motion events trigger a leave event on the surface the pointer is on. The test case shows errors in the input handling. More tests need to be added.
2016-02-01 14:10:00 +00:00
void LockScreenTest::initTestCase()
{
Rename AbstractClient to Window
2022-04-22 17:39:12 +00:00
qRegisterMetaType<KWin::Window *>();
Introduce started signal in Application The new signal is emitted when the Application has fully been initialized. It allows us to change the startup sequence, for example create workspace before starting the Xwayland server, without making any adjustments in our test suit.
2020-07-07 09:32:29 +00:00
QSignalSpy applicationStartedSpy(kwinApp(), &Application::started);
QVERIFY(applicationStartedSpy.isValid());
waylandServer()->backend() replaced by kwinApp()->platform()
2016-04-07 06:28:35 +00:00
kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
Avoid converting socket name between QString and QByteArray back and forth It only contributes overhead.
2020-12-09 13:06:15 +00:00
QVERIFY(waylandServer()->init(s_socketName));
[platforms/virtual] Create output devices Summary: Create output devices in virtual backend. For that the setVirtualOutputs call can only come after the Wayland server has been initiliazied such that the display exists to create the output and output device interfaces. Tests have been adjusted for that. Test Plan: ``` 98% tests passed, 3 tests failed out of 148 Total Test time (real) = 362.97 sec The following tests FAILED: 33 - kwin-testInternalWindow (Failed) 39 - kwin-testPointerInput (Failed) 101 - kwin-testMoveResize (Failed) ``` Failing of these tests looks unrelated to the change. Reviewers: #kwin Subscribers: kwin Tags: #kwin Maniphest Tasks: T11459 Differential Revision: https://phabricator.kde.org/D23477
2019-08-26 21:16:53 +00:00
QMetaObject::invokeMethod(kwinApp()->platform(), "setVirtualOutputs", Qt::DirectConnection, Q_ARG(int, 2));
[autotest] Add a test for locking the screen First test case is to ensure that pointer motion events trigger a leave event on the surface the pointer is on. The test case shows errors in the input handling. More tests need to be added.
2016-02-01 14:10:00 +00:00
Switch lockscreen test to OpenGL Summary: Main reason for using QPainter was the fact that build.kde.org did not support OpenGL back when the test got introduced. As we have vgem support nowadays we can switch back to OpenGL. Test Plan: 100% tests passed, 0 tests failed out of 130, but the test is flaky with and without this change Reviewers: #kwin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D16940
2018-11-17 08:52:53 +00:00
qputenv("KWIN_COMPOSE", QByteArrayLiteral("O2"));
[autotest] Add a test for locking the screen First test case is to ensure that pointer motion events trigger a leave event on the surface the pointer is on. The test case shows errors in the input handling. More tests need to be added.
2016-02-01 14:10:00 +00:00
kwinApp()->start();
Introduce started signal in Application The new signal is emitted when the Application has fully been initialized. It allows us to change the startup sequence, for example create workspace before starting the Xwayland server, without making any adjustments in our test suit.
2020-07-07 09:32:29 +00:00
QVERIFY(applicationStartedSpy.wait());
autotests: Port common screen check preamble to AbstractOutput
2021-08-31 07:03:05 +00:00
const auto outputs = kwinApp()->platform()->enabledOutputs();
QCOMPARE(outputs.count(), 2);
QCOMPARE(outputs[0]->geometry(), QRect(0, 0, 1280, 1024));
QCOMPARE(outputs[1]->geometry(), QRect(1280, 0, 1280, 1024));
[autotest] Add a test for locking the screen First test case is to ensure that pointer motion events trigger a leave event on the surface the pointer is on. The test case shows errors in the input handling. More tests need to be added.
2016-02-01 14:10:00 +00:00
setenv("QT_QPA_PLATFORM", "wayland", true);
Ensure we start our tests with wayland already initialised When debugging modifier_only_shortcut_test in _waylandonly mode I saw that it was failing, among other things, because some aspects were not initialised. This changes every test we have to run the new Test::initWaylandWorkspace() that calls waylandServer()->initWorkspace() but also makes sure that WaylandServer::initialized is emitted before we proceed.
2021-05-08 00:08:22 +00:00
Test::initWaylandWorkspace();
[autotests] Don't check whether there is a /dev/dri/card0 Summary: With EGL_MESA_platform_surfaceless we don't need a dri device anymore. So we don't need to skip the tests if the device is missing. Instead the tests verify that OpenGL compositing is used if requested. Test Plan: ctest passes Reviewers: #kwin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D18014
2019-01-06 15:34:10 +00:00
Introduce explicit base render backend type The main idea behind the render backend is to decouple low level bits from scenes. The end goal is to make the render backend provide render targets where the scene can render. Design-wise, such a split is more flexible than the current state, for example we could start experimenting with using qtquick (assuming that the legacy scene is properly encapsulated) or creating multiple scenes, for example for each output layer, etc. So far, the RenderBackend class only contains one getter, more stuff will be moved from the Scene as it makes sense.
2021-11-10 10:34:18 +00:00
QCOMPARE(Compositor::self()->backend()->compositingType(), KWin::OpenGLCompositing);
[autotest] Add a test for locking the screen First test case is to ensure that pointer motion events trigger a leave event on the surface the pointer is on. The test case shows errors in the input handling. More tests need to be added.
2016-02-01 14:10:00 +00:00
}
void LockScreenTest::init()
{
[autotests/integration] Use socketpair for Wayland connection Summary: This is a preparation step for no longer creating a socket in the tests and slightly simplifies the init test code. Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D3575
2016-12-03 13:31:14 +00:00
QVERIFY(Test::setupWaylandConnection(Test::AdditionalWaylandInterface::Seat));
[autotest/integration] Introduce a Test helper library to have less code duplication Summary: A new namespace KWin::Test is added which provides a few helper functions. It makes it easy to setup a KWayland client connection with the base set to be able to create a Surface and flags to create additional interfaces. This replaces the KWayland connection dance in init() methods. For cleanup() there is also a dedicated helper function. In addition there are helper functions to: * render a surface * create a surface * create a shell surface * flush the wayland client connection * access to the created interfaces - for compatibility with existing code The idea is to extend this Test library also for other common use cases like creating an X11 connection and X11 windows, etc. Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D2053
2016-06-30 11:32:54 +00:00
QVERIFY(Test::waitForWaylandPointer());
m_connection = Test::waylandConnection();
m_compositor = Test::waylandCompositor();
m_shm = Test::waylandShmPool();
m_seat = Test::waylandSeat();
[autotest] Add a test for locking the screen First test case is to ensure that pointer motion events trigger a leave event on the surface the pointer is on. The test case shows errors in the input handling. More tests need to be added.
2016-02-01 14:10:00 +00:00
Move active output tracking to workspace Active output is a window management concept. It indicates what output new windows have to be placed on if they have no output hint. So Workspace seems to be a better place for it than the Screens class, which is obsolete.
2021-08-28 18:58:29 +00:00
workspace()->setActiveOutput(QPoint(640, 512));
Make it possible to have a separate cursor for the tablet Summary: As is KWin only had 1 Cursor which was a singleton. This made it impossible for us to properly implement the tablet (as in drawing tablets) support and show where we're drawing. This patch makes it possible to have different Cursors in KWin, it makes all the current code still follow the mouse but the tablet can still render a cursor. Test Plan: Tests pass, been using it and works as well as before but with beautiful tablet cursors. Reviewers: #kwin, cblack, davidedmundson Reviewed By: #kwin, cblack, davidedmundson Subscribers: davidedmundson, cblack, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D28155
2020-04-02 16:18:01 +00:00
Cursors::self()->mouse()->setPos(QPoint(640, 512));
[autotest] Add a test for locking the screen First test case is to ensure that pointer motion events trigger a leave event on the surface the pointer is on. The test case shows errors in the input handling. More tests need to be added.
2016-02-01 14:10:00 +00:00
}
void LockScreenTest::cleanup()
{
[autotest/integration] Introduce a Test helper library to have less code duplication Summary: A new namespace KWin::Test is added which provides a few helper functions. It makes it easy to setup a KWayland client connection with the base set to be able to create a Surface and flags to create additional interfaces. This replaces the KWayland connection dance in init() methods. For cleanup() there is also a dedicated helper function. In addition there are helper functions to: * render a surface * create a surface * create a shell surface * flush the wayland client connection * access to the created interfaces - for compatibility with existing code The idea is to extend this Test library also for other common use cases like creating an X11 connection and X11 windows, etc. Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D2053
2016-06-30 11:32:54 +00:00
Test::destroyWaylandConnection();
[autotest] Add a test for locking the screen First test case is to ensure that pointer motion events trigger a leave event on the surface the pointer is on. The test case shows errors in the input handling. More tests need to be added.
2016-02-01 14:10:00 +00:00
}
[wayland] Place lockscreen greeter above other windows Summary: BUG: 420802 Reviewers: #kwin, davidedmundson Reviewed By: #kwin, davidedmundson Subscribers: apol, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D29523
2020-05-08 08:26:27 +00:00
void LockScreenTest::testStackingOrder()
{
// This test verifies that the lockscreen greeter is placed above other windows.
Emit clientAdded for wayland clients Emit the clientAdded() signal also for Wayland clients in order to unify the API of the Workspace class for different client types.
2020-07-22 18:35:41 +00:00
QSignalSpy clientAddedSpy(workspace(), &Workspace::clientAdded);
[wayland] Place lockscreen greeter above other windows Summary: BUG: 420802 Reviewers: #kwin, davidedmundson Reviewed By: #kwin, davidedmundson Subscribers: apol, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D29523
2020-05-08 08:26:27 +00:00
QVERIFY(clientAddedSpy.isValid());
Run clang-format The .clang-format file is based on the one in ECM except the following style options: - AlwaysBreakBeforeMultilineStrings - BinPackArguments - BinPackParameters - ColumnLimit - BreakBeforeBraces - KeepEmptyLinesAtTheStartOfBlocks
2022-03-23 10:13:38 +00:00
LOCK;
[wayland] Place lockscreen greeter above other windows Summary: BUG: 420802 Reviewers: #kwin, davidedmundson Reviewed By: #kwin, davidedmundson Subscribers: apol, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D29523
2020-05-08 08:26:27 +00:00
QVERIFY(clientAddedSpy.wait());
Rename AbstractClient to Window
2022-04-22 17:39:12 +00:00
Window *client = clientAddedSpy.first().first().value<Window *>();
[wayland] Place lockscreen greeter above other windows Summary: BUG: 420802 Reviewers: #kwin, davidedmundson Reviewed By: #kwin, davidedmundson Subscribers: apol, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D29523
2020-05-08 08:26:27 +00:00
QVERIFY(client);
QVERIFY(client->isLockScreen());
QCOMPARE(client->layer(), UnmanagedLayer);
Run clang-format The .clang-format file is based on the one in ECM except the following style options: - AlwaysBreakBeforeMultilineStrings - BinPackArguments - BinPackParameters - ColumnLimit - BreakBeforeBraces - KeepEmptyLinesAtTheStartOfBlocks
2022-03-23 10:13:38 +00:00
UNLOCK;
[wayland] Place lockscreen greeter above other windows Summary: BUG: 420802 Reviewers: #kwin, davidedmundson Reviewed By: #kwin, davidedmundson Subscribers: apol, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D29523
2020-05-08 08:26:27 +00:00
}
[autotest] Add a test for locking the screen First test case is to ensure that pointer motion events trigger a leave event on the surface the pointer is on. The test case shows errors in the input handling. More tests need to be added.
2016-02-01 14:10:00 +00:00
void LockScreenTest::testPointer()
{
using namespace KWayland::Client;
QScopedPointer<Pointer> pointer(m_seat->createPointer());
QVERIFY(!pointer.isNull());
QSignalSpy enteredSpy(pointer.data(), &Pointer::entered);
QVERIFY(enteredSpy.isValid());
QSignalSpy leftSpy(pointer.data(), &Pointer::left);
QVERIFY(leftSpy.isValid());
Rename AbstractClient to Window
2022-04-22 17:39:12 +00:00
Window *c = showWindow();
[autotest] Add a test for locking the screen First test case is to ensure that pointer motion events trigger a leave event on the surface the pointer is on. The test case shows errors in the input handling. More tests need to be added.
2016-02-01 14:10:00 +00:00
QVERIFY(c);
// first move cursor into the center of the window
quint32 timestamp = 1;
Rename geometry property to frameGeometry Summary: In order to properly implement xdg_surface.set_window_geometry we need two kinds of geometry - frame and buffer. The frame geometry specifies visible bounds of the client on the screen, excluding client-side drop shadows. The buffer geometry specifies rectangle on the screen that the attached buffer or x11 pixmap occupies on the screen. This change renames the geometry property to frameGeometry in order to reflect the new meaning assigned to it as well to make it easier to differentiate between frame geometry and buffer geometry in the future. Reviewers: #kwin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D24334
2019-09-27 10:01:10 +00:00
MOTION(c->frameGeometry().center());
[autotest] Add a test for locking the screen First test case is to ensure that pointer motion events trigger a leave event on the surface the pointer is on. The test case shows errors in the input handling. More tests need to be added.
2016-02-01 14:10:00 +00:00
QVERIFY(enteredSpy.wait());
Run clang-format The .clang-format file is based on the one in ECM except the following style options: - AlwaysBreakBeforeMultilineStrings - BinPackArguments - BinPackParameters - ColumnLimit - BreakBeforeBraces - KeepEmptyLinesAtTheStartOfBlocks
2022-03-23 10:13:38 +00:00
LOCK;
[autotest] Add a test for locking the screen First test case is to ensure that pointer motion events trigger a leave event on the surface the pointer is on. The test case shows errors in the input handling. More tests need to be added.
2016-02-01 14:10:00 +00:00
[autotests] Wait longer in LockScreenTest It timed out on build.kde.org, so let's try to wait longer.
2016-11-25 06:56:24 +00:00
QVERIFY(leftSpy.wait());
[autotest] Add a test for locking the screen First test case is to ensure that pointer motion events trigger a leave event on the surface the pointer is on. The test case shows errors in the input handling. More tests need to be added.
2016-02-01 14:10:00 +00:00
QCOMPARE(leftSpy.count(), 1);
// simulate moving out in and out again
Rename geometry property to frameGeometry Summary: In order to properly implement xdg_surface.set_window_geometry we need two kinds of geometry - frame and buffer. The frame geometry specifies visible bounds of the client on the screen, excluding client-side drop shadows. The buffer geometry specifies rectangle on the screen that the attached buffer or x11 pixmap occupies on the screen. This change renames the geometry property to frameGeometry in order to reflect the new meaning assigned to it as well to make it easier to differentiate between frame geometry and buffer geometry in the future. Reviewers: #kwin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D24334
2019-09-27 10:01:10 +00:00
MOTION(c->frameGeometry().center());
MOTION(c->frameGeometry().bottomRight() + QPoint(100, 100));
MOTION(c->frameGeometry().bottomRight() + QPoint(100, 100));
[autotests] Wait longer in LockScreenTest It timed out on build.kde.org, so let's try to wait longer.
2016-11-25 06:56:24 +00:00
QVERIFY(!leftSpy.wait());
[autotest] Add a test for locking the screen First test case is to ensure that pointer motion events trigger a leave event on the surface the pointer is on. The test case shows errors in the input handling. More tests need to be added.
2016-02-01 14:10:00 +00:00
QCOMPARE(leftSpy.count(), 1);
QCOMPARE(enteredSpy.count(), 1);
// go back on the window
Rename geometry property to frameGeometry Summary: In order to properly implement xdg_surface.set_window_geometry we need two kinds of geometry - frame and buffer. The frame geometry specifies visible bounds of the client on the screen, excluding client-side drop shadows. The buffer geometry specifies rectangle on the screen that the attached buffer or x11 pixmap occupies on the screen. This change renames the geometry property to frameGeometry in order to reflect the new meaning assigned to it as well to make it easier to differentiate between frame geometry and buffer geometry in the future. Reviewers: #kwin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D24334
2019-09-27 10:01:10 +00:00
MOTION(c->frameGeometry().center());
[autotest] Add a test for locking the screen First test case is to ensure that pointer motion events trigger a leave event on the surface the pointer is on. The test case shows errors in the input handling. More tests need to be added.
2016-02-01 14:10:00 +00:00
// and unlock
Run clang-format The .clang-format file is based on the one in ECM except the following style options: - AlwaysBreakBeforeMultilineStrings - BinPackArguments - BinPackParameters - ColumnLimit - BreakBeforeBraces - KeepEmptyLinesAtTheStartOfBlocks
2022-03-23 10:13:38 +00:00
UNLOCK;
[autotest] Add a test for locking the screen First test case is to ensure that pointer motion events trigger a leave event on the surface the pointer is on. The test case shows errors in the input handling. More tests need to be added.
2016-02-01 14:10:00 +00:00
[autotests] Wait longer in LockScreenTest It timed out on build.kde.org, so let's try to wait longer.
2016-11-25 06:56:24 +00:00
QVERIFY(enteredSpy.wait());
[autotest] Add a test for locking the screen First test case is to ensure that pointer motion events trigger a leave event on the surface the pointer is on. The test case shows errors in the input handling. More tests need to be added.
2016-02-01 14:10:00 +00:00
QCOMPARE(enteredSpy.count(), 2);
// move on the window
Rename geometry property to frameGeometry Summary: In order to properly implement xdg_surface.set_window_geometry we need two kinds of geometry - frame and buffer. The frame geometry specifies visible bounds of the client on the screen, excluding client-side drop shadows. The buffer geometry specifies rectangle on the screen that the attached buffer or x11 pixmap occupies on the screen. This change renames the geometry property to frameGeometry in order to reflect the new meaning assigned to it as well to make it easier to differentiate between frame geometry and buffer geometry in the future. Reviewers: #kwin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D24334
2019-09-27 10:01:10 +00:00
MOTION(c->frameGeometry().center() + QPoint(100, 100));
Improve lock screen interaction for pointer in InputRedirection InputRedirection connects to lockStateChanged to udate the current pointer window. This way we can ensure that the current pointer surface gets reset as soon as the screen locks (c.f. the expect fail in the autotest) and also that it restores to the surface under the mouse once the screen is unlocked. The relevant code was not yet lock screen aware and performed an early exit. Part of the code was fine, e.g. findToplevel is lock screen aware. So this change adjusts the methods for updating the internal window and decoration to be lock screen aware, that is they get reset. With that updatePointerWindow is also lock screen aware. Thus the LockScreenFilter can also use updatePointerWindow just like the normal handling and does not need to reimplement parts of it. As it now relies on other code being correct it has an additional check to verify that the current pointer surface is a surface which is allowed to get events. If it isn't the events are not forwarded. Reviewed-By: Bhushan Shah
2016-02-09 16:18:58 +00:00
QVERIFY(leftSpy.wait());
Rename geometry property to frameGeometry Summary: In order to properly implement xdg_surface.set_window_geometry we need two kinds of geometry - frame and buffer. The frame geometry specifies visible bounds of the client on the screen, excluding client-side drop shadows. The buffer geometry specifies rectangle on the screen that the attached buffer or x11 pixmap occupies on the screen. This change renames the geometry property to frameGeometry in order to reflect the new meaning assigned to it as well to make it easier to differentiate between frame geometry and buffer geometry in the future. Reviewers: #kwin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D24334
2019-09-27 10:01:10 +00:00
MOTION(c->frameGeometry().center());
Improve lock screen interaction for pointer in InputRedirection InputRedirection connects to lockStateChanged to udate the current pointer window. This way we can ensure that the current pointer surface gets reset as soon as the screen locks (c.f. the expect fail in the autotest) and also that it restores to the surface under the mouse once the screen is unlocked. The relevant code was not yet lock screen aware and performed an early exit. Part of the code was fine, e.g. findToplevel is lock screen aware. So this change adjusts the methods for updating the internal window and decoration to be lock screen aware, that is they get reset. With that updatePointerWindow is also lock screen aware. Thus the LockScreenFilter can also use updatePointerWindow just like the normal handling and does not need to reimplement parts of it. As it now relies on other code being correct it has an additional check to verify that the current pointer surface is a surface which is allowed to get events. If it isn't the events are not forwarded. Reviewed-By: Bhushan Shah
2016-02-09 16:18:58 +00:00
QVERIFY(enteredSpy.wait());
QCOMPARE(enteredSpy.count(), 3);
[autotest] Add a test for locking the screen First test case is to ensure that pointer motion events trigger a leave event on the surface the pointer is on. The test case shows errors in the input handling. More tests need to be added.
2016-02-01 14:10:00 +00:00
}
[autotest] Add test case for pointer buttons on locked screen Extends the lock screen tests by verifying that pointer button press/release events will be intercepted by the lock screen.
2016-02-01 16:57:38 +00:00
void LockScreenTest::testPointerButton()
{
using namespace KWayland::Client;
QScopedPointer<Pointer> pointer(m_seat->createPointer());
QVERIFY(!pointer.isNull());
[autotest/intergration] Wait for pointer enter before simulating button press The test LockScreenTest::testPointerButton and testPointerAxis both fail on Neon's CI infrastructure. In order to make the test more reliable the tests first wait for the pointer enter after unlock before simulating another button press.
2016-08-08 09:12:22 +00:00
QSignalSpy enteredSpy(pointer.data(), &Pointer::entered);
QVERIFY(enteredSpy.isValid());
[autotest] Add test case for pointer buttons on locked screen Extends the lock screen tests by verifying that pointer button press/release events will be intercepted by the lock screen.
2016-02-01 16:57:38 +00:00
QSignalSpy buttonChangedSpy(pointer.data(), &Pointer::buttonStateChanged);
QVERIFY(buttonChangedSpy.isValid());
Rename AbstractClient to Window
2022-04-22 17:39:12 +00:00
Window *c = showWindow();
[autotest] Add test case for pointer buttons on locked screen Extends the lock screen tests by verifying that pointer button press/release events will be intercepted by the lock screen.
2016-02-01 16:57:38 +00:00
QVERIFY(c);
// first move cursor into the center of the window
quint32 timestamp = 1;
Rename geometry property to frameGeometry Summary: In order to properly implement xdg_surface.set_window_geometry we need two kinds of geometry - frame and buffer. The frame geometry specifies visible bounds of the client on the screen, excluding client-side drop shadows. The buffer geometry specifies rectangle on the screen that the attached buffer or x11 pixmap occupies on the screen. This change renames the geometry property to frameGeometry in order to reflect the new meaning assigned to it as well to make it easier to differentiate between frame geometry and buffer geometry in the future. Reviewers: #kwin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D24334
2019-09-27 10:01:10 +00:00
MOTION(c->frameGeometry().center());
[autotest/intergration] Wait for pointer enter before simulating button press The test LockScreenTest::testPointerButton and testPointerAxis both fail on Neon's CI infrastructure. In order to make the test more reliable the tests first wait for the pointer enter after unlock before simulating another button press.
2016-08-08 09:12:22 +00:00
QVERIFY(enteredSpy.wait());
[autotest] Add test case for pointer buttons on locked screen Extends the lock screen tests by verifying that pointer button press/release events will be intercepted by the lock screen.
2016-02-01 16:57:38 +00:00
// and simulate a click
[autotest] Reduce code duplication in LockScreenTest
2016-02-02 15:11:21 +00:00
PRESS;
[autotest] Add test case for pointer buttons on locked screen Extends the lock screen tests by verifying that pointer button press/release events will be intercepted by the lock screen.
2016-02-01 16:57:38 +00:00
QVERIFY(buttonChangedSpy.wait());
[autotest] Reduce code duplication in LockScreenTest
2016-02-02 15:11:21 +00:00
RELEASE;
[autotest] Add test case for pointer buttons on locked screen Extends the lock screen tests by verifying that pointer button press/release events will be intercepted by the lock screen.
2016-02-01 16:57:38 +00:00
QVERIFY(buttonChangedSpy.wait());
Run clang-format The .clang-format file is based on the one in ECM except the following style options: - AlwaysBreakBeforeMultilineStrings - BinPackArguments - BinPackParameters - ColumnLimit - BreakBeforeBraces - KeepEmptyLinesAtTheStartOfBlocks
2022-03-23 10:13:38 +00:00
LOCK;
[autotest] Add test case for pointer buttons on locked screen Extends the lock screen tests by verifying that pointer button press/release events will be intercepted by the lock screen.
2016-02-01 16:57:38 +00:00
// and simulate a click
[autotest] Reduce code duplication in LockScreenTest
2016-02-02 15:11:21 +00:00
PRESS;
[autotests] Wait longer in LockScreenTest It timed out on build.kde.org, so let's try to wait longer.
2016-11-25 06:56:24 +00:00
QVERIFY(!buttonChangedSpy.wait());
[autotest] Reduce code duplication in LockScreenTest
2016-02-02 15:11:21 +00:00
RELEASE;
[autotests] Wait longer in LockScreenTest It timed out on build.kde.org, so let's try to wait longer.
2016-11-25 06:56:24 +00:00
QVERIFY(!buttonChangedSpy.wait());
[autotest] Add test case for pointer buttons on locked screen Extends the lock screen tests by verifying that pointer button press/release events will be intercepted by the lock screen.
2016-02-01 16:57:38 +00:00
Run clang-format The .clang-format file is based on the one in ECM except the following style options: - AlwaysBreakBeforeMultilineStrings - BinPackArguments - BinPackParameters - ColumnLimit - BreakBeforeBraces - KeepEmptyLinesAtTheStartOfBlocks
2022-03-23 10:13:38 +00:00
UNLOCK;
[autotest/intergration] Wait for pointer enter before simulating button press The test LockScreenTest::testPointerButton and testPointerAxis both fail on Neon's CI infrastructure. In order to make the test more reliable the tests first wait for the pointer enter after unlock before simulating another button press.
2016-08-08 09:12:22 +00:00
QVERIFY(enteredSpy.wait());
QCOMPARE(enteredSpy.count(), 2);
[autotests] Adjust lockscreen test to improvements in KSld On the CI system our tests failed due to the greeter failing to start due to OpenGL problems. This was because we waited for a window to show which never happened. Thus the test failed. This change makes use of the new lockStateChanged signal to determine when the screen gets locked/unlocked. It's still possible that the test fails as I'm not able to reproduce the failure condition on the CI system.
2016-02-02 09:22:37 +00:00
[autotest] Add test case for pointer buttons on locked screen Extends the lock screen tests by verifying that pointer button press/release events will be intercepted by the lock screen.
2016-02-01 16:57:38 +00:00
// and click again
[autotest] Reduce code duplication in LockScreenTest
2016-02-02 15:11:21 +00:00
PRESS;
[autotest] Add test case for pointer buttons on locked screen Extends the lock screen tests by verifying that pointer button press/release events will be intercepted by the lock screen.
2016-02-01 16:57:38 +00:00
QVERIFY(buttonChangedSpy.wait());
[autotest] Reduce code duplication in LockScreenTest
2016-02-02 15:11:21 +00:00
RELEASE;
[autotest] Add test case for pointer buttons on locked screen Extends the lock screen tests by verifying that pointer button press/release events will be intercepted by the lock screen.
2016-02-01 16:57:38 +00:00
QVERIFY(buttonChangedSpy.wait());
}
[autotest] Extend lockscreen test * verifies that pointer axis isn't passed to windows * verifies that screen edge is not activated while screen is locked
2016-02-02 12:50:13 +00:00
void LockScreenTest::testPointerAxis()
{
using namespace KWayland::Client;
QScopedPointer<Pointer> pointer(m_seat->createPointer());
QVERIFY(!pointer.isNull());
QSignalSpy axisChangedSpy(pointer.data(), &Pointer::axisChanged);
QVERIFY(axisChangedSpy.isValid());
[autotest/intergration] Wait for pointer enter before simulating button press The test LockScreenTest::testPointerButton and testPointerAxis both fail on Neon's CI infrastructure. In order to make the test more reliable the tests first wait for the pointer enter after unlock before simulating another button press.
2016-08-08 09:12:22 +00:00
QSignalSpy enteredSpy(pointer.data(), &Pointer::entered);
QVERIFY(enteredSpy.isValid());
[autotest] Extend lockscreen test * verifies that pointer axis isn't passed to windows * verifies that screen edge is not activated while screen is locked
2016-02-02 12:50:13 +00:00
Rename AbstractClient to Window
2022-04-22 17:39:12 +00:00
Window *c = showWindow();
[autotest] Extend lockscreen test * verifies that pointer axis isn't passed to windows * verifies that screen edge is not activated while screen is locked
2016-02-02 12:50:13 +00:00
QVERIFY(c);
// first move cursor into the center of the window
quint32 timestamp = 1;
Rename geometry property to frameGeometry Summary: In order to properly implement xdg_surface.set_window_geometry we need two kinds of geometry - frame and buffer. The frame geometry specifies visible bounds of the client on the screen, excluding client-side drop shadows. The buffer geometry specifies rectangle on the screen that the attached buffer or x11 pixmap occupies on the screen. This change renames the geometry property to frameGeometry in order to reflect the new meaning assigned to it as well to make it easier to differentiate between frame geometry and buffer geometry in the future. Reviewers: #kwin Subscribers: kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D24334
2019-09-27 10:01:10 +00:00
MOTION(c->frameGeometry().center());
[autotest/intergration] Wait for pointer enter before simulating button press The test LockScreenTest::testPointerButton and testPointerAxis both fail on Neon's CI infrastructure. In order to make the test more reliable the tests first wait for the pointer enter after unlock before simulating another button press.
2016-08-08 09:12:22 +00:00
QVERIFY(enteredSpy.wait());
[autotest] Extend lockscreen test * verifies that pointer axis isn't passed to windows * verifies that screen edge is not activated while screen is locked
2016-02-02 12:50:13 +00:00
// and simulate axis
Migrate all autotest input simulation functions [5/6] Make autotests create fake input devices Migrate all input simulation functions from kwinApp()->platform()->... to the their counter part in the Test namespace.
2022-03-10 10:27:35 +00:00
Test::pointerAxisHorizontal(5.0, timestamp++);
[autotest] Extend lockscreen test * verifies that pointer axis isn't passed to windows * verifies that screen edge is not activated while screen is locked
2016-02-02 12:50:13 +00:00
QVERIFY(axisChangedSpy.wait());
Run clang-format The .clang-format file is based on the one in ECM except the following style options: - AlwaysBreakBeforeMultilineStrings - BinPackArguments - BinPackParameters - ColumnLimit - BreakBeforeBraces - KeepEmptyLinesAtTheStartOfBlocks
2022-03-23 10:13:38 +00:00
LOCK;
[autotest] Extend lockscreen test * verifies that pointer axis isn't passed to windows * verifies that screen edge is not activated while screen is locked
2016-02-02 12:50:13 +00:00
Run clang-format The .clang-format file is based on the one in ECM except the following style options: - AlwaysBreakBeforeMultilineStrings - BinPackArguments - BinPackParameters - ColumnLimit - BreakBeforeBraces - KeepEmptyLinesAtTheStartOfBlocks
2022-03-23 10:13:38 +00:00
// and simulate axis
Test::pointerAxisHorizontal(5.0, timestamp++);
[autotest] Extend lockscreen test * verifies that pointer axis isn't passed to windows * verifies that screen edge is not activated while screen is locked
2016-02-02 12:50:13 +00:00
QVERIFY(!axisChangedSpy.wait(100));
Migrate all autotest input simulation functions [5/6] Make autotests create fake input devices Migrate all input simulation functions from kwinApp()->platform()->... to the their counter part in the Test namespace.
2022-03-10 10:27:35 +00:00
Test::pointerAxisVertical(5.0, timestamp++);
[autotest] Extend lockscreen test * verifies that pointer axis isn't passed to windows * verifies that screen edge is not activated while screen is locked
2016-02-02 12:50:13 +00:00
QVERIFY(!axisChangedSpy.wait(100));
// and unlock
Run clang-format The .clang-format file is based on the one in ECM except the following style options: - AlwaysBreakBeforeMultilineStrings - BinPackArguments - BinPackParameters - ColumnLimit - BreakBeforeBraces - KeepEmptyLinesAtTheStartOfBlocks
2022-03-23 10:13:38 +00:00
UNLOCK;
[autotest/intergration] Wait for pointer enter before simulating button press The test LockScreenTest::testPointerButton and testPointerAxis both fail on Neon's CI infrastructure. In order to make the test more reliable the tests first wait for the pointer enter after unlock before simulating another button press.
2016-08-08 09:12:22 +00:00
QVERIFY(enteredSpy.wait());
QCOMPARE(enteredSpy.count(), 2);
[autotest] Extend lockscreen test * verifies that pointer axis isn't passed to windows * verifies that screen edge is not activated while screen is locked
2016-02-02 12:50:13 +00:00
// and move axis again
Migrate all autotest input simulation functions [5/6] Make autotests create fake input devices Migrate all input simulation functions from kwinApp()->platform()->... to the their counter part in the Test namespace.
2022-03-10 10:27:35 +00:00
Test::pointerAxisHorizontal(5.0, timestamp++);
[autotest] Extend lockscreen test * verifies that pointer axis isn't passed to windows * verifies that screen edge is not activated while screen is locked
2016-02-02 12:50:13 +00:00
QVERIFY(axisChangedSpy.wait());
Migrate all autotest input simulation functions [5/6] Make autotests create fake input devices Migrate all input simulation functions from kwinApp()->platform()->... to the their counter part in the Test namespace.
2022-03-10 10:27:35 +00:00
Test::pointerAxisVertical(5.0, timestamp++);
[autotest] Extend lockscreen test * verifies that pointer axis isn't passed to windows * verifies that screen edge is not activated while screen is locked
2016-02-02 12:50:13 +00:00
QVERIFY(axisChangedSpy.wait());
}
[autotests] Test case for lock screen intercepts key events Our active client should lose keyboard focus when screen gets locked and re-gain after the screen unlocks.
2016-02-08 15:52:22 +00:00
void LockScreenTest::testKeyboard()
{
using namespace KWayland::Client;
QScopedPointer<Keyboard> keyboard(m_seat->createKeyboard());
QVERIFY(!keyboard.isNull());
QSignalSpy enteredSpy(keyboard.data(), &Keyboard::entered);
QVERIFY(enteredSpy.isValid());
QSignalSpy leftSpy(keyboard.data(), &Keyboard::left);
QVERIFY(leftSpy.isValid());
QSignalSpy keyChangedSpy(keyboard.data(), &Keyboard::keyChanged);
QVERIFY(keyChangedSpy.isValid());
Rename AbstractClient to Window
2022-04-22 17:39:12 +00:00
Window *c = showWindow();
[autotests] Test case for lock screen intercepts key events Our active client should lose keyboard focus when screen gets locked and re-gain after the screen unlocks.
2016-02-08 15:52:22 +00:00
QVERIFY(c);
QVERIFY(enteredSpy.wait());
QTRY_COMPARE(enteredSpy.count(), 1);
quint32 timestamp = 1;
KEYPRESS(KEY_A);
QVERIFY(keyChangedSpy.wait());
QCOMPARE(keyChangedSpy.count(), 1);
QCOMPARE(keyChangedSpy.at(0).at(0).value<quint32>(), quint32(KEY_A));
QCOMPARE(keyChangedSpy.at(0).at(1).value<Keyboard::KeyState>(), Keyboard::KeyState::Pressed);
QCOMPARE(keyChangedSpy.at(0).at(2).value<quint32>(), quint32(1));
KEYRELEASE(KEY_A);
QVERIFY(keyChangedSpy.wait());
QCOMPARE(keyChangedSpy.count(), 2);
QCOMPARE(keyChangedSpy.at(1).at(0).value<quint32>(), quint32(KEY_A));
QCOMPARE(keyChangedSpy.at(1).at(1).value<Keyboard::KeyState>(), Keyboard::KeyState::Released);
QCOMPARE(keyChangedSpy.at(1).at(2).value<quint32>(), quint32(2));
Run clang-format The .clang-format file is based on the one in ECM except the following style options: - AlwaysBreakBeforeMultilineStrings - BinPackArguments - BinPackParameters - ColumnLimit - BreakBeforeBraces - KeepEmptyLinesAtTheStartOfBlocks
2022-03-23 10:13:38 +00:00
LOCK;
Add check for lock screen in InputRedirection::updateKeyboardWindow Instead of only making the active client the focused keyboard surface, the method now also performs the lock screen security restriction. Also just like udatePointerWindow the method becomes public, so that it can be used from the LockScreenEventFilter and is connected for lock state changes. This means as soon as the screen locks the current focused keyboard surface will get a leave event and get an enter event once the screen unlocks. The auto test is adjusted to verify these new conditions. Reviewed-By: Bhushan Shah
2016-02-10 13:40:56 +00:00
QVERIFY(leftSpy.wait());
[autotests] Test case for lock screen intercepts key events Our active client should lose keyboard focus when screen gets locked and re-gain after the screen unlocks.
2016-02-08 15:52:22 +00:00
KEYPRESS(KEY_B);
KEYRELEASE(KEY_B);
QCOMPARE(leftSpy.count(), 1);
QCOMPARE(keyChangedSpy.count(), 2);
Run clang-format The .clang-format file is based on the one in ECM except the following style options: - AlwaysBreakBeforeMultilineStrings - BinPackArguments - BinPackParameters - ColumnLimit - BreakBeforeBraces - KeepEmptyLinesAtTheStartOfBlocks
2022-03-23 10:13:38 +00:00
UNLOCK;
Add check for lock screen in InputRedirection::updateKeyboardWindow Instead of only making the active client the focused keyboard surface, the method now also performs the lock screen security restriction. Also just like udatePointerWindow the method becomes public, so that it can be used from the LockScreenEventFilter and is connected for lock state changes. This means as soon as the screen locks the current focused keyboard surface will get a leave event and get an enter event once the screen unlocks. The auto test is adjusted to verify these new conditions. Reviewed-By: Bhushan Shah
2016-02-10 13:40:56 +00:00
QVERIFY(enteredSpy.wait());
QCOMPARE(enteredSpy.count(), 2);
[autotests] Test case for lock screen intercepts key events Our active client should lose keyboard focus when screen gets locked and re-gain after the screen unlocks.
2016-02-08 15:52:22 +00:00
KEYPRESS(KEY_C);
QVERIFY(keyChangedSpy.wait());
QCOMPARE(keyChangedSpy.count(), 3);
KEYRELEASE(KEY_C);
QVERIFY(keyChangedSpy.wait());
QCOMPARE(keyChangedSpy.count(), 4);
QCOMPARE(enteredSpy.count(), 2);
QCOMPARE(keyChangedSpy.at(2).at(0).value<quint32>(), quint32(KEY_C));
QCOMPARE(keyChangedSpy.at(3).at(0).value<quint32>(), quint32(KEY_C));
QCOMPARE(keyChangedSpy.at(2).at(2).value<quint32>(), quint32(5));
QCOMPARE(keyChangedSpy.at(3).at(2).value<quint32>(), quint32(6));
QCOMPARE(keyChangedSpy.at(2).at(1).value<Keyboard::KeyState>(), Keyboard::KeyState::Pressed);
QCOMPARE(keyChangedSpy.at(3).at(1).value<Keyboard::KeyState>(), Keyboard::KeyState::Released);
}
[autotest] Extend lockscreen test * verifies that pointer axis isn't passed to windows * verifies that screen edge is not activated while screen is locked
2016-02-02 12:50:13 +00:00
void LockScreenTest::testScreenEdge()
{
QSignalSpy screenEdgeSpy(ScreenEdges::self(), &ScreenEdges::approaching);
QVERIFY(screenEdgeSpy.isValid());
QCOMPARE(screenEdgeSpy.count(), 0);
quint32 timestamp = 1;
[autotest] Reduce code duplication in LockScreenTest
2016-02-02 15:11:21 +00:00
MOTION(QPoint(5, 5));
[autotest] Extend lockscreen test * verifies that pointer axis isn't passed to windows * verifies that screen edge is not activated while screen is locked
2016-02-02 12:50:13 +00:00
QCOMPARE(screenEdgeSpy.count(), 1);
Run clang-format The .clang-format file is based on the one in ECM except the following style options: - AlwaysBreakBeforeMultilineStrings - BinPackArguments - BinPackParameters - ColumnLimit - BreakBeforeBraces - KeepEmptyLinesAtTheStartOfBlocks
2022-03-23 10:13:38 +00:00
LOCK;
[autotest] Extend lockscreen test * verifies that pointer axis isn't passed to windows * verifies that screen edge is not activated while screen is locked
2016-02-02 12:50:13 +00:00
[autotest] Reduce code duplication in LockScreenTest
2016-02-02 15:11:21 +00:00
MOTION(QPoint(4, 4));
[autotest] Extend lockscreen test * verifies that pointer axis isn't passed to windows * verifies that screen edge is not activated while screen is locked
2016-02-02 12:50:13 +00:00
QCOMPARE(screenEdgeSpy.count(), 1);
// and unlock
Run clang-format The .clang-format file is based on the one in ECM except the following style options: - AlwaysBreakBeforeMultilineStrings - BinPackArguments - BinPackParameters - ColumnLimit - BreakBeforeBraces - KeepEmptyLinesAtTheStartOfBlocks
2022-03-23 10:13:38 +00:00
UNLOCK;
[autotest] Extend lockscreen test * verifies that pointer axis isn't passed to windows * verifies that screen edge is not activated while screen is locked
2016-02-02 12:50:13 +00:00
[autotest] Reduce code duplication in LockScreenTest
2016-02-02 15:11:21 +00:00
MOTION(QPoint(5, 5));
[autotest] Extend lockscreen test * verifies that pointer axis isn't passed to windows * verifies that screen edge is not activated while screen is locked
2016-02-02 12:50:13 +00:00
QCOMPARE(screenEdgeSpy.count(), 2);
}
[autotests] Verify that Effects don't get pointer events on locked screen Interesting approach I would not have expected to work. A dummy Effect class is created in the test and an instance is passed to EffectsHandler's startMouseInterception. It doesn't verify whether it's an Effect it knows or has created, so it's totally happy with the dummy. It shows that motion and press/release are passed to the Effect when screen is not locked and doesn't while the screen is locked.
2016-02-02 13:41:28 +00:00
void LockScreenTest::testEffects()
{
QScopedPointer<HelperEffect> effect(new HelperEffect);
QSignalSpy inputSpy(effect.data(), &HelperEffect::inputEvent);
QVERIFY(inputSpy.isValid());
effects->startMouseInterception(effect.data(), Qt::ArrowCursor);
quint32 timestamp = 1;
QCOMPARE(inputSpy.count(), 0);
[autotest] Reduce code duplication in LockScreenTest
2016-02-02 15:11:21 +00:00
MOTION(QPoint(5, 5));
[autotests] Verify that Effects don't get pointer events on locked screen Interesting approach I would not have expected to work. A dummy Effect class is created in the test and an instance is passed to EffectsHandler's startMouseInterception. It doesn't verify whether it's an Effect it knows or has created, so it's totally happy with the dummy. It shows that motion and press/release are passed to the Effect when screen is not locked and doesn't while the screen is locked.
2016-02-02 13:41:28 +00:00
QCOMPARE(inputSpy.count(), 1);
// simlate click
[autotest] Reduce code duplication in LockScreenTest
2016-02-02 15:11:21 +00:00
PRESS;
[autotests] Verify that Effects don't get pointer events on locked screen Interesting approach I would not have expected to work. A dummy Effect class is created in the test and an instance is passed to EffectsHandler's startMouseInterception. It doesn't verify whether it's an Effect it knows or has created, so it's totally happy with the dummy. It shows that motion and press/release are passed to the Effect when screen is not locked and doesn't while the screen is locked.
2016-02-02 13:41:28 +00:00
QCOMPARE(inputSpy.count(), 2);
[autotest] Reduce code duplication in LockScreenTest
2016-02-02 15:11:21 +00:00
RELEASE;
[autotests] Verify that Effects don't get pointer events on locked screen Interesting approach I would not have expected to work. A dummy Effect class is created in the test and an instance is passed to EffectsHandler's startMouseInterception. It doesn't verify whether it's an Effect it knows or has created, so it's totally happy with the dummy. It shows that motion and press/release are passed to the Effect when screen is not locked and doesn't while the screen is locked.
2016-02-02 13:41:28 +00:00
QCOMPARE(inputSpy.count(), 3);
Run clang-format The .clang-format file is based on the one in ECM except the following style options: - AlwaysBreakBeforeMultilineStrings - BinPackArguments - BinPackParameters - ColumnLimit - BreakBeforeBraces - KeepEmptyLinesAtTheStartOfBlocks
2022-03-23 10:13:38 +00:00
LOCK;
[autotests] Verify that Effects don't get pointer events on locked screen Interesting approach I would not have expected to work. A dummy Effect class is created in the test and an instance is passed to EffectsHandler's startMouseInterception. It doesn't verify whether it's an Effect it knows or has created, so it's totally happy with the dummy. It shows that motion and press/release are passed to the Effect when screen is not locked and doesn't while the screen is locked.
2016-02-02 13:41:28 +00:00
[autotest] Reduce code duplication in LockScreenTest
2016-02-02 15:11:21 +00:00
MOTION(QPoint(6, 6));
[autotests] Verify that Effects don't get pointer events on locked screen Interesting approach I would not have expected to work. A dummy Effect class is created in the test and an instance is passed to EffectsHandler's startMouseInterception. It doesn't verify whether it's an Effect it knows or has created, so it's totally happy with the dummy. It shows that motion and press/release are passed to the Effect when screen is not locked and doesn't while the screen is locked.
2016-02-02 13:41:28 +00:00
QCOMPARE(inputSpy.count(), 3);
// simlate click
[autotest] Reduce code duplication in LockScreenTest
2016-02-02 15:11:21 +00:00
PRESS;
[autotests] Verify that Effects don't get pointer events on locked screen Interesting approach I would not have expected to work. A dummy Effect class is created in the test and an instance is passed to EffectsHandler's startMouseInterception. It doesn't verify whether it's an Effect it knows or has created, so it's totally happy with the dummy. It shows that motion and press/release are passed to the Effect when screen is not locked and doesn't while the screen is locked.
2016-02-02 13:41:28 +00:00
QCOMPARE(inputSpy.count(), 3);
[autotest] Reduce code duplication in LockScreenTest
2016-02-02 15:11:21 +00:00
RELEASE;
[autotests] Verify that Effects don't get pointer events on locked screen Interesting approach I would not have expected to work. A dummy Effect class is created in the test and an instance is passed to EffectsHandler's startMouseInterception. It doesn't verify whether it's an Effect it knows or has created, so it's totally happy with the dummy. It shows that motion and press/release are passed to the Effect when screen is not locked and doesn't while the screen is locked.
2016-02-02 13:41:28 +00:00
QCOMPARE(inputSpy.count(), 3);
Run clang-format The .clang-format file is based on the one in ECM except the following style options: - AlwaysBreakBeforeMultilineStrings - BinPackArguments - BinPackParameters - ColumnLimit - BreakBeforeBraces - KeepEmptyLinesAtTheStartOfBlocks
2022-03-23 10:13:38 +00:00
UNLOCK;
[autotests] Verify that Effects don't get pointer events on locked screen Interesting approach I would not have expected to work. A dummy Effect class is created in the test and an instance is passed to EffectsHandler's startMouseInterception. It doesn't verify whether it's an Effect it knows or has created, so it's totally happy with the dummy. It shows that motion and press/release are passed to the Effect when screen is not locked and doesn't while the screen is locked.
2016-02-02 13:41:28 +00:00
[autotest] Reduce code duplication in LockScreenTest
2016-02-02 15:11:21 +00:00
MOTION(QPoint(5, 5));
[autotests] Verify that Effects don't get pointer events on locked screen Interesting approach I would not have expected to work. A dummy Effect class is created in the test and an instance is passed to EffectsHandler's startMouseInterception. It doesn't verify whether it's an Effect it knows or has created, so it's totally happy with the dummy. It shows that motion and press/release are passed to the Effect when screen is not locked and doesn't while the screen is locked.
2016-02-02 13:41:28 +00:00
QCOMPARE(inputSpy.count(), 4);
// simlate click
[autotest] Reduce code duplication in LockScreenTest
2016-02-02 15:11:21 +00:00
PRESS;
[autotests] Verify that Effects don't get pointer events on locked screen Interesting approach I would not have expected to work. A dummy Effect class is created in the test and an instance is passed to EffectsHandler's startMouseInterception. It doesn't verify whether it's an Effect it knows or has created, so it's totally happy with the dummy. It shows that motion and press/release are passed to the Effect when screen is not locked and doesn't while the screen is locked.
2016-02-02 13:41:28 +00:00
QCOMPARE(inputSpy.count(), 5);
[autotest] Reduce code duplication in LockScreenTest
2016-02-02 15:11:21 +00:00
RELEASE;
[autotests] Verify that Effects don't get pointer events on locked screen Interesting approach I would not have expected to work. A dummy Effect class is created in the test and an instance is passed to EffectsHandler's startMouseInterception. It doesn't verify whether it's an Effect it knows or has created, so it's totally happy with the dummy. It shows that motion and press/release are passed to the Effect when screen is not locked and doesn't while the screen is locked.
2016-02-02 13:41:28 +00:00
QCOMPARE(inputSpy.count(), 6);
effects->stopMouseInterception(effect.data());
}
[autotests] Add test case for effects key handling during screen lock Verifies that no key events are forwarded to the Effects during a locked screen.
2016-02-08 11:36:39 +00:00
void LockScreenTest::testEffectsKeyboard()
{
QScopedPointer<HelperEffect> effect(new HelperEffect);
QSignalSpy inputSpy(effect.data(), &HelperEffect::keyEvent);
QVERIFY(inputSpy.isValid());
effects->grabKeyboard(effect.data());
quint32 timestamp = 1;
KEYPRESS(KEY_A);
QCOMPARE(inputSpy.count(), 1);
QCOMPARE(inputSpy.first().first().toString(), QStringLiteral("a"));
KEYRELEASE(KEY_A);
QCOMPARE(inputSpy.count(), 2);
QCOMPARE(inputSpy.first().first().toString(), QStringLiteral("a"));
QCOMPARE(inputSpy.at(1).first().toString(), QStringLiteral("a"));
Run clang-format The .clang-format file is based on the one in ECM except the following style options: - AlwaysBreakBeforeMultilineStrings - BinPackArguments - BinPackParameters - ColumnLimit - BreakBeforeBraces - KeepEmptyLinesAtTheStartOfBlocks
2022-03-23 10:13:38 +00:00
LOCK;
[autotests] Add test case for effects key handling during screen lock Verifies that no key events are forwarded to the Effects during a locked screen.
2016-02-08 11:36:39 +00:00
KEYPRESS(KEY_B);
QCOMPARE(inputSpy.count(), 2);
KEYRELEASE(KEY_B);
QCOMPARE(inputSpy.count(), 2);
Run clang-format The .clang-format file is based on the one in ECM except the following style options: - AlwaysBreakBeforeMultilineStrings - BinPackArguments - BinPackParameters - ColumnLimit - BreakBeforeBraces - KeepEmptyLinesAtTheStartOfBlocks
2022-03-23 10:13:38 +00:00
UNLOCK;
[autotests] Add test case for effects key handling during screen lock Verifies that no key events are forwarded to the Effects during a locked screen.
2016-02-08 11:36:39 +00:00
KEYPRESS(KEY_C);
QCOMPARE(inputSpy.count(), 3);
QCOMPARE(inputSpy.first().first().toString(), QStringLiteral("a"));
QCOMPARE(inputSpy.at(1).first().toString(), QStringLiteral("a"));
QCOMPARE(inputSpy.at(2).first().toString(), QStringLiteral("c"));
KEYRELEASE(KEY_C);
QCOMPARE(inputSpy.count(), 4);
QCOMPARE(inputSpy.first().first().toString(), QStringLiteral("a"));
QCOMPARE(inputSpy.at(1).first().toString(), QStringLiteral("a"));
QCOMPARE(inputSpy.at(2).first().toString(), QStringLiteral("c"));
QCOMPARE(inputSpy.at(3).first().toString(), QStringLiteral("c"));
effects->ungrabKeyboard();
}
Implement internal keyboard repeat As a Wayland server KWin does not have to emit additional key repeat events (unlike X11). The clients are responsible for handling this based on the provided key repeat information. Internally KWin needs key repeat, though. E.g. the effects need key repeat (filtering in Present Windows), window moving by keyboard needs repeat, etc. etc. This change introduces the internal key repeat. For each key press a QTimer is started which gets canceled again on the key release. If the timer fires it invoked processKey with a new KeyboardKeyAutoRepeat state. This is handled just like a KeyPress, but states are not updated and the QKeyEvent has autorepeat set to true. The event filters check for the autorepeat state and filter the event out if they are not interested in it. E.g. the filters passing the event to the Wayland client need to filter it out. Currently auto-repeat is bound to using libinput. This needs to be modified. The only backend sending repeated events is X11, thus for other backends it should be enabled. Whether creating a timer on each key event is a good idea is something to evaluate in future. Reviewed-By: Bhushan Shah
2016-02-19 06:53:20 +00:00
void LockScreenTest::testEffectsKeyboardAutorepeat()
{
// this test is just like testEffectsKeyboard, but tests auto repeat key events
// while the key is pressed the Effect should get auto repeated events
// but the lock screen should filter them out
QScopedPointer<HelperEffect> effect(new HelperEffect);
QSignalSpy inputSpy(effect.data(), &HelperEffect::keyEvent);
QVERIFY(inputSpy.isValid());
effects->grabKeyboard(effect.data());
// we need to configure the key repeat first. It is only enabled on libinput
adapt to changes in seat and keyboard interface Now several methods of keyboard_interface are public and wrappers for them are removed from the seat_interface.
2020-11-06 04:46:26 +00:00
waylandServer()->seat()->keyboard()->setRepeatInfo(25, 300);
Implement internal keyboard repeat As a Wayland server KWin does not have to emit additional key repeat events (unlike X11). The clients are responsible for handling this based on the provided key repeat information. Internally KWin needs key repeat, though. E.g. the effects need key repeat (filtering in Present Windows), window moving by keyboard needs repeat, etc. etc. This change introduces the internal key repeat. For each key press a QTimer is started which gets canceled again on the key release. If the timer fires it invoked processKey with a new KeyboardKeyAutoRepeat state. This is handled just like a KeyPress, but states are not updated and the QKeyEvent has autorepeat set to true. The event filters check for the autorepeat state and filter the event out if they are not interested in it. E.g. the filters passing the event to the Wayland client need to filter it out. Currently auto-repeat is bound to using libinput. This needs to be modified. The only backend sending repeated events is X11, thus for other backends it should be enabled. Whether creating a timer on each key event is a good idea is something to evaluate in future. Reviewed-By: Bhushan Shah
2016-02-19 06:53:20 +00:00
quint32 timestamp = 1;
KEYPRESS(KEY_A);
QCOMPARE(inputSpy.count(), 1);
QCOMPARE(inputSpy.first().first().toString(), QStringLiteral("a"));
QVERIFY(inputSpy.wait());
QVERIFY(inputSpy.count() > 1);
// and still more events
QVERIFY(inputSpy.wait());
QCOMPARE(inputSpy.at(1).first().toString(), QStringLiteral("a"));
// now release
inputSpy.clear();
KEYRELEASE(KEY_A);
QCOMPARE(inputSpy.count(), 1);
// while locked key repeat should not pass any events to the Effect
Run clang-format The .clang-format file is based on the one in ECM except the following style options: - AlwaysBreakBeforeMultilineStrings - BinPackArguments - BinPackParameters - ColumnLimit - BreakBeforeBraces - KeepEmptyLinesAtTheStartOfBlocks
2022-03-23 10:13:38 +00:00
LOCK;
Implement internal keyboard repeat As a Wayland server KWin does not have to emit additional key repeat events (unlike X11). The clients are responsible for handling this based on the provided key repeat information. Internally KWin needs key repeat, though. E.g. the effects need key repeat (filtering in Present Windows), window moving by keyboard needs repeat, etc. etc. This change introduces the internal key repeat. For each key press a QTimer is started which gets canceled again on the key release. If the timer fires it invoked processKey with a new KeyboardKeyAutoRepeat state. This is handled just like a KeyPress, but states are not updated and the QKeyEvent has autorepeat set to true. The event filters check for the autorepeat state and filter the event out if they are not interested in it. E.g. the filters passing the event to the Wayland client need to filter it out. Currently auto-repeat is bound to using libinput. This needs to be modified. The only backend sending repeated events is X11, thus for other backends it should be enabled. Whether creating a timer on each key event is a good idea is something to evaluate in future. Reviewed-By: Bhushan Shah
2016-02-19 06:53:20 +00:00
KEYPRESS(KEY_B);
QVERIFY(!inputSpy.wait(200));
KEYRELEASE(KEY_B);
QVERIFY(!inputSpy.wait(200));
Run clang-format The .clang-format file is based on the one in ECM except the following style options: - AlwaysBreakBeforeMultilineStrings - BinPackArguments - BinPackParameters - ColumnLimit - BreakBeforeBraces - KeepEmptyLinesAtTheStartOfBlocks
2022-03-23 10:13:38 +00:00
UNLOCK;
Implement internal keyboard repeat As a Wayland server KWin does not have to emit additional key repeat events (unlike X11). The clients are responsible for handling this based on the provided key repeat information. Internally KWin needs key repeat, though. E.g. the effects need key repeat (filtering in Present Windows), window moving by keyboard needs repeat, etc. etc. This change introduces the internal key repeat. For each key press a QTimer is started which gets canceled again on the key release. If the timer fires it invoked processKey with a new KeyboardKeyAutoRepeat state. This is handled just like a KeyPress, but states are not updated and the QKeyEvent has autorepeat set to true. The event filters check for the autorepeat state and filter the event out if they are not interested in it. E.g. the filters passing the event to the Wayland client need to filter it out. Currently auto-repeat is bound to using libinput. This needs to be modified. The only backend sending repeated events is X11, thus for other backends it should be enabled. Whether creating a timer on each key event is a good idea is something to evaluate in future. Reviewed-By: Bhushan Shah
2016-02-19 06:53:20 +00:00
// don't test again, that's covered by testEffectsKeyboard
effects->ungrabKeyboard();
}
[autotests] Extend LockScreenTest for locking while moving window Things which weren't possible on X11 are possible now.
2016-02-03 08:36:12 +00:00
void LockScreenTest::testMoveWindow()
{
using namespace KWayland::Client;
Rename AbstractClient to Window
2022-04-22 17:39:12 +00:00
Window *c = showWindow();
[autotests] Extend LockScreenTest for locking while moving window Things which weren't possible on X11 are possible now.
2016-02-03 08:36:12 +00:00
QVERIFY(c);
Rename AbstractClient to Window
2022-04-22 17:39:12 +00:00
QSignalSpy clientStepUserMovedResizedSpy(c, &Window::clientStepUserMovedResized);
[autotests] Extend LockScreenTest for locking while moving window Things which weren't possible on X11 are possible now.
2016-02-03 08:36:12 +00:00
QVERIFY(clientStepUserMovedResizedSpy.isValid());
quint32 timestamp = 1;
workspace()->slotWindowMove();
Use more accurate name for Workspace::getMovingClient method Summary: The name of Workspace::getMovingClient() method implies that the returned value is a client that is currently being moved around by the user, but this is of course incorrect. Reviewers: #kwin, apol Reviewed By: apol Subscribers: apol, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D20663
2019-04-18 12:28:11 +00:00
QCOMPARE(workspace()->moveResizeClient(), c);
Prepend "Interactive" to interactive move resize methods This is to improve code readability and make it easier to differentiate between methods that are used during interactive move-resize and normal move-resize methods in the future.
2021-04-30 18:06:58 +00:00
QVERIFY(c->isInteractiveMove());
Migrate all autotest input simulation functions [5/6] Make autotests create fake input devices Migrate all input simulation functions from kwinApp()->platform()->... to the their counter part in the Test namespace.
2022-03-10 10:27:35 +00:00
Test::keyboardKeyPressed(KEY_RIGHT, timestamp++);
Test::keyboardKeyReleased(KEY_RIGHT, timestamp++);
[autotests] Extend LockScreenTest for locking while moving window Things which weren't possible on X11 are possible now.
2016-02-03 08:36:12 +00:00
QEXPECT_FAIL("", "First event is ignored", Continue);
QCOMPARE(clientStepUserMovedResizedSpy.count(), 1);
// TODO adjust once the expected fail is fixed
Migrate all autotest input simulation functions [5/6] Make autotests create fake input devices Migrate all input simulation functions from kwinApp()->platform()->... to the their counter part in the Test namespace.
2022-03-10 10:27:35 +00:00
Test::keyboardKeyPressed(KEY_RIGHT, timestamp++);
Test::keyboardKeyReleased(KEY_RIGHT, timestamp++);
[autotests] Extend LockScreenTest for locking while moving window Things which weren't possible on X11 are possible now.
2016-02-03 08:36:12 +00:00
QCOMPARE(clientStepUserMovedResizedSpy.count(), 1);
// while locking our window should continue to be in move resize
Run clang-format The .clang-format file is based on the one in ECM except the following style options: - AlwaysBreakBeforeMultilineStrings - BinPackArguments - BinPackParameters - ColumnLimit - BreakBeforeBraces - KeepEmptyLinesAtTheStartOfBlocks
2022-03-23 10:13:38 +00:00
LOCK;
Use more accurate name for Workspace::getMovingClient method Summary: The name of Workspace::getMovingClient() method implies that the returned value is a client that is currently being moved around by the user, but this is of course incorrect. Reviewers: #kwin, apol Reviewed By: apol Subscribers: apol, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D20663
2019-04-18 12:28:11 +00:00
QCOMPARE(workspace()->moveResizeClient(), c);
Prepend "Interactive" to interactive move resize methods This is to improve code readability and make it easier to differentiate between methods that are used during interactive move-resize and normal move-resize methods in the future.
2021-04-30 18:06:58 +00:00
QVERIFY(c->isInteractiveMove());
Migrate all autotest input simulation functions [5/6] Make autotests create fake input devices Migrate all input simulation functions from kwinApp()->platform()->... to the their counter part in the Test namespace.
2022-03-10 10:27:35 +00:00
Test::keyboardKeyPressed(KEY_RIGHT, timestamp++);
Test::keyboardKeyReleased(KEY_RIGHT, timestamp++);
[autotests] Extend LockScreenTest for locking while moving window Things which weren't possible on X11 are possible now.
2016-02-03 08:36:12 +00:00
QCOMPARE(clientStepUserMovedResizedSpy.count(), 1);
Run clang-format The .clang-format file is based on the one in ECM except the following style options: - AlwaysBreakBeforeMultilineStrings - BinPackArguments - BinPackParameters - ColumnLimit - BreakBeforeBraces - KeepEmptyLinesAtTheStartOfBlocks
2022-03-23 10:13:38 +00:00
UNLOCK;
Use more accurate name for Workspace::getMovingClient method Summary: The name of Workspace::getMovingClient() method implies that the returned value is a client that is currently being moved around by the user, but this is of course incorrect. Reviewers: #kwin, apol Reviewed By: apol Subscribers: apol, kwin Tags: #kwin Differential Revision: https://phabricator.kde.org/D20663
2019-04-18 12:28:11 +00:00
QCOMPARE(workspace()->moveResizeClient(), c);
Prepend "Interactive" to interactive move resize methods This is to improve code readability and make it easier to differentiate between methods that are used during interactive move-resize and normal move-resize methods in the future.
2021-04-30 18:06:58 +00:00
QVERIFY(c->isInteractiveMove());
Migrate all autotest input simulation functions [5/6] Make autotests create fake input devices Migrate all input simulation functions from kwinApp()->platform()->... to the their counter part in the Test namespace.
2022-03-10 10:27:35 +00:00
Test::keyboardKeyPressed(KEY_RIGHT, timestamp++);
Test::keyboardKeyReleased(KEY_RIGHT, timestamp++);
[autotests] Extend LockScreenTest for locking while moving window Things which weren't possible on X11 are possible now.
2016-02-03 08:36:12 +00:00
QCOMPARE(clientStepUserMovedResizedSpy.count(), 2);
Migrate all autotest input simulation functions [5/6] Make autotests create fake input devices Migrate all input simulation functions from kwinApp()->platform()->... to the their counter part in the Test namespace.
2022-03-10 10:27:35 +00:00
Test::keyboardKeyPressed(KEY_ESC, timestamp++);
Test::keyboardKeyReleased(KEY_ESC, timestamp++);
Prepend "Interactive" to interactive move resize methods This is to improve code readability and make it easier to differentiate between methods that are used during interactive move-resize and normal move-resize methods in the future.
2021-04-30 18:06:58 +00:00
QVERIFY(!c->isInteractiveMove());
[autotests] Extend LockScreenTest for locking while moving window Things which weren't possible on X11 are possible now.
2016-02-03 08:36:12 +00:00
}
[autotest] Extend LockScreen test for global pointer and axis shortcuts The global shortcuts may not be triggered while screen is locked.
2016-02-04 08:06:15 +00:00
void LockScreenTest::testPointerShortcut()
{
using namespace KWayland::Client;
QScopedPointer<QAction> action(new QAction(nullptr));
QSignalSpy actionSpy(action.data(), &QAction::triggered);
QVERIFY(actionSpy.isValid());
input()->registerPointerShortcut(Qt::MetaModifier, Qt::LeftButton, action.data());
// try to trigger the shortcut
quint32 timestamp = 1;
Run clang-format The .clang-format file is based on the one in ECM except the following style options: - AlwaysBreakBeforeMultilineStrings - BinPackArguments - BinPackParameters - ColumnLimit - BreakBeforeBraces - KeepEmptyLinesAtTheStartOfBlocks
2022-03-23 10:13:38 +00:00
#define PERFORM(expectedCount) \
do { \
Test::keyboardKeyPressed(KEY_LEFTMETA, timestamp++); \
PRESS; \
QCoreApplication::instance()->processEvents(); \
QCOMPARE(actionSpy.count(), expectedCount); \
RELEASE; \
Test::keyboardKeyReleased(KEY_LEFTMETA, timestamp++); \
QCoreApplication::instance()->processEvents(); \
QCOMPARE(actionSpy.count(), expectedCount); \
} while (false)
PERFORM(1);
[autotest] Extend LockScreen test for global pointer and axis shortcuts The global shortcuts may not be triggered while screen is locked.
2016-02-04 08:06:15 +00:00
// now the same thing with a locked screen
Run clang-format The .clang-format file is based on the one in ECM except the following style options: - AlwaysBreakBeforeMultilineStrings - BinPackArguments - BinPackParameters - ColumnLimit - BreakBeforeBraces - KeepEmptyLinesAtTheStartOfBlocks
2022-03-23 10:13:38 +00:00
LOCK;
PERFORM(1);
[autotest] Extend LockScreen test for global pointer and axis shortcuts The global shortcuts may not be triggered while screen is locked.
2016-02-04 08:06:15 +00:00
// and as unlocked
Run clang-format The .clang-format file is based on the one in ECM except the following style options: - AlwaysBreakBeforeMultilineStrings - BinPackArguments - BinPackParameters - ColumnLimit - BreakBeforeBraces - KeepEmptyLinesAtTheStartOfBlocks
2022-03-23 10:13:38 +00:00
UNLOCK;
PERFORM(2);
[autotest] Extend LockScreen test for global pointer and axis shortcuts The global shortcuts may not be triggered while screen is locked.
2016-02-04 08:06:15 +00:00
#undef PERFORM
}
void LockScreenTest::testAxisShortcut_data()
{
QTest::addColumn<Qt::Orientation>("direction");
QTest::addColumn<int>("sign");
QTest::newRow("up") << Qt::Vertical << 1;
QTest::newRow("down") << Qt::Vertical << -1;
QTest::newRow("left") << Qt::Horizontal << 1;
QTest::newRow("right") << Qt::Horizontal << -1;
}
void LockScreenTest::testAxisShortcut()
{
using namespace KWayland::Client;
QScopedPointer<QAction> action(new QAction(nullptr));
QSignalSpy actionSpy(action.data(), &QAction::triggered);
QVERIFY(actionSpy.isValid());
QFETCH(Qt::Orientation, direction);
QFETCH(int, sign);
PointerAxisDirection axisDirection = PointerAxisUp;
if (direction == Qt::Vertical) {
axisDirection = sign > 0 ? PointerAxisUp : PointerAxisDown;
} else {
axisDirection = sign > 0 ? PointerAxisLeft : PointerAxisRight;
}
input()->registerAxisShortcut(Qt::MetaModifier, axisDirection, action.data());
// try to trigger the shortcut
quint32 timestamp = 1;
Run clang-format The .clang-format file is based on the one in ECM except the following style options: - AlwaysBreakBeforeMultilineStrings - BinPackArguments - BinPackParameters - ColumnLimit - BreakBeforeBraces - KeepEmptyLinesAtTheStartOfBlocks
2022-03-23 10:13:38 +00:00
#define PERFORM(expectedCount) \
do { \
Test::keyboardKeyPressed(KEY_LEFTMETA, timestamp++); \
if (direction == Qt::Vertical) \
Test::pointerAxisVertical(sign * 5.0, timestamp++); \
else \
Test::pointerAxisHorizontal(sign * 5.0, timestamp++); \
QCoreApplication::instance()->processEvents(); \
QCOMPARE(actionSpy.count(), expectedCount); \
Test::keyboardKeyReleased(KEY_LEFTMETA, timestamp++); \
QCoreApplication::instance()->processEvents(); \
QCOMPARE(actionSpy.count(), expectedCount); \
} while (false)
PERFORM(1);
[autotest] Extend LockScreen test for global pointer and axis shortcuts The global shortcuts may not be triggered while screen is locked.
2016-02-04 08:06:15 +00:00
// now the same thing with a locked screen
Run clang-format The .clang-format file is based on the one in ECM except the following style options: - AlwaysBreakBeforeMultilineStrings - BinPackArguments - BinPackParameters - ColumnLimit - BreakBeforeBraces - KeepEmptyLinesAtTheStartOfBlocks
2022-03-23 10:13:38 +00:00
LOCK;
PERFORM(1);
[autotest] Extend LockScreen test for global pointer and axis shortcuts The global shortcuts may not be triggered while screen is locked.
2016-02-04 08:06:15 +00:00
// and as unlocked
Run clang-format The .clang-format file is based on the one in ECM except the following style options: - AlwaysBreakBeforeMultilineStrings - BinPackArguments - BinPackParameters - ColumnLimit - BreakBeforeBraces - KeepEmptyLinesAtTheStartOfBlocks
2022-03-23 10:13:38 +00:00
UNLOCK;
PERFORM(2);
[autotest] Extend LockScreen test for global pointer and axis shortcuts The global shortcuts may not be triggered while screen is locked.
2016-02-04 08:06:15 +00:00
#undef PERFORM
}
[autotest] Add test case for global shortcuts while screen is locked They shouldn't be triggered if the screen is locked.
2016-02-08 14:23:06 +00:00
void LockScreenTest::testKeyboardShortcut()
{
using namespace KWayland::Client;
QScopedPointer<QAction> action(new QAction(nullptr));
QSignalSpy actionSpy(action.data(), &QAction::triggered);
QVERIFY(actionSpy.isValid());
[autotests] Fix LockScreenTest::testKeyboardShortcut 32f4e115e2c68b75a5eea86e0a582388d5abadb9 broke the test. To my surprise there was a test using the kwin internal shortcut handling instead of using KGlobalAccel. This change adjusts the test to go through KGlobalAccel for testing the global shortcut.
2017-01-18 19:24:17 +00:00
action->setProperty("componentName", QStringLiteral(KWIN_NAME));
action->setObjectName("LockScreenTest::testKeyboardShortcut");
Use | rather than + for combining QFlags The plus operator is no longer available for flags in Qt6.
2022-03-09 16:35:12 +00:00
KGlobalAccel::self()->setDefaultShortcut(action.data(), QList<QKeySequence>{Qt::CTRL | Qt::META | Qt::ALT | Qt::Key_Space});
KGlobalAccel::self()->setShortcut(action.data(), QList<QKeySequence>{Qt::CTRL | Qt::META | Qt::ALT | Qt::Key_Space},
Run clang-format The .clang-format file is based on the one in ECM except the following style options: - AlwaysBreakBeforeMultilineStrings - BinPackArguments - BinPackParameters - ColumnLimit - BreakBeforeBraces - KeepEmptyLinesAtTheStartOfBlocks
2022-03-23 10:13:38 +00:00
KGlobalAccel::NoAutoloading);
[autotest] Add test case for global shortcuts while screen is locked They shouldn't be triggered if the screen is locked.
2016-02-08 14:23:06 +00:00
// try to trigger the shortcut
quint32 timestamp = 1;
KEYPRESS(KEY_LEFTCTRL);
KEYPRESS(KEY_LEFTMETA);
KEYPRESS(KEY_LEFTALT);
KEYPRESS(KEY_SPACE);
[autotests] Fix LockScreenTest::testKeyboardShortcut 32f4e115e2c68b75a5eea86e0a582388d5abadb9 broke the test. To my surprise there was a test using the kwin internal shortcut handling instead of using KGlobalAccel. This change adjusts the test to go through KGlobalAccel for testing the global shortcut.
2017-01-18 19:24:17 +00:00
QVERIFY(actionSpy.wait());
[autotest] Add test case for global shortcuts while screen is locked They shouldn't be triggered if the screen is locked.
2016-02-08 14:23:06 +00:00
QCOMPARE(actionSpy.count(), 1);
KEYRELEASE(KEY_SPACE);
[autotests] Fix LockScreenTest::testKeyboardShortcut 32f4e115e2c68b75a5eea86e0a582388d5abadb9 broke the test. To my surprise there was a test using the kwin internal shortcut handling instead of using KGlobalAccel. This change adjusts the test to go through KGlobalAccel for testing the global shortcut.
2017-01-18 19:24:17 +00:00
QVERIFY(!actionSpy.wait());
[autotest] Add test case for global shortcuts while screen is locked They shouldn't be triggered if the screen is locked.
2016-02-08 14:23:06 +00:00
QCOMPARE(actionSpy.count(), 1);
Run clang-format The .clang-format file is based on the one in ECM except the following style options: - AlwaysBreakBeforeMultilineStrings - BinPackArguments - BinPackParameters - ColumnLimit - BreakBeforeBraces - KeepEmptyLinesAtTheStartOfBlocks
2022-03-23 10:13:38 +00:00
LOCK;
[autotest] Add test case for global shortcuts while screen is locked They shouldn't be triggered if the screen is locked.
2016-02-08 14:23:06 +00:00
KEYPRESS(KEY_SPACE);
[autotests] Fix LockScreenTest::testKeyboardShortcut 32f4e115e2c68b75a5eea86e0a582388d5abadb9 broke the test. To my surprise there was a test using the kwin internal shortcut handling instead of using KGlobalAccel. This change adjusts the test to go through KGlobalAccel for testing the global shortcut.
2017-01-18 19:24:17 +00:00
QVERIFY(!actionSpy.wait());
[autotest] Add test case for global shortcuts while screen is locked They shouldn't be triggered if the screen is locked.
2016-02-08 14:23:06 +00:00
QCOMPARE(actionSpy.count(), 1);
KEYRELEASE(KEY_SPACE);
[autotests] Fix LockScreenTest::testKeyboardShortcut 32f4e115e2c68b75a5eea86e0a582388d5abadb9 broke the test. To my surprise there was a test using the kwin internal shortcut handling instead of using KGlobalAccel. This change adjusts the test to go through KGlobalAccel for testing the global shortcut.
2017-01-18 19:24:17 +00:00
QVERIFY(!actionSpy.wait());
[autotest] Add test case for global shortcuts while screen is locked They shouldn't be triggered if the screen is locked.
2016-02-08 14:23:06 +00:00
QCOMPARE(actionSpy.count(), 1);
Run clang-format The .clang-format file is based on the one in ECM except the following style options: - AlwaysBreakBeforeMultilineStrings - BinPackArguments - BinPackParameters - ColumnLimit - BreakBeforeBraces - KeepEmptyLinesAtTheStartOfBlocks
2022-03-23 10:13:38 +00:00
UNLOCK;
[autotest] Add test case for global shortcuts while screen is locked They shouldn't be triggered if the screen is locked.
2016-02-08 14:23:06 +00:00
KEYPRESS(KEY_SPACE);
[autotests] Fix LockScreenTest::testKeyboardShortcut 32f4e115e2c68b75a5eea86e0a582388d5abadb9 broke the test. To my surprise there was a test using the kwin internal shortcut handling instead of using KGlobalAccel. This change adjusts the test to go through KGlobalAccel for testing the global shortcut.
2017-01-18 19:24:17 +00:00
QVERIFY(actionSpy.wait());
[autotest] Add test case for global shortcuts while screen is locked They shouldn't be triggered if the screen is locked.
2016-02-08 14:23:06 +00:00
QCOMPARE(actionSpy.count(), 2);
KEYRELEASE(KEY_SPACE);
[autotests] Fix LockScreenTest::testKeyboardShortcut 32f4e115e2c68b75a5eea86e0a582388d5abadb9 broke the test. To my surprise there was a test using the kwin internal shortcut handling instead of using KGlobalAccel. This change adjusts the test to go through KGlobalAccel for testing the global shortcut.
2017-01-18 19:24:17 +00:00
QVERIFY(!actionSpy.wait());
[autotest] Add test case for global shortcuts while screen is locked They shouldn't be triggered if the screen is locked.
2016-02-08 14:23:06 +00:00
QCOMPARE(actionSpy.count(), 2);
KEYRELEASE(KEY_LEFTCTRL);
KEYRELEASE(KEY_LEFTMETA);
KEYRELEASE(KEY_LEFTALT);
}
Implement lock screen security for touch events When the screen gets locked any existing sequence gets cancelled and the focused touch surface gets reset. While screen is locked touch events are filtered to only go to lock screen or input methods. Test case is added for touch event during lock screen. Reviewed-By: Bhushan Shah
2016-02-10 15:43:06 +00:00
void LockScreenTest::testTouch()
{
using namespace KWayland::Client;
auto touch = m_seat->createTouch(m_seat);
QVERIFY(touch);
QVERIFY(touch->isValid());
Rename AbstractClient to Window
2022-04-22 17:39:12 +00:00
Window *c = showWindow();
Implement lock screen security for touch events When the screen gets locked any existing sequence gets cancelled and the focused touch surface gets reset. While screen is locked touch events are filtered to only go to lock screen or input methods. Test case is added for touch event during lock screen. Reviewed-By: Bhushan Shah
2016-02-10 15:43:06 +00:00
QVERIFY(c);
QSignalSpy sequenceStartedSpy(touch, &Touch::sequenceStarted);
QVERIFY(sequenceStartedSpy.isValid());
QSignalSpy cancelSpy(touch, &Touch::sequenceCanceled);
QVERIFY(cancelSpy.isValid());
QSignalSpy pointRemovedSpy(touch, &Touch::pointRemoved);
QVERIFY(pointRemovedSpy.isValid());
quint32 timestamp = 1;
Migrate all autotest input simulation functions [5/6] Make autotests create fake input devices Migrate all input simulation functions from kwinApp()->platform()->... to the their counter part in the Test namespace.
2022-03-10 10:27:35 +00:00
Test::touchDown(1, QPointF(25, 25), timestamp++);
Implement lock screen security for touch events When the screen gets locked any existing sequence gets cancelled and the focused touch surface gets reset. While screen is locked touch events are filtered to only go to lock screen or input methods. Test case is added for touch event during lock screen. Reviewed-By: Bhushan Shah
2016-02-10 15:43:06 +00:00
QVERIFY(sequenceStartedSpy.wait());
QCOMPARE(sequenceStartedSpy.count(), 1);
Run clang-format The .clang-format file is based on the one in ECM except the following style options: - AlwaysBreakBeforeMultilineStrings - BinPackArguments - BinPackParameters - ColumnLimit - BreakBeforeBraces - KeepEmptyLinesAtTheStartOfBlocks
2022-03-23 10:13:38 +00:00
LOCK;
Implement lock screen security for touch events When the screen gets locked any existing sequence gets cancelled and the focused touch surface gets reset. While screen is locked touch events are filtered to only go to lock screen or input methods. Test case is added for touch event during lock screen. Reviewed-By: Bhushan Shah
2016-02-10 15:43:06 +00:00
QVERIFY(cancelSpy.wait());
Migrate all autotest input simulation functions [5/6] Make autotests create fake input devices Migrate all input simulation functions from kwinApp()->platform()->... to the their counter part in the Test namespace.
2022-03-10 10:27:35 +00:00
Test::touchUp(1, timestamp++);
Implement lock screen security for touch events When the screen gets locked any existing sequence gets cancelled and the focused touch surface gets reset. While screen is locked touch events are filtered to only go to lock screen or input methods. Test case is added for touch event during lock screen. Reviewed-By: Bhushan Shah
2016-02-10 15:43:06 +00:00
QVERIFY(!pointRemovedSpy.wait(100));
Migrate all autotest input simulation functions [5/6] Make autotests create fake input devices Migrate all input simulation functions from kwinApp()->platform()->... to the their counter part in the Test namespace.
2022-03-10 10:27:35 +00:00
Test::touchDown(1, QPointF(25, 25), timestamp++);
Test::touchMotion(1, QPointF(26, 26), timestamp++);
Test::touchUp(1, timestamp++);
Implement lock screen security for touch events When the screen gets locked any existing sequence gets cancelled and the focused touch surface gets reset. While screen is locked touch events are filtered to only go to lock screen or input methods. Test case is added for touch event during lock screen. Reviewed-By: Bhushan Shah
2016-02-10 15:43:06 +00:00
Run clang-format The .clang-format file is based on the one in ECM except the following style options: - AlwaysBreakBeforeMultilineStrings - BinPackArguments - BinPackParameters - ColumnLimit - BreakBeforeBraces - KeepEmptyLinesAtTheStartOfBlocks
2022-03-23 10:13:38 +00:00
UNLOCK;
Migrate all autotest input simulation functions [5/6] Make autotests create fake input devices Migrate all input simulation functions from kwinApp()->platform()->... to the their counter part in the Test namespace.
2022-03-10 10:27:35 +00:00
Test::touchDown(1, QPointF(25, 25), timestamp++);
Implement lock screen security for touch events When the screen gets locked any existing sequence gets cancelled and the focused touch surface gets reset. While screen is locked touch events are filtered to only go to lock screen or input methods. Test case is added for touch event during lock screen. Reviewed-By: Bhushan Shah
2016-02-10 15:43:06 +00:00
QVERIFY(sequenceStartedSpy.wait());
QCOMPARE(sequenceStartedSpy.count(), 2);
Migrate all autotest input simulation functions [5/6] Make autotests create fake input devices Migrate all input simulation functions from kwinApp()->platform()->... to the their counter part in the Test namespace.
2022-03-10 10:27:35 +00:00
Test::touchUp(1, timestamp++);
Implement lock screen security for touch events When the screen gets locked any existing sequence gets cancelled and the focused touch surface gets reset. While screen is locked touch events are filtered to only go to lock screen or input methods. Test case is added for touch event during lock screen. Reviewed-By: Bhushan Shah
2016-02-10 15:43:06 +00:00
QVERIFY(pointRemovedSpy.wait());
QCOMPARE(pointRemovedSpy.count(), 1);
}
[autotest] Add a test for locking the screen First test case is to ensure that pointer motion events trigger a leave event on the surface the pointer is on. The test case shows errors in the input handling. More tests need to be added.
2016-02-01 14:10:00 +00:00
}
Fix typo
2016-02-11 08:34:19 +00:00
WAYLANDTEST_MAIN(KWin::LockScreenTest)
[autotest] Add a test for locking the screen First test case is to ensure that pointer motion events trigger a leave event on the surface the pointer is on. The test case shows errors in the input handling. More tests need to be added.
2016-02-01 14:10:00 +00:00
#include "lockscreen.moc"
Reference in a new issue Copy permalink