Differential D15893 Diff 43507 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		QVERIFY(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		QVERIFY(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		QVERIFY(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		QVERIFY(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		{
209		xcb_window_t wid = xcb_generate_id(conn);
210		xcb_create_window(
211		conn, // c
212		XCB_COPY_FROM_PARENT, // depth
213		wid, // wid
214		rootWindow(), // parent
215		geometry.x(), // x
216		geometry.y(), // y
217		geometry.width(), // width
218		geometry.height(), // height
219		0, // border_width
220		XCB_WINDOW_CLASS_INPUT_OUTPUT, // _class
221		XCB_COPY_FROM_PARENT, // visual
222		0, // value_mask
223		nullptr // value_list
224		);
225
226		xcb_size_hints_t sizeHints = {};
227		xcb_icccm_size_hints_set_position(&sizeHints, 1, geometry.x(), geometry.y());
228		xcb_icccm_size_hints_set_size(&sizeHints, 1, geometry.width(), geometry.height());
229		xcb_icccm_set_wm_normal_hints(conn, wid, &sizeHints);
230
231		if (leaderWid == XCB_WINDOW_NONE) {
232		leaderWid = wid;
233		}
234
235		xcb_change_property(
236		conn, // c
237		XCB_PROP_MODE_REPLACE, // mode
238		wid, // window
239		atoms->wm_client_leader, // property
240		XCB_ATOM_WINDOW, // type
241		32, // format
242		1, // data_len
243		&leaderWid // data
244		);
245
246		return wid;
247		}
248
249		struct XcbConnectionDeleter
250		{
251		static inline void cleanup(xcb_connection_t *c) {
252		xcb_disconnect(c);
253		}
254		};
255
256		void StackingOrderTest::testGroupTransientIsAlwaysAboveWindowGroup()
257		{
258		// This test verifies that group transients are always above other
259		// window group members.
260
261		const QRect geometry = QRect(0, 0, 128, 128);
262
263		QScopedPointer<xcb_connection_t, XcbConnectionDeleter> conn(
264		xcb_connect(nullptr, nullptr));
265
266		QSignalSpy windowCreatedSpy(workspace(), &Workspace::clientAdded);
267		QVERIFY(windowCreatedSpy.isValid());
268
269		// Create the group leader.
270		xcb_window_t leaderWid = createGroupWindow(conn.data(), geometry);
271		xcb_map_window(conn.data(), leaderWid);
272		xcb_flush(conn.data());
273
274		QVERIFY(windowCreatedSpy.wait());
275		Client leader = windowCreatedSpy.first().first().value<Client >();
276		QVERIFY(leader);
277		QVERIFY(leader->isActive());
278		QCOMPARE(leader->windowId(), leaderWid);
279		QVERIFY(!leader->isTransient());
280
281		QCOMPARE(workspace()->stackingOrder(), (ToplevelList{leader}));
282
283		// Create another group member.
284		windowCreatedSpy.clear();
285		xcb_window_t member1Wid = createGroupWindow(conn.data(), geometry, leaderWid);
286		xcb_map_window(conn.data(), member1Wid);
287		xcb_flush(conn.data());
288
289		QVERIFY(windowCreatedSpy.wait());
290		Client member1 = windowCreatedSpy.first().first().value<Client >();
291		QVERIFY(member1);
292		QVERIFY(member1->isActive());
293		QCOMPARE(member1->windowId(), member1Wid);
294		QCOMPARE(member1->group(), leader->group());
295		QVERIFY(!member1->isTransient());
296
297		QCOMPARE(workspace()->stackingOrder(), (ToplevelList{leader, member1}));
298
299		// Create yet another group member.
300		windowCreatedSpy.clear();
301		xcb_window_t member2Wid = createGroupWindow(conn.data(), geometry, leaderWid);
302		xcb_map_window(conn.data(), member2Wid);
303		xcb_flush(conn.data());
304
305		QVERIFY(windowCreatedSpy.wait());
306		Client member2 = windowCreatedSpy.first().first().value<Client >();
307		QVERIFY(member2);
308		QVERIFY(member2->isActive());
309		QCOMPARE(member2->windowId(), member2Wid);
310		QCOMPARE(member2->group(), leader->group());
311		QVERIFY(!member2->isTransient());
312
313		QCOMPARE(workspace()->stackingOrder(), (ToplevelList{leader, member1, member2}));
314
315		// Create a group transient.
316		windowCreatedSpy.clear();
317		xcb_window_t transientWid = createGroupWindow(conn.data(), geometry, leaderWid);
318		xcb_icccm_set_wm_transient_for(conn.data(), transientWid, rootWindow());
319
320		// Currently, we have some weird bug workaround: if a group transient
321		// is a non-modal dialog, then it won't be kept above its window group.
322		// We need to explicitly specify window type, otherwise the window type
323		// will be deduced to _NET_WM_WINDOW_TYPE_DIALOG because we set transient
324		// for before (the EWMH spec says to do that).
325		xcb_atom_t net_wm_window_type = Xcb::Atom(
326		QByteArrayLiteral("_NET_WM_WINDOW_TYPE"), false, conn.data());
327		xcb_atom_t net_wm_window_type_normal = Xcb::Atom(
328		QByteArrayLiteral("_NET_WM_WINDOW_TYPE_NORMAL"), false, conn.data());
329		xcb_change_property(
330		conn.data(), // c
331		XCB_PROP_MODE_REPLACE, // mode
332		transientWid, // window
333		net_wm_window_type, // property
334		XCB_ATOM_ATOM, // type
335		32, // format
336		1, // data_len
337		&net_wm_window_type_normal // data
338		);
339
340		xcb_map_window(conn.data(), transientWid);
341		xcb_flush(conn.data());
342
343		QVERIFY(windowCreatedSpy.wait());
344		Client transient = windowCreatedSpy.first().first().value<Client >();
345		QVERIFY(transient);
346		QVERIFY(transient->isActive());
347		QCOMPARE(transient->windowId(), transientWid);
348		QCOMPARE(transient->group(), leader->group());
349		QVERIFY(transient->isTransient());
350		QVERIFY(transient->groupTransient());
351		QVERIFY(!transient->isDialog()); // See above why
352
353		QCOMPARE(workspace()->stackingOrder(), (ToplevelList{leader, member1, member2, transient}));
354
355		// If we activate any member of the window group, the transient will be above it.
356		workspace()->activateClient(leader);
357		QTRY_VERIFY(leader->isActive());
358		QCOMPARE(workspace()->stackingOrder(), (ToplevelList{member1, member2, leader, transient}));
359
360		workspace()->activateClient(member1);
361		QTRY_VERIFY(member1->isActive());
362		QCOMPARE(workspace()->stackingOrder(), (ToplevelList{member2, leader, member1, transient}));
363
364		workspace()->activateClient(member2);
365		QTRY_VERIFY(member2->isActive());
366		QCOMPARE(workspace()->stackingOrder(), (ToplevelList{leader, member1, member2, transient}));
367
368		workspace()->activateClient(transient);
369		QTRY_VERIFY(transient->isActive());
370		QCOMPARE(workspace()->stackingOrder(), (ToplevelList{leader, member1, member2, transient}));
371		}
372
373		void StackingOrderTest::testRaiseGroupTransientAndWindowGroup()
374		{
375		const QRect geometry = QRect(0, 0, 128, 128);
376
377		QScopedPointer<xcb_connection_t, XcbConnectionDeleter> conn(
378		xcb_connect(nullptr, nullptr));
379
380		QSignalSpy windowCreatedSpy(workspace(), &Workspace::clientAdded);
381		QVERIFY(windowCreatedSpy.isValid());
382
383		// Create the group leader.
384		xcb_window_t leaderWid = createGroupWindow(conn.data(), geometry);
385		xcb_map_window(conn.data(), leaderWid);
386		xcb_flush(conn.data());
387
388		QVERIFY(windowCreatedSpy.wait());
389		Client leader = windowCreatedSpy.first().first().value<Client >();
390		QVERIFY(leader);
391		QVERIFY(leader->isActive());
392		QCOMPARE(leader->windowId(), leaderWid);
393		QVERIFY(!leader->isTransient());
394
395		QCOMPARE(workspace()->stackingOrder(), (ToplevelList{leader}));
396
397		// Create another group member.
398		windowCreatedSpy.clear();
399		xcb_window_t member1Wid = createGroupWindow(conn.data(), geometry, leaderWid);
400		xcb_map_window(conn.data(), member1Wid);
401		xcb_flush(conn.data());
402
403		QVERIFY(windowCreatedSpy.wait());
404		Client member1 = windowCreatedSpy.first().first().value<Client >();
405		QVERIFY(member1);
406		QVERIFY(member1->isActive());
407		QCOMPARE(member1->windowId(), member1Wid);
408		QCOMPARE(member1->group(), leader->group());
409		QVERIFY(!member1->isTransient());
410
411		QCOMPARE(workspace()->stackingOrder(), (ToplevelList{leader, member1}));
412
413		// Create yet another group member.
414		windowCreatedSpy.clear();
415		xcb_window_t member2Wid = createGroupWindow(conn.data(), geometry, leaderWid);
416		xcb_map_window(conn.data(), member2Wid);
417		xcb_flush(conn.data());
418
419		QVERIFY(windowCreatedSpy.wait());
420		Client member2 = windowCreatedSpy.first().first().value<Client >();
421		QVERIFY(member2);
422		QVERIFY(member2->isActive());
423		QCOMPARE(member2->windowId(), member2Wid);
424		QCOMPARE(member2->group(), leader->group());
425		QVERIFY(!member2->isTransient());
426
427		QCOMPARE(workspace()->stackingOrder(), (ToplevelList{leader, member1, member2}));
428
429		// Create a group transient.
430		windowCreatedSpy.clear();
431		xcb_window_t transientWid = createGroupWindow(conn.data(), geometry, leaderWid);
432		xcb_icccm_set_wm_transient_for(conn.data(), transientWid, rootWindow());
433
434		// Currently, we have some weird bug workaround: if a group transient
435		// is a non-modal dialog, then it won't be kept above its window group.
436		// We need to explicitly specify window type, otherwise the window type
437		// will be deduced to _NET_WM_WINDOW_TYPE_DIALOG because we set transient
438		// for before (the EWMH spec says to do that).
439		xcb_atom_t net_wm_window_type = Xcb::Atom(
440		QByteArrayLiteral("_NET_WM_WINDOW_TYPE"), false, conn.data());
441		xcb_atom_t net_wm_window_type_normal = Xcb::Atom(
442		QByteArrayLiteral("_NET_WM_WINDOW_TYPE_NORMAL"), false, conn.data());
443		xcb_change_property(
444		conn.data(), // c
445		XCB_PROP_MODE_REPLACE, // mode
446		transientWid, // window
447		net_wm_window_type, // property
448		XCB_ATOM_ATOM, // type
449		32, // format
450		1, // data_len
451		&net_wm_window_type_normal // data
452		);
453
454		xcb_map_window(conn.data(), transientWid);
455		xcb_flush(conn.data());
456
457		QVERIFY(windowCreatedSpy.wait());
458		Client transient = windowCreatedSpy.first().first().value<Client >();
459		QVERIFY(transient);
460		QVERIFY(transient->isActive());
461		QCOMPARE(transient->windowId(), transientWid);
462		QCOMPARE(transient->group(), leader->group());
463		QVERIFY(transient->isTransient());
464		QVERIFY(transient->groupTransient());
465		QVERIFY(!transient->isDialog()); // See above why
466
467		QCOMPARE(workspace()->stackingOrder(), (ToplevelList{leader, member1, member2, transient}));
468
469		// Create a Wayland client that is not a member of the window group.
470		KWayland::Client::Surface *anotherSurface =
471		Test::createSurface(Test::waylandCompositor());
472		QVERIFY(anotherSurface);
473		KWayland::Client::ShellSurface *anotherShellSurface =
474		Test::createShellSurface(anotherSurface, anotherSurface);
475		QVERIFY(anotherShellSurface);
476		ShellClient *anotherClient = Test::renderAndWaitForShown(anotherSurface, QSize(128, 128), Qt::green);
477		QVERIFY(anotherClient);
478		QVERIFY(anotherClient->isActive());
479		QVERIFY(!anotherClient->isTransient());
480
481		QCOMPARE(workspace()->stackingOrder(), (ToplevelList{leader, member1, member2, transient, anotherClient}));
482
483		// If we activate the leader, then only it and the transient have to be raised.
484		workspace()->activateClient(leader);
485		QTRY_VERIFY(leader->isActive());
486		QCOMPARE(workspace()->stackingOrder(), (ToplevelList{member1, member2, anotherClient, leader, transient}));
487
488		// If another member of the window group is activated, then the transient will
489		// be above that member and the leader.
490		workspace()->activateClient(member2);
491		QTRY_VERIFY(member2->isActive());
492		QCOMPARE(workspace()->stackingOrder(), (ToplevelList{member1, anotherClient, leader, member2, transient}));
493
494		// If we activate the transient, only it will be raised.
495		workspace()->activateClient(anotherClient);
496		QTRY_VERIFY(anotherClient->isActive());
497		QCOMPARE(workspace()->stackingOrder(), (ToplevelList{member1, leader, member2, transient, anotherClient}));
498
	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		workspace()->activateClient(transient);
500		QTRY_VERIFY(transient->isActive());
501		QCOMPARE(workspace()->stackingOrder(), (ToplevelList{member1, leader, member2, anotherClient, transient}));
502		}
503
504		void StackingOrderTest::testDontKeepAboveNonModalDialogGroupTransients()
505		{
506		// Bug 76026
507
508		const QRect geometry = QRect(0, 0, 128, 128);
509
510		QScopedPointer<xcb_connection_t, XcbConnectionDeleter> conn(
511		xcb_connect(nullptr, nullptr));
512
513		QSignalSpy windowCreatedSpy(workspace(), &Workspace::clientAdded);
514		QVERIFY(windowCreatedSpy.isValid());
515
516		// Create the group leader.
517		xcb_window_t leaderWid = createGroupWindow(conn.data(), geometry);
518		xcb_map_window(conn.data(), leaderWid);
519		xcb_flush(conn.data());
520
521		QVERIFY(windowCreatedSpy.wait());
522		Client leader = windowCreatedSpy.first().first().value<Client >();
523		QVERIFY(leader);
524		QVERIFY(leader->isActive());
525		QCOMPARE(leader->windowId(), leaderWid);
526		QVERIFY(!leader->isTransient());
527
528		QCOMPARE(workspace()->stackingOrder(), (ToplevelList{leader}));
529
530		// Create another group member.
531		windowCreatedSpy.clear();
532		xcb_window_t member1Wid = createGroupWindow(conn.data(), geometry, leaderWid);
533		xcb_map_window(conn.data(), member1Wid);
534		xcb_flush(conn.data());
535
536		QVERIFY(windowCreatedSpy.wait());
537		Client member1 = windowCreatedSpy.first().first().value<Client >();
538		QVERIFY(member1);
539		QVERIFY(member1->isActive());
540		QCOMPARE(member1->windowId(), member1Wid);
541		QCOMPARE(member1->group(), leader->group());
542		QVERIFY(!member1->isTransient());
543
544		QCOMPARE(workspace()->stackingOrder(), (ToplevelList{leader, member1}));
545
546		// Create yet another group member.
547		windowCreatedSpy.clear();
548		xcb_window_t member2Wid = createGroupWindow(conn.data(), geometry, leaderWid);
549		xcb_map_window(conn.data(), member2Wid);
550		xcb_flush(conn.data());
551
552		QVERIFY(windowCreatedSpy.wait());
553		Client member2 = windowCreatedSpy.first().first().value<Client >();
554		QVERIFY(member2);
555		QVERIFY(member2->isActive());
556		QCOMPARE(member2->windowId(), member2Wid);
557		QCOMPARE(member2->group(), leader->group());
558		QVERIFY(!member2->isTransient());
559
560		QCOMPARE(workspace()->stackingOrder(), (ToplevelList{leader, member1, member2}));
561
562		// Create a group transient.
563		windowCreatedSpy.clear();
564		xcb_window_t transientWid = createGroupWindow(conn.data(), geometry, leaderWid);
565		xcb_icccm_set_wm_transient_for(conn.data(), transientWid, rootWindow());
566		xcb_map_window(conn.data(), transientWid);
567		xcb_flush(conn.data());
568
569		QVERIFY(windowCreatedSpy.wait());
570		Client transient = windowCreatedSpy.first().first().value<Client >();
571		QVERIFY(transient);
572		QVERIFY(transient->isActive());
573		QCOMPARE(transient->windowId(), transientWid);
574		QCOMPARE(transient->group(), leader->group());
575		QVERIFY(transient->isTransient());
576		QVERIFY(transient->groupTransient());
577		QVERIFY(transient->isDialog());
578		QVERIFY(!transient->isModal());
579
580		QCOMPARE(workspace()->stackingOrder(), (ToplevelList{leader, member1, member2, transient}));
581
582		workspace()->activateClient(leader);
583		QTRY_VERIFY(leader->isActive());
584		QCOMPARE(workspace()->stackingOrder(), (ToplevelList{member1, member2, transient, leader}));
585
586		workspace()->activateClient(member1);
587		QTRY_VERIFY(member1->isActive());
588		QCOMPARE(workspace()->stackingOrder(), (ToplevelList{member2, transient, leader, member1}));
589
590		workspace()->activateClient(member2);
591		QTRY_VERIFY(member2->isActive());
592		QCOMPARE(workspace()->stackingOrder(), (ToplevelList{transient, leader, member1, member2}));
593
594		workspace()->activateClient(transient);
595		QTRY_VERIFY(transient->isActive());
596		QCOMPARE(workspace()->stackingOrder(), (ToplevelList{leader, member1, member2, transient}));
597		}
598
599		WAYLANDTEST_MAIN(StackingOrderTest)
600		#include "stacking_order_test.moc"