Differential D15893 Diff 43494 autotests/integration/stacking_order_test.cpp

Changeset View

Standalone View

autotests/integration/stacking_order_test.cpp

This file was added.

1		/********************************************************************
2		KWin - the KDE window manager
3		This file is part of the KDE project.
4
5		Copyright (C) 2018 Vlad Zagorodniy <vladzzag@gmail.com>
6
7		This program is free software; you can redistribute it and/or modify
8		it under the terms of the GNU General Public License as published by
9		the Free Software Foundation; either version 2 of the License, or
10		(at your option) any later version.
11
12		This program 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
15		GNU General Public License for more details.
16
17		You should have received a copy of the GNU General Public License
18		along with this program. If not, see <http://www.gnu.org/licenses/>.
19		*********************************************************************/
20
21		#include "kwin_wayland_test.h"
22
23		#include "abstract_client.h"
24		#include "atoms.h"
25		#include "client.h"
26		#include "main.h"
27		#include "platform.h"
28		#include "shell_client.h"
29		#include "wayland_server.h"
30		#include "workspace.h"
31
32		#include <KWayland/Client/compositor.h>
33		#include <KWayland/Client/shell.h>
34		#include <KWayland/Client/surface.h>
35
36		#include <xcb/xcb.h>
37		#include <xcb/xcb_icccm.h>
38
39		using namespace KWin;
40
41		static const QString s_socketName = QStringLiteral("wayland_test_kwin_stacking_order-0");
42
43		class StackingOrderTest : public QObject
44		{
45		Q_OBJECT
46
47		private Q_SLOTS:
48		void initTestCase();
49		void init();
50		void cleanup();
51
52		void testTransientIsAlwaysAboveParent();
53		void testRaiseTransientAndParent();
54
55		void testGroupTransientIsAlwaysAboveWindowGroup();
56		void testRaiseGroupTransientAndWindowGroup();
57		void testDontKeepAboveNonModalDialogGroupTransients();
58
59		};
60
61		void StackingOrderTest::initTestCase()
62		{
63		qRegisterMetaType<KWin::AbstractClient *>();
64		qRegisterMetaType<KWin::ShellClient *>();
65
66		QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
67		QVERIFY(workspaceCreatedSpy.isValid());
68		kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
69		QVERIFY(waylandServer()->init(s_socketName.toLocal8Bit()));
70
71		kwinApp()->setConfig(KSharedConfig::openConfig(QString(), KConfig::SimpleConfig));
72
73		kwinApp()->start();
74		QVERIFY(workspaceCreatedSpy.wait());
75		waylandServer()->initWorkspace();
76		}
77
78		void StackingOrderTest::init()
79		{
80		QVERIFY(Test::setupWaylandConnection());
81		}
82
83		void StackingOrderTest::cleanup()
84		{
85		Test::destroyWaylandConnection();
86		}
87
88		void StackingOrderTest::testTransientIsAlwaysAboveParent()
89		{
90		// This test verifies that transients are always above their parents.
91
92		// Create the parent.
93		KWayland::Client::Surface *parentSurface =
94		Test::createSurface(Test::waylandCompositor());
95		QVERIFY(parentSurface);
96		KWayland::Client::ShellSurface *parentShellSurface =
97		Test::createShellSurface(parentSurface, parentSurface);
98		QVERIFY(parentShellSurface);
99		ShellClient *parent = Test::renderAndWaitForShown(parentSurface, QSize(256, 256), Qt::blue);
100		QVERIFY(parent);
101		QTRY_VERIFY(parent->isActive());
102		QVERIFY(!parent->isTransient());
103
104		// Initially, the stacking order should contain only the parent window.
105		QCOMPARE(workspace()->stackingOrder(), (ToplevelList{parent}));
106
107		// Create the transient.
108		KWayland::Client::Surface *transientSurface =
109		Test::createSurface(Test::waylandCompositor());
110		QVERIFY(transientSurface);
111		KWayland::Client::ShellSurface *transientShellSurface =
112		Test::createShellSurface(transientSurface, transientSurface);
113		QVERIFY(transientShellSurface);
114		transientShellSurface->setTransient(parentSurface, QPoint(0, 0));
115		ShellClient *transient = Test::renderAndWaitForShown(
116		transientSurface, QSize(128, 128), Qt::red);
117		QVERIFY(transient);
118		QTRY_VERIFY(transient->isActive());
119		QVERIFY(transient->isTransient());
120
121		// The transient should be above the parent.
122		QCOMPARE(workspace()->stackingOrder(), (ToplevelList{parent, transient}));
123
124		// The transient still stays above the parent if we activate the latter.
125		workspace()->activateClient(parent);
126		QTRY_VERIFY(parent->isActive());
127		QTRY_VERIFY(!transient->isActive());
128		QCOMPARE(workspace()->stackingOrder(), (ToplevelList{parent, transient}));
129		}
130
131		void StackingOrderTest::testRaiseTransientAndParent()
132		{
133		// This test verifies that both the parent and the transient will be
134		// raised if either one of them is activated.
135
136		// Create the parent.
137		KWayland::Client::Surface *parentSurface =
138		Test::createSurface(Test::waylandCompositor());
139		QVERIFY(parentSurface);
140		KWayland::Client::ShellSurface *parentShellSurface =
141		Test::createShellSurface(parentSurface, parentSurface);
142		QVERIFY(parentShellSurface);
143		ShellClient *parent = Test::renderAndWaitForShown(parentSurface, QSize(256, 256), Qt::blue);
144		QVERIFY(parent);
145		QTRY_VERIFY(parent->isActive());
146		QVERIFY(!parent->isTransient());
147
148		// Initially, the stacking order should contain only the parent window.
149		QCOMPARE(workspace()->stackingOrder(), (ToplevelList{parent}));
150
151		// Create the transient.
152		KWayland::Client::Surface *transientSurface =
153		Test::createSurface(Test::waylandCompositor());
154		QVERIFY(transientSurface);
155		KWayland::Client::ShellSurface *transientShellSurface =
156		Test::createShellSurface(transientSurface, transientSurface);
157		QVERIFY(transientShellSurface);
158		transientShellSurface->setTransient(parentSurface, QPoint(0, 0));
159		ShellClient *transient = Test::renderAndWaitForShown(
160		transientSurface, QSize(128, 128), Qt::red);
161		QVERIFY(transient);
162		QTRY_VERIFY(transient->isActive());
163		QVERIFY(transient->isTransient());
164
165		// The transient should be above the parent.
166		QCOMPARE(workspace()->stackingOrder(), (ToplevelList{parent, transient}));
167
168		// Create a window that doesn't have any relationship to the parent or the transient.
169		KWayland::Client::Surface *anotherSurface =
170		Test::createSurface(Test::waylandCompositor());
171		QVERIFY(anotherSurface);
172		KWayland::Client::ShellSurface *anotherShellSurface =
173		Test::createShellSurface(anotherSurface, anotherSurface);
174		QVERIFY(anotherShellSurface);
175		ShellClient *anotherClient = Test::renderAndWaitForShown(anotherSurface, QSize(128, 128), Qt::green);
176		QVERIFY(anotherClient);
177		QTRY_VERIFY(anotherClient->isActive());
178		QVERIFY(!anotherClient->isTransient());
179
180		// The newly created surface has to be above both the parent and the transient.
181		QCOMPARE(workspace()->stackingOrder(), (ToplevelList{parent, transient, anotherClient}));
182
183		// If we activate the parent, the transient should be raised too.
184		workspace()->activateClient(parent);
185		QTRY_VERIFY(parent->isActive());
186		QTRY_VERIFY(!transient->isActive());
187		QTRY_VERIFY(!anotherClient->isActive());
188		QCOMPARE(workspace()->stackingOrder(), (ToplevelList{anotherClient, parent, transient}));
189
190		// Go back to the initial setup.
191		workspace()->activateClient(anotherClient);
192		QTRY_VERIFY(!parent->isActive());
193		QTRY_VERIFY(!transient->isActive());
194		QTRY_VERIFY(anotherClient->isActive());
195		QCOMPARE(workspace()->stackingOrder(), (ToplevelList{parent, transient, anotherClient}));
196
197		// If we activate the transient, the parent should be raised too.
198		workspace()->activateClient(transient);
199		QTRY_VERIFY(!parent->isActive());
200		QTRY_VERIFY(transient->isActive());
201		QTRY_VERIFY(!anotherClient->isActive());
202		QCOMPARE(workspace()->stackingOrder(), (ToplevelList{anotherClient, parent, transient}));
203		}
204
205		static xcb_window_t createGroupWindow(xcb_connection_t *conn,
206		const QRect &geometry,
207		xcb_window_t leaderWid = XCB_WINDOW_NONE,
208		bool transient = false)
209		{
210		xcb_window_t wid = xcb_generate_id(conn);
211		xcb_create_window(
212		conn, // c
213		XCB_COPY_FROM_PARENT, // depth
214		wid, // wid
215		rootWindow(), // parent
216		geometry.x(), // x
217		geometry.y(), // y
218		geometry.width(), // width
219		geometry.height(), // height
220		0, // border_width
221		XCB_WINDOW_CLASS_INPUT_OUTPUT, // _class
222		XCB_COPY_FROM_PARENT, // visual
223		0, // value_mask
224		nullptr // value_list
225		);
226
227		xcb_size_hints_t sizeHints = {};
228		xcb_icccm_size_hints_set_position(&sizeHints, 1, geometry.x(), geometry.y());
229		xcb_icccm_size_hints_set_size(&sizeHints, 1, geometry.width(), geometry.height());
230		xcb_icccm_set_wm_normal_hints(conn, wid, &sizeHints);
231
232		if (leaderWid == XCB_WINDOW_NONE) {
233		leaderWid = wid;
234		}
235
236		xcb_change_property(
237		conn, // c
238		XCB_PROP_MODE_REPLACE, // mode
239		wid, // window
240		atoms->wm_client_leader, // property
241		XCB_ATOM_WINDOW, // type
242		32, // format
243		1, // data_len
244		&leaderWid // data
245		);
246
247		if (transient) {
248		xcb_icccm_set_wm_transient_for(conn, wid, rootWindow());
249		}
250
251		return wid;
252		}
253
254		struct XcbConnectionDeleter
255		{
256		static inline void cleanup(xcb_connection_t *c) {
257		xcb_disconnect(c);
258		}
259		};
260
261		void StackingOrderTest::testGroupTransientIsAlwaysAboveWindowGroup()
262		{
263		// This test verifies that group transients are always above other
264		// window group members.
265
266		const QRect geometry = QRect(0, 0, 128, 128);
267
268		QScopedPointer<xcb_connection_t, XcbConnectionDeleter> conn(
269		xcb_connect(nullptr, nullptr));
270
271		QSignalSpy windowCreatedSpy(workspace(), &Workspace::clientAdded);
272		QVERIFY(windowCreatedSpy.isValid());
273
274		// Create the group leader.
275		xcb_window_t leaderWid = createGroupWindow(conn.data(), geometry);
276		xcb_map_window(conn.data(), leaderWid);
277		xcb_flush(conn.data());
278
279		QVERIFY(windowCreatedSpy.wait());
280		Client leader = windowCreatedSpy.first().first().value<Client >();
281		QVERIFY(leader);
282		QVERIFY(leader->isActive());
283		QCOMPARE(leader->windowId(), leaderWid);
284		QVERIFY(!leader->isTransient());
285
286		QCOMPARE(workspace()->stackingOrder(), (ToplevelList{leader}));
287
288		// Create another group member.
289		windowCreatedSpy.clear();
290		xcb_window_t member1Wid = createGroupWindow(conn.data(), geometry, leaderWid);
291		xcb_map_window(conn.data(), member1Wid);
292		xcb_flush(conn.data());
293
294		QVERIFY(windowCreatedSpy.wait());
295		Client member1 = windowCreatedSpy.first().first().value<Client >();
296		QVERIFY(member1);
297		QVERIFY(member1->isActive());
298		QCOMPARE(member1->windowId(), member1Wid);
299		QCOMPARE(member1->group(), leader->group());
300		QVERIFY(!member1->isTransient());
301
302		QCOMPARE(workspace()->stackingOrder(), (ToplevelList{leader, member1}));
303
304		// Create yet another group member.
305		windowCreatedSpy.clear();
306		xcb_window_t member2Wid = createGroupWindow(conn.data(), geometry, leaderWid);
307		xcb_map_window(conn.data(), member2Wid);
308		xcb_flush(conn.data());
309
310		QVERIFY(windowCreatedSpy.wait());
311		Client member2 = windowCreatedSpy.first().first().value<Client >();
312		QVERIFY(member2);
313		QVERIFY(member2->isActive());
314		QCOMPARE(member2->windowId(), member2Wid);
315		QCOMPARE(member2->group(), leader->group());
316		QVERIFY(!member2->isTransient());
317
318		QCOMPARE(workspace()->stackingOrder(), (ToplevelList{leader, member1, member2}));
319
320		// Create a group transient.
321		windowCreatedSpy.clear();
322		xcb_window_t transientWid = createGroupWindow(conn.data(), geometry, leaderWid, true);
323
324		// Currently, we have some weird bug workaround: if a group transient
325		// is a non-modal dialog, then it won't be kept above its window group.
326		// We need to explicitly specify window type, otherwise the window type
327		// will be deduced to _NET_WM_WINDOW_TYPE_DIALOG because we set transient
328		// for before (the EWMH spec says to do that).
329		xcb_atom_t net_wm_window_type = Xcb::Atom(
330		QByteArrayLiteral("_NET_WM_WINDOW_TYPE"), false, conn.data());
331		xcb_atom_t net_wm_window_type_normal = Xcb::Atom(
332		QByteArrayLiteral("_NET_WM_WINDOW_TYPE_NORMAL"), false, conn.data());
333		xcb_change_property(
334		conn.data(), // c
335		XCB_PROP_MODE_REPLACE, // mode
336		transientWid, // window
337		net_wm_window_type, // property
338		XCB_ATOM_ATOM, // type
339		32, // format
340		1, // data_len
341		&net_wm_window_type_normal // data
342		);
343
344		xcb_map_window(conn.data(), transientWid);
345		xcb_flush(conn.data());
346
347		QVERIFY(windowCreatedSpy.wait());
348		Client transient = windowCreatedSpy.first().first().value<Client >();
349		QVERIFY(transient);
350		QVERIFY(transient->isActive());
351		QCOMPARE(transient->windowId(), transientWid);
352		QCOMPARE(transient->group(), leader->group());
353		QVERIFY(transient->isTransient());
354		QVERIFY(transient->groupTransient());
355		QVERIFY(!transient->isDialog()); // See above why
356
357		QCOMPARE(workspace()->stackingOrder(), (ToplevelList{leader, member1, member2, transient}));
358
359		// If we activate any member of the window group, the transient will be above it.
360		workspace()->activateClient(leader);
361		QTRY_VERIFY(leader->isActive());
362		QCOMPARE(workspace()->stackingOrder(), (ToplevelList{member1, member2, leader, transient}));
363
364		workspace()->activateClient(member1);
365		QTRY_VERIFY(member1->isActive());
366		QCOMPARE(workspace()->stackingOrder(), (ToplevelList{member2, leader, member1, transient}));
367
368		workspace()->activateClient(member2);
369		QTRY_VERIFY(member2->isActive());
370		QCOMPARE(workspace()->stackingOrder(), (ToplevelList{leader, member1, member2, transient}));
371
372		workspace()->activateClient(transient);
373		QTRY_VERIFY(transient->isActive());
374		QCOMPARE(workspace()->stackingOrder(), (ToplevelList{leader, member1, member2, transient}));
375		}
376
377		void StackingOrderTest::testRaiseGroupTransientAndWindowGroup()
378		{
379		const QRect geometry = QRect(0, 0, 128, 128);
380
381		QScopedPointer<xcb_connection_t, XcbConnectionDeleter> conn(
382		xcb_connect(nullptr, nullptr));
383
384		QSignalSpy windowCreatedSpy(workspace(), &Workspace::clientAdded);
385		QVERIFY(windowCreatedSpy.isValid());
386
387		// Create the group leader.
388		xcb_window_t leaderWid = createGroupWindow(conn.data(), geometry);
389		xcb_map_window(conn.data(), leaderWid);
390		xcb_flush(conn.data());
391
392		QVERIFY(windowCreatedSpy.wait());
393		Client leader = windowCreatedSpy.first().first().value<Client >();
394		QVERIFY(leader);
395		QVERIFY(leader->isActive());
396		QCOMPARE(leader->windowId(), leaderWid);
397		QVERIFY(!leader->isTransient());
398
399		QCOMPARE(workspace()->stackingOrder(), (ToplevelList{leader}));
400
401		// Create another group member.
402		windowCreatedSpy.clear();
403		xcb_window_t member1Wid = createGroupWindow(conn.data(), geometry, leaderWid);
404		xcb_map_window(conn.data(), member1Wid);
405		xcb_flush(conn.data());
406
407		QVERIFY(windowCreatedSpy.wait());
408		Client member1 = windowCreatedSpy.first().first().value<Client >();
409		QVERIFY(member1);
410		QVERIFY(member1->isActive());
411		QCOMPARE(member1->windowId(), member1Wid);
412		QCOMPARE(member1->group(), leader->group());
413		QVERIFY(!member1->isTransient());
414
415		QCOMPARE(workspace()->stackingOrder(), (ToplevelList{leader, member1}));
416
417		// Create yet another group member.
418		windowCreatedSpy.clear();
419		xcb_window_t member2Wid = createGroupWindow(conn.data(), geometry, leaderWid);
420		xcb_map_window(conn.data(), member2Wid);
421		xcb_flush(conn.data());
422
423		QVERIFY(windowCreatedSpy.wait());
424		Client member2 = windowCreatedSpy.first().first().value<Client >();
425		QVERIFY(member2);
426		QVERIFY(member2->isActive());
427		QCOMPARE(member2->windowId(), member2Wid);
428		QCOMPARE(member2->group(), leader->group());
429		QVERIFY(!member2->isTransient());
430
431		QCOMPARE(workspace()->stackingOrder(), (ToplevelList{leader, member1, member2}));
432
433		// Create a group transient.
434		windowCreatedSpy.clear();
435		xcb_window_t transientWid = createGroupWindow(conn.data(), geometry, leaderWid, true);
436
437		// Currently, we have some weird bug workaround: if a group transient
438		// is a non-modal dialog, then it won't be kept above its window group.
439		// We need to explicitly specify window type, otherwise the window type
440		// will be deduced to _NET_WM_WINDOW_TYPE_DIALOG because we set transient
441		// for before (the EWMH spec says to do that).
442		xcb_atom_t net_wm_window_type = Xcb::Atom(
443		QByteArrayLiteral("_NET_WM_WINDOW_TYPE"), false, conn.data());
444		xcb_atom_t net_wm_window_type_normal = Xcb::Atom(
445		QByteArrayLiteral("_NET_WM_WINDOW_TYPE_NORMAL"), false, conn.data());
446		xcb_change_property(
447		conn.data(), // c
448		XCB_PROP_MODE_REPLACE, // mode
449		transientWid, // window
450		net_wm_window_type, // property
451		XCB_ATOM_ATOM, // type
452		32, // format
453		1, // data_len
454		&net_wm_window_type_normal // data
455		);
456
457		xcb_map_window(conn.data(), transientWid);
458		xcb_flush(conn.data());
459
460		QVERIFY(windowCreatedSpy.wait());
461		Client transient = windowCreatedSpy.first().first().value<Client >();
462		QVERIFY(transient);
463		QVERIFY(transient->isActive());
464		QCOMPARE(transient->windowId(), transientWid);
465		QCOMPARE(transient->group(), leader->group());
466		QVERIFY(transient->isTransient());
467		QVERIFY(transient->groupTransient());
468		QVERIFY(!transient->isDialog()); // See above why
469
470		QCOMPARE(workspace()->stackingOrder(), (ToplevelList{leader, member1, member2, transient}));
471
472		// Create a Wayland client that is not member of the window group.
473		KWayland::Client::Surface *anotherSurface =
474		Test::createSurface(Test::waylandCompositor());
475		QVERIFY(anotherSurface);
476		KWayland::Client::ShellSurface *anotherShellSurface =
477		Test::createShellSurface(anotherSurface, anotherSurface);
478		QVERIFY(anotherShellSurface);
479		ShellClient *anotherClient = Test::renderAndWaitForShown(anotherSurface, QSize(128, 128), Qt::green);
480		QVERIFY(anotherClient);
481		QTRY_VERIFY(anotherClient->isActive());
482		QVERIFY(!anotherClient->isTransient());
483
484		QCOMPARE(workspace()->stackingOrder(), (ToplevelList{leader, member1, member2, transient, anotherClient}));
485
486		// If we activate the leader, then only it and the transient have to be raised.
487		workspace()->activateClient(leader);
488		QTRY_VERIFY(leader->isActive());
489		QCOMPARE(workspace()->stackingOrder(), (ToplevelList{member1, member2, anotherClient, leader, transient}));
490
491		// If another member of the window group is activated, then the transient will
492		// be above that member and the leader.
493		workspace()->activateClient(member2);
494		QTRY_VERIFY(member2->isActive());
495		QCOMPARE(workspace()->stackingOrder(), (ToplevelList{member1, anotherClient, leader, member2, transient}));
496
497		// If we activate the transient, only it will be raised.
498		workspace()->activateClient(anotherClient);
	zzagAuthorUnsubmitted Not Done This is probably a bug. zzag: This is probably a bug.
	zzagAuthorUnsubmitted Not Done I think that's because raiseClient doesn't use mainClients(). Should be fixed in another revision. zzag: I think that's because raiseClient doesn't use mainClients(). Should be fixed in another…
499		QTRY_VERIFY(anotherClient->isActive());
500		QCOMPARE(workspace()->stackingOrder(), (ToplevelList{member1, leader, member2, transient, anotherClient}));
501
502		workspace()->activateClient(transient);
503		QTRY_VERIFY(transient->isActive());
504		QCOMPARE(workspace()->stackingOrder(), (ToplevelList{member1, leader, member2, anotherClient, transient}));
505		}
506
507		void StackingOrderTest::testDontKeepAboveNonModalDialogGroupTransients()
508		{
509		// Bug 76026
510		const QRect geometry = QRect(0, 0, 128, 128);
511
512		QScopedPointer<xcb_connection_t, XcbConnectionDeleter> conn(
513		xcb_connect(nullptr, nullptr));
514
515		QSignalSpy windowCreatedSpy(workspace(), &Workspace::clientAdded);
516		QVERIFY(windowCreatedSpy.isValid());
517
518		// Create the group leader.
519		xcb_window_t leaderWid = createGroupWindow(conn.data(), geometry);
520		xcb_map_window(conn.data(), leaderWid);
521		xcb_flush(conn.data());
522
523		QVERIFY(windowCreatedSpy.wait());
524		Client leader = windowCreatedSpy.first().first().value<Client >();
525		QVERIFY(leader);
526		QVERIFY(leader->isActive());
527		QCOMPARE(leader->windowId(), leaderWid);
528		QVERIFY(!leader->isTransient());
529
530		QCOMPARE(workspace()->stackingOrder(), (ToplevelList{leader}));
531
532		// Create another group member.
533		windowCreatedSpy.clear();
534		xcb_window_t member1Wid = createGroupWindow(conn.data(), geometry, leaderWid);
535		xcb_map_window(conn.data(), member1Wid);
536		xcb_flush(conn.data());
537
538		QVERIFY(windowCreatedSpy.wait());
539		Client member1 = windowCreatedSpy.first().first().value<Client >();
540		QVERIFY(member1);
541		QVERIFY(member1->isActive());
542		QCOMPARE(member1->windowId(), member1Wid);
543		QCOMPARE(member1->group(), leader->group());
544		QVERIFY(!member1->isTransient());
545
546		QCOMPARE(workspace()->stackingOrder(), (ToplevelList{leader, member1}));
547
548		// Create yet another group member.
549		windowCreatedSpy.clear();
550		xcb_window_t member2Wid = createGroupWindow(conn.data(), geometry, leaderWid);
551		xcb_map_window(conn.data(), member2Wid);
552		xcb_flush(conn.data());
553
554		QVERIFY(windowCreatedSpy.wait());
555		Client member2 = windowCreatedSpy.first().first().value<Client >();
556		QVERIFY(member2);
557		QVERIFY(member2->isActive());
558		QCOMPARE(member2->windowId(), member2Wid);
559		QCOMPARE(member2->group(), leader->group());
560		QVERIFY(!member2->isTransient());
561
562		QCOMPARE(workspace()->stackingOrder(), (ToplevelList{leader, member1, member2}));
563
564		// Create a group transient.
565		windowCreatedSpy.clear();
566		xcb_window_t transientWid = createGroupWindow(conn.data(), geometry, leaderWid, true);
567		xcb_map_window(conn.data(), transientWid);
568		xcb_flush(conn.data());
569
570		QVERIFY(windowCreatedSpy.wait());
571		Client transient = windowCreatedSpy.first().first().value<Client >();
572		QVERIFY(transient);
573		QVERIFY(transient->isActive());
574		QCOMPARE(transient->windowId(), transientWid);
575		QCOMPARE(transient->group(), leader->group());
576		QVERIFY(transient->isTransient());
577		QVERIFY(transient->groupTransient());
578		QVERIFY(transient->isDialog());
579		QVERIFY(!transient->isModal());
580
581		QCOMPARE(workspace()->stackingOrder(), (ToplevelList{leader, member1, member2, transient}));
582
583		// If we activate any member of the window group, the transient will be above it.
584		workspace()->activateClient(leader);
585		QTRY_VERIFY(leader->isActive());
586		QCOMPARE(workspace()->stackingOrder(), (ToplevelList{member1, member2, transient, leader}));
587
588		workspace()->activateClient(member1);
589		QTRY_VERIFY(member1->isActive());
590		QCOMPARE(workspace()->stackingOrder(), (ToplevelList{member2, transient, leader, member1}));
591
592		workspace()->activateClient(member2);
593		QTRY_VERIFY(member2->isActive());
594		QCOMPARE(workspace()->stackingOrder(), (ToplevelList{transient, leader, member1, member2}));
595
596		workspace()->activateClient(transient);
597		QTRY_VERIFY(transient->isActive());
598		QCOMPARE(workspace()->stackingOrder(), (ToplevelList{leader, member1, member2, transient}));
599		}
600
601		WAYLANDTEST_MAIN(StackingOrderTest)
602		#include "stacking_order_test.moc"