[cairo-commit] cairo/test Makefile.am, 1.102, 1.103 cairo-test.c,
1.65, 1.66 make-html.pl, NONE, 1.1
Vladimir Vukicevic
commit at pdx.freedesktop.org
Mon Dec 12 11:56:42 PST 2005
Committed by: vladimir
Update of /cvs/cairo/cairo/test
In directory gabe:/tmp/cvs-serv16497/test
Modified Files:
Makefile.am cairo-test.c
Added Files:
make-html.pl
Log Message:
2005-12-12 Vladimir Vukicevic <vladimir at 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 at 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.
Index: Makefile.am
===================================================================
RCS file: /cvs/cairo/cairo/test/Makefile.am,v
retrieving revision 1.102
retrieving revision 1.103
diff -u -d -r1.102 -r1.103
--- Makefile.am 8 Dec 2005 21:09:27 -0000 1.102
+++ Makefile.am 12 Dec 2005 19:56:40 -0000 1.103
@@ -254,6 +254,20 @@
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
Index: cairo-test.c
===================================================================
RCS file: /cvs/cairo/cairo/test/cairo-test.c,v
retrieving revision 1.65
retrieving revision 1.66
diff -u -d -r1.65 -r1.66
--- cairo-test.c 8 Dec 2005 00:06:12 -0000 1.65
+++ cairo-test.c 12 Dec 2005 19:56:40 -0000 1.66
@@ -197,21 +197,469 @@
free (buf);
}
-/* XXX: Someone who knows glitz better than I do should fix this up to
- * work. */
-#if 0 /* #ifdef CAIRO_HAS_GLITZ_SURFACE */
+#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)
+{
+ 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_glitz_surface (int width, int height, void **closure)
+create_cairo_glitz_glx_surface (cairo_test_t *test,
+ cairo_format_t format,
+ void **closure)
{
-#error Not yet implemented
+ 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 @@
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 @@
{ "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 @@
#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 @@
* -> 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 @@
fclose (cairo_test_log_file);
+ free (targets_to_test);
+
#if HAVE_FCFINI
FcFini ();
#endif
--- NEW FILE: make-html.pl ---
(This appears to be a binary file; contents omitted.)
More information about the cairo-commit
mailing list