Differential D26858 Diff 74212 autotests/server/test_tablet_interface.cpp

Changeset View

Standalone View

View Options

autotests/server/test_tablet_interface.cpp

  • This file was added.
1​/********************************************************************
2​Copyright 2020 Aleix Pol Gonzalez <aleixpol@kde.org>
3​
zzagUnsubmitted
Done

Haven't you written this autotest?

zzag: Haven't you written this autotest?
4​This library is free software; you can redistribute it and/or
5​modify it under the terms of the GNU Lesser General Public
6​License as published by the Free Software Foundation; either
7​version 2.1 of the License, or (at your option) version 3, or any
8​later version accepted by the membership of KDE e.V. (or its
9​successor approved by the membership of KDE e.V.), which shall
10​act as a proxy defined in Section 6 of version 3 of the license.
11​
12​This library is distributed in the hope that it will be useful,
13​but WITHOUT ANY WARRANTY; without even the implied warranty of
14​MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15​Lesser General Public License for more details.
16​
17​You should have received a copy of the GNU Lesser General Public
18​License along with this library. If not, see <http://www.gnu.org/licenses/>.
19​*********************************************************************/
20​// Qt
zzagUnsubmitted
Not Done

Note that we've switched to SPDX markers.

zzag: Note that we've switched to SPDX markers.
21​#include <QtTest>
22​#include <QThread>
23​#include <QHash>
24​// WaylandServer
25​#include "../../src/server/display.h"
26​#include "../../src/server/tablet_interface.h"
27​#include "../../src/server/seat_interface.h"
28​#include "../../src/server/compositor_interface.h"
29​
30​#include "../../src/client/connection_thread.h"
31​#include "../../src/client/event_queue.h"
32​#include "../../src/client/registry.h"
33​#include "../../src/client/compositor.h"
34​#include "../../src/client/seat.h"
35​
36​#include "qwayland-tablet-unstable-v2.h"
37​
38​using namespace KWayland::Server;
39​
40​class Tablet : public QtWayland::zwp_tablet_v2
41​{
zzagUnsubmitted
Done

The opening has to be on its own line.

zzag: The opening has to be on its own line.
42​public:
43​ Tablet(::zwp_tablet_v2 *t) : QtWayland::zwp_tablet_v2(t) {}
44​};
45​
46​class Tool : public QObject, public QtWayland::zwp_tablet_tool_v2
47​{
48​ Q_OBJECT
49​public:
50​ Tool(::zwp_tablet_tool_v2 *t) : QtWayland::zwp_tablet_tool_v2(t) {}
51​
52​ void zwp_tablet_tool_v2_proximity_in(uint32_t /*serial*/, struct ::zwp_tablet_v2 * /*tablet*/, struct ::wl_surface * surface) override {
53​ surfaceApproximated[surface]++;
54​ }
55​
56​ void zwp_tablet_tool_v2_frame(uint32_t time) override {
57​ Q_EMIT frame(time);
58​ }
59​
60​ QHash<struct ::wl_surface *, int> surfaceApproximated;
61​Q_SIGNALS:
62​ void frame(quint32 time);
63​};
64​
65​class TabletSeat : public QObject, public QtWayland::zwp_tablet_seat_v2
66​{
67​ Q_OBJECT
68​public:
69​ TabletSeat(::zwp_tablet_seat_v2 *seat) : QtWayland::zwp_tablet_seat_v2(seat) {}
70​
71​ void zwp_tablet_seat_v2_tablet_added(struct ::zwp_tablet_v2 *id) override {
72​ m_tablets << new Tablet(id);
73​ Q_EMIT tabletAdded();
74​ }
75​ void zwp_tablet_seat_v2_tool_added(struct ::zwp_tablet_tool_v2 *id) override {
76​ m_tools << new Tool(id);
77​ Q_EMIT toolAdded();
78​ }
79​
80​ QVector<Tablet *> m_tablets;
zzagUnsubmitted
Done

Put a single space before * and &.

zzag: Put a single space before `*` and `&`.
81​ QVector<Tool *> m_tools;
82​
83​Q_SIGNALS:
84​ void toolAdded();
85​ void tabletAdded();
86​};
87​
88​class TestTabletInterface : public QObject
89​{
90​ Q_OBJECT
91​public:
92​ TestTabletInterface() {}
93​ ~TestTabletInterface() override;
94​
95​private Q_SLOTS:
96​ void initTestCase();
97​ void testAdd();
98​ void testInteractSimple();
99​ void testInteractSurfaceChange();
100​
101​private:
102​ KWayland::Client::ConnectionThread* m_connection;
103​ KWayland::Client::EventQueue* m_queue;
104​ KWayland::Client::Compositor* m_clientCompositor;
105​ KWayland::Client::Seat* m_clientSeat = nullptr;
106​
107​ QThread* m_thread;
108​ Display m_display;
109​ SeatInterface* m_seat;
110​ CompositorInterface* m_serverCompositor;
111​
112​ TabletSeat *m_tabletSeatClient = nullptr;
113​ TabletManagerInterface* m_tabletManager;
114​
115​ TabletInterface* m_tablet;
116​ TabletToolInterface* m_tool;
117​
118​ QVector<SurfaceInterface*> m_surfaces;
zzagUnsubmitted
Done

Put a single space before *.

zzag: Put a single space before `*`.
119​};
120​
121​static const QString s_socketName = QStringLiteral("kwin-wayland-server-tablet-test-0");
122​
123​void TestTabletInterface::initTestCase()
124​{
125​ m_display.setSocketName(s_socketName);
126​ m_display.start();
127​ QVERIFY(m_display.isRunning());
128​
129​ m_seat = m_display.createSeat(this);
130​ m_seat->create();
131​ m_serverCompositor = m_display.createCompositor(this);
132​ m_serverCompositor->create();
133​ m_tabletManager = m_display.createTabletManagerInterface(this);
134​ QVERIFY(m_serverCompositor->isValid());
135​ connect(m_serverCompositor, &CompositorInterface::surfaceCreated, this, [this] (SurfaceInterface* surface) {
136​ m_surfaces += surface;
137​ });
138​
139​ // setup connection
140​ m_connection = new KWayland::Client::ConnectionThread;
141​ QSignalSpy connectedSpy(m_connection, &KWayland::Client::ConnectionThread::connected);
142​ m_connection->setSocketName(s_socketName);
143​
144​ m_thread = new QThread(this);
145​ m_connection->moveToThread(m_thread);
146​ m_thread->start();
147​
148​ m_connection->initConnection();
149​ QVERIFY(connectedSpy.wait());
150​ QVERIFY(!m_connection->connections().isEmpty());
151​
152​ m_queue = new KWayland::Client::EventQueue(this);
153​ QVERIFY(!m_queue->isValid());
154​ m_queue->setup(m_connection);
155​ QVERIFY(m_queue->isValid());
156​
157​ auto registry = new KWayland::Client::Registry(this);
158​ connect(registry, &KWayland::Client::Registry::interfaceAnnounced, this, [this, registry](const QByteArray &interface, quint32 name, quint32 version){
159​ if (interface == "zwp_tablet_manager_v2") {
160​ auto tabletClient = new QtWayland::zwp_tablet_manager_v2(registry->registry(), name, version);
161​ auto _seat = tabletClient->get_tablet_seat(*m_clientSeat);
162​ m_tabletSeatClient = new TabletSeat(_seat);
163​ }
164​ });
165​ connect(registry, &KWayland::Client::Registry::seatAnnounced, this, [this, registry](quint32 name, quint32 version) {
166​ m_clientSeat = registry->createSeat(name, version);
167​ });
168​ registry->setEventQueue(m_queue);
169​ QSignalSpy compositorSpy(registry, &KWayland::Client::Registry::compositorAnnounced);
170​ registry->create(m_connection->display());
171​ QVERIFY(registry->isValid());
172​ registry->setup();
173​ wl_display_flush(m_connection->display());
174​
175​ QVERIFY(compositorSpy.wait());
176​ m_clientCompositor = registry->createCompositor(compositorSpy.first().first().value<quint32>(), compositorSpy.first().last().value<quint32>(), this);
177​ QVERIFY(m_clientCompositor->isValid());
178​
179​ QSignalSpy surfaceSpy(m_serverCompositor, &CompositorInterface::surfaceCreated);
180​ for(int i = 0; i<3; ++i) {
181​ m_clientCompositor->createSurface(this);
182​ }
183​ QVERIFY(surfaceSpy.count() < 3 && surfaceSpy.wait(200));
184​ QVERIFY(m_surfaces.count() == 3);
185​ QVERIFY(m_tabletSeatClient);
186​}
187​
188​TestTabletInterface::~TestTabletInterface()
189​{
190​ if (m_queue) {
191​ delete m_queue;
192​ m_queue = nullptr;
193​ }
194​ if (m_thread) {
195​ m_thread->quit();
196​ m_thread->wait();
197​ delete m_thread;
198​ m_thread = nullptr;
199​ }
200​ delete m_tabletSeatClient;
201​ m_connection->deleteLater();
202​ m_connection = nullptr;
203​}
204​
205​void TestTabletInterface::testAdd()
206​{
zzagUnsubmitted
Done

No short names.

zzag: No short names.
207​ TabletSeatInterface* seatInterface = m_tabletManager->seat(m_seat);
208​ QVERIFY(seatInterface);
209​
210​ QSignalSpy tabletSpy(m_tabletSeatClient, &TabletSeat::tabletAdded);
211​ m_tablet = seatInterface->addTablet(1, 2, QStringLiteral("event33"), QStringLiteral("my tablet"), {QStringLiteral("/test/event33")});
212​ QVERIFY(m_tablet);
213​ QVERIFY(tabletSpy.wait() || tabletSpy.count() == 1);
214​ QCOMPARE(m_tabletSeatClient->m_tablets.count(), 1);
215​
216​ QSignalSpy toolSpy(m_tabletSeatClient, &TabletSeat::toolAdded);
217​ m_tool = seatInterface->addTool(KWayland::Server::TabletToolInterface::Pen, 0,0, {TabletToolInterface::Tilt, TabletToolInterface::Pressure});
218​ QVERIFY(m_tool);
219​ QVERIFY(toolSpy.wait() || toolSpy.count() == 1);
220​ QCOMPARE(m_tabletSeatClient->m_tools.count(), 1);
221​
222​ QVERIFY(!m_tool->isClientSupported()); //There's no surface in it yet
223​ m_tool->setCurrentSurface(nullptr);
224​ QVERIFY(!m_tool->isClientSupported()); //There's no surface in it
225​
226​ QCOMPARE(m_surfaces.count(), 3);
zzagUnsubmitted
Done

No auto.

https://community.kde.org/Policies/Library_Code_Policy#auto_Keyword

zzag: No `auto`. https://community.kde.org/Policies/Library_Code_Policy#auto_Keyword
227​ for (SurfaceInterface* surface : m_surfaces) {
228​ m_tool->setCurrentSurface(surface);
zzagUnsubmitted
Done

Align pointers to right.

zzag: Align pointers to right.
229​ }
230​ m_tool->setCurrentSurface(nullptr);
231​}
232​
zzagUnsubmitted
Done

What's n?

zzag: What's `n`?
233​static uint s_serial = 0;
234​void TestTabletInterface::testInteractSimple()
235​{
236​ QSignalSpy frameSpy(m_tabletSeatClient->m_tools[0], &Tool::frame);
237​
238​ QVERIFY(!m_tool->isClientSupported());
239​ m_tool->setCurrentSurface(m_surfaces[0]);
240​ QVERIFY(m_tool->isClientSupported() && m_tablet->resourceForSurface(m_surfaces[0]));
241​ m_tool->sendProximityIn(m_tablet);
242​ m_tool->sendPressure(0);
243​ m_tool->sendFrame(s_serial++);
244​ m_tool->sendMotion({3,3});
245​ m_tool->sendFrame(s_serial++);
246​ m_tool->sendProximityOut();
247​ QVERIFY(m_tool->isClientSupported());
248​ m_tool->sendFrame(s_serial++);
249​ QVERIFY(!m_tool->isClientSupported());
250​
251​ QVERIFY(frameSpy.wait(500));
252​ QCOMPARE(m_tabletSeatClient->m_tools[0]->surfaceApproximated.count(), 1);
253​}
254​
255​void TestTabletInterface::testInteractSurfaceChange()
256​{
257​ m_tabletSeatClient->m_tools[0]->surfaceApproximated.clear();
258​ QSignalSpy frameSpy(m_tabletSeatClient->m_tools[0], &Tool::frame);
259​ QVERIFY(!m_tool->isClientSupported());
260​ m_tool->setCurrentSurface(m_surfaces[0]);
261​ QVERIFY(m_tool->isClientSupported() && m_tablet->resourceForSurface(m_surfaces[0]));
262​ m_tool->sendProximityIn(m_tablet);
263​ m_tool->sendPressure(0);
264​ m_tool->sendFrame(s_serial++);
265​
266​ m_tool->setCurrentSurface(m_surfaces[1]);
267​ QVERIFY(m_tool->isClientSupported());
268​
269​ m_tool->sendMotion({3,3});
270​ m_tool->sendFrame(s_serial++);
271​ m_tool->sendProximityOut();
272​ QVERIFY(m_tool->isClientSupported());
273​ m_tool->sendFrame(s_serial++);
274​ QVERIFY(!m_tool->isClientSupported());
275​
276​ QVERIFY(frameSpy.wait(500));
277​ QCOMPARE(m_tabletSeatClient->m_tools[0]->surfaceApproximated.count(), 2);
278​}
279​
280​QTEST_GUILESS_MAIN(TestTabletInterface)
281​#include "test_tablet_interface.moc"