mainnika
/
weston
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

xwayland-test: Replace the xwayland-test

Browse Source 
The old xwayland-test hasn't worked in a while...

This new test checks that the wayland specific WL_SURFACE_ID atom exists,
checks that the window manager name is "Weston WM" and then maps a window
and waits for an exposure event.

Signed-off-by: Derek Foreman <derekf@osg.samsung.com>
Reviewed-by: Bryce Harrington <bryce@osg.samsung.com>
Tested-by: Bryce Harrington <bryce@osg.samsung.com>
dev
Derek Foreman 10 years ago committed by Bryce Harrington
parent 9e1aeb86c2
commit 8771a14ff3
2 changed files with 65 additions and 107 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 2
      configure.ac
  2. 170
      tests/xwayland-test.c

2
configure.ac
Unescape View File

@ -103,7 +103,7 @@ if test x$enable_xwayland = xyes; then
[XSERVER_PATH="$bindir/Xwayland"]) [XSERVER_PATH="$bindir/Xwayland"])
AC_SUBST([XSERVER_PATH]) AC_SUBST([XSERVER_PATH])
if test x$enable_xwayland_test = xyes; then if test x$enable_xwayland_test = xyes; then
PKG_CHECK_MODULES([XWAYLAND_TEST], xcb xcb-dri2 libdrm) PKG_CHECK_MODULES([XWAYLAND_TEST], x11)
fi fi
fi fi

170
tests/xwayland-test.c
Unescape View File

@ -1,5 +1,5 @@
/* /*
* Copyright © 2013 Intel Corporation * Copyright © 2015 Samsung
* *
* Permission to use, copy, modify, distribute, and sell this software and * Permission to use, copy, modify, distribute, and sell this software and
* its documentation for any purpose is hereby granted without fee, provided * its documentation for any purpose is hereby granted without fee, provided
@ -19,125 +19,83 @@
* CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN * CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
* CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
* *
* Author: Tiago Vignatti * xwayland-test: Confirm that we can map a window and we're running
* under Xwayland, not just X.
* *
* xwayland-test: the idea is to guarantee that XWayland infrastructure in * This is done in steps:
* general works with Weston. * 1) Confirm that the WL_SURFACE_ID atom exists
* 2) Confirm that the window manager's name is "Weston WM"
* 3) Make sure we can map a window
*/ */
#include "config.h" #include "config.h"
#include <unistd.h>
#include <assert.h> #include <assert.h>
#include <stdlib.h> #include <stdlib.h>
#include <stdio.h> #include <stdio.h>
#include <fcntl.h> #include <X11/Xlib.h>
#include <X11/Xatom.h>
#include <string.h> #include <string.h>
#include <xcb/xcb.h>
#include <xcb/dri2.h>
#include <xf86drm.h>
#include "weston-test-runner.h" #include "weston-test-runner.h"
TEST(xwayland_client_test)
static int
dri2_open(xcb_connection_t *c, xcb_screen_t *screen)
{
xcb_dri2_connect_cookie_t cookie;
xcb_dri2_connect_reply_t *reply;
xcb_dri2_authenticate_cookie_t cookie_auth;
xcb_dri2_authenticate_reply_t *reply_auth;
char *driver, *device;
int fd;
drm_magic_t magic;
cookie = xcb_dri2_connect(c, screen->root, XCB_DRI2_DRIVER_TYPE_DRI);
reply = xcb_dri2_connect_reply(c, cookie, 0);
assert(reply);
driver = strndup(xcb_dri2_connect_driver_name (reply),
xcb_dri2_connect_driver_name_length (reply));
device = strndup(xcb_dri2_connect_device_name (reply),
xcb_dri2_connect_device_name_length (reply));
fd = open(device, O_RDWR);
printf ("Trying connect to %s driver on %s\n", driver, device);
free(driver);
free(device);
if (fd < 0)
return -1;
drmGetMagic(fd, &magic);
cookie_auth = xcb_dri2_authenticate(c, screen->root, magic);
reply_auth = xcb_dri2_authenticate_reply(c, cookie_auth, 0);
assert(reply_auth);
return fd;
}
static int
create_window(void)
{ {
xcb_connection_t *c; Display *display;
xcb_screen_t *screen; Window window, root, *support;
xcb_window_t win; XEvent event;
int fd; int screen, status, actual_format;
unsigned long nitems, bytes;
c = xcb_connect (NULL, NULL); Atom atom, type_atom, actual_type;
if (c == NULL) { char *wm_name;
printf("failed to get X11 connection\n");
return -1; display = XOpenDisplay(NULL);
if (!display)
exit(EXIT_FAILURE);
atom = XInternAtom(display, "WL_SURFACE_ID", True);
assert(atom != None);
atom = XInternAtom(display, "_NET_SUPPORTING_WM_CHECK", True);
assert(atom != None);
screen = DefaultScreen(display);
root = RootWindow(display, screen);
status = XGetWindowProperty(display, root, atom, 0L, ~0L,
False, XA_WINDOW, &actual_type,
&actual_format, &nitems, &bytes,
(void *)&support);
assert(status == Success);
atom = XInternAtom(display, "_NET_WM_NAME", True);
assert(atom != None);
type_atom = XInternAtom(display, "UTF8_STRING", True);
assert(atom != None);
status = XGetWindowProperty(display, *support, atom, 0L, BUFSIZ,
False, type_atom, &actual_type,
&actual_format, &nitems, &bytes,
(void *)&wm_name);
assert(status == Success);
assert(nitems);
assert(strcmp("Weston WM", wm_name) == 0);
free(support);
free(wm_name);
window = XCreateSimpleWindow(display, root, 100, 100, 300, 300, 1,
BlackPixel(display, screen),
WhitePixel(display, screen));
XSelectInput(display, window, ExposureMask);
XMapWindow(display, window);
alarm(4);
while (1) {
XNextEvent(display, &event);
if (event.type == Expose)
break;
} }
screen = xcb_setup_roots_iterator(xcb_get_setup(c)).data; XCloseDisplay(display);
win = xcb_generate_id(c);
xcb_create_window(c, XCB_COPY_FROM_PARENT, win, screen->root,
0, 0, 150, 150, 1, XCB_WINDOW_CLASS_INPUT_OUTPUT,
screen->root_visual, 0, NULL);
xcb_change_property (c, XCB_PROP_MODE_REPLACE, win,
XCB_ATOM_WM_NAME, XCB_ATOM_STRING, 8,
5, "title");
xcb_map_window(c, win);
xcb_flush(c);
fd = dri2_open(c, screen);
if (fd < 0)
return -1;
xcb_destroy_window(c, win);
xcb_disconnect(c);
return 0;
}
/*
* Ideally, the X Window Manager (XWM) and Weston Wayland compositor shouldn't
* be in the same process because they are using two different protocol
* streams in which one does not interface with the other. Probably the
* biggest problem with such architecture are the potentials dead locks that
* it may occur. So hypothetically, an X client might issue an X11 blocking
* request via X (DRI2Authenticate) which in turn sends a Wayland blocking
* request for Weston process it. X is blocked. At the same time, XWM might be
* trying to process an XChangeProperty, so it requests a blocking X11 call to
* the X server (xcb_get_property_reply -> xcb_wait_for_reply) which therefore
* will blocks there. It's a deadlock situation and this test is trying to
* catch that.
*/
static void
check_dri2_authenticate(void)
{
int i, num_tests;
/* TODO: explain why num_tests times */
num_tests = 10;
for (i = 0; i < num_tests; i++)
assert(create_window() == 0);
}
TEST(xwayland_client_test)
{
check_dri2_authenticate();
exit(EXIT_SUCCESS); exit(EXIT_SUCCESS);
} }

Write Preview
Loading…
Cancel
Save