fix weston launch error
[platform/upstream/weston.git] / tests / subsurface-test.c
1 /*
2  * Copyright © 2012 Collabora, Ltd.
3  *
4  * Permission is hereby granted, free of charge, to any person obtaining
5  * a copy of this software and associated documentation files (the
6  * "Software"), to deal in the Software without restriction, including
7  * without limitation the rights to use, copy, modify, merge, publish,
8  * distribute, sublicense, and/or sell copies of the Software, and to
9  * permit persons to whom the Software is furnished to do so, subject to
10  * the following conditions:
11  *
12  * The above copyright notice and this permission notice (including the
13  * next paragraph) shall be included in all copies or substantial
14  * portions of the Software.
15  *
16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
17  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
18  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
19  * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
20  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
21  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
22  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
23  * SOFTWARE.
24  */
25
26 #include "config.h"
27
28 #include <stdio.h>
29 #include <string.h>
30
31 #include "weston-test-client-helper.h"
32
33 #define NUM_SUBSURFACES 3
34
35 struct compound_surface {
36         struct wl_subcompositor *subco;
37         struct wl_surface *parent;
38         struct wl_surface *child[NUM_SUBSURFACES];
39         struct wl_subsurface *sub[NUM_SUBSURFACES];
40 };
41
42 static struct wl_subcompositor *
43 get_subcompositor(struct client *client)
44 {
45         struct global *g;
46         struct global *global_sub = NULL;
47         struct wl_subcompositor *sub;
48
49         wl_list_for_each(g, &client->global_list, link) {
50                 if (strcmp(g->interface, "wl_subcompositor"))
51                         continue;
52
53                 if (global_sub)
54                         assert(0 && "multiple wl_subcompositor objects");
55
56                 global_sub = g;
57         }
58
59         assert(global_sub && "no wl_subcompositor found");
60
61         assert(global_sub->version == 1);
62
63         sub = wl_registry_bind(client->wl_registry, global_sub->name,
64                                &wl_subcompositor_interface, 1);
65         assert(sub);
66
67         return sub;
68 }
69
70 static void
71 populate_compound_surface(struct compound_surface *com, struct client *client)
72 {
73         int i;
74
75         com->subco = get_subcompositor(client);
76
77         com->parent = wl_compositor_create_surface(client->wl_compositor);
78
79         for (i = 0; i < NUM_SUBSURFACES; i++) {
80                 com->child[i] =
81                         wl_compositor_create_surface(client->wl_compositor);
82                 com->sub[i] =
83                         wl_subcompositor_get_subsurface(com->subco,
84                                                         com->child[i],
85                                                         com->parent);
86         }
87 }
88
89 TEST(test_subsurface_basic_protocol)
90 {
91         struct client *client;
92         struct compound_surface com1;
93         struct compound_surface com2;
94
95         client = create_client_and_test_surface(100, 50, 123, 77);
96         assert(client);
97
98         populate_compound_surface(&com1, client);
99         populate_compound_surface(&com2, client);
100
101         client_roundtrip(client);
102 }
103
104 TEST(test_subsurface_position_protocol)
105 {
106         struct client *client;
107         struct compound_surface com;
108         int i;
109
110         client = create_client_and_test_surface(100, 50, 123, 77);
111         assert(client);
112
113         populate_compound_surface(&com, client);
114         for (i = 0; i < NUM_SUBSURFACES; i++)
115                 wl_subsurface_set_position(com.sub[i],
116                                            (i + 2) * 20, (i + 2) * 10);
117
118         client_roundtrip(client);
119 }
120
121 TEST(test_subsurface_placement_protocol)
122 {
123         struct client *client;
124         struct compound_surface com;
125
126         client = create_client_and_test_surface(100, 50, 123, 77);
127         assert(client);
128
129         populate_compound_surface(&com, client);
130
131         wl_subsurface_place_above(com.sub[0], com.child[1]);
132         wl_subsurface_place_above(com.sub[1], com.parent);
133         wl_subsurface_place_below(com.sub[2], com.child[0]);
134         wl_subsurface_place_below(com.sub[1], com.parent);
135
136         client_roundtrip(client);
137 }
138
139 TEST(test_subsurface_paradox)
140 {
141         struct client *client;
142         struct wl_surface *parent;
143         struct wl_subcompositor *subco;
144
145         client = create_client_and_test_surface(100, 50, 123, 77);
146         assert(client);
147
148         subco = get_subcompositor(client);
149         parent = wl_compositor_create_surface(client->wl_compositor);
150
151         /* surface is its own parent */
152         wl_subcompositor_get_subsurface(subco, parent, parent);
153
154         expect_protocol_error(client, &wl_subcompositor_interface,
155                               WL_SUBCOMPOSITOR_ERROR_BAD_SURFACE);
156 }
157
158 TEST(test_subsurface_identical_link)
159 {
160         struct client *client;
161         struct compound_surface com;
162
163         client = create_client_and_test_surface(100, 50, 123, 77);
164         assert(client);
165
166         populate_compound_surface(&com, client);
167
168         /* surface is already a subsurface */
169         wl_subcompositor_get_subsurface(com.subco, com.child[0], com.parent);
170
171         expect_protocol_error(client, &wl_subcompositor_interface,
172                               WL_SUBCOMPOSITOR_ERROR_BAD_SURFACE);
173 }
174
175 TEST(test_subsurface_change_link)
176 {
177         struct client *client;
178         struct compound_surface com;
179         struct wl_surface *stranger;
180
181         client = create_client_and_test_surface(100, 50, 123, 77);
182         assert(client);
183
184         stranger = wl_compositor_create_surface(client->wl_compositor);
185         populate_compound_surface(&com, client);
186
187         /* surface is already a subsurface */
188         wl_subcompositor_get_subsurface(com.subco, com.child[0], stranger);
189
190         expect_protocol_error(client, &wl_subcompositor_interface,
191                               WL_SUBCOMPOSITOR_ERROR_BAD_SURFACE);
192 }
193
194 TEST(test_subsurface_nesting)
195 {
196         struct client *client;
197         struct compound_surface com;
198         struct wl_surface *stranger;
199
200         client = create_client_and_test_surface(100, 50, 123, 77);
201         assert(client);
202
203         stranger = wl_compositor_create_surface(client->wl_compositor);
204         populate_compound_surface(&com, client);
205
206         /* parent is a sub-surface */
207         wl_subcompositor_get_subsurface(com.subco, stranger, com.child[0]);
208
209         client_roundtrip(client);
210 }
211
212 TEST(test_subsurface_nesting_parent)
213 {
214         struct client *client;
215         struct compound_surface com;
216         struct wl_surface *stranger;
217
218         client = create_client_and_test_surface(100, 50, 123, 77);
219         assert(client);
220
221         stranger = wl_compositor_create_surface(client->wl_compositor);
222         populate_compound_surface(&com, client);
223
224         /* surface is already a parent */
225         wl_subcompositor_get_subsurface(com.subco, com.parent, stranger);
226
227         client_roundtrip(client);
228 }
229
230 TEST(test_subsurface_loop_paradox)
231 {
232         struct client *client;
233         struct wl_surface *surface[3];
234         struct wl_subcompositor *subco;
235
236         client = create_client_and_test_surface(100, 50, 123, 77);
237         assert(client);
238
239         subco = get_subcompositor(client);
240         surface[0] = wl_compositor_create_surface(client->wl_compositor);
241         surface[1] = wl_compositor_create_surface(client->wl_compositor);
242         surface[2] = wl_compositor_create_surface(client->wl_compositor);
243
244         /* create a nesting loop */
245         wl_subcompositor_get_subsurface(subco, surface[1], surface[0]);
246         wl_subcompositor_get_subsurface(subco, surface[2], surface[1]);
247         wl_subcompositor_get_subsurface(subco, surface[0], surface[2]);
248
249         expect_protocol_error(client, &wl_subcompositor_interface,
250                               WL_SUBCOMPOSITOR_ERROR_BAD_SURFACE);
251 }
252
253 TEST(test_subsurface_place_above_nested_parent)
254 {
255         struct client *client;
256         struct compound_surface com;
257         struct wl_surface *grandchild;
258         struct wl_subcompositor *subco;
259         struct wl_subsurface *sub;
260
261         client = create_client_and_test_surface(100, 50, 123, 77);
262         assert(client);
263
264         populate_compound_surface(&com, client);
265
266         subco = get_subcompositor(client);
267         grandchild = wl_compositor_create_surface(client->wl_compositor);
268         sub = wl_subcompositor_get_subsurface(subco, grandchild, com.child[0]);
269
270         wl_subsurface_place_above(sub, com.child[0]);
271
272         client_roundtrip(client);
273 }
274
275 TEST(test_subsurface_place_above_grandparent)
276 {
277         struct client *client;
278         struct compound_surface com;
279         struct wl_surface *grandchild;
280         struct wl_subsurface *sub;
281         struct wl_subcompositor *subco;
282
283         client = create_client_and_test_surface(100, 50, 123, 77);
284         assert(client);
285
286         populate_compound_surface(&com, client);
287
288         subco = get_subcompositor(client);
289         grandchild = wl_compositor_create_surface(client->wl_compositor);
290         sub = wl_subcompositor_get_subsurface(subco, grandchild, com.child[0]);
291
292         /* can't place a subsurface above its grandparent */
293         wl_subsurface_place_above(sub, com.parent);
294
295         expect_protocol_error(client, &wl_subsurface_interface,
296                               WL_SUBSURFACE_ERROR_BAD_SURFACE);
297 }
298
299 TEST(test_subsurface_place_above_great_aunt)
300 {
301         struct client *client;
302         struct compound_surface com;
303         struct wl_surface *grandchild;
304         struct wl_subsurface *sub;
305         struct wl_subcompositor *subco;
306
307         client = create_client_and_test_surface(100, 50, 123, 77);
308         assert(client);
309
310         populate_compound_surface(&com, client);
311
312         subco = get_subcompositor(client);
313         grandchild = wl_compositor_create_surface(client->wl_compositor);
314         sub = wl_subcompositor_get_subsurface(subco, grandchild, com.child[0]);
315
316         /* can't place a subsurface above its parents' siblings */
317         wl_subsurface_place_above(sub, com.child[1]);
318
319         expect_protocol_error(client, &wl_subsurface_interface,
320                               WL_SUBSURFACE_ERROR_BAD_SURFACE);
321 }
322
323 TEST(test_subsurface_place_above_child)
324 {
325         struct client *client;
326         struct compound_surface com;
327         struct wl_surface *grandchild;
328         struct wl_subcompositor *subco;
329
330         client = create_client_and_test_surface(100, 50, 123, 77);
331         assert(client);
332
333         populate_compound_surface(&com, client);
334
335         subco = get_subcompositor(client);
336         grandchild = wl_compositor_create_surface(client->wl_compositor);
337         wl_subcompositor_get_subsurface(subco, grandchild, com.child[0]);
338
339         /* can't place a subsurface above its own child subsurface */
340         wl_subsurface_place_above(com.sub[0], grandchild);
341
342         expect_protocol_error(client, &wl_subsurface_interface,
343                               WL_SUBSURFACE_ERROR_BAD_SURFACE);
344 }
345
346 TEST(test_subsurface_place_below_nested_parent)
347 {
348         struct client *client;
349         struct compound_surface com;
350         struct wl_subcompositor *subco;
351         struct wl_surface *grandchild;
352         struct wl_subsurface *sub;
353
354         client = create_client_and_test_surface(100, 50, 123, 77);
355         assert(client);
356
357         populate_compound_surface(&com, client);
358
359         subco = get_subcompositor(client);
360         grandchild = wl_compositor_create_surface(client->wl_compositor);
361         sub = wl_subcompositor_get_subsurface(subco, grandchild, com.child[0]);
362
363         wl_subsurface_place_below(sub, com.child[0]);
364
365         client_roundtrip(client);
366 }
367
368 TEST(test_subsurface_place_below_grandparent)
369 {
370         struct client *client;
371         struct compound_surface com;
372         struct wl_surface *grandchild;
373         struct wl_subsurface *sub;
374         struct wl_subcompositor *subco;
375
376         client = create_client_and_test_surface(100, 50, 123, 77);
377         assert(client);
378
379         populate_compound_surface(&com, client);
380
381         subco = get_subcompositor(client);
382         grandchild = wl_compositor_create_surface(client->wl_compositor);
383         sub = wl_subcompositor_get_subsurface(subco, grandchild, com.child[0]);
384
385         /* can't place a subsurface below its grandparent */
386         wl_subsurface_place_below(sub, com.parent);
387
388         expect_protocol_error(client, &wl_subsurface_interface,
389                               WL_SUBSURFACE_ERROR_BAD_SURFACE);
390 }
391
392 TEST(test_subsurface_place_below_great_aunt)
393 {
394         struct client *client;
395         struct compound_surface com;
396         struct wl_surface *grandchild;
397         struct wl_subsurface *sub;
398         struct wl_subcompositor *subco;
399
400         client = create_client_and_test_surface(100, 50, 123, 77);
401         assert(client);
402
403         populate_compound_surface(&com, client);
404
405         subco = get_subcompositor(client);
406         grandchild = wl_compositor_create_surface(client->wl_compositor);
407         sub = wl_subcompositor_get_subsurface(subco, grandchild, com.child[0]);
408
409         /* can't place a subsurface below its parents' siblings */
410         wl_subsurface_place_below(sub, com.child[1]);
411
412         expect_protocol_error(client, &wl_subsurface_interface,
413                               WL_SUBSURFACE_ERROR_BAD_SURFACE);
414 }
415
416 TEST(test_subsurface_place_below_child)
417 {
418         struct client *client;
419         struct compound_surface com;
420         struct wl_surface *grandchild;
421         struct wl_subcompositor *subco;
422
423         client = create_client_and_test_surface(100, 50, 123, 77);
424         assert(client);
425
426         populate_compound_surface(&com, client);
427
428         subco = get_subcompositor(client);
429         grandchild = wl_compositor_create_surface(client->wl_compositor);
430         wl_subcompositor_get_subsurface(subco, grandchild, com.child[0]);
431
432         /* can't place a subsurface below its own child subsurface */
433         wl_subsurface_place_below(com.sub[0], grandchild);
434
435         expect_protocol_error(client, &wl_subsurface_interface,
436                               WL_SUBSURFACE_ERROR_BAD_SURFACE);
437 }
438
439 TEST(test_subsurface_place_above_stranger)
440 {
441         struct client *client;
442         struct compound_surface com;
443         struct wl_surface *stranger;
444
445         client = create_client_and_test_surface(100, 50, 123, 77);
446         assert(client);
447
448         stranger = wl_compositor_create_surface(client->wl_compositor);
449         populate_compound_surface(&com, client);
450
451         /* bad sibling */
452         wl_subsurface_place_above(com.sub[0], stranger);
453
454         expect_protocol_error(client, &wl_subsurface_interface,
455                               WL_SUBSURFACE_ERROR_BAD_SURFACE);
456 }
457
458 TEST(test_subsurface_place_below_stranger)
459 {
460         struct client *client;
461         struct compound_surface com;
462         struct wl_surface *stranger;
463
464         client = create_client_and_test_surface(100, 50, 123, 77);
465         assert(client);
466
467         stranger = wl_compositor_create_surface(client->wl_compositor);
468         populate_compound_surface(&com, client);
469
470         /* bad sibling */
471         wl_subsurface_place_below(com.sub[0], stranger);
472
473         expect_protocol_error(client, &wl_subsurface_interface,
474                               WL_SUBSURFACE_ERROR_BAD_SURFACE);
475 }
476
477 TEST(test_subsurface_place_above_foreign)
478 {
479         struct client *client;
480         struct compound_surface com1;
481         struct compound_surface com2;
482
483         client = create_client_and_test_surface(100, 50, 123, 77);
484         assert(client);
485
486         populate_compound_surface(&com1, client);
487         populate_compound_surface(&com2, client);
488
489         /* bad sibling */
490         wl_subsurface_place_above(com1.sub[0], com2.child[0]);
491
492         expect_protocol_error(client, &wl_subsurface_interface,
493                               WL_SUBSURFACE_ERROR_BAD_SURFACE);
494 }
495
496 TEST(test_subsurface_place_below_foreign)
497 {
498         struct client *client;
499         struct compound_surface com1;
500         struct compound_surface com2;
501
502         client = create_client_and_test_surface(100, 50, 123, 77);
503         assert(client);
504
505         populate_compound_surface(&com1, client);
506         populate_compound_surface(&com2, client);
507
508         /* bad sibling */
509         wl_subsurface_place_below(com1.sub[0], com2.child[0]);
510
511         expect_protocol_error(client, &wl_subsurface_interface,
512                               WL_SUBSURFACE_ERROR_BAD_SURFACE);
513 }
514
515 TEST(test_subsurface_destroy_protocol)
516 {
517         struct client *client;
518         struct compound_surface com;
519
520         client = create_client_and_test_surface(100, 50, 123, 77);
521         assert(client);
522
523         populate_compound_surface(&com, client);
524
525         /* not needed anymore */
526         wl_subcompositor_destroy(com.subco);
527
528         /* detach child from parent */
529         wl_subsurface_destroy(com.sub[0]);
530
531         /* destroy: child, parent */
532         wl_surface_destroy(com.child[1]);
533         wl_surface_destroy(com.parent);
534
535         /* destroy: parent, child */
536         wl_surface_destroy(com.child[2]);
537
538         /* destroy: sub, child */
539         wl_surface_destroy(com.child[0]);
540
541         /* 2x destroy: child, sub */
542         wl_subsurface_destroy(com.sub[2]);
543         wl_subsurface_destroy(com.sub[1]);
544
545         client_roundtrip(client);
546 }
547
548 static void
549 create_subsurface_tree(struct client *client, struct wl_surface **surfs,
550                        struct wl_subsurface **subs, int n)
551 {
552         struct wl_subcompositor *subco;
553         int i;
554
555         subco = get_subcompositor(client);
556
557         for (i = 0; i < n; i++)
558                 surfs[i] = wl_compositor_create_surface(client->wl_compositor);
559
560         /*
561          * The tree of sub-surfaces:
562          *                            0
563          *                           / \
564          *                          1   2 - 10
565          *                         / \  |\
566          *                        3   5 9 6
567          *                       /       / \
568          *                      4       7   8
569          * Surface 0 has no wl_subsurface, others do.
570          */
571
572         switch (n) {
573         default:
574                 assert(0);
575                 break;
576
577 #define SUB_LINK(s,p) \
578         subs[s] = wl_subcompositor_get_subsurface(subco, surfs[s], surfs[p])
579
580         case 11:
581                 SUB_LINK(10, 2);
582                 /* fallthrough */
583         case 10:
584                 SUB_LINK(9, 2);
585                 /* fallthrough */
586         case 9:
587                 SUB_LINK(8, 6);
588                 /* fallthrough */
589         case 8:
590                 SUB_LINK(7, 6);
591                 /* fallthrough */
592         case 7:
593                 SUB_LINK(6, 2);
594                 /* fallthrough */
595         case 6:
596                 SUB_LINK(5, 1);
597                 /* fallthrough */
598         case 5:
599                 SUB_LINK(4, 3);
600                 /* fallthrough */
601         case 4:
602                 SUB_LINK(3, 1);
603                 /* fallthrough */
604         case 3:
605                 SUB_LINK(2, 0);
606                 /* fallthrough */
607         case 2:
608                 SUB_LINK(1, 0);
609
610 #undef SUB_LINK
611         };
612 }
613
614 static void
615 destroy_subsurface_tree(struct wl_surface **surfs,
616                         struct wl_subsurface **subs, int n)
617 {
618         int i;
619
620         for (i = n; i-- > 0; ) {
621                 if (surfs[i])
622                         wl_surface_destroy(surfs[i]);
623
624                 if (subs[i])
625                         wl_subsurface_destroy(subs[i]);
626         }
627 }
628
629 static int
630 has_dupe(int *cnt, int n)
631 {
632         int i;
633
634         for (i = 0; i < n; i++)
635                 if (cnt[i] == cnt[n])
636                         return 1;
637
638         return 0;
639 }
640
641 /* Note: number of permutations to test is: set_size! / (set_size - NSTEPS)!
642  */
643 #define NSTEPS 3
644
645 struct permu_state {
646         int set_size;
647         int cnt[NSTEPS];
648 };
649
650 static void
651 permu_init(struct permu_state *s, int set_size)
652 {
653         int i;
654
655         s->set_size = set_size;
656         for (i = 0; i < NSTEPS; i++)
657                 s->cnt[i] = 0;
658 }
659
660 static int
661 permu_next(struct permu_state *s)
662 {
663         int k;
664
665         s->cnt[NSTEPS - 1]++;
666
667         while (1) {
668                 if (s->cnt[0] >= s->set_size) {
669                         return -1;
670                 }
671
672                 for (k = 1; k < NSTEPS; k++) {
673                         if (s->cnt[k] >= s->set_size) {
674                                 s->cnt[k - 1]++;
675                                 s->cnt[k] = 0;
676                                 break;
677                         }
678
679                         if (has_dupe(s->cnt, k)) {
680                                 s->cnt[k]++;
681                                 break;
682                         }
683                 }
684
685                 if (k == NSTEPS)
686                         return 0;
687         }
688 }
689
690 static void
691 destroy_permu_object(struct wl_surface **surfs,
692                      struct wl_subsurface **subs, int i)
693 {
694         int h = (i + 1) / 2;
695
696         if (i & 1) {
697                 fprintf(stderr, " [sub  %2d]", h);
698                 wl_subsurface_destroy(subs[h]);
699                 subs[h] = NULL;
700         } else {
701                 fprintf(stderr, " [surf %2d]", h);
702                 wl_surface_destroy(surfs[h]);
703                 surfs[h] = NULL;
704         }
705 }
706
707 TEST(test_subsurface_destroy_permutations)
708 {
709         /*
710          * Test wl_surface and wl_subsurface destruction orders in a
711          * complex tree of sub-surfaces.
712          *
713          * In the tree of sub-surfaces, go through every possible
714          * permutation of destroying all wl_surface and wl_subsurface
715          * objects. Execpt, to limit running time to a reasonable level,
716          * execute only the first NSTEPS destructions from each
717          * permutation, and ignore identical cases.
718          */
719
720         const int test_size = 11;
721         struct client *client;
722         struct wl_surface *surfs[test_size];
723         struct wl_subsurface *subs[test_size];
724         struct permu_state per;
725         int counter = 0;
726         int i;
727
728         client = create_client_and_test_surface(100, 50, 123, 77);
729         assert(client);
730
731         permu_init(&per, test_size * 2 - 1);
732         while (permu_next(&per) != -1) {
733                 /* for each permutation of NSTEPS out of test_size */
734                 memset(surfs, 0, sizeof surfs);
735                 memset(subs, 0, sizeof subs);
736
737                 create_subsurface_tree(client, surfs, subs, test_size);
738
739                 fprintf(stderr, "permu");
740
741                 for (i = 0; i < NSTEPS; i++)
742                         fprintf(stderr, " %2d", per.cnt[i]);
743
744                 for (i = 0; i < NSTEPS; i++)
745                         destroy_permu_object(surfs, subs, per.cnt[i]);
746
747                 fprintf(stderr, "\n");
748                 client_roundtrip(client);
749
750                 destroy_subsurface_tree(surfs, subs, test_size);
751                 counter++;
752         }
753
754         client_roundtrip(client);
755         fprintf(stderr, "tried %d destroy permutations\n", counter);
756 }