/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */ /* * Copyright (C) 2014-2017 Red Hat, Inc. * * This program 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 2 of the * License, or (at your option) any later version. * * This program 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 this program; if not, see . */ #include "config.h" #include "tests/meta-test-utils-private.h" #include #include #include #include "core/display-private.h" #include "core/window-private.h" #include "meta-test/meta-context-test.h" #include "wayland/meta-wayland.h" #include "wayland/meta-xwayland.h" #include "x11/meta-x11-display-private.h" struct _MetaTestClient { char *id; MetaWindowClientType type; GSubprocess *subprocess; GCancellable *cancellable; GMainLoop *loop; GDataOutputStream *in; GDataInputStream *out; char *line; GError **error; MetaAsyncWaiter *waiter; }; struct _MetaAsyncWaiter { XSyncCounter counter; int counter_value; XSyncAlarm alarm; GMainLoop *loop; int counter_wait_value; }; G_DEFINE_QUARK (meta-test-client-error-quark, meta_test_client_error) static char *test_client_path; void meta_ensure_test_client_path (int argc, char **argv) { test_client_path = g_test_build_filename (G_TEST_BUILT, "src", "tests", "mutter-test-client", NULL); if (!g_file_test (test_client_path, G_FILE_TEST_EXISTS | G_FILE_TEST_IS_EXECUTABLE)) { g_autofree char *basename = NULL; g_autofree char *dirname = NULL; basename = g_path_get_basename (argv[0]); dirname = g_path_get_dirname (argv[0]); test_client_path = g_build_filename (dirname, "mutter-test-client", NULL); } if (!g_file_test (test_client_path, G_FILE_TEST_EXISTS | G_FILE_TEST_IS_EXECUTABLE)) g_error ("mutter-test-client executable not found"); } MetaAsyncWaiter * meta_async_waiter_new (void) { MetaAsyncWaiter *waiter = g_new0 (MetaAsyncWaiter, 1); MetaDisplay *display = meta_get_display (); Display *xdisplay = display->x11_display->xdisplay; XSyncValue value; XSyncAlarmAttributes attr; waiter->counter_value = 0; XSyncIntToValue (&value, waiter->counter_value); waiter->counter = XSyncCreateCounter (xdisplay, value); attr.trigger.counter = waiter->counter; attr.trigger.test_type = XSyncPositiveComparison; /* Initialize to one greater than the current value */ attr.trigger.value_type = XSyncRelative; XSyncIntToValue (&attr.trigger.wait_value, 1); /* After triggering, increment test_value by this until * until the test condition is false */ XSyncIntToValue (&attr.delta, 1); /* we want events (on by default anyway) */ attr.events = True; waiter->alarm = XSyncCreateAlarm (xdisplay, XSyncCACounter | XSyncCAValueType | XSyncCAValue | XSyncCATestType | XSyncCADelta | XSyncCAEvents, &attr); waiter->loop = g_main_loop_new (NULL, FALSE); return waiter; } void meta_async_waiter_destroy (MetaAsyncWaiter *waiter) { MetaDisplay *display = meta_get_display (); Display *xdisplay = display->x11_display->xdisplay; XSyncDestroyAlarm (xdisplay, waiter->alarm); XSyncDestroyCounter (xdisplay, waiter->counter); g_main_loop_unref (waiter->loop); } static int meta_async_waiter_next_value (MetaAsyncWaiter *waiter) { return waiter->counter_value + 1; } static void meta_async_waiter_wait (MetaAsyncWaiter *waiter, int wait_value) { if (waiter->counter_value < wait_value) { waiter->counter_wait_value = wait_value; g_main_loop_run (waiter->loop); waiter->counter_wait_value = 0; } } void meta_async_waiter_set_and_wait (MetaAsyncWaiter *waiter) { MetaDisplay *display = meta_get_display (); Display *xdisplay = display->x11_display->xdisplay; int wait_value = meta_async_waiter_next_value (waiter); XSyncValue sync_value; XSyncIntToValue (&sync_value, wait_value); XSyncSetCounter (xdisplay, waiter->counter, sync_value); meta_async_waiter_wait (waiter, wait_value); } gboolean meta_async_waiter_process_x11_event (MetaAsyncWaiter *waiter, MetaX11Display *x11_display, XSyncAlarmNotifyEvent *event) { if (event->alarm != waiter->alarm) return FALSE; waiter->counter_value = XSyncValueLow32 (event->counter_value); if (waiter->counter_wait_value != 0 && waiter->counter_value >= waiter->counter_wait_value) g_main_loop_quit (waiter->loop); return TRUE; } char * meta_test_client_get_id (MetaTestClient *client) { return client->id; } static void test_client_line_read (GObject *source, GAsyncResult *result, gpointer user_data) { MetaTestClient *client = user_data; client->line = g_data_input_stream_read_line_finish_utf8 (client->out, result, NULL, client->error); g_main_loop_quit (client->loop); } gboolean meta_test_client_dov (MetaTestClient *client, GError **error, va_list vap) { GString *command = g_string_new (NULL); char *line = NULL; while (TRUE) { char *word = va_arg (vap, char *); char *quoted; if (word == NULL) break; if (command->len > 0) g_string_append_c (command, ' '); quoted = g_shell_quote (word); g_string_append (command, quoted); g_free (quoted); } g_string_append_c (command, '\n'); if (!g_data_output_stream_put_string (client->in, command->str, client->cancellable, error)) goto out; g_data_input_stream_read_line_async (client->out, G_PRIORITY_DEFAULT, client->cancellable, test_client_line_read, client); client->error = error; g_main_loop_run (client->loop); line = client->line; client->line = NULL; client->error = NULL; if (!line) { if (*error == NULL) { g_set_error (error, META_TEST_CLIENT_ERROR, META_TEST_CLIENT_ERROR_RUNTIME_ERROR, "test client exited"); } goto out; } if (strcmp (line, "OK") != 0) { g_set_error (error, META_TEST_CLIENT_ERROR, META_TEST_CLIENT_ERROR_RUNTIME_ERROR, "%s", line); goto out; } out: g_string_free (command, TRUE); g_free (line); return *error == NULL; } gboolean meta_test_client_do (MetaTestClient *client, GError **error, ...) { va_list vap; gboolean retval; va_start (vap, error); retval = meta_test_client_dov (client, error, vap); va_end (vap); return retval; } gboolean meta_test_client_wait (MetaTestClient *client, GError **error) { if (client->type == META_WINDOW_CLIENT_TYPE_WAYLAND) { return meta_test_client_do (client, error, "sync", NULL); } else { int wait_value = meta_async_waiter_next_value (client->waiter); char *counter_str = g_strdup_printf ("%lu", client->waiter->counter); char *wait_value_str = g_strdup_printf ("%d", wait_value); gboolean success; success = meta_test_client_do (client, error, "set_counter", counter_str, wait_value_str, NULL); g_free (counter_str); g_free (wait_value_str); if (!success) return FALSE; meta_async_waiter_wait (client->waiter, wait_value); return TRUE; } } MetaWindow * meta_test_client_find_window (MetaTestClient *client, const char *window_id, GError **error) { MetaDisplay *display = meta_get_display (); GSList *windows; GSList *l; MetaWindow *result; char *expected_title; windows = meta_display_list_windows (display, META_LIST_INCLUDE_OVERRIDE_REDIRECT); expected_title = g_strdup_printf ("test/%s/%s", client->id, window_id); result = NULL; for (l = windows; l; l = l->next) { MetaWindow *window = l->data; if (g_strcmp0 (window->title, expected_title) == 0) { result = window; break; } } g_slist_free (windows); g_free (expected_title); if (result == NULL) { g_set_error (error, META_TEST_CLIENT_ERROR, META_TEST_CLIENT_ERROR_RUNTIME_ERROR, "window %s/%s isn't known to Mutter", client->id, window_id); } return result; } typedef struct _WaitForShownData { GMainLoop *loop; MetaWindow *window; gulong shown_handler_id; } WaitForShownData; static void on_window_shown (MetaWindow *window, WaitForShownData *data) { g_main_loop_quit (data->loop); } static gboolean wait_for_showing_before_redraw (gpointer user_data) { WaitForShownData *data = user_data; if (meta_window_is_hidden (data->window)) { data->shown_handler_id = g_signal_connect (data->window, "shown", G_CALLBACK (on_window_shown), data); } else { g_main_loop_quit (data->loop); } return FALSE; } void meta_test_client_wait_for_window_shown (MetaTestClient *client, MetaWindow *window) { WaitForShownData data = { .loop = g_main_loop_new (NULL, FALSE), .window = window, }; meta_later_add (META_LATER_BEFORE_REDRAW, wait_for_showing_before_redraw, &data, NULL); g_main_loop_run (data.loop); g_clear_signal_handler (&data.shown_handler_id, window); g_main_loop_unref (data.loop); } gboolean meta_test_client_process_x11_event (MetaTestClient *client, MetaX11Display *x11_display, XSyncAlarmNotifyEvent *event) { if (client->waiter) { return meta_async_waiter_process_x11_event (client->waiter, x11_display, event); } else { return FALSE; } } static gpointer spawn_xwayland (gpointer user_data) { xcb_connection_t *connection; connection = xcb_connect (NULL, NULL); g_assert_nonnull (connection); xcb_disconnect (connection); return NULL; } MetaTestClient * meta_test_client_new (MetaContext *context, const char *id, MetaWindowClientType type, GError **error) { MetaTestClient *client; GSubprocessLauncher *launcher; GSubprocess *subprocess; MetaWaylandCompositor *compositor; const char *wayland_display_name; const char *x11_display_name; launcher = g_subprocess_launcher_new ((G_SUBPROCESS_FLAGS_STDIN_PIPE | G_SUBPROCESS_FLAGS_STDOUT_PIPE)); g_assert (meta_is_wayland_compositor ()); compositor = meta_context_get_wayland_compositor (context); wayland_display_name = meta_wayland_get_wayland_display_name (compositor); x11_display_name = meta_wayland_get_public_xwayland_display_name (compositor); g_subprocess_launcher_setenv (launcher, "WAYLAND_DISPLAY", wayland_display_name, TRUE); g_subprocess_launcher_setenv (launcher, "DISPLAY", x11_display_name, TRUE); subprocess = g_subprocess_launcher_spawn (launcher, error, test_client_path, "--client-id", id, (type == META_WINDOW_CLIENT_TYPE_WAYLAND ? "--wayland" : NULL), NULL); g_object_unref (launcher); if (!subprocess) return NULL; client = g_new0 (MetaTestClient, 1); client->type = type; client->id = g_strdup (id); client->cancellable = g_cancellable_new (); client->subprocess = subprocess; client->in = g_data_output_stream_new (g_subprocess_get_stdin_pipe (subprocess)); client->out = g_data_input_stream_new (g_subprocess_get_stdout_pipe (subprocess)); client->loop = g_main_loop_new (NULL, FALSE); if (client->type == META_WINDOW_CLIENT_TYPE_X11) { MetaDisplay *display = meta_get_display (); if (!display->x11_display) { GThread *thread; thread = g_thread_new ("Mutter Spawn Xwayland Thread", spawn_xwayland, NULL); meta_context_test_wait_for_x11_display (META_CONTEXT_TEST (context)); g_thread_join (thread); } client->waiter = meta_async_waiter_new (); } return client; } gboolean meta_test_client_quit (MetaTestClient *client, GError **error) { if (!meta_test_client_do (client, error, "destroy_all", NULL)) return FALSE; if (!meta_test_client_wait (client, error)) return FALSE; return TRUE; } void meta_test_client_destroy (MetaTestClient *client) { GError *error = NULL; if (client->waiter) meta_async_waiter_destroy (client->waiter); g_output_stream_close (G_OUTPUT_STREAM (client->in), NULL, &error); if (error) { g_warning ("Error closing client stdin: %s", error->message); g_clear_error (&error); } g_object_unref (client->in); g_input_stream_close (G_INPUT_STREAM (client->out), NULL, &error); if (error) { g_warning ("Error closing client stdout: %s", error->message); g_clear_error (&error); } g_object_unref (client->out); g_object_unref (client->cancellable); g_object_unref (client->subprocess); g_main_loop_unref (client->loop); g_free (client->id); g_free (client); } const char * meta_test_get_plugin_name (void) { const char *name; name = g_getenv ("MUTTER_TEST_PLUGIN_PATH"); if (name) return name; else return "libdefault"; }