fdo-mirrors/cairo
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/cairo/cairo.git synced 2026-05-02 06:08:01 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

bump glitz req to 0.5.1, test for backends

Browse source 
Add glitz backend (original patches from sunmoon1997@gmail.com), including glx, wgl, and agl support. Add CAIRO_TEST_TARGET environment variable for limiting backends to test.
Takes all *.log files and spits out html to stdout that can be used to view all test results at once.
This commit is contained in:
Vladimir Vukicevic 2005-12-12 11:56:40 +00:00
parent 840f93698d
commit c2c4f0bb25
6 changed files with 754 additions and 27 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

12
ChangeLog
View file

@ -1,3 +1,15 @@
2005-12-12 Vladimir Vukicevic <vladimir@pobox.com>
* configure.in: bump glitz req to 0.5.1, test for backends
* test/cairo-test.c: Add glitz backend (original patches from
sunmoon1997@gmail.com), including glx, wgl, and agl support.
Add CAIRO_TEST_TARGET environment variable for limiting backends
to test.
* test/make-html.pl: Takes all *.log files and spits out html
to stdout that can be used to view all test results at once.
2005-12-08 Emmanuel Pacaud <emmanuel.pacaud@free.fr>
* test/.cvsignore: shhh...

31
configure.in
View file

@ -235,11 +235,40 @@ AC_ARG_ENABLE(glitz,
[use_glitz=$enableval], [use_glitz=no])
if test "x$use_glitz" = "xyes"; then
PKG_CHECK_MODULES(GLITZ, glitz >= 0.5.0, [
PKG_CHECK_MODULES(GLITZ, glitz >= 0.5.1, [
GLITZ_REQUIRES=glitz
use_glitz=yes], [use_glitz="no (requires glitz http://freedesktop.org/Software/glitz)"])
fi
if test "x$use_glitz" = "xyes";then
PKG_CHECK_MODULES(GLITZ_AGL, glitz-agl >= 0.5.1,
[have_glitz_agl=yes], [have_glitz_agl=no])
PKG_CHECK_MODULES(GLITZ_EGL, glitz-egl >= 0.5.1,
[have_glitz_egl=yes], [have_glitz_egl=no])
PKG_CHECK_MODULES(GLITZ_GLX, glitz-glx >= 0.5.1,
[have_glitz_glx=yes], [have_glitz_glx=no])
PKG_CHECK_MODULES(GLITZ_WGL, glitz-wgl >= 0.5.1,
[have_glitz_wgl=yes], [have_glitz_wgl=no])
if test "x$have_glitz_agl" = "xyes";then
AC_DEFINE(CAIRO_CAN_TEST_GLITZ_AGL_SURFACE, 1, [define if glitz backend can be tested against agl])
fi
if test "x$have_glitz_egl" = "xyes";then
AC_DEFINE(CAIRO_CAN_TEST_GLITZ_EGL_SURFACE, 1, [define if glitz backend can be tested against egl])
fi
if test "x$have_glitz_glx" = "xyes";then
AC_DEFINE(CAIRO_CAN_TEST_GLITZ_GLX_SURFACE, 1, [define if glitz backend can be tested against glx])
fi
if test "x$have_glitz_wgl" = "xyes";then
AC_DEFINE(CAIRO_CAN_TEST_GLITZ_WGL_SURFACE, 1, [define if glitz backend can be tested against wgl])
fi
fi
AM_CONDITIONAL(CAIRO_CAN_TEST_GLITZ_AGL_SURFACE, test "x$have_glitz_agl" = "xyes")
AM_CONDITIONAL(CAIRO_CAN_TEST_GLITZ_EGL_SURFACE, test "x$have_glitz_egl" = "xyes")
AM_CONDITIONAL(CAIRO_CAN_TEST_GLITZ_GLX_SURFACE, test "x$have_glitz_glx" = "xyes")
AM_CONDITIONAL(CAIRO_CAN_TEST_GLITZ_WGL_SURFACE, test "x$have_glitz_wgl" = "xyes")
AM_CONDITIONAL(CAIRO_HAS_GLITZ_SURFACE, test "x$use_glitz" = "xyes")
if test "x$use_glitz" = "xyes"; then
GLITZ_SURFACE_FEATURE="#define CAIRO_HAS_GLITZ_SURFACE 1"

21
src/Makefile.am
View file

@ -64,12 +64,21 @@ endif
# Headers that declare the functions in the cairo DLL API on Windows
cairo_win32_api_headers = \
$(srcdir)/cairo.h \
$(srcdir)/cairo-ft.h \
$(srcdir)/cairo-pdf.h \
$(srcdir)/cairo-ps.h \
$(srcdir)/cairo-win32.h \
$(srcdir)/cairo-debug.h
if CAIRO_HAS_GLITZ_SURFACE
cairo_win32_api_headers += \
$(srcdir)/cairo-glitz.h
endif
if CAIRO_HAS_FT_FONT
cairo_win32_api_headers += \
$(srcdir)/cairo-ft.h \
$(srcdir)/cairo-pdf.h \
$(srcdir)/cairo-ps.h
endif
# These names match automake style variable definition conventions so
# without these lines, automake will complain during the handling of
# the libcairo_la_LIBADD below. (The INCLUDES is an autoconf only
@ -170,11 +179,7 @@ cairo.def: $(cairo_win32_api_headers)
(echo EXPORTS; \
cat $(cairo_win32_api_headers) | \
grep -v -E '^# *include' | \
gcc \
-DCAIRO_HAS_WIN32_SURFACE \
-DCAIRO_HAS_WIN32_FONT \
-DCAIRO_HAS_PNG_FUNCTIONS \
-E - | \
gcc -include cairo-features.h -E - |\
grep -E '^cairo_.* \(' | \
sed -e 's/\([^ ]*\).*/\1/' | \
sort; \

14
test/Makefile.am
View file

@ -254,6 +254,20 @@ xmalloc.h
LDADDS = libcairotest.la $(top_builddir)/src/libcairo.la
if CAIRO_CAN_TEST_GLITZ_AGL_SURFACE
LDADDS += $(GLITZ_AGL_LIBS)
endif
if CAIRO_CAN_TEST_GLITZ_EGL_SURFACE
LDADDS += $(GLITZ_EGL_LIBS)
endif
if CAIRO_CAN_TEST_GLITZ_GLX_SURFACE
LDADDS += $(GLITZ_GLX_LIBS)
endif
if CAIRO_CAN_TEST_GLITZ_WGL_SURFACE
LDADDS += $(GLITZ_WGL_LIBS)
endif
if HAVE_PTHREAD
LDADDS += -lpthread
endif

542
test/cairo-test.c
View file

@ -197,21 +197,469 @@ cleanup_image (void *closure)
free (buf);
}
/* XXX: Someone who knows glitz better than I do should fix this up to
* work. */
#if 0 /* #ifdef CAIRO_HAS_GLITZ_SURFACE */
static cairo_surface_t *
create_glitz_surface (int width, int height, void **closure)
#ifdef CAIRO_HAS_GLITZ_SURFACE
#include <glitz.h>
#include <cairo-glitz.h>
static const cairo_user_data_key_t glitz_closure_key;
typedef struct _glitz_target_closure_base {
int width;
int height;
cairo_format_t format;
} glitz_target_closure_base_t;
static cairo_status_t
cairo_glitz_surface_write_to_png (cairo_surface_t *surface,
const char *filename)
{
#error Not yet implemented
glitz_target_closure_base_t *closure;
cairo_surface_t * imgsr;
cairo_t * imgcr;
closure = cairo_surface_get_user_data (surface, &glitz_closure_key);
imgsr = cairo_image_surface_create (closure->format, closure->width, closure->height);
imgcr = cairo_create (imgsr);
cairo_set_source_surface (imgcr, surface, 0, 0);
cairo_paint (imgcr);
cairo_surface_write_to_png (imgsr, filename);
cairo_destroy (imgcr);
cairo_surface_destroy (imgsr);
return CAIRO_STATUS_SUCCESS;
}
#if CAIRO_CAN_TEST_GLITZ_GLX_SURFACE
#include <glitz-glx.h>
typedef struct _glitz_glx_target_closure {
glitz_target_closure_base_t base;
Display *dpy;
int scr;
Window win;
} glitz_glx_target_closure_t;
static glitz_surface_t *
create_glitz_glx_surface (glitz_format_name_t formatname,
int width,
int height,
glitz_glx_target_closure_t *closure)
{
Display * dpy = closure->dpy;
int scr = closure->scr;
glitz_drawable_format_t templ;
glitz_drawable_format_t * dformat = NULL;
unsigned long mask;
glitz_drawable_t * drawable = NULL;
glitz_format_t * format;
glitz_surface_t * sr;
XSizeHints xsh;
XSetWindowAttributes xswa;
XVisualInfo * vinfo;
memset(&templ, 0, sizeof(templ));
templ.color.red_size = 8;
templ.color.green_size = 8;
templ.color.blue_size = 8;
templ.color.alpha_size = 8;
templ.color.fourcc = GLITZ_FOURCC_RGB;
templ.samples = 1;
mask = GLITZ_FORMAT_SAMPLES_MASK | GLITZ_FORMAT_FOURCC_MASK |
GLITZ_FORMAT_RED_SIZE_MASK | GLITZ_FORMAT_GREEN_SIZE_MASK |
GLITZ_FORMAT_BLUE_SIZE_MASK;
if (formatname == GLITZ_STANDARD_ARGB32)
mask |= GLITZ_FORMAT_ALPHA_SIZE_MASK;
/* Try for a pbuffer first */
if (!getenv("CAIRO_TEST_FORCE_GLITZ_WINDOW"))
dformat = glitz_glx_find_pbuffer_format (dpy, scr, mask, &templ, 0);
if (dformat) {
closure->win = NULL;
drawable = glitz_glx_create_pbuffer_drawable (dpy, scr, dformat,
width, height);
if (!drawable)
goto FAIL;
} else {
/* No pbuffer, try window */
dformat = glitz_glx_find_window_format (dpy, scr, mask, &templ, 0);
if (!dformat)
goto FAIL;
vinfo = glitz_glx_get_visual_info_from_format(dpy,
DefaultScreen(dpy),
dformat);
if (!vinfo)
goto FAIL;
xsh.flags = PSize;
xsh.x = 0;
xsh.y = 0;
xsh.width = width;
xsh.height = height;
xswa.colormap = XCreateColormap (dpy, RootWindow(dpy, scr),
vinfo->visual, AllocNone);
closure->win = XCreateWindow (dpy, RootWindow(dpy, scr),
xsh.x, xsh.y, xsh.width, xsh.height,
0, vinfo->depth, CopyFromParent,
vinfo->visual, CWColormap, &xswa);
drawable =
glitz_glx_create_drawable_for_window (dpy, scr,
dformat, closure->win,
width, height);
if (!drawable)
goto DESTROY_WINDOW;
}
format = glitz_find_standard_format (drawable, formatname);
if (!format)
goto DESTROY_DRAWABLE;
sr = glitz_surface_create (drawable, format, width, height, 0, NULL);
if (!sr)
goto DESTROY_DRAWABLE;
if (closure->win == NULL || dformat->doublebuffer) {
glitz_surface_attach (sr, drawable, GLITZ_DRAWABLE_BUFFER_BACK_COLOR);
} else {
XMapWindow (closure->dpy, closure->win);
glitz_surface_attach (sr, drawable, GLITZ_DRAWABLE_BUFFER_FRONT_COLOR);
}
glitz_drawable_destroy (drawable);
return sr;
DESTROY_DRAWABLE:
glitz_drawable_destroy (drawable);
DESTROY_WINDOW:
if (closure->win)
XDestroyWindow (dpy, closure->win);
FAIL:
return NULL;
}
static cairo_surface_t *
create_cairo_glitz_glx_surface (cairo_test_t *test,
cairo_format_t format,
void **closure)
{
int width = test->width;
int height = test->height;
glitz_glx_target_closure_t *gxtc;
glitz_surface_t * glitz_surface;
cairo_surface_t * surface;
*closure = gxtc = xmalloc (sizeof (glitz_glx_target_closure_t));
if (width == 0)
width = 1;
if (height == 0)
height = 1;
gxtc->dpy = XOpenDisplay (NULL);
if (!gxtc->dpy) {
cairo_test_log ("Failed to open display: %s\n", XDisplayName(0));
goto FAIL;
}
XSynchronize (gxtc->dpy, 1);
gxtc->scr = DefaultScreen(gxtc->dpy);
switch (format) {
case CAIRO_FORMAT_RGB24:
glitz_surface = create_glitz_glx_surface (GLITZ_STANDARD_RGB24, width, height, gxtc);
break;
case CAIRO_FORMAT_ARGB32:
glitz_surface = create_glitz_glx_surface (GLITZ_STANDARD_ARGB32, width, height, gxtc);
break;
default:
cairo_test_log ("Invalid format for glitz-glx test: %d\n", format);
goto FAIL_CLOSE_DISPLAY;
}
if (!glitz_surface) {
cairo_test_log ("Failed to create glitz-glx surface\n");
goto FAIL_CLOSE_DISPLAY;
}
surface = cairo_glitz_surface_create (glitz_surface);
gxtc->base.width = test->width;
gxtc->base.height = test->height;
gxtc->base.format = format;
cairo_surface_set_user_data (surface, &glitz_closure_key,
gxtc, NULL);
return surface;
FAIL_CLOSE_DISPLAY:
XCloseDisplay (gxtc->dpy);
FAIL:
return NULL;
}
static void
cleanup_glitz (cairo_t *cr)
cleanup_cairo_glitz_glx (void *closure)
{
#error Not yet implemented
glitz_glx_target_closure_t *gxtc = closure;
glitz_glx_fini ();
if (gxtc->win)
XDestroyWindow (gxtc->dpy, gxtc->win);
XCloseDisplay (gxtc->dpy);
free (gxtc);
}
#endif
#endif /* CAIRO_CAN_TEST_GLITZ_GLX_SURFACE */
#if CAIRO_CAN_TEST_GLITZ_AGL_SURFACE
#include <glitz-agl.h>
typedef struct _glitz_agl_target_closure {
glitz_target_closure_base_t base;
} glitz_agl_target_closure_t;
static glitz_surface_t *
create_glitz_agl_surface (glitz_format_name_t formatname,
int width, int height,
glitz_agl_target_closure_t *closure)
{
glitz_drawable_format_t *dformat;
glitz_drawable_format_t templ;
glitz_drawable_t *gdraw;
glitz_format_t *format;
glitz_surface_t *sr = NULL;
unsigned long mask;
memset(&templ, 0, sizeof(templ));
templ.color.red_size = 8;
templ.color.green_size = 8;
templ.color.blue_size = 8;
templ.color.alpha_size = 8;
templ.color.fourcc = GLITZ_FOURCC_RGB;
templ.samples = 1;
mask = GLITZ_FORMAT_SAMPLES_MASK | GLITZ_FORMAT_FOURCC_MASK |
GLITZ_FORMAT_RED_SIZE_MASK | GLITZ_FORMAT_GREEN_SIZE_MASK |
GLITZ_FORMAT_BLUE_SIZE_MASK;
if (formatname == GLITZ_STANDARD_ARGB32)
mask |= GLITZ_FORMAT_ALPHA_SIZE_MASK;
dformat = glitz_agl_find_pbuffer_format (mask, &templ, 0);
if (!dformat) {
cairo_test_log ("Glitz failed to find pbuffer format for template.");
goto FAIL;
}
gdraw = glitz_agl_create_pbuffer_drawable (dformat, width, height);
if (!gdraw) {
cairo_test_log ("Glitz failed to create pbuffer drawable.");
goto FAIL;
}
format = glitz_find_standard_format (gdraw, formatname);
if (!format) {
cairo_test_log ("Glitz failed to find standard format for drawable.");
goto DESTROY_DRAWABLE;
}
sr = glitz_surface_create (gdraw, format, width, height, 0, NULL);
if (!sr) {
cairo_test_log ("Glitz failed to create a surface.");
goto DESTROY_DRAWABLE;
}
glitz_surface_attach (sr, gdraw, GLITZ_DRAWABLE_BUFFER_FRONT_COLOR);
DESTROY_DRAWABLE:
glitz_drawable_destroy (gdraw);
FAIL:
return sr; /* will be NULL unless we create it and attach */
}
static cairo_surface_t *
create_cairo_glitz_agl_surface (cairo_test_t *test,
cairo_format_t format,
void **closure)
{
glitz_surface_t *glitz_surface;
cairo_surface_t *surface;
glitz_agl_target_closure_t *aglc;
glitz_agl_init ();
*closure = aglc = xmalloc (sizeof (glitz_agl_target_closure_t));
switch (format) {
case CAIRO_FORMAT_RGB24:
glitz_surface = create_glitz_agl_surface (GLITZ_STANDARD_RGB24, test->width, test->height, NULL);
break;
case CAIRO_FORMAT_ARGB32:
glitz_surface = create_glitz_agl_surface (GLITZ_STANDARD_ARGB32, test->width, test->height, NULL);
break;
default:
cairo_test_log ("Invalid format for glitz-agl test: %d\n", format);
goto FAIL;
}
if (!glitz_surface)
goto FAIL;
surface = cairo_glitz_surface_create (glitz_surface);
aglc->base.width = test->width;
aglc->base.height = test->height;
aglc->base.format = format;
cairo_surface_set_user_data (surface, &glitz_closure_key, aglc, NULL);
return surface;
FAIL:
return NULL;
}
static void
cleanup_cairo_glitz_agl (void *closure)
{
free (closure);
glitz_agl_fini ();
}
#endif /* CAIRO_CAN_TEST_GLITZ_AGL_SURFACE */
#if CAIRO_CAN_TEST_GLITZ_WGL_SURFACE
#include <glitz-wgl.h>
typedef struct _glitz_wgl_target_closure {
glitz_target_closure_base_t base;
} glitz_wgl_target_closure_t;
static glitz_surface_t *
create_glitz_wgl_surface (glitz_format_name_t formatname,
int width, int height,
glitz_wgl_target_closure_t *closure)
{
glitz_drawable_format_t *dformat;
glitz_drawable_format_t templ;
glitz_drawable_t *gdraw;
glitz_format_t *format;
glitz_surface_t *sr = NULL;
unsigned long mask;
memset(&templ, 0, sizeof(templ));
templ.color.red_size = 8;
templ.color.green_size = 8;
templ.color.blue_size = 8;
templ.color.alpha_size = 8;
templ.color.fourcc = GLITZ_FOURCC_RGB;
templ.samples = 1;
mask = GLITZ_FORMAT_SAMPLES_MASK | GLITZ_FORMAT_FOURCC_MASK |
GLITZ_FORMAT_RED_SIZE_MASK | GLITZ_FORMAT_GREEN_SIZE_MASK |
GLITZ_FORMAT_BLUE_SIZE_MASK;
if (formatname == GLITZ_STANDARD_ARGB32)
mask |= GLITZ_FORMAT_ALPHA_SIZE_MASK;
dformat = glitz_wgl_find_pbuffer_format (mask, &templ, 0);
if (!dformat) {
cairo_test_log ("Glitz failed to find pbuffer format for template.");
goto FAIL;
}
gdraw = glitz_wgl_create_pbuffer_drawable (dformat, width, height);
if (!gdraw) {
cairo_test_log ("Glitz failed to create pbuffer drawable.");
goto FAIL;
}
format = glitz_find_standard_format (gdraw, formatname);
if (!format) {
cairo_test_log ("Glitz failed to find standard format for drawable.");
goto DESTROY_DRAWABLE;
}
sr = glitz_surface_create (gdraw, format, width, height, 0, NULL);
if (!sr) {
cairo_test_log ("Glitz failed to create a surface.");
goto DESTROY_DRAWABLE;
}
glitz_surface_attach (sr, gdraw, GLITZ_DRAWABLE_BUFFER_FRONT_COLOR);
DESTROY_DRAWABLE:
glitz_drawable_destroy (gdraw);
FAIL:
return sr; /* will be NULL unless we create it and attach */
}
static cairo_surface_t *
create_cairo_glitz_wgl_surface (cairo_test_t *test,
cairo_format_t format,
void **closure)
{
glitz_surface_t *glitz_surface;
cairo_surface_t *surface;
glitz_wgl_target_closure_t *wglc;
glitz_wgl_init (NULL);
*closure = wglc = xmalloc (sizeof (glitz_wgl_target_closure_t));
switch (format) {
case CAIRO_FORMAT_RGB24:
glitz_surface = create_glitz_wgl_surface (GLITZ_STANDARD_RGB24, test->width, test->height, NULL);
break;
case CAIRO_FORMAT_ARGB32:
glitz_surface = create_glitz_wgl_surface (GLITZ_STANDARD_ARGB32, test->width, test->height, NULL);
break;
default:
cairo_test_log ("Invalid format for glitz-wgl test: %d\n", format);
goto FAIL;
}
if (!glitz_surface)
goto FAIL;
surface = cairo_glitz_surface_create (glitz_surface);
wglc->base.width = test->width;
wglc->base.height = test->height;
wglc->base.format = format;
cairo_surface_set_user_data (surface, &glitz_closure_key, wglc, NULL);
return surface;
FAIL:
return NULL;
}
static void
cleanup_cairo_glitz_wgl (void *closure)
{
free (closure);
glitz_wgl_fini ();
}
#endif /* CAIRO_CAN_TEST_GLITZ_WGL_SURFACE */
#endif /* CAIRO_HAS_GLITZ_SURFACE */
#if 0 && CAIRO_HAS_QUARTZ_SURFACE
static cairo_surface_t *
@ -753,8 +1201,10 @@ static cairo_test_status_t
cairo_test_expecting (cairo_test_t *test, cairo_test_draw_function_t draw,
cairo_test_status_t expectation)
{
int i;
int i, num_targets;
const char *tname;
cairo_test_status_t status, ret;
cairo_test_target_t **targets_to_test;
cairo_test_target_t targets[] =
{
{ "image", CAIRO_FORMAT_ARGB32,
@ -763,11 +1213,32 @@ cairo_test_expecting (cairo_test_t *test, cairo_test_draw_function_t draw,
{ "image", CAIRO_FORMAT_RGB24,
create_image_surface, cairo_surface_write_to_png,
cleanup_image },
#if 0 /* #ifdef CAIRO_HAS_GLITZ_SURFACE */
{ "glitz", CAIRO_FORMAT_ARGB32,
create_glitz_surface, cairo_surface_write_to_png,
cleanup_glitz },
#ifdef CAIRO_HAS_GLITZ_SURFACE
#if CAIRO_CAN_TEST_GLITZ_GLX_SURFACE
{ "glitz-glx", CAIRO_FORMAT_ARGB32,
create_cairo_glitz_glx_surface, cairo_glitz_surface_write_to_png,
cleanup_cairo_glitz_glx },
{ "glitz-glx", CAIRO_FORMAT_RGB24,
create_cairo_glitz_glx_surface, cairo_glitz_surface_write_to_png,
cleanup_cairo_glitz_glx },
#endif
#if CAIRO_CAN_TEST_GLITZ_AGL_SURFACE
{ "glitz-agl", CAIRO_FORMAT_ARGB32,
create_cairo_glitz_agl_surface, cairo_glitz_surface_write_to_png,
cleanup_cairo_glitz_agl },
{ "glitz-agl", CAIRO_FORMAT_RGB24,
create_cairo_glitz_agl_surface, cairo_glitz_surface_write_to_png,
cleanup_cairo_glitz_agl },
#endif
#if CAIRO_CAN_TEST_GLITZ_WGL_SURFACE
{ "glitz-wgl", CAIRO_FORMAT_ARGB32,
create_cairo_glitz_wgl_surface, cairo_glitz_surface_write_to_png,
cleanup_cairo_glitz_wgl },
{ "glitz-wgl", CAIRO_FORMAT_RGB24,
create_cairo_glitz_wgl_surface, cairo_glitz_surface_write_to_png,
cleanup_cairo_glitz_wgl },
#endif
#endif /* CAIRO_HAS_GLITZ_SURFACE */
#if 0 && CAIRO_HAS_QUARTZ_SURFACE
{ "quartz", CAIRO_FORMAT_RGB24,
create_quartz_surface, cairo_surface_write_to_png,
@ -797,6 +1268,29 @@ cairo_test_expecting (cairo_test_t *test, cairo_test_draw_function_t draw,
#endif
};
if ((tname = getenv ("CAIRO_TEST_TARGET")) != NULL) {
const char *tname = getenv ("CAIRO_TEST_TARGET");
num_targets = 0;
targets_to_test = NULL;
/* realloc isn't exactly the best thing here, but meh. */
for (i = 0; i < sizeof(targets)/sizeof(targets[0]); i++) {
if (strcmp (targets[i].name, tname) == 0) {
targets_to_test = realloc (targets_to_test, sizeof(cairo_test_target_t *) * (num_targets+1));
targets_to_test[num_targets++] = &targets[i];
}
}
if (num_targets == 0) {
fprintf (stderr, "CAIRO_TEST_TARGET '%s' not found in targets list!\n", tname);
exit(-1);
}
} else {
num_targets = sizeof(targets)/sizeof(targets[0]);
targets_to_test = malloc (sizeof(cairo_test_target_t*) * num_targets);
for (i = 0; i < num_targets; i++)
targets_to_test[i] = &targets[i];
}
cairo_test_init (test->name);
/* The intended logic here is that we return overall SUCCESS
@ -811,26 +1305,36 @@ cairo_test_expecting (cairo_test_t *test, cairo_test_draw_function_t draw,
* -> SUCCESS
*/
ret = CAIRO_TEST_UNTESTED;
for (i=0; i < sizeof(targets)/sizeof(targets[0]); i++) {
cairo_test_target_t *target = &targets[i];
for (i = 0; i < num_targets; i++) {
cairo_test_target_t *target = targets_to_test[i];
cairo_test_log ("Testing %s with %s target\n", test->name, target->name);
printf ("%s-%s-%s:\t", test->name, target->name, cairo_target_format_name(target));
status = cairo_test_for_target (test, draw, target);
cairo_test_log ("TEST: %s TARGET: %s FORMAT: %s RESULT: ",
test->name, target->name, cairo_target_format_name(target));
switch (status) {
case CAIRO_TEST_SUCCESS:
printf ("PASS\n");
cairo_test_log ("PASS\n");
if (ret == CAIRO_TEST_UNTESTED)
ret = CAIRO_TEST_SUCCESS;
break;
case CAIRO_TEST_UNTESTED:
printf ("UNTESTED\n");
cairo_test_log ("UNTESTED\n");
break;
default:
case CAIRO_TEST_FAILURE:
if (expectation == CAIRO_TEST_FAILURE)
if (expectation == CAIRO_TEST_FAILURE) {
printf ("XFAIL\n");
else
cairo_test_log ("XFAIL\n");
} else {
printf ("FAIL\n");
cairo_test_log ("FAIL\n");
}
ret = status;
break;
}
@ -840,6 +1344,8 @@ cairo_test_expecting (cairo_test_t *test, cairo_test_draw_function_t draw,
fclose (cairo_test_log_file);
free (targets_to_test);
#if HAVE_FCFINI
FcFini ();
#endif

161
test/make-html.pl Executable file
View file

@ -0,0 +1,161 @@
#!/usr/bin/perl
#
# Copyright © 2005 Mozilla Corporation
#
# 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
# Mozilla Corporation not be used in advertising or publicity pertaining to
# distribution of the software without specific, written prior
# permission. Mozilla Corporation makes no representations about the
# suitability of this software for any purpose. It is provided "as
# is" without express or implied warranty.
#
# MOZILLA CORPORTAION DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS
# SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
# FITNESS, IN NO EVENT SHALL MOZILLA CORPORATION 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: Vladimir Vukicevic <vladimir@pobox.com>
#
##
## Takes all the *.log files in the current directory and spits out
## html to stdout that can be used to view all the test results at once.
##
my $tests = {};
my $teststats = {};
foreach (<*.log>) {
(open LOG, "$_") || next;
while (<LOG>) {
next unless /^TEST: (.*) TARGET: (.*) FORMAT: (.*) RESULT: (.*)$/;
$tests->{$1} = {} unless $tests->{$1};
$tests->{$1}->{$2} = {} unless $tests->{$1}->{$2};
$tests->{$1}->{$2}->{$3} = $4;
$teststats->{$2} = {"PASS" => 0, "FAIL" => 0, "XFAIL" => 0, "UNTESTED" => 0}
unless $teststats->{$2};
($teststats->{$2}->{$4})++;
}
close LOG;
}
my $targeth = {};
my $formath = {};
foreach my $testname (sort(keys %$tests)) {
my $v0 = $tests->{$testname};
foreach my $targetname (sort(keys %$v0)) {
my $v1 = $v0->{$targetname};
$targeth->{$targetname} = 1;
foreach my $formatname (sort(keys %$v1)) {
$formath->{$formatname} = 1;
}
}
}
my @targets = sort(keys %$targeth);
my @formats = sort(keys %$formath);
sub printl {
print @_, "\n";
}
printl '<html><head>';
printl '<title>Cairo Test Results</title>';
printl '<style type="text/css">';
printl '.PASS { border: 2px solid #009900; background-color: #999999; }';
printl '.FAIL { background-color: #990000; }';
printl '.XFAIL { background-color: #999900; }';
printl '.UNTESTED { background-color: #333333; }';
printl 'img { max-width: 15em; min-width: 3em; }';
printl 'td { vertical-align: top; }';
printl '</style>';
printl '<body>';
printl '<table border="1">';
print '<tr><th>Test</th><th>Ref</th>';
foreach my $target (@targets) {
print '<th>', $target, '</th>';
}
printl '</tr>';
print '<tr><td></td><td></td>';
foreach my $target (@targets) {
print '<td>';
print 'PASS: ', $teststats->{$target}->{"PASS"}, '<br>';
print 'FAIL: ', $teststats->{$target}->{"FAIL"}, '<br>';
print 'XFAIL: ', $teststats->{$target}->{"XFAIL"}, '<br>';
print 'UNTESTED: ', $teststats->{$target}->{"UNTESTED"};
print '</td>';
}
printl '</tr>';
sub testref {
my ($test, $format, $rest) = @_;
my $fmtstr = "";
if ($format eq "rgb24") {
$fmtstr = "-rgb24";
}
return "$test$fmtstr-ref.png";
}
sub testfiles {
my ($test, $target, $format, $rest) = @_;
my $fmtstr = "";
if ($format eq "rgb24") {
$fmtstr = "-rgb24";
} elsif ($format eq "argb32") {
$fmtstr = "-argb32";
}
return ("out" => "$test-$target$fmtstr-out.png",
"diff" => "$test-$target$fmtstr-diff.png");
}
foreach my $test (sort(keys %$tests)) {
foreach my $format (@formats) {
print '<tr><td>', $test, ' (', $format, ')</td>';
my $testref = testref($test, $format);
print "<td><img src=\"$testref\"></td>";
foreach my $target (@targets) {
my $tgtdata = $tests->{$test}->{$target};
if ($tgtdata) {
my $testres = $tgtdata->{$format};
if ($testres) {
my %testfiles = testfiles($test, $target, $format);
print "<td class=\"$testres\">";
$stats{$target}{$testres}++;
if ($testres eq "PASS") {
print "<img src=\"", $testfiles{"out"}, "\"></td>";
} elsif ($testres eq "FAIL" || $testres eq "XFAIL") {
print "<img src=\"", $testfiles{"out"}, "\"><br><hr size=\"1\">";
print "<img src=\"", $testfiles{"diff"}, "\">";
}
print "</td>";
} else {
print '<td></td>';
}
} else {
print '<td></td>';
}
}
print "</tr>\n";
}
}
print "</table></body></html>\n";