mirror of
https://gitlab.freedesktop.org/cairo/cairo.git
synced 2025-12-20 21:00:10 +01:00
e90073f7dd
Avoid calling libtool to link every single test case, by building just one binary from all the sources. This binary is then given the task of choosing tests to run (based on user selection and individual test requirement), forking each test into its own process and accumulating the results.
369 lines
9.2 KiB
C
369 lines
9.2 KiB
C
/*
|
|
* Copyright © 2005 Red Hat, Inc.
|
|
*
|
|
* Permission to use, copy, modify, distribute, and sell this software
|
|
* and its documentation for any purpose is hereby granted without
|
|
* fee, provided that the above copyright notice appear in all copies
|
|
* and that both that copyright notice and this permission notice
|
|
* appear in supporting documentation, and that the name of
|
|
* Red Hat, Inc. not be used in advertising or publicity pertaining to
|
|
* distribution of the software without specific, written prior
|
|
* permission. Red Hat, Inc. makes no representations about the
|
|
* suitability of this software for any purpose. It is provided "as
|
|
* is" without express or implied warranty.
|
|
*
|
|
* RED HAT, INC. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS
|
|
* SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
|
|
* FITNESS, IN NO EVENT SHALL RED HAT, INC. BE LIABLE FOR ANY SPECIAL,
|
|
* INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
|
|
* RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
|
|
* OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
|
|
* IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
|
*
|
|
* Author: Carl D. Worth <cworth@cworth.org>
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
|
|
#include "cairo.h"
|
|
#include "cairo-xlib.h"
|
|
#include "cairo-test.h"
|
|
|
|
#include "cairo-boilerplate-xlib.h"
|
|
|
|
#include "buffer-diff.h"
|
|
|
|
#define SIZE 100
|
|
#define OFFSCREEN_OFFSET 50
|
|
|
|
cairo_bool_t result = 0;
|
|
|
|
#if CAIRO_HAS_XLIB_XRENDER_SURFACE
|
|
|
|
#include "cairo-xlib-xrender.h"
|
|
|
|
/* Vladimir Vukicevic reported that surfaces were being created with
|
|
* mismatching Visuals and XRenderPictFormats.
|
|
*/
|
|
static cairo_bool_t
|
|
surface_compare_visual_and_format (cairo_surface_t *surface)
|
|
{
|
|
Display *dpy;
|
|
Visual *visual;
|
|
XRenderPictFormat *format;
|
|
|
|
dpy = cairo_xlib_surface_get_display (surface);
|
|
|
|
visual = cairo_xlib_surface_get_visual (surface);
|
|
if (visual == NULL)
|
|
return TRUE;
|
|
|
|
format = cairo_xlib_surface_get_xrender_format (surface);
|
|
if (format == NULL)
|
|
return TRUE;
|
|
|
|
return format == XRenderFindVisualFormat (dpy, visual);
|
|
|
|
}
|
|
#else
|
|
|
|
static cairo_bool_t
|
|
surface_compare_visual_and_format (cairo_surface_t *surface)
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
#endif
|
|
|
|
static cairo_bool_t
|
|
check_similar_visual_and_format (cairo_surface_t *surface)
|
|
{
|
|
cairo_surface_t *similar;
|
|
cairo_bool_t ret;
|
|
|
|
similar = cairo_surface_create_similar (surface,
|
|
CAIRO_CONTENT_COLOR_ALPHA,
|
|
1, 1);
|
|
if (cairo_surface_status (similar))
|
|
return FALSE;
|
|
|
|
ret = surface_compare_visual_and_format (similar);
|
|
|
|
cairo_surface_destroy (similar);
|
|
|
|
return ret;
|
|
}
|
|
|
|
|
|
static void
|
|
draw_pattern (cairo_surface_t *surface)
|
|
{
|
|
cairo_t *cr = cairo_create (surface);
|
|
int i;
|
|
|
|
cairo_set_source_rgb (cr, 1.0, 1.0, 1.0); /* white */
|
|
cairo_paint (cr);
|
|
|
|
cairo_set_source_rgba (cr, 0, 0.0, 0.0, 0.50); /* half-alpha-black */
|
|
|
|
for (i = 1; i <= 3; i++) {
|
|
int inset = SIZE / 8 * i;
|
|
|
|
cairo_rectangle (cr,
|
|
inset, inset,
|
|
SIZE - 2 * inset, SIZE - 2 * inset);
|
|
cairo_fill (cr);
|
|
}
|
|
|
|
cairo_destroy (cr);
|
|
}
|
|
|
|
static void
|
|
erase_pattern (cairo_surface_t *surface)
|
|
{
|
|
cairo_t *cr = cairo_create (surface);
|
|
|
|
cairo_set_source_rgb (cr, 0.0, 0.0, 0.0); /* black */
|
|
cairo_paint (cr);
|
|
|
|
cairo_destroy (cr);
|
|
}
|
|
|
|
static cairo_test_status_t
|
|
do_test (const cairo_test_context_t *ctx,
|
|
Display *dpy,
|
|
unsigned char *reference_data,
|
|
unsigned char *test_data,
|
|
unsigned char *diff_data,
|
|
cairo_bool_t use_render,
|
|
cairo_bool_t use_pixmap,
|
|
cairo_bool_t set_size,
|
|
cairo_bool_t offscreen)
|
|
{
|
|
cairo_surface_t *surface;
|
|
cairo_surface_t *test_surface;
|
|
cairo_t *test_cr;
|
|
buffer_diff_result_t result;
|
|
Drawable drawable;
|
|
int screen = DefaultScreen (dpy);
|
|
|
|
if (use_pixmap && offscreen)
|
|
return CAIRO_TEST_SUCCESS;
|
|
|
|
if (use_pixmap) {
|
|
drawable = XCreatePixmap (dpy, DefaultRootWindow (dpy),
|
|
SIZE, SIZE, DefaultDepth (dpy, screen));
|
|
} else {
|
|
XSetWindowAttributes xwa;
|
|
int x, y;
|
|
|
|
xwa.override_redirect = True;
|
|
|
|
if (offscreen) {
|
|
x = - OFFSCREEN_OFFSET;
|
|
y = - OFFSCREEN_OFFSET;
|
|
} else {
|
|
x = 0;
|
|
y = 0;
|
|
}
|
|
|
|
drawable = XCreateWindow (dpy, DefaultRootWindow (dpy),
|
|
x, y, SIZE, SIZE, 0,
|
|
DefaultDepth (dpy, screen), InputOutput,
|
|
DefaultVisual (dpy, screen),
|
|
CWOverrideRedirect, &xwa);
|
|
XMapWindow (dpy, drawable);
|
|
}
|
|
|
|
surface = cairo_xlib_surface_create (dpy,
|
|
drawable,
|
|
DefaultVisual (dpy, screen),
|
|
SIZE, SIZE);
|
|
|
|
if (! surface_compare_visual_and_format (surface))
|
|
return CAIRO_TEST_FAILURE;
|
|
|
|
if (!use_render)
|
|
cairo_boilerplate_xlib_surface_disable_render (surface);
|
|
|
|
if (set_size) {
|
|
cairo_xlib_surface_set_size (surface, SIZE, SIZE);
|
|
|
|
if (cairo_xlib_surface_get_width (surface) != SIZE ||
|
|
cairo_xlib_surface_get_height (surface) != SIZE)
|
|
return CAIRO_TEST_FAILURE;
|
|
}
|
|
|
|
if (! check_similar_visual_and_format (surface))
|
|
return CAIRO_TEST_FAILURE;
|
|
|
|
draw_pattern (surface);
|
|
|
|
test_surface = cairo_image_surface_create_for_data (test_data,
|
|
CAIRO_FORMAT_RGB24,
|
|
SIZE, SIZE,
|
|
SIZE * 4);
|
|
|
|
test_cr = cairo_create (test_surface);
|
|
cairo_set_source_surface (test_cr, surface, 0, 0);
|
|
cairo_paint (test_cr);
|
|
|
|
cairo_destroy (test_cr);
|
|
cairo_surface_destroy (test_surface);
|
|
|
|
/* We erase the surface to black in case we get the same
|
|
* memory back again for the pixmap case.
|
|
*/
|
|
erase_pattern (surface);
|
|
cairo_surface_destroy (surface);
|
|
|
|
if (use_pixmap)
|
|
XFreePixmap (dpy, drawable);
|
|
else
|
|
XDestroyWindow (dpy, drawable);
|
|
|
|
if (offscreen) {
|
|
size_t offset = 4 * (SIZE * OFFSCREEN_OFFSET + OFFSCREEN_OFFSET);
|
|
|
|
buffer_diff_noalpha (reference_data + offset,
|
|
test_data + offset,
|
|
diff_data + offset,
|
|
SIZE - OFFSCREEN_OFFSET,
|
|
SIZE - OFFSCREEN_OFFSET,
|
|
4 * SIZE,
|
|
&result);
|
|
} else {
|
|
buffer_diff_noalpha (reference_data,
|
|
test_data,
|
|
diff_data,
|
|
SIZE,
|
|
SIZE,
|
|
4 * SIZE,
|
|
&result);
|
|
}
|
|
|
|
cairo_test_log (ctx, "xlib-surface: %s, %s, %s%s: %s\n",
|
|
use_render ? " render" : "no-render",
|
|
set_size ? " size" : "no-size",
|
|
use_pixmap ? "pixmap" : "window",
|
|
use_pixmap ?
|
|
" " :
|
|
(offscreen ? ", offscreen" : ", onscreen"),
|
|
result.pixels_changed ? "FAIL" : "PASS");
|
|
|
|
if (result.pixels_changed)
|
|
return CAIRO_TEST_FAILURE;
|
|
else
|
|
return CAIRO_TEST_SUCCESS;
|
|
}
|
|
|
|
static cairo_bool_t
|
|
check_visual (Display *dpy)
|
|
{
|
|
Visual *visual = DefaultVisual (dpy, DefaultScreen (dpy));
|
|
|
|
if ((visual->red_mask == 0xff0000 &&
|
|
visual->green_mask == 0x00ff00 &&
|
|
visual->blue_mask == 0x0000ff) ||
|
|
(visual->red_mask == 0x0000ff &&
|
|
visual->green_mask == 0x00ff00 &&
|
|
visual->blue_mask == 0xff0000))
|
|
return 1;
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
#undef xcalloc
|
|
static void *
|
|
xcalloc (const cairo_test_context_t *ctx, size_t a, size_t b)
|
|
{
|
|
void *ptr = calloc (a, b);
|
|
if (ptr == NULL) {
|
|
cairo_test_log (ctx, "xlib-surface: unable to allocate memory, skipping\n");
|
|
abort ();
|
|
}
|
|
return ptr;
|
|
}
|
|
|
|
static cairo_test_status_t
|
|
preamble (cairo_test_context_t *ctx)
|
|
{
|
|
Display *dpy;
|
|
unsigned char *reference_data;
|
|
unsigned char *test_data;
|
|
unsigned char *diff_data;
|
|
cairo_surface_t *reference_surface;
|
|
cairo_bool_t use_pixmap;
|
|
cairo_bool_t set_size;
|
|
cairo_bool_t offscreen;
|
|
cairo_test_status_t status, result = CAIRO_TEST_UNTESTED;
|
|
int stride;
|
|
|
|
if (! cairo_test_is_target_enabled (ctx, "xlib"))
|
|
goto CLEANUP_TEST;
|
|
|
|
dpy = XOpenDisplay (NULL);
|
|
if (!dpy) {
|
|
cairo_test_log (ctx, "xlib-surface: Cannot open display, skipping\n");
|
|
goto CLEANUP_TEST;
|
|
}
|
|
|
|
if (!check_visual (dpy)) {
|
|
cairo_test_log (ctx, "xlib-surface: default visual is not RGB24 or BGR24, skipping\n");
|
|
goto CLEANUP_DISPLAY;
|
|
}
|
|
|
|
stride = cairo_format_stride_for_width (CAIRO_FORMAT_RGB24, SIZE);
|
|
|
|
reference_data = xcalloc (ctx, SIZE, stride);
|
|
test_data = xcalloc (ctx, SIZE, stride);
|
|
diff_data = xcalloc (ctx, SIZE, stride);
|
|
|
|
reference_surface = cairo_image_surface_create_for_data (reference_data,
|
|
CAIRO_FORMAT_RGB24,
|
|
SIZE, SIZE,
|
|
stride);
|
|
|
|
draw_pattern (reference_surface);
|
|
cairo_surface_destroy (reference_surface);
|
|
|
|
result = CAIRO_TEST_SUCCESS;
|
|
|
|
for (set_size = 0; set_size <= 1; set_size++)
|
|
for (use_pixmap = 0; use_pixmap <= 1; use_pixmap++)
|
|
for (offscreen = 0; offscreen <= 1; offscreen++) {
|
|
status = do_test (ctx, dpy,
|
|
reference_data, test_data, diff_data,
|
|
1, use_pixmap, set_size, offscreen);
|
|
if (status)
|
|
result = status;
|
|
}
|
|
|
|
for (set_size = 0; set_size <= 1; set_size++)
|
|
for (use_pixmap = 0; use_pixmap <= 1; use_pixmap++)
|
|
for (offscreen = 0; offscreen <= 1; offscreen++) {
|
|
status = do_test (ctx, dpy,
|
|
reference_data, test_data, diff_data,
|
|
0, use_pixmap, set_size, offscreen);
|
|
if (status)
|
|
result = status;
|
|
}
|
|
|
|
free (reference_data);
|
|
free (test_data);
|
|
free (diff_data);
|
|
|
|
CLEANUP_DISPLAY:
|
|
XCloseDisplay (dpy);
|
|
|
|
CLEANUP_TEST:
|
|
return result;
|
|
}
|
|
|
|
CAIRO_TEST (xlib_surface,
|
|
"Check creating surfaces for various XWindows",
|
|
"xlib", /* keywords */
|
|
NULL, /* requirements */
|
|
0, 0,
|
|
preamble, NULL)
|