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