Differential D1231 Diff 30271 autotests/client/test_remote_access.cpp

Changeset View

Standalone View

autotests/client/test_remote_access.cpp

This file was added.

1		/********************************************************************
2		Copyright 2016 Oleg Chernovskiy <kanedias@xaker.ru>
3
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
21		#include <QtTest/QtTest>
22		// client
23		#include "../../src/client/connection_thread.h"
24		#include "../../src/client/event_queue.h"
25		#include "../../src/client/remote_access.h"
26		#include "../../src/client/registry.h"
27		#include "../../src/client/output.h"
28		// server
29		#include "../../src/server/display.h"
30		#include "../../src/server/output_interface.h"
31		#include "../../src/server/remote_access_interface.h"
32
33		#include <linux/input.h>
34
35		using namespace KWayland::Client;
36		using namespace KWayland::Server;
37
38		Q_DECLARE_METATYPE(const BufferHandle *)
39		Q_DECLARE_METATYPE(const RemoteBuffer *)
40		Q_DECLARE_METATYPE(const void *)
41
42		class RemoteAccessTest : public QObject
43		{
44		Q_OBJECT
45		private Q_SLOTS:
46		void init();
47		void cleanup();
48
49		void testSendReleaseSingle();
50		void testSendReleaseMultiple();
51		void testSendClientGone();
52		void testSendReceiveClientGone();
53
54		private:
55		Display *m_display = nullptr;
56		OutputInterface *m_outputInterface = nullptr;
57		RemoteAccessManagerInterface *m_remoteAccessInterface = nullptr;
58		ConnectionThread *m_connection = nullptr;
59		QThread *m_thread = nullptr;
60		EventQueue *m_queue = nullptr;
61		Registry *m_registry = nullptr;
62		Output *m_output = nullptr;
63		};
64
65		static const QString s_socketName = QStringLiteral("kwayland-test-remote-access-0");
66
67		void RemoteAccessTest::init()
68		{
69		qRegisterMetaType<const BufferHandle *>();
70		qRegisterMetaType<const RemoteBuffer *>();
71		qRegisterMetaType<const void *>();
72
73		delete m_display;
74		m_display = new Display(this);
75		m_display->setSocketName(s_socketName);
76		m_display->start();
77		QVERIFY(m_display->isRunning());
78		m_display->createShm();
79		m_outputInterface = m_display->createOutput();
80		m_outputInterface->create();
81		m_remoteAccessInterface = m_display->createRemoteAccessManager();
82		m_remoteAccessInterface->create();
83		QSignalSpy bufferReleasedSpy(m_remoteAccessInterface, &RemoteAccessManagerInterface::bufferReleased);
84		QVERIFY(bufferReleasedSpy.isValid());
85
86		// setup connection
87		m_connection = new KWayland::Client::ConnectionThread;
88		QSignalSpy connectedSpy(m_connection, &ConnectionThread::connected);
89		QVERIFY(connectedSpy.isValid());
90		m_connection->setSocketName(s_socketName);
91
92		m_thread = new QThread(this);
93		m_connection->moveToThread(m_thread);
94		m_thread->start();
95
96		m_connection->initConnection();
97		QVERIFY(connectedSpy.wait());
98
99		m_queue = new EventQueue(this);
100		m_queue->setup(m_connection);
101
102		m_registry = new Registry(this);
103		QSignalSpy interfacesAnnouncedSpy(m_registry, &Registry::interfacesAnnounced);
104		QVERIFY(interfacesAnnouncedSpy.isValid());
105		m_registry->setEventQueue(m_queue);
106		m_registry->create(m_connection);
107		QVERIFY(m_registry->isValid());
108		m_registry->setup();
109		QVERIFY(interfacesAnnouncedSpy.wait());
110
111		// client-bound output
112		m_output = m_registry->createOutput(m_registry->interface(Registry::Interface::Output).name,
113		m_registry->interface(Registry::Interface::Output).version,
114		this);
115		}
116
117		void RemoteAccessTest::cleanup()
118		{
119		#define CLEANUP(variable) \
120		if (variable) { \
121		delete variable; \
122		variable = nullptr; \
123		}
124		CLEANUP(m_output)
125		CLEANUP(m_queue)
126		CLEANUP(m_registry)
127		if (m_thread) {
128		if (m_connection) {
129		m_connection->flush();
130		m_connection->deleteLater();
131		m_connection = nullptr;
132		}
133
134		m_thread->quit();
135		m_thread->wait();
136		delete m_thread;
137		m_thread = nullptr;
138		}
139
140		CLEANUP(m_remoteAccessInterface)
141		CLEANUP(m_display)
142		#undef CLEANUP
143		}
144
145		void RemoteAccessTest::testSendReleaseSingle()
146		{
147		// this test verifies that a buffer is sent to client and returned back
148
149		// setup
150		QVERIFY(!m_remoteAccessInterface->isBound());
151		auto client = m_registry->createRemoteAccessManager(
152		m_registry->interface(Registry::Interface::RemoteAccessManager).name,
153		m_registry->interface(Registry::Interface::RemoteAccessManager).version,
154		this);
155		QVERIFY(client->isValid());
156		m_connection->flush();
157		m_display->dispatchEvents();
158
159		QVERIFY(m_remoteAccessInterface->isBound()); // we have one client now
160		QSignalSpy bufferReadySpy(client, &RemoteAccessManager::bufferReady);
161		QVERIFY(bufferReadySpy.isValid());
162
	graesslinUnsubmitted Done use QCOMPARE to test two values. If it fails with QCOMPARE you get the values it actually had. With QVERIFY you only see that it failed graesslin: use QCOMPARE to test two values. If it fails with QCOMPARE you get the values it actually had.
	KanediasAuthorUnsubmitted Not Done Got it Kanedias: Got it
163		BufferHandle *buf = new BufferHandle();
164		QTemporaryFile *tmpFile = new QTemporaryFile(this);
165		tmpFile->open();
166
167		buf->setFd(tmpFile->handle());
168		buf->setSize(50, 50);
169		buf->setFormat(100500);
170		buf->setStride(7800);
171		m_remoteAccessInterface->sendBufferReady(m_outputInterface, buf);
172
173		// receive buffer
174		QVERIFY(bufferReadySpy.wait());
175		auto rbuf = bufferReadySpy.takeFirst()[1].value<const RemoteBuffer *>();
176		QSignalSpy paramsObtainedSpy(rbuf, &RemoteBuffer::parametersObtained);
177		QVERIFY(paramsObtainedSpy.isValid());
178
179		// wait for params
180		QVERIFY(paramsObtainedSpy.wait());
181		// client fd is different, not subject to check
182		QCOMPARE(rbuf->width(), 50u);
183		QCOMPARE(rbuf->height(), 50u);
184		QCOMPARE(rbuf->format(), 100500u);
185		QCOMPARE(rbuf->stride(), 7800u);
186
187		// release
188		QSignalSpy bufferReleasedSpy(m_remoteAccessInterface, &RemoteAccessManagerInterface::bufferReleased);
189		QVERIFY(bufferReleasedSpy.isValid());
190		delete rbuf;
191		QVERIFY(bufferReleasedSpy.wait());
192
193		// cleanup
194		delete buf;
195		delete client;
196		m_connection->flush();
197		m_display->dispatchEvents();
198		QVERIFY(!m_remoteAccessInterface->isBound());
199		}
200
201		void RemoteAccessTest::testSendReleaseMultiple()
202		{
203		// this test verifies that a buffer is sent to 2 clients and returned back
204
205		// setup
206		QVERIFY(!m_remoteAccessInterface->isBound());
207		auto client1 = m_registry->createRemoteAccessManager(
208		m_registry->interface(Registry::Interface::RemoteAccessManager).name,
209		m_registry->interface(Registry::Interface::RemoteAccessManager).version,
210		this);
211		QVERIFY(client1->isValid());
212		auto client2 = m_registry->createRemoteAccessManager(
213		m_registry->interface(Registry::Interface::RemoteAccessManager).name,
214		m_registry->interface(Registry::Interface::RemoteAccessManager).version,
215		this);
216		QVERIFY(client2->isValid());
217		m_connection->flush();
218		m_display->dispatchEvents();
219
220		QVERIFY(m_remoteAccessInterface->isBound()); // now we have 2 clients
221		QSignalSpy bufferReadySpy1(client1, &RemoteAccessManager::bufferReady);
222		QVERIFY(bufferReadySpy1.isValid());
223		QSignalSpy bufferReadySpy2(client2, &RemoteAccessManager::bufferReady);
224		QVERIFY(bufferReadySpy2.isValid());
225
226		BufferHandle *buf = new BufferHandle();
227		QTemporaryFile *tmpFile = new QTemporaryFile(this);
228		tmpFile->open();
229
230		buf->setFd(tmpFile->handle());
231		buf->setSize(50, 50);
232		buf->setFormat(100500);
233		buf->setStride(7800);
234		m_remoteAccessInterface->sendBufferReady(m_outputInterface, buf);
235
236		// wait for event loop
237		QVERIFY(bufferReadySpy1.wait());
238
239		// receive buffer at client 1
240		QCOMPARE(bufferReadySpy1.size(), 1);
241		auto rbuf1 = bufferReadySpy1.takeFirst()[1].value<const RemoteBuffer *>();
242		QSignalSpy paramsObtainedSpy1(rbuf1, &RemoteBuffer::parametersObtained);
243		QVERIFY(paramsObtainedSpy1.isValid());
244
245		// receive buffer at client 2
246		QCOMPARE(bufferReadySpy2.size(), 1);
247		auto rbuf2 = bufferReadySpy2.takeFirst()[1].value<const RemoteBuffer *>();
248		QSignalSpy paramsObtainedSpy2(rbuf2, &RemoteBuffer::parametersObtained);
249		QVERIFY(paramsObtainedSpy2.isValid());
250
251		// wait for event loop
252		QVERIFY(paramsObtainedSpy1.wait());
253		QCOMPARE(paramsObtainedSpy1.size(), 1);
254		QCOMPARE(paramsObtainedSpy2.size(), 1);
255
256		// release
257		QSignalSpy bufferReleasedSpy(m_remoteAccessInterface, &RemoteAccessManagerInterface::bufferReleased);
258		QVERIFY(bufferReleasedSpy.isValid());
259		delete rbuf1;
260		QVERIFY(!bufferReleasedSpy.wait(1000)); // one client released, second still holds buffer!
261
262		delete rbuf2;
263		QVERIFY(bufferReleasedSpy.wait()); // all clients released, buffer should be freed
264
265		// cleanup
266		delete buf;
267		delete client1;
268		delete client2;
269		m_connection->flush();
270		m_display->dispatchEvents();
271		QVERIFY(!m_remoteAccessInterface->isBound());
272		}
273
274		void RemoteAccessTest::testSendClientGone()
275		{
276		// this test verifies that when buffer is sent and client is gone, server will release buffer correctly
277		QVERIFY(!m_remoteAccessInterface->isBound());
278		auto client = m_registry->createRemoteAccessManager(
279		m_registry->interface(Registry::Interface::RemoteAccessManager).name,
280		m_registry->interface(Registry::Interface::RemoteAccessManager).version,
281		this);
282		QVERIFY(client->isValid());
283		m_connection->flush();
284		m_display->dispatchEvents();
285
286		QVERIFY(m_remoteAccessInterface->isBound()); // we have one client now
287		QSignalSpy bufferReadySpy(client, &RemoteAccessManager::bufferReady);
288		QVERIFY(bufferReadySpy.isValid());
289
290		BufferHandle *buf = new BufferHandle();
291		QTemporaryFile *tmpFile = new QTemporaryFile(this);
292		tmpFile->open();
293
294		buf->setFd(tmpFile->handle());
295		buf->setSize(50, 50);
296		buf->setFormat(100500);
297		buf->setStride(7800);
298		m_remoteAccessInterface->sendBufferReady(m_outputInterface, buf);
299
300		// release forcefully
301		QSignalSpy bufferReleasedSpy(m_remoteAccessInterface, &RemoteAccessManagerInterface::bufferReleased);
302		QVERIFY(bufferReleasedSpy.isValid());
303		delete client;
304		QVERIFY(bufferReleasedSpy.wait());
305
306		// cleanup
307		delete buf;
308		m_connection->flush();
309		m_display->dispatchEvents();
310		QVERIFY(!m_remoteAccessInterface->isBound());
311		}
312
313		void RemoteAccessTest::testSendReceiveClientGone()
314		{
315		// this test verifies that when buffer is sent, received and client is gone,
316		// both client and server will release buffer correctly
317		QVERIFY(!m_remoteAccessInterface->isBound());
318		auto client = m_registry->createRemoteAccessManager(
319		m_registry->interface(Registry::Interface::RemoteAccessManager).name,
320		m_registry->interface(Registry::Interface::RemoteAccessManager).version,
321		this);
322		QVERIFY(client->isValid());
323		m_connection->flush();
324		m_display->dispatchEvents();
325
326		QVERIFY(m_remoteAccessInterface->isBound()); // we have one client now
327		QSignalSpy bufferReadySpy(client, &RemoteAccessManager::bufferReady);
328		QVERIFY(bufferReadySpy.isValid());
329
330		BufferHandle *buf = new BufferHandle();
331		QTemporaryFile *tmpFile = new QTemporaryFile(this);
332		tmpFile->open();
333
334		buf->setFd(tmpFile->handle());
335		buf->setSize(50, 50);
336		buf->setFormat(100500);
337		buf->setStride(7800);
338		m_remoteAccessInterface->sendBufferReady(m_outputInterface, buf);
339
340		// receive buffer
341		QVERIFY(bufferReadySpy.wait());
342		auto rbuf = bufferReadySpy.takeFirst()[1].value<const RemoteBuffer *>();
343		QSignalSpy paramsObtainedSpy(rbuf, &RemoteBuffer::parametersObtained);
344		QVERIFY(paramsObtainedSpy.isValid());
345
346		// wait for params
347		QVERIFY(paramsObtainedSpy.wait());
348		// client fd is different, not subject to check
349		QCOMPARE(rbuf->width(), 50u);
350		QCOMPARE(rbuf->height(), 50u);
351		QCOMPARE(rbuf->format(), 100500u);
352		QCOMPARE(rbuf->stride(), 7800u);
353
354		// release forcefully
355		QSignalSpy bufferReleasedSpy(m_remoteAccessInterface, &RemoteAccessManagerInterface::bufferReleased);
356		QVERIFY(bufferReleasedSpy.isValid());
357		delete client;
358		QVERIFY(bufferReleasedSpy.wait());
359
360		// cleanup
361		delete buf;
362		m_connection->flush();
363		m_display->dispatchEvents();
364		QVERIFY(!m_remoteAccessInterface->isBound());
365		}
366
367
368		QTEST_GUILESS_MAIN(RemoteAccessTest)
369		#include "test_remote_access.moc"