Commit 93194a67 authored by Vlad Zahorodnii's avatar Vlad Zahorodnii
Browse files

autotests: Convert testScreens into an integration test

At the moment, the Screens class is convoluted with ifdefs because of
MockScreens.

The goal of this change is to reduce the number of usages of the
MockScreens class so it is possible to get rid of the ifdefs.
parent c324cd14
......@@ -240,42 +240,6 @@ add_library(effectversionplugin MODULE fakeeffectplugin_version.cpp)
set_target_properties(effectversionplugin PROPERTIES PREFIX "")
target_link_libraries(effectversionplugin kwineffects)
########################################################
# Test Screens
########################################################
set(testScreens_SRCS
../screens.cpp
../cursor.cpp
../x11eventfilter.cpp
mock_abstract_client.cpp
mock_screens.cpp
mock_workspace.cpp
mock_x11client.cpp
test_screens.cpp
)
kconfig_add_kcfg_files(testScreens_SRCS ../settings.kcfgc)
add_executable(testScreens ${testScreens_SRCS})
target_include_directories(testScreens BEFORE PRIVATE ./)
target_link_libraries(testScreens
Qt5::DBus
Qt5::Sensors
Qt5::Test
Qt5::Widgets
Qt5::X11Extras
KF5::ConfigCore
KF5::ConfigGui
KF5::I18n
KF5::Notifications
KF5::WindowSystem
XCB::XCB #for xcbutils.h
)
add_test(NAME kwin_testScreens COMMAND testScreens)
ecm_mark_as_test(testScreens)
########################################################
# Test ScreenEdges
########################################################
......
......@@ -96,6 +96,7 @@ integrationTest(WAYLAND_ONLY NAME testBufferSizeChange SRCS buffer_size_change_t
integrationTest(WAYLAND_ONLY NAME testPlacement SRCS placement_test.cpp)
integrationTest(WAYLAND_ONLY NAME testActivation SRCS activation_test.cpp)
integrationTest(WAYLAND_ONLY NAME testInputMethod SRCS inputmethod_test.cpp)
integrationTest(WAYLAND_ONLY NAME testScreens SRCS screens_test.cpp)
if (KWIN_BUILD_CMS)
integrationTest(WAYLAND_ONLY NAME testNightColor SRCS nightcolor_test.cpp LIBS KWinNightColorPlugin)
......
......@@ -6,24 +6,31 @@
SPDX-License-Identifier: GPL-2.0-or-later
*/
#include "mock_workspace.h"
#include "../cursor.h"
#include "mock_screens.h"
#include "mock_x11client.h"
// frameworks
#include "kwin_wayland_test.h"
#include "abstract_client.h"
#include "cursor.h"
#include "platform.h"
#include "screens.h"
#include "wayland_server.h"
#include "workspace.h"
#include <KConfigGroup>
// Qt
#include <QtTest>
#include <KWayland/Client/surface.h>
#include <KWayland/Client/xdgshell.h>
Q_LOGGING_CATEGORY(KWIN_CORE, "kwin_core")
namespace KWin
{
// Mock
static const QString s_socketName = QStringLiteral("wayland_test_kwin_screens-0");
class TestScreens : public QObject
class ScreensTest : public QObject
{
Q_OBJECT
private Q_SLOTS:
void initTestCase();
void init();
void cleanup();
void testCurrentFollowsMouse();
void testReconfigure_data();
void testReconfigure();
......@@ -41,31 +48,73 @@ private Q_SLOTS:
void testCurrentPoint();
};
void TestScreens::init()
void ScreensTest::initTestCase()
{
qRegisterMetaType<KWin::AbstractClient *>();
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));
kwinApp()->start();
QVERIFY(applicationStartedSpy.wait());
QCOMPARE(screens()->count(), 2);
QCOMPARE(screens()->geometry(0), QRect(0, 0, 1280, 1024));
QCOMPARE(screens()->geometry(1), QRect(1280, 0, 1280, 1024));
waylandServer()->initWorkspace();
}
void ScreensTest::init()
{
KWin::Cursors::self()->setMouse(new KWin::Cursor(this));
Screens::self()->setCurrent(0);
KWin::Cursors::self()->mouse()->setPos(QPoint(640, 512));
QVERIFY(Test::setupWaylandConnection());
}
void TestScreens::testCurrentFollowsMouse()
static void purge(KConfig *config)
{
KWin::MockWorkspace ws;
KWin::Screens *screens = KWin::Screens::create(&ws);
QVERIFY(!screens->isCurrentFollowsMouse());
screens->setCurrentFollowsMouse(true);
QVERIFY(screens->isCurrentFollowsMouse());
const QStringList groups = config->groupList();
for (const QString &group : groups) {
config->deleteGroup(group);
}
}
void ScreensTest::cleanup()
{
// Destroy the wayland connection of the test client.
Test::destroyWaylandConnection();
// Wipe the screens config clean.
auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
purge(config.data());
config->sync();
screens()->setConfig(config);
screens()->reconfigure();
// Reset the screen layout of the test environment.
QMetaObject::invokeMethod(kwinApp()->platform(), "setVirtualOutputs", Qt::DirectConnection, Q_ARG(int, 2));
}
void ScreensTest::testCurrentFollowsMouse()
{
QVERIFY(!screens()->isCurrentFollowsMouse());
screens()->setCurrentFollowsMouse(true);
QVERIFY(screens()->isCurrentFollowsMouse());
// setting to same should not do anything
screens->setCurrentFollowsMouse(true);
QVERIFY(screens->isCurrentFollowsMouse());
screens()->setCurrentFollowsMouse(true);
QVERIFY(screens()->isCurrentFollowsMouse());
// setting back to other value
screens->setCurrentFollowsMouse(false);
QVERIFY(!screens->isCurrentFollowsMouse());
screens()->setCurrentFollowsMouse(false);
QVERIFY(!screens()->isCurrentFollowsMouse());
// setting to same should not do anything
screens->setCurrentFollowsMouse(false);
QVERIFY(!screens->isCurrentFollowsMouse());
screens()->setCurrentFollowsMouse(false);
QVERIFY(!screens()->isCurrentFollowsMouse());
}
void TestScreens::testReconfigure_data()
void ScreensTest::testReconfigure_data()
{
QTest::addColumn<QString>("focusPolicy");
QTest::addColumn<bool>("expectedDefault");
......@@ -77,11 +126,8 @@ void TestScreens::testReconfigure_data()
QTest::newRow("FocusStrictlyUnderMouse") << QStringLiteral("FocusStrictlyUnderMouse") << true << false;
}
void TestScreens::testReconfigure()
void ScreensTest::testReconfigure()
{
using namespace KWin;
MockWorkspace ws;
Screens::create(&ws);
screens()->reconfigure();
QVERIFY(!screens()->isCurrentFollowsMouse());
......@@ -103,100 +149,75 @@ void TestScreens::testReconfigure()
QCOMPARE(screens()->isCurrentFollowsMouse(), setting);
}
void TestScreens::testSize_data()
void ScreensTest::testSize_data()
{
QTest::addColumn< QList<QRect> >("geometries");
QTest::addColumn<QVector<QRect>>("geometries");
QTest::addColumn<QSize>("expectedSize");
QTest::newRow("empty") << QList<QRect>{{QRect()}} << QSize(0, 0);
QTest::newRow("cloned") << QList<QRect>{{QRect{0, 0, 200, 100}, QRect{0, 0, 200, 100}}} << QSize(200, 100);
QTest::newRow("adjacent") << QList<QRect>{{QRect{0, 0, 200, 100}, QRect{200, 100, 400, 300}}} << QSize(600, 400);
QTest::newRow("overlapping") << QList<QRect>{{QRect{-10, -20, 50, 100}, QRect{0, 0, 100, 200}}} << QSize(110, 220);
QTest::newRow("gap") << QList<QRect>{{QRect{0, 0, 10, 20}, QRect{20, 40, 10, 20}}} << QSize(30, 60);
QTest::newRow("empty") << QVector<QRect>{{QRect()}} << QSize(0, 0);
QTest::newRow("cloned") << QVector<QRect>{{QRect{0, 0, 200, 100}, QRect{0, 0, 200, 100}}} << QSize(200, 100);
QTest::newRow("adjacent") << QVector<QRect>{{QRect{0, 0, 200, 100}, QRect{200, 100, 400, 300}}} << QSize(600, 400);
QTest::newRow("overlapping") << QVector<QRect>{{QRect{-10, -20, 50, 100}, QRect{0, 0, 100, 200}}} << QSize(110, 220);
QTest::newRow("gap") << QVector<QRect>{{QRect{0, 0, 10, 20}, QRect{20, 40, 10, 20}}} << QSize(30, 60);
}
void TestScreens::testSize()
void ScreensTest::testSize()
{
using namespace KWin;
MockWorkspace ws;
MockScreens *mockScreens = static_cast<MockScreens*>(Screens::create(&ws));
QSignalSpy sizeChangedSpy(screens(), &KWin::Screens::sizeChanged);
QSignalSpy sizeChangedSpy(screens(), &Screens::sizeChanged);
QVERIFY(sizeChangedSpy.isValid());
QCOMPARE(screens()->size(), QSize(100, 100));
QFETCH(QList<QRect>, geometries);
QVERIFY(!mockScreens->isChanging());
mockScreens->setGeometries(geometries);
QVERIFY(mockScreens->isChanging());
QFETCH(QVector<QRect>, geometries);
QMetaObject::invokeMethod(kwinApp()->platform(), "setVirtualOutputs", Qt::QueuedConnection,
Q_ARG(int, geometries.count()), Q_ARG(QVector<QRect>, geometries));
QVERIFY(sizeChangedSpy.wait());
QVERIFY(!mockScreens->isChanging());
QTEST(screens()->size(), "expectedSize");
}
void TestScreens::testCount()
void ScreensTest::testCount()
{
using namespace KWin;
MockWorkspace ws;
MockScreens *mockScreens = static_cast<MockScreens*>(Screens::create(&ws));
QSignalSpy countChangedSpy(screens(), &KWin::Screens::countChanged);
QSignalSpy countChangedSpy(screens(), &Screens::countChanged);
QVERIFY(countChangedSpy.isValid());
QCOMPARE(screens()->count(), 1);
// change to two screens
QList<QRect> geometries{{QRect{0, 0, 100, 200}, QRect{100, 0, 100, 200}}};
mockScreens->setGeometries(geometries);
QVERIFY(countChangedSpy.wait());
QCOMPARE(countChangedSpy.count(), 1);
QCOMPARE(countChangedSpy.first().first().toInt(), 1);
QCOMPARE(countChangedSpy.first().last().toInt(), 2);
// the test environments has two outputs
QCOMPARE(screens()->count(), 2);
// go back to one screen
geometries.takeLast();
mockScreens->setGeometries(geometries);
// change to one screen
QMetaObject::invokeMethod(kwinApp()->platform(), "setVirtualOutputs", Qt::QueuedConnection, Q_ARG(int, 1));
QVERIFY(countChangedSpy.wait());
QCOMPARE(countChangedSpy.count(), 2);
QCOMPARE(countChangedSpy.last().first().toInt(), 2);
QCOMPARE(countChangedSpy.last().last().toInt(), 1);
QCOMPARE(countChangedSpy.count(), 1);
QCOMPARE(screens()->count(), 1);
// setting the same geometries shouldn't emit the signal, but we should get a changed signal
QSignalSpy changedSpy(screens(), &KWin::Screens::changed);
QSignalSpy changedSpy(screens(), &Screens::changed);
QVERIFY(changedSpy.isValid());
mockScreens->setGeometries(geometries);
QMetaObject::invokeMethod(kwinApp()->platform(), "setVirtualOutputs", Qt::QueuedConnection, Q_ARG(int, 1));
QVERIFY(changedSpy.wait());
QCOMPARE(countChangedSpy.count(), 2);
QCOMPARE(countChangedSpy.count(), 1);
}
void TestScreens::testIntersecting_data()
void ScreensTest::testIntersecting_data()
{
QTest::addColumn<QList<QRect>>("geometries");
QTest::addColumn<QVector<QRect>>("geometries");
QTest::addColumn<QRect>("testGeometry");
QTest::addColumn<int>("expectedCount");
QTest::newRow("null-rect") << QList<QRect>{{QRect{0, 0, 100, 100}}} << QRect() << 0;
QTest::newRow("non-overlapping") << QList<QRect>{{QRect{0, 0, 100, 100}}} << QRect(100, 0, 100, 100) << 0;
QTest::newRow("in-between") << QList<QRect>{{QRect{0, 0, 10, 20}, QRect{20, 40, 10, 20}}} << QRect(15, 0, 2, 2) << 0;
QTest::newRow("gap-overlapping") << QList<QRect>{{QRect{0, 0, 10, 20}, QRect{20, 40, 10, 20}}} << QRect(9, 10, 200, 200) << 2;
QTest::newRow("larger") << QList<QRect>{{QRect{0, 0, 100, 100}}} << QRect(-10, -10, 200, 200) << 1;
QTest::newRow("several") << QList<QRect>{{QRect{0, 0, 100, 100}, QRect{100, 0, 100, 100}, QRect{200, 100, 100, 100}, QRect{300, 100, 100, 100}}} << QRect(0, 0, 300, 300) << 3;
QTest::newRow("null-rect") << QVector<QRect>{{QRect{0, 0, 100, 100}}} << QRect() << 0;
QTest::newRow("non-overlapping") << QVector<QRect>{{QRect{0, 0, 100, 100}}} << QRect(100, 0, 100, 100) << 0;
QTest::newRow("in-between") << QVector<QRect>{{QRect{0, 0, 10, 20}, QRect{20, 40, 10, 20}}} << QRect(15, 0, 2, 2) << 0;
QTest::newRow("gap-overlapping") << QVector<QRect>{{QRect{0, 0, 10, 20}, QRect{20, 40, 10, 20}}} << QRect(9, 10, 200, 200) << 2;
QTest::newRow("larger") << QVector<QRect>{{QRect{0, 0, 100, 100}}} << QRect(-10, -10, 200, 200) << 1;
QTest::newRow("several") << QVector<QRect>{{QRect{0, 0, 100, 100}, QRect{100, 0, 100, 100}, QRect{200, 100, 100, 100}, QRect{300, 100, 100, 100}}} << QRect(0, 0, 300, 300) << 3;
}
void TestScreens::testIntersecting()
void ScreensTest::testIntersecting()
{
using namespace KWin;
MockWorkspace ws;
MockScreens *mockScreens = static_cast<MockScreens*>(Screens::create(&ws));
QSignalSpy changedSpy(screens(), &KWin::Screens::changed);
QSignalSpy changedSpy(screens(), &Screens::changed);
QVERIFY(changedSpy.isValid());
QFETCH(QList<QRect>, geometries);
mockScreens->setGeometries(geometries);
// first is before it's updated
QVERIFY(changedSpy.wait());
// second is after it's updated
QFETCH(QVector<QRect>, geometries);
QMetaObject::invokeMethod(kwinApp()->platform(), "setVirtualOutputs", Qt::QueuedConnection,
Q_ARG(int, geometries.count()), Q_ARG(QVector<QRect>, geometries));
QVERIFY(changedSpy.wait());
QFETCH(QRect, testGeometry);
......@@ -204,7 +225,7 @@ void TestScreens::testIntersecting()
QTEST(screens()->intersecting(testGeometry), "expectedCount");
}
void TestScreens::testCurrent_data()
void ScreensTest::testCurrent_data()
{
QTest::addColumn<int>("current");
QTest::addColumn<bool>("signal");
......@@ -213,11 +234,8 @@ void TestScreens::testCurrent_data()
QTest::newRow("changed") << 1 << true;
}
void TestScreens::testCurrent()
void ScreensTest::testCurrent()
{
using namespace KWin;
MockWorkspace ws;
Screens::create(&ws);
QSignalSpy currentChangedSpy(screens(), &KWin::Screens::currentChanged);
QVERIFY(currentChangedSpy.isValid());
......@@ -227,80 +245,62 @@ void TestScreens::testCurrent()
QTEST(!currentChangedSpy.isEmpty(), "signal");
}
void TestScreens::testCurrentClient()
void ScreensTest::testCurrentClient()
{
using namespace KWin;
MockWorkspace ws;
MockScreens *mockScreens = static_cast<MockScreens*>(Screens::create(&ws));
QSignalSpy changedSpy(screens(), &KWin::Screens::changed);
QVERIFY(changedSpy.isValid());
mockScreens->setGeometries(QList<QRect>{{QRect{0, 0, 100, 100}, QRect{100, 0, 100, 100}}});
// first is before it's updated
QVERIFY(changedSpy.wait());
// second is after it's updated
QVERIFY(changedSpy.wait());
QSignalSpy currentChangedSpy(screens(), &KWin::Screens::currentChanged);
QSignalSpy currentChangedSpy(screens(), &Screens::currentChanged);
QVERIFY(currentChangedSpy.isValid());
// create a mock client
X11Client *client = new X11Client(&ws);
client->setScreen(1);
// it's not the active client, so changing won't work
screens()->setCurrent(client);
QVERIFY(currentChangedSpy.isEmpty());
QCOMPARE(screens()->current(), 0);
// making the client active should affect things
client->setActive(true);
ws.setActiveClient(client);
// create a test window
QScopedPointer<KWayland::Client::Surface> surface(Test::createSurface());
QScopedPointer<KWayland::Client::XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
AbstractClient *client = Test::renderAndWaitForShown(surface.data(), QSize(200, 100), Qt::red);
QVERIFY(client);
QVERIFY(client->isActive());
// first of all current should be changed just by the fact that there is an active client
QCOMPARE(screens()->current(), 1);
// but also calling setCurrent should emit the changed signal
screens()->setCurrent(client);
// if the window is sent to another screen, that screen will become current
client->sendToScreen(1);
QCOMPARE(currentChangedSpy.count(), 1);
QCOMPARE(screens()->current(), 1);
// setting current with the same client again should not change, though
// setting current with the same client again should not change
screens()->setCurrent(client);
QCOMPARE(currentChangedSpy.count(), 1);
// and it should even still be on screen 1 if we make the client non-current again
ws.setActiveClient(nullptr);
workspace()->setActiveClient(nullptr);
client->setActive(false);
QCOMPARE(screens()->current(), 1);
// it's not the active client, so changing won't work
screens()->setCurrent(client);
client->sendToScreen(0);
QCOMPARE(currentChangedSpy.count(), 1);
QCOMPARE(screens()->current(), 1);
}
void TestScreens::testCurrentWithFollowsMouse_data()
void ScreensTest::testCurrentWithFollowsMouse_data()
{
QTest::addColumn< QList<QRect> >("geometries");
QTest::addColumn<QVector<QRect>>("geometries");
QTest::addColumn<QPoint>("cursorPos");
QTest::addColumn<int>("expected");
QTest::newRow("empty") << QList<QRect>{{QRect()}} << QPoint(100, 100) << 0;
QTest::newRow("cloned") << QList<QRect>{{QRect{0, 0, 200, 100}, QRect{0, 0, 200, 100}}} << QPoint(50, 50) << 0;
QTest::newRow("adjacent-0") << QList<QRect>{{QRect{0, 0, 200, 100}, QRect{200, 100, 400, 300}}} << QPoint(199, 99) << 0;
QTest::newRow("adjacent-1") << QList<QRect>{{QRect{0, 0, 200, 100}, QRect{200, 100, 400, 300}}} << QPoint(200, 100) << 1;
QTest::newRow("gap") << QList<QRect>{{QRect{0, 0, 10, 20}, QRect{20, 40, 10, 20}}} << QPoint(15, 30) << 1;
QTest::newRow("empty") << QVector<QRect>{{QRect()}} << QPoint(100, 100) << 0;
QTest::newRow("cloned") << QVector<QRect>{{QRect{0, 0, 200, 100}, QRect{0, 0, 200, 100}}} << QPoint(50, 50) << 0;
QTest::newRow("adjacent-0") << QVector<QRect>{{QRect{0, 0, 200, 100}, QRect{200, 100, 400, 300}}} << QPoint(199, 99) << 0;
QTest::newRow("adjacent-1") << QVector<QRect>{{QRect{0, 0, 200, 100}, QRect{200, 100, 400, 300}}} << QPoint(200, 100) << 1;
QTest::newRow("gap") << QVector<QRect>{{QRect{0, 0, 10, 20}, QRect{20, 40, 10, 20}}} << QPoint(15, 30) << 1;
}
void TestScreens::testCurrentWithFollowsMouse()
void ScreensTest::testCurrentWithFollowsMouse()
{
using namespace KWin;
MockWorkspace ws;
MockScreens *mockScreens = static_cast<MockScreens*>(Screens::create(&ws));
QSignalSpy changedSpy(screens(), &KWin::Screens::changed);
QSignalSpy changedSpy(screens(), &Screens::changed);
QVERIFY(changedSpy.isValid());
screens()->setCurrentFollowsMouse(true);
QCOMPARE(screens()->current(), 0);
QFETCH(QList<QRect>, geometries);
mockScreens->setGeometries(geometries);
// first is before it's updated
QVERIFY(changedSpy.wait());
// second is after it's updated
QFETCH(QVector<QRect>, geometries);
QMetaObject::invokeMethod(kwinApp()->platform(), "setVirtualOutputs", Qt::QueuedConnection,
Q_ARG(int, geometries.count()), Q_ARG(QVector<QRect>, geometries));
QVERIFY(changedSpy.wait());
QFETCH(QPoint, cursorPos);
......@@ -308,32 +308,27 @@ void TestScreens::testCurrentWithFollowsMouse()
QTEST(screens()->current(), "expected");
}
void TestScreens::testCurrentPoint_data()
void ScreensTest::testCurrentPoint_data()
{
QTest::addColumn< QList<QRect> >("geometries");
QTest::addColumn<QVector<QRect>>("geometries");
QTest::addColumn<QPoint>("cursorPos");
QTest::addColumn<int>("expected");
QTest::newRow("empty") << QList<QRect>{{QRect()}} << QPoint(100, 100) << 0;
QTest::newRow("cloned") << QList<QRect>{{QRect{0, 0, 200, 100}, QRect{0, 0, 200, 100}}} << QPoint(50, 50) << 0;
QTest::newRow("adjacent-0") << QList<QRect>{{QRect{0, 0, 200, 100}, QRect{200, 100, 400, 300}}} << QPoint(199, 99) << 0;
QTest::newRow("adjacent-1") << QList<QRect>{{QRect{0, 0, 200, 100}, QRect{200, 100, 400, 300}}} << QPoint(200, 100) << 1;
QTest::newRow("gap") << QList<QRect>{{QRect{0, 0, 10, 20}, QRect{20, 40, 10, 20}}} << QPoint(15, 30) << 1;
QTest::newRow("empty") << QVector<QRect>{{QRect()}} << QPoint(100, 100) << 0;
QTest::newRow("cloned") << QVector<QRect>{{QRect{0, 0, 200, 100}, QRect{0, 0, 200, 100}}} << QPoint(50, 50) << 0;
QTest::newRow("adjacent-0") << QVector<QRect>{{QRect{0, 0, 200, 100}, QRect{200, 100, 400, 300}}} << QPoint(199, 99) << 0;
QTest::newRow("adjacent-1") << QVector<QRect>{{QRect{0, 0, 200, 100}, QRect{200, 100, 400, 300}}} << QPoint(200, 100) << 1;
QTest::newRow("gap") << QVector<QRect>{{QRect{0, 0, 10, 20}, QRect{20, 40, 10, 20}}} << QPoint(15, 30) << 1;
}
void TestScreens::testCurrentPoint()
void ScreensTest::testCurrentPoint()
{
using namespace KWin;
MockWorkspace ws;
MockScreens *mockScreens = static_cast<MockScreens*>(Screens::create(&ws));
QSignalSpy changedSpy(screens(), &KWin::Screens::changed);
QVERIFY(changedSpy.isValid());
QFETCH(QList<QRect>, geometries);
mockScreens->setGeometries(geometries);
// first is before it's updated
QVERIFY(changedSpy.wait());
// second is after it's updated
QFETCH(QVector<QRect>, geometries);
QMetaObject::invokeMethod(kwinApp()->platform(), "setVirtualOutputs", Qt::QueuedConnection,
Q_ARG(int, geometries.count()), Q_ARG(QVector<QRect>, geometries));
QVERIFY(changedSpy.wait());
QFETCH(QPoint, cursorPos);
......@@ -341,5 +336,7 @@ void TestScreens::testCurrentPoint()
QTEST(screens()->current(), "expected");
}
QTEST_MAIN(TestScreens)
#include "test_screens.moc"
} // namespace KWin
WAYLANDTEST_MAIN(KWin::ScreensTest)
#include "screens_test.moc"
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment