/* Tests for the Wayland compositor running on the X server. Copyright (C) 2022 to various contributors. This file is part of 12to11. 12to11 is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. 12to11 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with 12to11. If not, see . */ #include "test_harness.h" #include "viewporter.h" /* Tests for subsurfaces. */ enum test_kind { MAP_WINDOW_KIND, SUBSURFACE_UNDER_KIND, SUBSURFACE_OVER_KIND, SUBSURFACE_MOVE_KIND, SUBSURFACE_STACKING_KIND, SUBSURFACE_TREE_KIND, SUBSURFACE_GROW_SHRINK_KIND, SUBSURFACE_STACKING_1_KIND, SUBSURFACE_DESYNC_KIND, SUBSURFACE_COMPLEX_DAMAGE_KIND, SUBSURFACE_SCALE_KIND, SUBSURFACE_REPARENT_KIND, }; static const char *test_names[] = { "map_window", "subsurface_under", "subsurface_over", "subsurface_move", "subsurface_stacking", "subsurface_tree", "subsurface_grow_shrink", "subsurface_stacking_1", "subsurface_desync", "subsurface_complex_damage", "subsurface_scale", "subsurface_reparent", }; struct test_subsurface { /* The subsurface itself. */ struct wl_subsurface *subsurface; /* The associated surface. */ struct wl_surface *surface; }; #define LAST_TEST SUBSURFACE_REPARENT_KIND /* The display. */ static struct test_display *display; /* The subcompositor interface. */ static struct wl_subcompositor *subcompositor; /* Test interfaces. */ static struct test_interface test_interfaces[] = { { "wl_subcompositor", &subcompositor, &wl_subcompositor_interface, 1, }, }; /* The test surface window. */ static Window test_surface_window; /* The test surface and Wayland surface. */ static struct test_surface *test_surface; static struct wl_surface *wayland_surface; /* Various subsurfaces. */ static struct test_subsurface *subsurfaces[11]; /* Various buffers. */ static struct wl_buffer *tiny_png; static struct wl_buffer *subsurface_base_png; static struct wl_buffer *subsurface_damage_png; static struct wl_buffer *subsurface_1_png; static struct wl_buffer *subsurface_1_damaged_png; static struct wl_buffer *subsurface_transparency_png; static struct wl_buffer *cow_transparent_png; static struct wl_buffer *gradient_png; static struct wl_buffer *big_png; static struct wl_buffer *small_png; static struct wl_buffer *subsurface_1_complex_png; static struct wl_buffer *subsurface_transparency_damage_png; static struct wl_buffer *subsurface_stack_1_png; static struct wl_buffer *subsurface_stack_2_png; /* The test image ID. */ static uint32_t current_test_image; /* Forward declarations. */ static void wait_frame_callback (struct wl_surface *); static void sleep_or_verify (void) { #ifndef INSPECTION char *dump_name; #endif #ifdef INSPECTION /* Sleep for 1 second so the human can see what is happening. */ sleep (1); #else if (asprintf (&dump_name, "subsurface_test_%"PRIu32".dump", ++current_test_image) < 0) die ("asprintf"); verify_image_data (display, test_surface_window, dump_name); free (dump_name); #endif } static void submit_surface_opaque_region (struct wl_surface *surface, int x, int y, int width, int height) { struct wl_region *region; region = wl_compositor_create_region (display->compositor); wl_region_add (region, x, y, width, height); wl_surface_set_opaque_region (surface, region); wl_region_destroy (region); } static struct test_subsurface * make_test_subsurface (void) { struct test_subsurface *subsurface; subsurface = malloc (sizeof *subsurface); if (!subsurface) goto error_1; subsurface->surface = wl_compositor_create_surface (display->compositor); if (!subsurface->surface) goto error_2; subsurface->subsurface = wl_subcompositor_get_subsurface (subcompositor, subsurface->surface, wayland_surface); if (!subsurface->subsurface) goto error_3; return subsurface; error_3: wl_surface_destroy (subsurface->surface); error_2: free (subsurface); error_1: return NULL; } static struct test_subsurface * make_test_subsurface_with_parent (struct test_subsurface *parent) { struct test_subsurface *subsurface; subsurface = malloc (sizeof *subsurface); if (!subsurface) goto error_1; subsurface->surface = wl_compositor_create_surface (display->compositor); if (!subsurface->surface) goto error_2; subsurface->subsurface = wl_subcompositor_get_subsurface (subcompositor, subsurface->surface, parent->surface); if (!subsurface->subsurface) goto error_3; return subsurface; error_3: wl_surface_destroy (subsurface->surface); error_2: free (subsurface); error_1: return NULL; } static void delete_subsurface_role (struct test_subsurface *subsurface) { wl_subsurface_destroy (subsurface->subsurface); subsurface->subsurface = NULL; } static void recreate_subsurface (struct test_subsurface *subsurface, struct wl_surface *parent) { subsurface->subsurface = wl_subcompositor_get_subsurface (subcompositor, subsurface->surface, parent); if (!subsurface->subsurface) report_test_failure ("failed to recreate subsurface"); } static void test_single_step (enum test_kind kind) { struct wl_region *region; test_log ("running test step: %s", test_names[kind]); switch (kind) { case MAP_WINDOW_KIND: tiny_png = load_png_image (display, "tiny.png"); if (!tiny_png) report_test_failure ("failed to load tiny.png"); wl_surface_attach (wayland_surface, tiny_png, 0, 0); wl_surface_damage (wayland_surface, 0, 0, INT_MAX, INT_MAX); submit_surface_opaque_region (wayland_surface, 0, 0, 4, 4); wl_surface_commit (wayland_surface); break; case SUBSURFACE_UNDER_KIND: /* Make a subsurface, and then place it *under* the parent. Wait for a frame callback, damage it, and check the results. */ subsurfaces[0] = make_test_subsurface (); if (!subsurfaces[0]) report_test_failure ("failed to create subsurface"); subsurface_base_png = load_png_image (display, "subsurface_base.png"); if (!subsurface_base_png) report_test_failure ("failed to load subsurface_base.png"); subsurface_damage_png = load_png_image (display, "subsurface_damage.png"); if (!subsurface_damage_png) report_test_failure ("failed to load subsurface_damage.png"); wl_subsurface_place_below (subsurfaces[0]->subsurface, wayland_surface); wl_surface_attach (subsurfaces[0]->surface, subsurface_base_png, 0, 0); wl_surface_damage (subsurfaces[0]->surface, 0, 0, 1024, 1024); submit_surface_opaque_region (subsurfaces[0]->surface, 0, 0, 1024, 1024); wl_surface_commit (subsurfaces[0]->surface); wait_frame_callback (wayland_surface); sleep_or_verify (); wl_surface_attach (subsurfaces[0]->surface, subsurface_damage_png, 0, 0); wl_surface_damage (subsurfaces[0]->surface, 256, 256, 512, 512); wl_surface_commit (subsurfaces[0]->surface); wait_frame_callback (wayland_surface); sleep_or_verify (); test_single_step (SUBSURFACE_OVER_KIND); break; case SUBSURFACE_OVER_KIND: /* Make a subsurface, and then place it over the parent. Set an opaque region and attach a buffer. Move the subsurface. */ subsurfaces[1] = make_test_subsurface (); if (!subsurfaces[1]) report_test_failure ("failed to create subsurface"); subsurface_1_png = load_png_image (display, "subsurface_1.png"); if (!subsurface_1_png) report_test_failure ("failed to load subsurface_1.png"); subsurface_1_damaged_png = load_png_image (display, "subsurface_1_damaged.png"); if (!subsurface_1_damaged_png) report_test_failure ("failed to load subsurface_1_damaged.png"); /* Now, move the surface a little. */ wl_subsurface_set_position (subsurfaces[1]->subsurface, 40, 40); /* Set an opaque region. */ submit_surface_opaque_region (subsurfaces[1]->surface, 0, 0, 256, 256); /* Damage the subsurface. */ wl_surface_attach (subsurfaces[1]->surface, subsurface_1_png, 0, 0); wl_surface_damage (subsurfaces[1]->surface, 0, 0, 256, 256); /* Commit the subsurface and its parent. */ wl_surface_commit (subsurfaces[1]->surface); wait_frame_callback (wayland_surface); sleep_or_verify (); /* Change the opaque region. */ region = wl_compositor_create_region (display->compositor); wl_region_add (region, 0, 0, 256, 256); wl_region_subtract (region, 128, 128, 70, 70); wl_surface_set_opaque_region (subsurfaces[1]->surface, region); wl_region_destroy (region); /* Attach a buffer with transparency. */ wl_surface_attach (subsurfaces[1]->surface, subsurface_1_damaged_png, 0, 0); wl_surface_damage (subsurfaces[1]->surface, 128, 128, 70, 70); /* Commit the subsurface and its parent. */ wl_surface_commit (subsurfaces[1]->surface); wait_frame_callback (wayland_surface); sleep_or_verify (); test_single_step (SUBSURFACE_MOVE_KIND); break; case SUBSURFACE_MOVE_KIND: /* Move the subsurface to the right a little and check that the correct area is exposed. */ wl_subsurface_set_position (subsurfaces[1]->subsurface, 50, 50); wait_frame_callback (wayland_surface); sleep_or_verify (); /* Move the subsurface to the right a little more. */ wl_subsurface_set_position (subsurfaces[1]->subsurface, 100, 100); wait_frame_callback (wayland_surface); sleep_or_verify (); test_single_step (SUBSURFACE_STACKING_KIND); break; case SUBSURFACE_STACKING_KIND: /* Stack the first test subsurface above the other test subsurface. Then, load a transparent pattern into the first subsurface to verify the stacking order. */ subsurface_transparency_png = load_png_image (display, "subsurface_transparency.png"); if (!subsurface_transparency_png) report_test_failure ("failed to load subsurface_transparency.png"); wl_subsurface_place_above (subsurfaces[0]->subsurface, subsurfaces[1]->surface); wl_surface_attach (subsurfaces[0]->surface, subsurface_transparency_png, 0, 0); /* Also update the opaque region. */ submit_surface_opaque_region (subsurfaces[0]->surface, 640, 640, 128, 128); wl_surface_damage (subsurfaces[0]->surface, 0, 0, 1024, 1024); wl_surface_commit (subsurfaces[0]->surface); wait_frame_callback (wayland_surface); sleep_or_verify (); /* Afterwards, damage the other test subsurface and see if the damage is composited correctly. */ submit_surface_opaque_region (subsurfaces[1]->surface, 0, 0, 256, 256); wl_surface_attach (subsurfaces[1]->surface, subsurface_1_png, 0, 0); wl_surface_damage (subsurfaces[1]->surface, 128, 128, 70, 70); /* Commit the subsurface and its parent. */ wl_surface_commit (subsurfaces[1]->surface); wait_frame_callback (wayland_surface); sleep_or_verify (); test_single_step (SUBSURFACE_TREE_KIND); break; case SUBSURFACE_TREE_KIND: /* Create two subsurfaces attached to the other test subsurface; 1 below, 1 over. */ subsurfaces[2] = make_test_subsurface_with_parent (subsurfaces[1]); subsurfaces[3] = make_test_subsurface_with_parent (subsurfaces[1]); if (!subsurfaces[2] || !subsurfaces[3]) report_test_failure ("failed to create subsurfaces"); gradient_png = load_png_image (display, "gradient.png"); if (!gradient_png) report_test_failure ("failed to load gradient.png"); cow_transparent_png = load_png_image (display, "cow_transparent.png"); if (!cow_transparent_png) report_test_failure ("failed to load cow_transparent.png"); wl_subsurface_place_below (subsurfaces[2]->subsurface, subsurfaces[1]->surface); wl_subsurface_place_above (subsurfaces[3]->subsurface, subsurfaces[1]->surface); /* Attach buffers to the various subsurfaces and commit them. */ wl_surface_attach (subsurfaces[2]->surface, gradient_png, 0, 0); wl_surface_attach (subsurfaces[3]->surface, cow_transparent_png, 0, 0); submit_surface_opaque_region (subsurfaces[2]->surface, 0, 0, 100, 300); wl_surface_damage (subsurfaces[2]->surface, 0, 0, INT_MAX, INT_MAX); wl_surface_damage (subsurfaces[3]->surface, 0, 0, INT_MAX, INT_MAX); wl_surface_commit (subsurfaces[2]->surface); wl_surface_commit (subsurfaces[3]->surface); /* Nothing should happen to the surface here. */ wait_frame_callback (wayland_surface); sleep_or_verify (); /* Nor here. */ wl_surface_commit (subsurfaces[1]->surface); /* Until here. */ wait_frame_callback (wayland_surface); sleep_or_verify (); /* Now, unmap the surface. Subsurfaces 2, 3, 4 should all disappear! */ wl_surface_attach (subsurfaces[1]->surface, NULL, 0, 0); wl_surface_commit (subsurfaces[1]->surface); wait_frame_callback (wayland_surface); sleep_or_verify (); /* Map it again. All subsurfaces should appear again, this time with the opaque circle in subsurface 2 transparent. */ wl_surface_attach (subsurfaces[1]->surface, subsurface_1_damaged_png, 0, 0); region = wl_compositor_create_region (display->compositor); wl_region_add (region, 0, 0, 256, 256); wl_region_subtract (region, 128, 128, 70, 70); wl_surface_set_opaque_region (subsurfaces[1]->surface, region); wl_region_destroy (region); wl_surface_damage (subsurfaces[1]->surface, 128, 128, 70, 70); wl_surface_commit (subsurfaces[1]->surface); wait_frame_callback (wayland_surface); sleep_or_verify (); /* Move subsurface 1 to where it gets obscured by the opaque region of the view above. Verify that the views all move accordingly. */ wl_subsurface_set_position (subsurfaces[1]->subsurface, 640, 640); wait_frame_callback (wayland_surface); sleep_or_verify (); /* Move one of the views further to the right. */ wl_subsurface_set_position (subsurfaces[2]->subsurface, 100, 100); wl_surface_commit (subsurfaces[1]->surface); wait_frame_callback (wayland_surface); sleep_or_verify (); test_single_step (SUBSURFACE_GROW_SHRINK_KIND); break; case SUBSURFACE_GROW_SHRINK_KIND: /* This test attaches a big buffer to the second subsurface. Then, it attaches a smaller buffer to the second subsurface. But first, it moves the first subsurface back to 40, 40, and unmaps the second and third subsurfaces. */ big_png = load_png_image (display, "big.png"); if (!big_png) report_test_failure ("failed to load big.png"); small_png = load_png_image (display, "small.png"); if (!small_png) report_test_failure ("failed to load small.png"); wl_subsurface_set_position (subsurfaces[1]->subsurface, 40, 40); wl_surface_attach (subsurfaces[3]->surface, NULL, 0, 0); wl_surface_attach (subsurfaces[2]->surface, NULL, 0, 0); wl_surface_commit (subsurfaces[3]->surface); wl_surface_commit (subsurfaces[2]->surface); wl_surface_commit (subsurfaces[1]->surface); wait_frame_callback (wayland_surface); sleep_or_verify (); submit_surface_opaque_region (subsurfaces[1]->surface, 0, 0, 300, 300); wl_surface_attach (subsurfaces[1]->surface, big_png, 0, 0); wl_surface_damage (subsurfaces[1]->surface, 0, 0, 300, 300); wl_surface_commit (subsurfaces[1]->surface); wait_frame_callback (wayland_surface); sleep_or_verify (); submit_surface_opaque_region (subsurfaces[1]->surface, 0, 0, 150, 150); wl_surface_attach (subsurfaces[1]->surface, small_png, 0, 0); wl_surface_damage (subsurfaces[1]->surface, 0, 0, 150, 150); wl_surface_commit (subsurfaces[1]->surface); wait_frame_callback (wayland_surface); sleep_or_verify (); test_single_step (SUBSURFACE_STACKING_1_KIND); break; case SUBSURFACE_STACKING_1_KIND: /* Move the second subsurface above the first. Then, move the third subsurface above the fourth, and the fourth below the second. */ wl_subsurface_place_above (subsurfaces[1]->subsurface, subsurfaces[0]->surface); wl_subsurface_place_above (subsurfaces[2]->subsurface, subsurfaces[3]->surface); wl_subsurface_place_below (subsurfaces[3]->subsurface, subsurfaces[1]->surface); /* Next, attach some buffers to the third and fourth surface. */ wl_surface_attach (subsurfaces[2]->surface, gradient_png, 0, 0); wl_surface_attach (subsurfaces[3]->surface, cow_transparent_png, 0, 0); submit_surface_opaque_region (subsurfaces[2]->surface, 0, 0, 100, 300); wl_surface_commit (subsurfaces[2]->surface); wl_surface_commit (subsurfaces[3]->surface); /* Commit the first subsurface. */ wl_surface_commit (subsurfaces[1]->surface); wait_frame_callback (wayland_surface); /* The result of the test should be as follows. Above the first subsurface lies the fourth subsurface (cow_transparent.png), above which is the second subsurface (small.png), above which is the third subsurface (gradient.png). */ sleep_or_verify (); /* Next, test moving the third subsurface immediately below the fourth. */ wl_subsurface_place_below (subsurfaces[2]->subsurface, subsurfaces[3]->surface); wl_surface_commit (subsurfaces[1]->surface); wait_frame_callback (wayland_surface); /* The result of the test should be as follows. Above the first subsurface lies the third subsurface (gradient.png), above which lies the fourth subsurface (cow_transparent.png), and finally the third (small.png). */ sleep_or_verify (); test_single_step (SUBSURFACE_DESYNC_KIND); break; case SUBSURFACE_DESYNC_KIND: /* Hide every other subsurface other than subsurfaces[0]. */ wl_surface_attach (subsurfaces[1]->surface, NULL, 0, 0); wl_surface_attach (subsurfaces[2]->surface, NULL, 0, 0); wl_surface_attach (subsurfaces[3]->surface, NULL, 0, 0); wl_surface_commit (subsurfaces[3]->surface); wl_surface_commit (subsurfaces[2]->surface); wl_surface_commit (subsurfaces[1]->surface); wait_frame_callback (wayland_surface); sleep_or_verify (); /* Create a tree of subsurfaces as follows: subsurfaces[4] (as a child of subsurfaces[0]) subsurfaces[5] subsurfaces[6] subsurfaces[7] subsurfaces[8] */ subsurfaces[4] = make_test_subsurface_with_parent (subsurfaces[0]); if (!subsurfaces[4]) report_test_failure ("failed to create subsurfaces"); subsurfaces[5] = make_test_subsurface_with_parent (subsurfaces[4]); subsurfaces[6] = make_test_subsurface_with_parent (subsurfaces[4]); if (!subsurfaces[5] || !subsurfaces[6]) report_test_failure ("failed to create subsurfaces"); subsurfaces[7] = make_test_subsurface_with_parent (subsurfaces[6]); subsurfaces[8] = make_test_subsurface_with_parent (subsurfaces[6]); if (!subsurfaces[7] || !subsurfaces[8]) report_test_failure ("failed to create subsurfaces"); /* Confirm all the children. Attach tiny_png to prevent some subsurfaces from being unmapped. */ wl_surface_attach (subsurfaces[4]->surface, tiny_png, 0, 0); wl_surface_attach (subsurfaces[6]->surface, tiny_png, 0, 0); wl_surface_damage (subsurfaces[4]->surface, 0, 0, 4, 4); wl_surface_damage (subsurfaces[6]->surface, 0, 0, 4, 4); wl_surface_commit (subsurfaces[6]->surface); wl_surface_commit (subsurfaces[4]->surface); wl_surface_commit (subsurfaces[0]->surface); /* Now, make subsurfaces[8] desynchronous. */ wl_subsurface_set_desync (subsurfaces[8]->subsurface); /* Attach gradient.png to subsurfaces[8]. While subsurfaces[8] is desync, 6 and 4 are both synchronous. */ wl_surface_attach (subsurfaces[8]->surface, gradient_png, 0, 0); wl_surface_damage (subsurfaces[8]->surface, 0, 0, 100, 300); wl_surface_commit (subsurfaces[8]->surface); /* Thus, the state should not appear. */ wait_frame_callback (wayland_surface); sleep_or_verify (); /* Next, make subsurfaces[6] desynchronous. */ wl_subsurface_set_desync (subsurfaces[6]->subsurface); /* gradient.png should still not appear. */ wait_frame_callback (wayland_surface); sleep_or_verify (); /* Finally, make subsurfaces[0] and subsurfaces[4] desynchronous. As subsurfaces[0] has cached state (it was committed earlier), its state and that of all its children should be applied. As a result, gradient.png should appear without having to commit subsurfaces[8] again. */ wl_subsurface_set_desync (subsurfaces[4]->subsurface); wl_subsurface_set_desync (subsurfaces[0]->subsurface); /* Commit wayland_surface to get a frame callback. */ wait_frame_callback (wayland_surface); /* gradient.png should now appear onscreen. */ sleep_or_verify (); /* Next, make subsurfaces[6] synchronous. Attach small.png to subsurfaces[8] and gradient.png to subsurfaces[5]. */ wl_subsurface_set_sync (subsurfaces[6]->subsurface); wl_surface_attach (subsurfaces[8]->surface, small_png, 0, 0); wl_surface_damage (subsurfaces[8]->surface, 0, 0, 150, 150); wl_surface_commit (subsurfaces[8]->surface); /* Commit subsurfaces[4] for a frame callback. Verify that the contents did not change, as subsurfaces[6] is synchronous. */ wait_frame_callback (subsurfaces[4]->surface); sleep_or_verify (); /* Commit subsurfaces[6], then commit subsurfaces[4] to apply the pending state. The state in subsurfaces[8] should be applied. */ wl_surface_commit (subsurfaces[6]->surface); wait_frame_callback (subsurfaces[4]->surface); sleep_or_verify (); /* Now, attach big_png to subsurfaces[8]. */ wl_surface_attach (subsurfaces[8]->surface, big_png, 0, 0); wl_surface_damage (subsurfaces[8]->surface, 0, 0, 300, 300); wl_surface_commit (subsurfaces[8]->surface); /* Make subsurfaces[6]->surface desynchronous. Nothing should appear despite subsurfaces[8] having become desynchronous, as subsurfaces[6] has no cached state. subsurfaces[4] is only committed to get a frame callback. */ wl_subsurface_set_desync (subsurfaces[6]->subsurface); wait_frame_callback (subsurfaces[4]->surface); sleep_or_verify (); /* Now, apply a buffer transform to subsurfaces[8]. Upon commit, big.png should be displayed rotated 90 degrees clockwise, by the buffer transform being merged with the cached state of the surface prior to being committed. */ wl_surface_set_buffer_transform (subsurfaces[8]->surface, WL_OUTPUT_TRANSFORM_90); wait_frame_callback (subsurfaces[8]->surface); sleep_or_verify (); /* Now, attach subsurface_1.png in subsurfaces[7]. Nothing should be displayed. */ wl_surface_attach (subsurfaces[7]->surface, subsurface_1_png, 0, 0); wl_surface_damage (subsurfaces[7]->surface, 0, 0, 256, 256); wl_surface_commit (subsurfaces[7]->surface); /* Also move the subsurface a little. */ wl_subsurface_set_position (subsurfaces[7]->subsurface, 100, 100); wait_frame_callback (wayland_surface); sleep_or_verify (); /* Commit subsurfaces[6]. As it is now desynchronous, subsurface_1.png should be displayed. */ wait_frame_callback (subsurfaces[6]->surface); sleep_or_verify (); test_single_step (SUBSURFACE_COMPLEX_DAMAGE_KIND); break; case SUBSURFACE_COMPLEX_DAMAGE_KIND: /* Hide subsurfaces[8]. After this, subsurfaces[7].png should be displayed entirely. */ wl_surface_attach (subsurfaces[8]->surface, NULL, 0, 0); wait_frame_callback (subsurfaces[8]->surface); sleep_or_verify (); /* Move subsurfaces[8] to 270, 270. This adds some damage to quadrant D. */ wl_subsurface_set_position (subsurfaces[8]->subsurface, 600, 600); /* Make subsurfaces[8] synchronous. */ wl_subsurface_set_sync (subsurfaces[8]->subsurface); /* Attach a buffer to subsurfaces[8]. */ wl_surface_set_buffer_transform (subsurfaces[8]->surface, WL_OUTPUT_TRANSFORM_NORMAL); wl_surface_attach (subsurfaces[8]->surface, small_png, 0, 0); wl_surface_damage (subsurfaces[8]->surface, 0, 0, 150, 150); wl_surface_commit (subsurfaces[8]->surface); /* Nothing should appear. */ wait_frame_callback (wayland_surface); sleep_or_verify (); /* Attach subsurface_1_complex.png to subsurfaces[7], and apply detailed damage. Verify that the result remains correct despite the subcompositor performing damage simplification. */ subsurface_1_complex_png = load_png_image (display, "subsurface_1_complex.png"); if (!subsurface_1_complex_png) report_test_failure ("failed to load subsurface_1_complex.png"); subsurface_transparency_damage_png = load_png_image (display, "subsurface_transparency_damage.png"); if (!subsurface_transparency_damage_png) report_test_failure ("failed to load subsurface_transparency_damage.png"); /* Set a complex opaque region. */ region = wl_compositor_create_region (display->compositor); wl_region_add (region, 0, 0, 256, 256); wl_region_subtract (region, 128, 128, 70, 70); wl_surface_set_opaque_region (subsurfaces[0]->surface, region); wl_region_destroy (region); /* Attach subsurface_1_complex.png. */ wl_surface_attach (subsurfaces[7]->surface, subsurface_1_complex_png, 0, 0); wl_surface_damage (subsurfaces[7]->surface, 20, 24, 139, 55); wl_surface_damage (subsurfaces[7]->surface, 31, 108, 25, 24); wl_surface_damage (subsurfaces[7]->surface, 16, 179, 10, 9); wl_surface_damage (subsurfaces[7]->surface, 80, 85, 73, 43); wl_surface_damage (subsurfaces[7]->surface, 153, 56, 39, 53); wl_surface_damage (subsurfaces[7]->surface, 125, 56, 28, 29); wl_surface_damage (subsurfaces[7]->surface, 128, 128, 70, 70); wl_surface_commit (subsurfaces[7]->surface); /* Make subsurfaces[6] and subsurfaces[4] synchronous. */ wl_subsurface_set_sync (subsurfaces[4]->subsurface); wl_subsurface_set_sync (subsurfaces[6]->subsurface); /* Commit subsurfaces[6]->surface and subsurfaces[4]->surface. */ wl_surface_commit (subsurfaces[6]->surface); wl_surface_commit (subsurfaces[4]->surface); /* Now, apply damage to quadrants C and D. Attach subsurface_transparency_damage.png to subsurfaces[0]. */ wl_surface_attach (subsurfaces[0]->surface, subsurface_transparency_damage_png, 0, 0); wl_surface_damage (subsurfaces[0]->surface, 52, 882, 810, 58); wait_frame_callback (subsurfaces[0]->surface); sleep_or_verify (); test_single_step (SUBSURFACE_SCALE_KIND); break; case SUBSURFACE_SCALE_KIND: /* Set the global output scale to two, then three. Verify the subcompositor tree each time. */ test_set_scale (display, 2); wait_frame_callback (wayland_surface); /* Sleep for 1 second to wait for the scale hooks to completely run. */ sleep (1); sleep_or_verify (); test_set_scale (display, 3); wait_frame_callback (wayland_surface); /* Sleep for 1 second to wait for the scale hooks to completely run. */ sleep (1); sleep_or_verify (); /* Reset the scale. */ test_set_scale (display, 1); wait_frame_callback (wayland_surface); /* Sleep for 1 second to wait for the scale hooks to completely run. */ sleep (1); test_single_step (SUBSURFACE_REPARENT_KIND); break; case SUBSURFACE_REPARENT_KIND: subsurface_stack_1_png = load_png_image (display, "subsurface_stack_1.png"); if (!subsurface_stack_1_png) report_test_failure ("failed to load subsurface_stack_1.png"); subsurface_stack_2_png = load_png_image (display, "subsurface_stack_2.png"); if (!subsurface_stack_2_png) report_test_failure ("failed to load subsurface_stack_2.png"); /* Delete subsurfaces[6]. Verify that after doing so, subsurfaces[7] and subsurfaces[8] disappear. */ delete_subsurface_role (subsurfaces[6]); wait_frame_callback (wayland_surface); sleep_or_verify (); /* Next, recreate the subsurface. The children should not become visible, as subsurfaces[4] was not committed. */ recreate_subsurface (subsurfaces[6], subsurfaces[4]->surface); wait_frame_callback (wayland_surface); sleep_or_verify (); /* Finally, create two new subsurfaces. Both are children of subsurfaces[6]. The first, subsurfaces[9] has subsurface_stack_1 applied, and is placed at 600, 600. */ subsurfaces[9] = make_test_subsurface_with_parent (subsurfaces[6]); if (!subsurfaces[9]) report_test_failure ("failed to create subsurface"); wl_surface_attach (subsurfaces[9]->surface, subsurface_stack_1_png, 0, 0); wl_surface_damage (subsurfaces[9]->surface, 0, 0, 100, 100); wl_surface_commit (subsurfaces[9]->surface); wl_subsurface_set_position (subsurfaces[9]->subsurface, 600, 600); /* The second, subsurfaces[10] is a child of subsurfaces[6]. It is also placed at 600, 600, on top of subsurfaces[9]. */ subsurfaces[10] = make_test_subsurface_with_parent (subsurfaces[6]); if (!subsurfaces[10]) report_test_failure ("failed to create subsurface"); wl_surface_attach (subsurfaces[10]->surface, subsurface_stack_2_png, 0, 0); wl_surface_damage (subsurfaces[10]->surface, 0, 0, 100, 100); wl_surface_commit (subsurfaces[10]->surface); wl_subsurface_set_position (subsurfaces[10]->subsurface, 600, 600); /* Now, commit subsurfaces[6]. Nothing should become visible. */ wl_surface_commit (subsurfaces[6]->surface); wait_frame_callback (wayland_surface); sleep_or_verify (); /* Finally, commit subsurfaces[4] and then subsurfaces[0]. Everything should now show up: a completely white W on top of a translucent red cube, partly obscuring small.png, at 600, 600. */ wl_surface_commit (subsurfaces[4]->surface); wait_frame_callback (subsurfaces[0]->surface); sleep_or_verify (); /* Test that subsurface actions are applied in the right order for newly unparented (pending) subsurfaces. Destroy and recreate subsurfaces[9] and subsurfaces[10]. */ delete_subsurface_role (subsurfaces[9]); delete_subsurface_role (subsurfaces[10]); recreate_subsurface (subsurfaces[9], subsurfaces[6]->surface); recreate_subsurface (subsurfaces[10], subsurfaces[6]->surface); wl_subsurface_set_position (subsurfaces[9]->subsurface, 600, 600); wl_subsurface_set_position (subsurfaces[10]->subsurface, 600, 600); /* Place subsurfaces[9] above subsurfaces[10]. At this point, the subsurfaces have not yet been confirmed. */ wl_subsurface_place_above (subsurfaces[9]->subsurface, subsurfaces[10]->surface); /* Commit the parents. W should now be tinted red. */ wl_surface_commit (subsurfaces[6]->surface); wl_surface_commit (subsurfaces[4]->surface); wait_frame_callback (subsurfaces[0]->surface); sleep_or_verify (); break; } if (kind == LAST_TEST) test_complete (); } static void handle_test_surface_mapped (void *data, struct test_surface *surface, uint32_t xid, const char *display_string) { /* Sleep for 1 second to ensure that the window is exposed and redirected. */ sleep (1); /* Start the test. */ test_surface_window = xid; /* Run the test again. */ test_single_step (SUBSURFACE_UNDER_KIND); } static void handle_test_surface_committed (void *data, struct test_surface *surface, uint32_t presentation_hint) { } static const struct test_surface_listener test_surface_listener = { handle_test_surface_mapped, NULL, handle_test_surface_committed, }; static void handle_wl_callback_done (void *data, struct wl_callback *callback, uint32_t callback_data) { bool *flag; wl_callback_destroy (callback); /* Now tell wait_frame_callback to break out of the loop. */ flag = data; *flag = true; } static const struct wl_callback_listener wl_callback_listener = { handle_wl_callback_done, }; static void wait_frame_callback (struct wl_surface *surface) { struct wl_callback *callback; bool flag; /* Commit surface and wait for a frame callback. */ callback = wl_surface_frame (surface); flag = false; wl_callback_add_listener (callback, &wl_callback_listener, &flag); wl_surface_commit (surface); while (!flag) { if (wl_display_dispatch (display->display) == -1) die ("wl_display_dispatch"); } } static void run_test (void) { if (!make_test_surface (display, &wayland_surface, &test_surface)) report_test_failure ("failed to create test surface"); test_surface_add_listener (test_surface, &test_surface_listener, NULL); test_single_step (MAP_WINDOW_KIND); while (true) { if (wl_display_dispatch (display->display) == -1) die ("wl_display_dispatch"); } } int main (void) { test_init (); display = open_test_display (test_interfaces, ARRAYELTS (test_interfaces)); if (!display) report_test_failure ("failed to open display"); run_test (); }