Differential D26858 Diff 75564 autotests/server/test_tablet_interface.cpp

Changeset View

Standalone View

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 <QHash>
22		#include <QThread>
23		#include <QtTest>
24		// WaylandServer
25		#include "../../src/server/compositor_interface.h"
26		#include "../../src/server/display.h"
27		#include "../../src/server/seat_interface.h"
28		#include "../../src/server/tablet_interface.h"
29
30		#include "../../src/client/compositor.h"
31		#include "../../src/client/connection_thread.h"
32		#include "../../src/client/event_queue.h"
33		#include "../../src/client/registry.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)
44		: QtWayland::zwp_tablet_v2(t)
45		{
46		}
47		};
48
49		class Tool : public QObject, public QtWayland::zwp_tablet_tool_v2
50		{
51		Q_OBJECT
52		public:
53		Tool(::zwp_tablet_tool_v2 *t)
54		: QtWayland::zwp_tablet_tool_v2(t)
55		{
56		}
57
58		void zwp_tablet_tool_v2_proximity_in(uint32_t /serial/, struct ::zwp_tablet_v2 * /tablet/, struct ::wl_surface *surface) override
59		{
60		surfaceApproximated[surface]++;
61		}
62
63		void zwp_tablet_tool_v2_frame(uint32_t time) override
64		{
65		Q_EMIT frame(time);
66		}
67
68		QHash<struct ::wl_surface *, int> surfaceApproximated;
69		Q_SIGNALS:
70		void frame(quint32 time);
71		};
72
73		class TabletSeat : public QObject, public QtWayland::zwp_tablet_seat_v2
74		{
75		Q_OBJECT
76		public:
77		TabletSeat(::zwp_tablet_seat_v2 *seat)
78		: QtWayland::zwp_tablet_seat_v2(seat)
79		{
80		}
	zzagUnsubmitted Done Put a single space before `` and `&`. zzag:* Put a single space before `*` and `&`.
81
82		void zwp_tablet_seat_v2_tablet_added(struct ::zwp_tablet_v2 *id) override
83		{
84		m_tablets << new Tablet(id);
85		Q_EMIT tabletAdded();
86		}
87		void zwp_tablet_seat_v2_tool_added(struct ::zwp_tablet_tool_v2 *id) override
88		{
89		m_tools << new Tool(id);
90		Q_EMIT toolAdded();
91		}
92
93		QVector<Tablet *> m_tablets;
94		QVector<Tool *> m_tools;
95
96		Q_SIGNALS:
97		void toolAdded();
98		void tabletAdded();
99		};
100
101		class TestTabletInterface : public QObject
102		{
103		Q_OBJECT
104		public:
105		TestTabletInterface()
106		{
107		}
108		~TestTabletInterface() override;
109
110		private Q_SLOTS:
111		void initTestCase();
112		void testAdd();
113		void testInteractSimple();
114		void testInteractSurfaceChange();
115
116		private:
117		KWayland::Client::ConnectionThread *m_connection;
118		KWayland::Client::EventQueue *m_queue;
119		KWayland::Client::Compositor *m_clientCompositor;
	zzagUnsubmitted Done Put a single space before ``. zzag:* Put a single space before `*`.
120		KWayland::Client::Seat *m_clientSeat = nullptr;
121
122		QThread *m_thread;
123		Display m_display;
124		SeatInterface *m_seat;
125		CompositorInterface *m_serverCompositor;
126
127		TabletSeat *m_tabletSeatClient = nullptr;
128		TabletManagerInterface *m_tabletManager;
129
130		TabletInterface *m_tablet;
131		TabletToolInterface *m_tool;
132
133		QVector<SurfaceInterface *> m_surfaces;
134		};
135
136		static const QString s_socketName = QStringLiteral("kwin-wayland-server-tablet-test-0");
137
138		void TestTabletInterface::initTestCase()
139		{
140		m_display.setSocketName(s_socketName);
141		m_display.start();
142		QVERIFY(m_display.isRunning());
143
144		m_seat = m_display.createSeat(this);
145		m_seat->create();
146		m_serverCompositor = m_display.createCompositor(this);
147		m_serverCompositor->create();
148		m_tabletManager = m_display.createTabletManagerInterface(this);
149		QVERIFY(m_serverCompositor->isValid());
150		connect(m_serverCompositor, &CompositorInterface::surfaceCreated, this, [this](SurfaceInterface *surface) {
151		m_surfaces += surface;
152		});
153
154		// setup connection
155		m_connection = new KWayland::Client::ConnectionThread;
156		QSignalSpy connectedSpy(m_connection, &KWayland::Client::ConnectionThread::connected);
157		m_connection->setSocketName(s_socketName);
158
159		m_thread = new QThread(this);
160		m_connection->moveToThread(m_thread);
161		m_thread->start();
162
163		m_connection->initConnection();
164		QVERIFY(connectedSpy.wait());
165		QVERIFY(!m_connection->connections().isEmpty());
166
167		m_queue = new KWayland::Client::EventQueue(this);
168		QVERIFY(!m_queue->isValid());
169		m_queue->setup(m_connection);
170		QVERIFY(m_queue->isValid());
171
172		auto registry = new KWayland::Client::Registry(this);
173		connect(registry, &KWayland::Client::Registry::interfaceAnnounced, this, [this, registry](const QByteArray &interface, quint32 name, quint32 version) {
174		if (interface == "zwp_tablet_manager_v2") {
175		auto tabletClient = new QtWayland::zwp_tablet_manager_v2(registry->registry(), name, version);
176		auto _seat = tabletClient->get_tablet_seat(*m_clientSeat);
177		m_tabletSeatClient = new TabletSeat(_seat);
178		}
179		});
180		connect(registry, &KWayland::Client::Registry::seatAnnounced, this, [this, registry](quint32 name, quint32 version) {
181		m_clientSeat = registry->createSeat(name, version);
182		});
183		registry->setEventQueue(m_queue);
184		QSignalSpy compositorSpy(registry, &KWayland::Client::Registry::compositorAnnounced);
185		registry->create(m_connection->display());
186		QVERIFY(registry->isValid());
187		registry->setup();
188		wl_display_flush(m_connection->display());
189
190		QVERIFY(compositorSpy.wait());
191		m_clientCompositor = registry->createCompositor(compositorSpy.first().first().value<quint32>(), compositorSpy.first().last().value<quint32>(), this);
192		QVERIFY(m_clientCompositor->isValid());
193
194		QSignalSpy surfaceSpy(m_serverCompositor, &CompositorInterface::surfaceCreated);
195		for (int i = 0; i < 3; ++i) {
196		m_clientCompositor->createSurface(this);
197		}
198		QVERIFY(surfaceSpy.count() < 3 && surfaceSpy.wait(200));
199		QVERIFY(m_surfaces.count() == 3);
200		QVERIFY(m_tabletSeatClient);
201		}
202
203		TestTabletInterface::~TestTabletInterface()
204		{
205		if (m_queue) {
206		delete m_queue;
	zzagUnsubmitted Done No short names. zzag: No short names.
207		m_queue = nullptr;
208		}
209		if (m_thread) {
210		m_thread->quit();
211		m_thread->wait();
212		delete m_thread;
213		m_thread = nullptr;
214		}
215		delete m_tabletSeatClient;
216		m_connection->deleteLater();
217		m_connection = nullptr;
218		}
219
220		void TestTabletInterface::testAdd()
221		{
222		TabletSeatInterface *seatInterface = m_tabletManager->seat(m_seat);
223		QVERIFY(seatInterface);
224
225		QSignalSpy tabletSpy(m_tabletSeatClient, &TabletSeat::tabletAdded);
226		m_tablet = seatInterface->addTablet(1, 2, QStringLiteral("event33"), QStringLiteral("my tablet"), {QStringLiteral("/test/event33")});
	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		QVERIFY(m_tablet);
228		QVERIFY(tabletSpy.wait() \|\| tabletSpy.count() == 1);
	zzagUnsubmitted Done Align pointers to right. zzag: Align pointers to right.
229		QCOMPARE(m_tabletSeatClient->m_tablets.count(), 1);
230
231		QSignalSpy toolSpy(m_tabletSeatClient, &TabletSeat::toolAdded);
232		m_tool = seatInterface->addTool(KWayland::Server::TabletToolInterface::Pen, 0, 0, {TabletToolInterface::Tilt, TabletToolInterface::Pressure});
	zzagUnsubmitted Done What's `n`? zzag: What's `n`?
233		QVERIFY(m_tool);
234		QVERIFY(toolSpy.wait() \|\| toolSpy.count() == 1);
235		QCOMPARE(m_tabletSeatClient->m_tools.count(), 1);
236
237		QVERIFY(!m_tool->isClientSupported()); //There's no surface in it yet
238		m_tool->setCurrentSurface(nullptr);
239		QVERIFY(!m_tool->isClientSupported()); //There's no surface in it
240
241		QCOMPARE(m_surfaces.count(), 3);
242		for (SurfaceInterface *surface : m_surfaces) {
243		m_tool->setCurrentSurface(surface);
244		}
245		m_tool->setCurrentSurface(nullptr);
246		}
247
248		static uint s_serial = 0;
249		void TestTabletInterface::testInteractSimple()
250		{
251		QSignalSpy frameSpy(m_tabletSeatClient->m_tools[0], &Tool::frame);
252
253		QVERIFY(!m_tool->isClientSupported());
254		m_tool->setCurrentSurface(m_surfaces[0]);
255		QVERIFY(m_tool->isClientSupported() && m_tablet->isSurfaceSupported(m_surfaces[0]));
256		m_tool->sendProximityIn(m_tablet);
257		m_tool->sendPressure(0);
258		m_tool->sendFrame(s_serial++);
259		m_tool->sendMotion({3, 3});
260		m_tool->sendFrame(s_serial++);
261		m_tool->sendProximityOut();
262		QVERIFY(m_tool->isClientSupported());
263		m_tool->sendFrame(s_serial++);
264		QVERIFY(!m_tool->isClientSupported());
265
266		QVERIFY(frameSpy.wait(500));
267		QCOMPARE(m_tabletSeatClient->m_tools[0]->surfaceApproximated.count(), 1);
268		}
269
270		void TestTabletInterface::testInteractSurfaceChange()
271		{
272		m_tabletSeatClient->m_tools[0]->surfaceApproximated.clear();
273		QSignalSpy frameSpy(m_tabletSeatClient->m_tools[0], &Tool::frame);
274		QVERIFY(!m_tool->isClientSupported());
275		m_tool->setCurrentSurface(m_surfaces[0]);
276		QVERIFY(m_tool->isClientSupported() && m_tablet->isSurfaceSupported(m_surfaces[0]));
277		m_tool->sendProximityIn(m_tablet);
278		m_tool->sendPressure(0);
279		m_tool->sendFrame(s_serial++);
280
281		m_tool->setCurrentSurface(m_surfaces[1]);
282		QVERIFY(m_tool->isClientSupported());
283
284		m_tool->sendMotion({3, 3});
285		m_tool->sendFrame(s_serial++);
286		m_tool->sendProximityOut();
287		QVERIFY(m_tool->isClientSupported());
288		m_tool->sendFrame(s_serial++);
289		QVERIFY(!m_tool->isClientSupported());
290
291		QVERIFY(frameSpy.wait(500));
292		QCOMPARE(m_tabletSeatClient->m_tools[0]->surfaceApproximated.count(), 2);
293		}
294
295		QTEST_GUILESS_MAIN(TestTabletInterface)
296		#include "test_tablet_interface.moc"