yukijoou/kwin
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
kwin/autotests/integration/lockscreen.cpp
Vlad Zahorodnii d2fb4147fc Move multi-purpose code in its own directory 
Things such as Output, InputDevice and so on are made to be
multi-purpose. In order to make this separation more clear, this change
moves that code in the core directory. Some things still link to the
abstraction level above (kwin), they can be tackled in future refactors.
Ideally code in core/ should depend either on other code in core/ or
system libs.
2022-09-06 11:21:40 +03:00

780 lines
26 KiB
C++
Raw Blame History

/*
KWin - the KDE window manager
This file is part of the KDE project.
SPDX-FileCopyrightText: 2016 Martin Gräßlin <mgraesslin@kde.org>
SPDX-License-Identifier: GPL-2.0-or-later
*/
#include "kwin_wayland_test.h"
#include "composite.h"
#include "core/output.h"
#include "core/platform.h"
#include "core/renderbackend.h"
#include "cursor.h"
#include "screenedge.h"
#include "wayland/keyboard_interface.h"
#include "wayland/seat_interface.h"
#include "wayland_server.h"
#include "window.h"
#include "workspace.h"
#include <kwineffects.h>
#include <KWayland/Client/compositor.h>
#include <KWayland/Client/connection_thread.h>
#include <KWayland/Client/keyboard.h>
#include <KWayland/Client/pointer.h>
#include <KWayland/Client/registry.h>
#include <KWayland/Client/seat.h>
#include <KWayland/Client/shm_pool.h>
#include <KWayland/Client/surface.h>
#include <KWayland/Client/touch.h>
// screenlocker
#include <KScreenLocker/KsldApp>
#include <KGlobalAccel>
#include <linux/input.h>
Q_DECLARE_METATYPE(Qt::Orientation)
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();
void testStackingOrder();
void testPointer();
void testPointerButton();
void testPointerAxis();
void testKeyboard();
void testScreenEdge();
void testEffects();
void testEffectsKeyboard();
void testEffectsKeyboardAutorepeat();
void testMoveWindow();
void testPointerShortcut();
void testAxisShortcut_data();
void testAxisShortcut();
void testKeyboardShortcut();
void testTouch();
private:
void unlock();
std::pair<Window *, std::unique_ptr<KWayland::Client::Surface>> showWindow();
KWayland::Client::ConnectionThread *m_connection = nullptr;
KWayland::Client::Compositor *m_compositor = nullptr;
KWayland::Client::Seat *m_seat = nullptr;
KWayland::Client::ShmPool *m_shm = nullptr;
};
class HelperEffect : public Effect
{
Q_OBJECT
public:
HelperEffect()
{
}
~HelperEffect() override
{
}
void windowInputMouseEvent(QEvent *) override
{
Q_EMIT inputEvent();
}
void grabbedKeyboardEvent(QKeyEvent *e) override
{
Q_EMIT keyEvent(e->text());
}
Q_SIGNALS:
void inputEvent();
void keyEvent(const QString &);
};
#define LOCK \
do { \
QVERIFY(!waylandServer()->isScreenLocked()); \
QSignalSpy lockStateChangedSpy(ScreenLocker::KSldApp::self(), &ScreenLocker::KSldApp::lockStateChanged); \
QVERIFY(lockStateChangedSpy.isValid()); \
ScreenLocker::KSldApp::self()->lock(ScreenLocker::EstablishLock::Immediate); \
QTRY_COMPARE(ScreenLocker::KSldApp::self()->lockState(), ScreenLocker::KSldApp::Locked); \
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)
#define MOTION(target) Test::pointerMotion(target, timestamp++)
#define PRESS Test::pointerButtonPressed(BTN_LEFT, timestamp++)
#define RELEASE Test::pointerButtonReleased(BTN_LEFT, timestamp++)
#define KEYPRESS(key) Test::keyboardKeyPressed(key, timestamp++)
#define KEYRELEASE(key) Test::keyboardKeyReleased(key, timestamp++)
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;
}
}
std::pair<Window *, std::unique_ptr<KWayland::Client::Surface>> LockScreenTest::showWindow()
{
using namespace KWayland::Client;
#define VERIFY(statement) \
if (!QTest::qVerify((statement), #statement, "", __FILE__, __LINE__)) \
return {nullptr, nullptr};
#define COMPARE(actual, expected) \
if (!QTest::qCompare(actual, expected, #actual, #expected, __FILE__, __LINE__)) \
return {nullptr, nullptr};
std::unique_ptr<KWayland::Client::Surface> surface = Test::createSurface();
VERIFY(surface.get());
Test::XdgToplevel *shellSurface = Test::createXdgToplevelSurface(surface.get(), surface.get());
VERIFY(shellSurface);
// let's render
auto window = Test::renderAndWaitForShown(surface.get(), QSize(100, 50), Qt::blue);
VERIFY(window);
COMPARE(workspace()->activeWindow(), window);
#undef VERIFY
#undef COMPARE
return {window, std::move(surface)};
}
void LockScreenTest::initTestCase()
{
qRegisterMetaType<KWin::Window *>();
qRegisterMetaType<KWin::ElectricBorder>("ElectricBorder");
QSignalSpy applicationStartedSpy(kwinApp(), &Application::started);
QVERIFY(applicationStartedSpy.isValid());
kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
QVERIFY(waylandServer()->init(s_socketName));
QMetaObject::invokeMethod(kwinApp()->platform(), "setVirtualOutputs", Qt::DirectConnection, Q_ARG(int, 2));
qputenv("KWIN_COMPOSE", QByteArrayLiteral("O2"));
kwinApp()->start();
QVERIFY(applicationStartedSpy.wait());
const auto outputs = workspace()->outputs();
QCOMPARE(outputs.count(), 2);
QCOMPARE(outputs[0]->geometry(), QRect(0, 0, 1280, 1024));
QCOMPARE(outputs[1]->geometry(), QRect(1280, 0, 1280, 1024));
setenv("QT_QPA_PLATFORM", "wayland", true);
QCOMPARE(Compositor::self()->backend()->compositingType(), KWin::OpenGLCompositing);
}
void LockScreenTest::init()
{
QVERIFY(Test::setupWaylandConnection(Test::AdditionalWaylandInterface::Seat));
QVERIFY(Test::waitForWaylandPointer());
m_connection = Test::waylandConnection();
m_compositor = Test::waylandCompositor();
m_shm = Test::waylandShmPool();
m_seat = Test::waylandSeat();
workspace()->setActiveOutput(QPoint(640, 512));
Cursors::self()->mouse()->setPos(QPoint(640, 512));
}
void LockScreenTest::cleanup()
{
Test::destroyWaylandConnection();
}
void LockScreenTest::testStackingOrder()
{
// This test verifies that the lockscreen greeter is placed above other windows.
QSignalSpy windowAddedSpy(workspace(), &Workspace::windowAdded);
QVERIFY(windowAddedSpy.isValid());
LOCK;
QVERIFY(windowAddedSpy.wait());
Window *window = windowAddedSpy.first().first().value<Window *>();
QVERIFY(window);
QVERIFY(window->isLockScreen());
QCOMPARE(window->layer(), UnmanagedLayer);
UNLOCK;
}
void LockScreenTest::testPointer()
{
using namespace KWayland::Client;
std::unique_ptr<Pointer> pointer(m_seat->createPointer());
QVERIFY(pointer != nullptr);
QSignalSpy enteredSpy(pointer.get(), &Pointer::entered);
QVERIFY(enteredSpy.isValid());
QSignalSpy leftSpy(pointer.get(), &Pointer::left);
QVERIFY(leftSpy.isValid());
auto [window, surface] = showWindow();
QVERIFY(window);
// first move cursor into the center of the window
quint32 timestamp = 1;
MOTION(window->frameGeometry().center());
QVERIFY(enteredSpy.wait());
LOCK;
QVERIFY(leftSpy.wait());
QCOMPARE(leftSpy.count(), 1);
// simulate moving out in and out again
MOTION(window->frameGeometry().center());
MOTION(window->frameGeometry().bottomRight() + QPoint(100, 100));
MOTION(window->frameGeometry().bottomRight() + QPoint(100, 100));
QVERIFY(!leftSpy.wait());
QCOMPARE(leftSpy.count(), 1);
QCOMPARE(enteredSpy.count(), 1);
// go back on the window
MOTION(window->frameGeometry().center());
// and unlock
UNLOCK;
QVERIFY(enteredSpy.wait());
QCOMPARE(enteredSpy.count(), 2);
// move on the window
MOTION(window->frameGeometry().center() + QPoint(100, 100));
QVERIFY(leftSpy.wait());
MOTION(window->frameGeometry().center());
QVERIFY(enteredSpy.wait());
QCOMPARE(enteredSpy.count(), 3);
}
void LockScreenTest::testPointerButton()
{
using namespace KWayland::Client;
std::unique_ptr<Pointer> pointer(m_seat->createPointer());
QVERIFY(pointer != nullptr);
QSignalSpy enteredSpy(pointer.get(), &Pointer::entered);
QVERIFY(enteredSpy.isValid());
QSignalSpy buttonChangedSpy(pointer.get(), &Pointer::buttonStateChanged);
QVERIFY(buttonChangedSpy.isValid());
auto [window, surface] = showWindow();
QVERIFY(window);
// first move cursor into the center of the window
quint32 timestamp = 1;
MOTION(window->frameGeometry().center());
QVERIFY(enteredSpy.wait());
// and simulate a click
PRESS;
QVERIFY(buttonChangedSpy.wait());
RELEASE;
QVERIFY(buttonChangedSpy.wait());
LOCK;
// and simulate a click
PRESS;
QVERIFY(!buttonChangedSpy.wait());
RELEASE;
QVERIFY(!buttonChangedSpy.wait());
UNLOCK;
QVERIFY(enteredSpy.wait());
QCOMPARE(enteredSpy.count(), 2);
// and click again
PRESS;
QVERIFY(buttonChangedSpy.wait());
RELEASE;
QVERIFY(buttonChangedSpy.wait());
}
void LockScreenTest::testPointerAxis()
{
using namespace KWayland::Client;
std::unique_ptr<Pointer> pointer(m_seat->createPointer());
QVERIFY(pointer != nullptr);
QSignalSpy axisChangedSpy(pointer.get(), &Pointer::axisChanged);
QVERIFY(axisChangedSpy.isValid());
QSignalSpy enteredSpy(pointer.get(), &Pointer::entered);
QVERIFY(enteredSpy.isValid());
auto [window, surface] = showWindow();
QVERIFY(window);
// first move cursor into the center of the window
quint32 timestamp = 1;
MOTION(window->frameGeometry().center());
QVERIFY(enteredSpy.wait());
// and simulate axis
Test::pointerAxisHorizontal(5.0, timestamp++);
QVERIFY(axisChangedSpy.wait());
LOCK;
// and simulate axis
Test::pointerAxisHorizontal(5.0, timestamp++);
QVERIFY(!axisChangedSpy.wait(100));
Test::pointerAxisVertical(5.0, timestamp++);
QVERIFY(!axisChangedSpy.wait(100));
// and unlock
UNLOCK;
QVERIFY(enteredSpy.wait());
QCOMPARE(enteredSpy.count(), 2);
// and move axis again
Test::pointerAxisHorizontal(5.0, timestamp++);
QVERIFY(axisChangedSpy.wait());
Test::pointerAxisVertical(5.0, timestamp++);
QVERIFY(axisChangedSpy.wait());
}
void LockScreenTest::testKeyboard()
{
using namespace KWayland::Client;
std::unique_ptr<Keyboard> keyboard(m_seat->createKeyboard());
QVERIFY(keyboard != nullptr);
QSignalSpy enteredSpy(keyboard.get(), &Keyboard::entered);
QVERIFY(enteredSpy.isValid());
QSignalSpy leftSpy(keyboard.get(), &Keyboard::left);
QVERIFY(leftSpy.isValid());
QSignalSpy keyChangedSpy(keyboard.get(), &Keyboard::keyChanged);
QVERIFY(keyChangedSpy.isValid());
auto [window, surface] = showWindow();
QVERIFY(window);
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));
LOCK;
QVERIFY(leftSpy.wait());
KEYPRESS(KEY_B);
KEYRELEASE(KEY_B);
QCOMPARE(leftSpy.count(), 1);
QCOMPARE(keyChangedSpy.count(), 2);
UNLOCK;
QVERIFY(enteredSpy.wait());
QCOMPARE(enteredSpy.count(), 2);
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);
}
void LockScreenTest::testScreenEdge()
{
QSignalSpy screenEdgeSpy(workspace()->screenEdges(), &ScreenEdges::approaching);
QVERIFY(screenEdgeSpy.isValid());
QCOMPARE(screenEdgeSpy.count(), 0);
quint32 timestamp = 1;
MOTION(QPoint(5, 5));
QCOMPARE(screenEdgeSpy.count(), 1);
LOCK;
MOTION(QPoint(4, 4));
QCOMPARE(screenEdgeSpy.count(), 1);
// and unlock
UNLOCK;
MOTION(QPoint(5, 5));
QCOMPARE(screenEdgeSpy.count(), 2);
}
void LockScreenTest::testEffects()
{
std::unique_ptr<HelperEffect> effect(new HelperEffect);
QSignalSpy inputSpy(effect.get(), &HelperEffect::inputEvent);
QVERIFY(inputSpy.isValid());
effects->startMouseInterception(effect.get(), Qt::ArrowCursor);
quint32 timestamp = 1;
QCOMPARE(inputSpy.count(), 0);
MOTION(QPoint(5, 5));
QCOMPARE(inputSpy.count(), 1);
// simlate click
PRESS;
QCOMPARE(inputSpy.count(), 2);
RELEASE;
QCOMPARE(inputSpy.count(), 3);
LOCK;
MOTION(QPoint(6, 6));
QCOMPARE(inputSpy.count(), 3);
// simlate click
PRESS;
QCOMPARE(inputSpy.count(), 3);
RELEASE;
QCOMPARE(inputSpy.count(), 3);
UNLOCK;
MOTION(QPoint(5, 5));
QCOMPARE(inputSpy.count(), 4);
// simlate click
PRESS;
QCOMPARE(inputSpy.count(), 5);
RELEASE;
QCOMPARE(inputSpy.count(), 6);
effects->stopMouseInterception(effect.get());
}
void LockScreenTest::testEffectsKeyboard()
{
std::unique_ptr<HelperEffect> effect(new HelperEffect);
QSignalSpy inputSpy(effect.get(), &HelperEffect::keyEvent);
QVERIFY(inputSpy.isValid());
effects->grabKeyboard(effect.get());
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"));
LOCK;
KEYPRESS(KEY_B);
QCOMPARE(inputSpy.count(), 2);
KEYRELEASE(KEY_B);
QCOMPARE(inputSpy.count(), 2);
UNLOCK;
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();
}
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
std::unique_ptr<HelperEffect> effect(new HelperEffect);
QSignalSpy inputSpy(effect.get(), &HelperEffect::keyEvent);
QVERIFY(inputSpy.isValid());
effects->grabKeyboard(effect.get());
// we need to configure the key repeat first. It is only enabled on libinput
waylandServer()->seat()->keyboard()->setRepeatInfo(25, 300);
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
LOCK;
KEYPRESS(KEY_B);
QVERIFY(!inputSpy.wait(200));
KEYRELEASE(KEY_B);
QVERIFY(!inputSpy.wait(200));
UNLOCK;
// don't test again, that's covered by testEffectsKeyboard
effects->ungrabKeyboard();
}
void LockScreenTest::testMoveWindow()
{
using namespace KWayland::Client;
auto [window, surface] = showWindow();
QVERIFY(window);
QSignalSpy clientStepUserMovedResizedSpy(window, &Window::clientStepUserMovedResized);
QVERIFY(clientStepUserMovedResizedSpy.isValid());
quint32 timestamp = 1;
workspace()->slotWindowMove();
QCOMPARE(workspace()->moveResizeWindow(), window);
QVERIFY(window->isInteractiveMove());
Test::keyboardKeyPressed(KEY_RIGHT, timestamp++);
Test::keyboardKeyReleased(KEY_RIGHT, timestamp++);
QEXPECT_FAIL("", "First event is ignored", Continue);
QCOMPARE(clientStepUserMovedResizedSpy.count(), 1);
// TODO adjust once the expected fail is fixed
Test::keyboardKeyPressed(KEY_RIGHT, timestamp++);
Test::keyboardKeyReleased(KEY_RIGHT, timestamp++);
QCOMPARE(clientStepUserMovedResizedSpy.count(), 1);
// while locking our window should continue to be in move resize
LOCK;
QCOMPARE(workspace()->moveResizeWindow(), window);
QVERIFY(window->isInteractiveMove());
Test::keyboardKeyPressed(KEY_RIGHT, timestamp++);
Test::keyboardKeyReleased(KEY_RIGHT, timestamp++);
QCOMPARE(clientStepUserMovedResizedSpy.count(), 1);
UNLOCK;
QCOMPARE(workspace()->moveResizeWindow(), window);
QVERIFY(window->isInteractiveMove());
Test::keyboardKeyPressed(KEY_RIGHT, timestamp++);
Test::keyboardKeyReleased(KEY_RIGHT, timestamp++);
QCOMPARE(clientStepUserMovedResizedSpy.count(), 2);
Test::keyboardKeyPressed(KEY_ESC, timestamp++);
Test::keyboardKeyReleased(KEY_ESC, timestamp++);
QVERIFY(!window->isInteractiveMove());
}
void LockScreenTest::testPointerShortcut()
{
using namespace KWayland::Client;
std::unique_ptr<QAction> action(new QAction(nullptr));
QSignalSpy actionSpy(action.get(), &QAction::triggered);
QVERIFY(actionSpy.isValid());
input()->registerPointerShortcut(Qt::MetaModifier, Qt::LeftButton, action.get());
// try to trigger the shortcut
quint32 timestamp = 1;
#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);
// now the same thing with a locked screen
LOCK;
PERFORM(1);
// and as unlocked
UNLOCK;
PERFORM(2);
#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;
std::unique_ptr<QAction> action(new QAction(nullptr));
QSignalSpy actionSpy(action.get(), &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.get());
// try to trigger the shortcut
quint32 timestamp = 1;
#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);
// now the same thing with a locked screen
LOCK;
PERFORM(1);
// and as unlocked
UNLOCK;
PERFORM(2);
#undef PERFORM
}
void LockScreenTest::testKeyboardShortcut()
{
using namespace KWayland::Client;
std::unique_ptr<QAction> action(new QAction(nullptr));
QSignalSpy actionSpy(action.get(), &QAction::triggered);
QVERIFY(actionSpy.isValid());
action->setProperty("componentName", QStringLiteral(KWIN_NAME));
action->setObjectName("LockScreenTest::testKeyboardShortcut");
KGlobalAccel::self()->setDefaultShortcut(action.get(), QList<QKeySequence>{Qt::CTRL | Qt::META | Qt::ALT | Qt::Key_Space});
KGlobalAccel::self()->setShortcut(action.get(), QList<QKeySequence>{Qt::CTRL | Qt::META | Qt::ALT | Qt::Key_Space},
KGlobalAccel::NoAutoloading);
// try to trigger the shortcut
quint32 timestamp = 1;
KEYPRESS(KEY_LEFTCTRL);
KEYPRESS(KEY_LEFTMETA);
KEYPRESS(KEY_LEFTALT);
KEYPRESS(KEY_SPACE);
QVERIFY(actionSpy.wait());
QCOMPARE(actionSpy.count(), 1);
KEYRELEASE(KEY_SPACE);
QVERIFY(!actionSpy.wait());
QCOMPARE(actionSpy.count(), 1);
LOCK;
KEYPRESS(KEY_SPACE);
QVERIFY(!actionSpy.wait());
QCOMPARE(actionSpy.count(), 1);
KEYRELEASE(KEY_SPACE);
QVERIFY(!actionSpy.wait());
QCOMPARE(actionSpy.count(), 1);
UNLOCK;
KEYPRESS(KEY_SPACE);
QVERIFY(actionSpy.wait());
QCOMPARE(actionSpy.count(), 2);
KEYRELEASE(KEY_SPACE);
QVERIFY(!actionSpy.wait());
QCOMPARE(actionSpy.count(), 2);
KEYRELEASE(KEY_LEFTCTRL);
KEYRELEASE(KEY_LEFTMETA);
KEYRELEASE(KEY_LEFTALT);
}
void LockScreenTest::testTouch()
{
using namespace KWayland::Client;
auto touch = m_seat->createTouch(m_seat);
QVERIFY(touch);
QVERIFY(touch->isValid());
auto [window, surface] = showWindow();
QVERIFY(window);
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;
Test::touchDown(1, QPointF(25, 25), timestamp++);
QVERIFY(sequenceStartedSpy.wait());
QCOMPARE(sequenceStartedSpy.count(), 1);
LOCK;
QVERIFY(cancelSpy.wait());
Test::touchUp(1, timestamp++);
QVERIFY(!pointRemovedSpy.wait(100));
Test::touchDown(1, QPointF(25, 25), timestamp++);
Test::touchMotion(1, QPointF(26, 26), timestamp++);
Test::touchUp(1, timestamp++);
UNLOCK;
Test::touchDown(1, QPointF(25, 25), timestamp++);
QVERIFY(sequenceStartedSpy.wait());
QCOMPARE(sequenceStartedSpy.count(), 2);
Test::touchUp(1, timestamp++);
QVERIFY(pointRemovedSpy.wait());
QCOMPARE(pointRemovedSpy.count(), 1);
}
}
WAYLANDTEST_MAIN(KWin::LockScreenTest)
#include "lockscreen.moc"
Reference in a new issue View git blame Copy permalink