diff options
Diffstat (limited to 'libs/cairo-1.16.0/test/cairo-test.c')
| -rw-r--r-- | libs/cairo-1.16.0/test/cairo-test.c | 1812 |
1 files changed, 1812 insertions, 0 deletions
diff --git a/libs/cairo-1.16.0/test/cairo-test.c b/libs/cairo-1.16.0/test/cairo-test.c new file mode 100644 index 0000000..d93468b --- /dev/null +++ b/libs/cairo-1.16.0/test/cairo-test.c @@ -0,0 +1,1812 @@ +/* + * Copyright © 2004 Red Hat, Inc. + * Copyright © 2008 Chris Wilson + * + * 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> + * Chris Wilson <chris@chris-wilson.co.uk> + */ + +#define _GNU_SOURCE 1 /* for feenableexcept() et al */ + +#if HAVE_CONFIG_H +#include "config.h" +#endif + +#include <stdio.h> +#include <stdlib.h> +#include <stdarg.h> +#include <ctype.h> +#include <assert.h> +#if HAVE_UNISTD_H +#include <unistd.h> +#endif +#include <errno.h> +#include <string.h> +#if HAVE_FCFINI +#include <fontconfig/fontconfig.h> +#endif +#if CAIRO_HAS_REAL_PTHREAD +#include <pthread.h> +#endif +#if HAVE_SYS_STAT_H +#include <sys/stat.h> +#endif + +#if HAVE_VALGRIND +#include <valgrind.h> +#else +#define RUNNING_ON_VALGRIND 0 +#endif + +#if HAVE_MEMFAULT +#include <memfault.h> +#define MF(x) x +#else +#define MF(x) +#endif + +#include "cairo-test-private.h" + +#include "buffer-diff.h" + +#ifdef _MSC_VER +#include <crtdbg.h> +#include <direct.h> +#define F_OK 0 +#define HAVE_MKDIR 1 +#define mkdir _mkdir +#endif + +#ifndef FALSE +#define FALSE 0 +#endif +#ifndef TRUE +#define TRUE !FALSE +#endif + +#if ! HAVE_ALARM || ! defined(SIGALRM) +#define alarm(X); +#endif + +static const cairo_user_data_key_t _cairo_test_context_key; + +static void +_xunlink (const cairo_test_context_t *ctx, const char *pathname); + +static const char *fail_face = "", *xfail_face="", *normal_face = ""; +static cairo_bool_t print_fail_on_stdout; +static int cairo_test_timeout = 60; + +#define NUM_DEVICE_OFFSETS 2 +#define NUM_DEVICE_SCALE 2 + +cairo_bool_t +cairo_test_mkdir (const char *path) +{ +#if ! HAVE_MKDIR + return FALSE; +#elif HAVE_MKDIR == 1 + if (mkdir (path) == 0) + return TRUE; +#elif HAVE_MKDIR == 2 + if (mkdir (path, 0770) == 0) + return TRUE; +#else +#error Bad value for HAVE_MKDIR +#endif + + return errno == EEXIST; +} + +static char * +_cairo_test_fixup_name (const char *original) +{ + char *name, *s; + + s = name = xstrdup (original); + while ((s = strchr (s, '_')) != NULL) + *s++ = '-'; + + return name; +} + +char * +cairo_test_get_name (const cairo_test_t *test) +{ + return _cairo_test_fixup_name (test->name); +} + +static void +_cairo_test_init (cairo_test_context_t *ctx, + const cairo_test_context_t *parent, + const cairo_test_t *test, + const char *test_name, + const char *output) +{ + char *log_name; + + MF (MEMFAULT_DISABLE_FAULTS ()); + +#if HAVE_FEENABLEEXCEPT + feenableexcept (FE_DIVBYZERO | FE_INVALID | FE_OVERFLOW); +#endif + + ctx->test = test; + ctx->test_name = _cairo_test_fixup_name (test_name); + ctx->output = output; + + cairo_test_mkdir (ctx->output); + + ctx->malloc_failure = 0; +#if HAVE_MEMFAULT + if (getenv ("CAIRO_TEST_MALLOC_FAILURE")) + ctx->malloc_failure = atoi (getenv ("CAIRO_TEST_MALLOC_FAILURE")); + if (ctx->malloc_failure && ! RUNNING_ON_MEMFAULT ()) + ctx->malloc_failure = 0; +#endif + + ctx->timeout = cairo_test_timeout; + if (getenv ("CAIRO_TEST_TIMEOUT")) + ctx->timeout = atoi (getenv ("CAIRO_TEST_TIMEOUT")); + + xasprintf (&log_name, "%s/%s%s", ctx->output, ctx->test_name, CAIRO_TEST_LOG_SUFFIX); + _xunlink (NULL, log_name); + + ctx->log_file = fopen (log_name, "a"); + if (ctx->log_file == NULL) { + fprintf (stderr, "Error opening log file: %s\n", log_name); + ctx->log_file = stderr; + } + free (log_name); + + ctx->ref_name = NULL; + ctx->ref_image = NULL; + ctx->ref_image_flattened = NULL; + + if (parent != NULL) { + ctx->targets_to_test = parent->targets_to_test; + ctx->num_targets = parent->num_targets; + ctx->limited_targets = parent->limited_targets; + ctx->own_targets = FALSE; + + ctx->srcdir = parent->srcdir; + ctx->refdir = parent->refdir; + } else { + int tmp_num_targets; + cairo_bool_t tmp_limited_targets; + + ctx->targets_to_test = cairo_boilerplate_get_targets (&tmp_num_targets, &tmp_limited_targets); + ctx->num_targets = tmp_num_targets; + ctx->limited_targets = tmp_limited_targets; + ctx->own_targets = TRUE; + + ctx->srcdir = getenv ("srcdir"); + if (ctx->srcdir == NULL) + ctx->srcdir = "."; + + ctx->refdir = getenv ("CAIRO_REF_DIR"); + } + +#ifdef HAVE_UNISTD_H + if (*fail_face == '\0' && isatty (2)) { + fail_face = "\033[41;37;1m"; + xfail_face = "\033[43;37;1m"; + normal_face = "\033[m"; + if (isatty (1)) + print_fail_on_stdout = FALSE; + } +#endif + + printf ("\nTESTING %s\n", ctx->test_name); +} + +void +_cairo_test_context_init_for_test (cairo_test_context_t *ctx, + const cairo_test_context_t *parent, + const cairo_test_t *test) +{ + _cairo_test_init (ctx, parent, test, test->name, CAIRO_TEST_OUTPUT_DIR); +} + +void +cairo_test_init (cairo_test_context_t *ctx, + const char *test_name, + const char *output) +{ + _cairo_test_init (ctx, NULL, NULL, test_name, output); +} + +void +cairo_test_fini (cairo_test_context_t *ctx) +{ + if (ctx->log_file == NULL) + return; + + if (ctx->log_file != stderr) + fclose (ctx->log_file); + ctx->log_file = NULL; + + free (ctx->ref_name); + cairo_surface_destroy (ctx->ref_image); + cairo_surface_destroy (ctx->ref_image_flattened); + + if (ctx->test_name != NULL) + free ((char *) ctx->test_name); + + if (ctx->own_targets) + cairo_boilerplate_free_targets (ctx->targets_to_test); + + cairo_boilerplate_fini (); + + cairo_debug_reset_static_data (); +#if HAVE_FCFINI + FcFini (); +#endif +} + +void +cairo_test_logv (const cairo_test_context_t *ctx, + const char *fmt, va_list va) +{ + FILE *file = ctx && ctx->log_file ? ctx->log_file : stderr; + vfprintf (file, fmt, va); +} + +void +cairo_test_log (const cairo_test_context_t *ctx, const char *fmt, ...) +{ + va_list va; + + va_start (va, fmt); + cairo_test_logv (ctx, fmt, va); + va_end (va); +} + +static void +_xunlink (const cairo_test_context_t *ctx, const char *pathname) +{ + if (unlink (pathname) < 0 && errno != ENOENT) { + cairo_test_log (ctx, "Error: Cannot remove %s: %s\n", + pathname, strerror (errno)); + exit (1); + } +} + +char * +cairo_test_reference_filename (const cairo_test_context_t *ctx, + const char *base_name, + const char *test_name, + const char *target_name, + const char *base_target_name, + const char *format, + const char *suffix, + const char *extension) +{ + char *ref_name = NULL; + + /* First look for a previous build for comparison. */ + if (ctx->refdir != NULL && strcmp(suffix, CAIRO_TEST_REF_SUFFIX) == 0) { + xasprintf (&ref_name, "%s/%s" CAIRO_TEST_OUT_SUFFIX "%s", + ctx->refdir, + base_name, + extension); + if (access (ref_name, F_OK) != 0) + free (ref_name); + else + goto done; + } + + if (target_name != NULL) { + /* Next look for a target/format-specific reference image. */ + xasprintf (&ref_name, "%s/reference/%s.%s.%s%s%s", + ctx->srcdir, + test_name, + target_name, + format, + suffix, + extension); + if (access (ref_name, F_OK) != 0) + free (ref_name); + else + goto done; + + /* Next, look for target-specific reference image. */ + xasprintf (&ref_name, "%s/reference/%s.%s%s%s", + ctx->srcdir, + test_name, + target_name, + suffix, + extension); + if (access (ref_name, F_OK) != 0) + free (ref_name); + else + goto done; + } + + if (base_target_name != NULL) { + /* Next look for a base/format-specific reference image. */ + xasprintf (&ref_name, "%s/reference/%s.%s.%s%s%s", + ctx->srcdir, + test_name, + base_target_name, + format, + suffix, + extension); + if (access (ref_name, F_OK) != 0) + free (ref_name); + else + goto done; + + /* Next, look for base-specific reference image. */ + xasprintf (&ref_name, "%s/reference/%s.%s%s%s", + ctx->srcdir, + test_name, + base_target_name, + suffix, + extension); + if (access (ref_name, F_OK) != 0) + free (ref_name); + else + goto done; + } + + /* Next, look for format-specific reference image. */ + xasprintf (&ref_name, "%s/reference/%s.%s%s%s", + ctx->srcdir, + test_name, + format, + suffix, + extension); + if (access (ref_name, F_OK) != 0) + free (ref_name); + else + goto done; + + /* Finally, look for the standard reference image. */ + xasprintf (&ref_name, "%s/reference/%s%s%s", ctx->srcdir, + test_name, + suffix, + extension); + if (access (ref_name, F_OK) != 0) + free (ref_name); + else + goto done; + + ref_name = NULL; + +done: + return ref_name; +} + +cairo_test_similar_t +cairo_test_target_has_similar (const cairo_test_context_t *ctx, + const cairo_boilerplate_target_t *target) +{ + cairo_surface_t *surface; + cairo_test_similar_t has_similar; + cairo_t * cr; + cairo_surface_t *similar; + cairo_status_t status; + void *closure; + char *path; + + /* ignore image intermediate targets */ + if (target->expected_type == CAIRO_SURFACE_TYPE_IMAGE) + return DIRECT; + + if (getenv ("CAIRO_TEST_IGNORE_SIMILAR")) + return DIRECT; + + xasprintf (&path, "%s/%s", + cairo_test_mkdir (ctx->output) ? ctx->output : ".", + ctx->test_name); + + has_similar = DIRECT; + do { + do { + surface = (target->create_surface) (path, + target->content, + ctx->test->width, + ctx->test->height, + ctx->test->width* NUM_DEVICE_SCALE + 25 * NUM_DEVICE_OFFSETS, + ctx->test->height* NUM_DEVICE_SCALE + 25 * NUM_DEVICE_OFFSETS, + CAIRO_BOILERPLATE_MODE_TEST, + &closure); + if (surface == NULL) + goto out; + } while (cairo_test_malloc_failure (ctx, cairo_surface_status (surface))); + + if (cairo_surface_status (surface)) + goto out; + + cr = cairo_create (surface); + cairo_push_group_with_content (cr, + cairo_boilerplate_content (target->content)); + similar = cairo_get_group_target (cr); + status = cairo_surface_status (similar); + + if (cairo_surface_get_type (similar) == cairo_surface_get_type (surface)) + has_similar = SIMILAR; + else + has_similar = DIRECT; + + cairo_destroy (cr); + cairo_surface_destroy (surface); + + if (target->cleanup) + target->cleanup (closure); + } while (! has_similar && cairo_test_malloc_failure (ctx, status)); +out: + free (path); + + return has_similar; +} + +static cairo_surface_t * +_cairo_test_flatten_reference_image (cairo_test_context_t *ctx, + cairo_bool_t flatten) +{ + cairo_surface_t *surface; + cairo_t *cr; + + if (! flatten) + return ctx->ref_image; + + if (ctx->ref_image_flattened != NULL) + return ctx->ref_image_flattened; + + surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, + cairo_image_surface_get_width (ctx->ref_image), + cairo_image_surface_get_height (ctx->ref_image)); + cr = cairo_create (surface); + cairo_surface_destroy (surface); + + cairo_set_source_rgb (cr, 1, 1, 1); + cairo_paint (cr); + + cairo_set_source_surface (cr, ctx->ref_image, 0, 0); + cairo_paint (cr); + + surface = cairo_surface_reference (cairo_get_target (cr)); + cairo_destroy (cr); + + if (cairo_surface_status (surface) == CAIRO_STATUS_SUCCESS) + ctx->ref_image_flattened = surface; + return surface; +} + +cairo_surface_t * +cairo_test_get_reference_image (cairo_test_context_t *ctx, + const char *filename, + cairo_bool_t flatten) +{ + cairo_surface_t *surface; + + if (ctx->ref_name != NULL) { + if (strcmp (ctx->ref_name, filename) == 0) + return _cairo_test_flatten_reference_image (ctx, flatten); + + cairo_surface_destroy (ctx->ref_image); + ctx->ref_image = NULL; + + cairo_surface_destroy (ctx->ref_image_flattened); + ctx->ref_image_flattened = NULL; + + free (ctx->ref_name); + ctx->ref_name = NULL; + } + + surface = cairo_image_surface_create_from_png (filename); + if (cairo_surface_status (surface)) + return surface; + + ctx->ref_name = xstrdup (filename); + ctx->ref_image = surface; + return _cairo_test_flatten_reference_image (ctx, flatten); +} + +static cairo_bool_t +cairo_test_file_is_older (const char *filename, + char **ref_filenames, + int num_ref_filenames) +{ +#if HAVE_SYS_STAT_H + struct stat st; + + if (stat (filename, &st) < 0) + return FALSE; + + while (num_ref_filenames--) { + struct stat ref; + char *ref_filename = *ref_filenames++; + + if (ref_filename == NULL) + continue; + + if (stat (ref_filename++, &ref) < 0) + continue; + + if (st.st_mtime <= ref.st_mtime) + return TRUE; + } +#endif + + return FALSE; +} + +static cairo_bool_t +cairo_test_files_equal (const char *test_filename, + const char *pass_filename) +{ + FILE *test, *pass; + int t, p; + + if (test_filename == NULL || pass_filename == NULL) + return FALSE; + + test = fopen (test_filename, "rb"); + if (test == NULL) + return FALSE; + + pass = fopen (pass_filename, "rb"); + if (pass == NULL) { + fclose (test); + return FALSE; + } + + /* as simple as it gets */ + do { + t = getc (test); + p = getc (pass); + if (t != p) + break; + } while (t != EOF && p != EOF); + + fclose (pass); + fclose (test); + + return t == p; /* both EOF */ +} + +static cairo_bool_t +cairo_test_copy_file (const char *src_filename, + const char *dst_filename) +{ + FILE *src, *dst; + int c; + +#if HAVE_LINK + if (link (src_filename, dst_filename) == 0) + return TRUE; + + unlink (dst_filename); +#endif + + src = fopen (src_filename, "rb"); + if (src == NULL) + return FALSE; + + dst = fopen (dst_filename, "wb"); + if (dst == NULL) { + fclose (src); + return FALSE; + } + + /* as simple as it gets */ + while ((c = getc (src)) != EOF) + putc (c, dst); + + fclose (src); + fclose (dst); + + return TRUE; +} + +static cairo_test_status_t +cairo_test_for_target (cairo_test_context_t *ctx, + const cairo_boilerplate_target_t *target, + int dev_offset, + int dev_scale, + cairo_bool_t similar) +{ + cairo_test_status_t status; + cairo_surface_t *surface = NULL; + cairo_t *cr; + const char *empty_str = ""; + char *offset_str; + char *scale_str; + char *base_name, *base_path; + char *out_png_path; + char *ref_path = NULL, *ref_png_path, *cmp_png_path = NULL; + char *new_path = NULL, *new_png_path; + char *xfail_path = NULL, *xfail_png_path; + char *base_ref_png_path; + char *base_new_png_path; + char *base_xfail_png_path; + char *diff_png_path; + char *test_filename = NULL, *pass_filename = NULL, *fail_filename = NULL; + cairo_test_status_t ret; + cairo_content_t expected_content; + cairo_font_options_t *font_options; + const char *format; + cairo_bool_t have_output = FALSE; + cairo_bool_t have_result = FALSE; + void *closure; + double width, height; + cairo_bool_t have_output_dir; +#if HAVE_MEMFAULT + int malloc_failure_iterations = ctx->malloc_failure; + int last_fault_count = 0; +#endif + + /* Get the strings ready that we'll need. */ + format = cairo_boilerplate_content_name (target->content); + if (dev_offset) + xasprintf (&offset_str, ".%d", dev_offset); + else + offset_str = (char *) empty_str; + + if (dev_scale != 1) + xasprintf (&scale_str, ".x%d", dev_scale); + else + scale_str = (char *) empty_str; + + xasprintf (&base_name, "%s.%s.%s%s%s%s", + ctx->test_name, + target->name, + format, + similar ? ".similar" : "", + offset_str, + scale_str); + + if (offset_str != empty_str) + free (offset_str); + if (scale_str != empty_str) + free (scale_str); + + ref_png_path = cairo_test_reference_filename (ctx, + base_name, + ctx->test_name, + target->name, + target->basename, + format, + CAIRO_TEST_REF_SUFFIX, + CAIRO_TEST_PNG_EXTENSION); + new_png_path = cairo_test_reference_filename (ctx, + base_name, + ctx->test_name, + target->name, + target->basename, + format, + CAIRO_TEST_NEW_SUFFIX, + CAIRO_TEST_PNG_EXTENSION); + xfail_png_path = cairo_test_reference_filename (ctx, + base_name, + ctx->test_name, + target->name, + target->basename, + format, + CAIRO_TEST_XFAIL_SUFFIX, + CAIRO_TEST_PNG_EXTENSION); + + base_ref_png_path = cairo_test_reference_filename (ctx, + base_name, + ctx->test_name, + NULL, NULL, + format, + CAIRO_TEST_REF_SUFFIX, + CAIRO_TEST_PNG_EXTENSION); + base_new_png_path = cairo_test_reference_filename (ctx, + base_name, + ctx->test_name, + NULL, NULL, + format, + CAIRO_TEST_NEW_SUFFIX, + CAIRO_TEST_PNG_EXTENSION); + base_xfail_png_path = cairo_test_reference_filename (ctx, + base_name, + ctx->test_name, + NULL, NULL, + format, + CAIRO_TEST_XFAIL_SUFFIX, + CAIRO_TEST_PNG_EXTENSION); + + if (target->file_extension != NULL) { + ref_path = cairo_test_reference_filename (ctx, + base_name, + ctx->test_name, + target->name, + target->basename, + format, + CAIRO_TEST_REF_SUFFIX, + target->file_extension); + new_path = cairo_test_reference_filename (ctx, + base_name, + ctx->test_name, + target->name, + target->basename, + format, + CAIRO_TEST_NEW_SUFFIX, + target->file_extension); + xfail_path = cairo_test_reference_filename (ctx, + base_name, + ctx->test_name, + target->name, + target->basename, + format, + CAIRO_TEST_XFAIL_SUFFIX, + target->file_extension); + } + + have_output_dir = cairo_test_mkdir (ctx->output); + xasprintf (&base_path, "%s/%s", + have_output_dir ? ctx->output : ".", + base_name); + xasprintf (&out_png_path, "%s" CAIRO_TEST_OUT_PNG, base_path); + xasprintf (&diff_png_path, "%s" CAIRO_TEST_DIFF_PNG, base_path); + + if (ctx->test->requirements != NULL) { + const char *required; + + required = target->is_vector ? "target=raster" : "target=vector"; + if (strstr (ctx->test->requirements, required) != NULL) { + cairo_test_log (ctx, "Error: Skipping for %s target %s\n", + target->is_vector ? "vector" : "raster", + target->name); + ret = CAIRO_TEST_UNTESTED; + goto UNWIND_STRINGS; + } + + required = target->is_recording ? "target=!recording" : "target=recording"; + if (strstr (ctx->test->requirements, required) != NULL) { + cairo_test_log (ctx, "Error: Skipping for %s target %s\n", + target->is_recording ? "recording" : "non-recording", + target->name); + ret = CAIRO_TEST_UNTESTED; + goto UNWIND_STRINGS; + } + } + + width = ctx->test->width; + height = ctx->test->height; + if (width && height) { + width *= dev_scale; + height *= dev_scale; + width += dev_offset; + height += dev_offset; + } + +#if HAVE_MEMFAULT +REPEAT: + MEMFAULT_CLEAR_FAULTS (); + MEMFAULT_RESET_LEAKS (); + ctx->last_fault_count = 0; + last_fault_count = MEMFAULT_COUNT_FAULTS (); + + /* Pre-initialise fontconfig so that the configuration is loaded without + * malloc failures (our primary goal is to test cairo fault tolerance). + */ +#if HAVE_FCINIT + FcInit (); +#endif + + MEMFAULT_ENABLE_FAULTS (); +#endif + have_output = FALSE; + have_result = FALSE; + + /* Run the actual drawing code. */ + ret = CAIRO_TEST_SUCCESS; + surface = (target->create_surface) (base_path, + target->content, + width, height, + ctx->test->width * NUM_DEVICE_SCALE + 25 * NUM_DEVICE_OFFSETS, + ctx->test->height * NUM_DEVICE_SCALE + 25 * NUM_DEVICE_OFFSETS, + CAIRO_BOILERPLATE_MODE_TEST, + &closure); + if (surface == NULL) { + cairo_test_log (ctx, "Error: Failed to set %s target\n", target->name); + ret = CAIRO_TEST_UNTESTED; + goto UNWIND_STRINGS; + } + +#if HAVE_MEMFAULT + if (ctx->malloc_failure && + MEMFAULT_COUNT_FAULTS () - last_fault_count > 0 && + cairo_surface_status (surface) == CAIRO_STATUS_NO_MEMORY) + { + goto REPEAT; + } +#endif + + if (cairo_surface_status (surface)) { + MF (MEMFAULT_PRINT_FAULTS ()); + cairo_test_log (ctx, "Error: Created an error surface: %s\n", + cairo_status_to_string (cairo_surface_status (surface))); + ret = CAIRO_TEST_FAILURE; + goto UNWIND_STRINGS; + } + + /* Check that we created a surface of the expected type. */ + if (cairo_surface_get_type (surface) != target->expected_type) { + MF (MEMFAULT_PRINT_FAULTS ()); + cairo_test_log (ctx, "Error: Created surface is of type %d (expected %d)\n", + cairo_surface_get_type (surface), target->expected_type); + ret = CAIRO_TEST_UNTESTED; + goto UNWIND_SURFACE; + } + + /* Check that we created a surface of the expected content, + * (ignore the artificial CAIRO_TEST_CONTENT_COLOR_ALPHA_FLATTENED value). + */ + expected_content = cairo_boilerplate_content (target->content); + + if (cairo_surface_get_content (surface) != expected_content) { + MF (MEMFAULT_PRINT_FAULTS ()); + cairo_test_log (ctx, "Error: Created surface has content %d (expected %d)\n", + cairo_surface_get_content (surface), expected_content); + ret = CAIRO_TEST_FAILURE; + goto UNWIND_SURFACE; + } + + if (cairo_surface_set_user_data (surface, + &cairo_boilerplate_output_basename_key, + base_path, + NULL)) + { +#if HAVE_MEMFAULT + cairo_surface_destroy (surface); + + if (target->cleanup) + target->cleanup (closure); + + goto REPEAT; +#else + ret = CAIRO_TEST_FAILURE; + goto UNWIND_SURFACE; +#endif + } + + cairo_surface_set_device_offset (surface, dev_offset, dev_offset); + cairo_surface_set_device_scale (surface, dev_scale, dev_scale); + + cr = cairo_create (surface); + if (cairo_set_user_data (cr, &_cairo_test_context_key, (void*) ctx, NULL)) { +#if HAVE_MEMFAULT + cairo_destroy (cr); + cairo_surface_destroy (surface); + + if (target->cleanup) + target->cleanup (closure); + + goto REPEAT; +#else + ret = CAIRO_TEST_FAILURE; + goto UNWIND_CAIRO; +#endif + } + + if (similar) + cairo_push_group_with_content (cr, expected_content); + + /* Clear to transparent (or black) depending on whether the target + * surface supports alpha. */ + cairo_save (cr); + cairo_set_operator (cr, CAIRO_OPERATOR_CLEAR); + cairo_paint (cr); + cairo_restore (cr); + + cairo_select_font_face (cr, CAIRO_TEST_FONT_FAMILY " Sans", + CAIRO_FONT_SLANT_NORMAL, + CAIRO_FONT_WEIGHT_NORMAL); + + /* Set all components of font_options to avoid backend differences + * and reduce number of needed reference images. */ + font_options = cairo_font_options_create (); + cairo_font_options_set_hint_style (font_options, CAIRO_HINT_STYLE_NONE); + cairo_font_options_set_hint_metrics (font_options, CAIRO_HINT_METRICS_ON); + cairo_font_options_set_antialias (font_options, CAIRO_ANTIALIAS_GRAY); + cairo_set_font_options (cr, font_options); + cairo_font_options_destroy (font_options); + + cairo_save (cr); + alarm (ctx->timeout); + status = (ctx->test->draw) (cr, ctx->test->width, ctx->test->height); + alarm (0); + cairo_restore (cr); + + if (similar) { + cairo_pop_group_to_source (cr); + cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE); + cairo_paint (cr); + } + +#if HAVE_MEMFAULT + MEMFAULT_DISABLE_FAULTS (); + + /* repeat test after malloc failure injection */ + if (ctx->malloc_failure && + MEMFAULT_COUNT_FAULTS () - last_fault_count > 0 && + (status == CAIRO_TEST_NO_MEMORY || + cairo_status (cr) == CAIRO_STATUS_NO_MEMORY || + cairo_surface_status (surface) == CAIRO_STATUS_NO_MEMORY)) + { + cairo_destroy (cr); + cairo_surface_destroy (surface); + if (target->cleanup) + target->cleanup (closure); + cairo_debug_reset_static_data (); +#if HAVE_FCFINI + FcFini (); +#endif + if (MEMFAULT_COUNT_LEAKS () > 0) { + MEMFAULT_PRINT_FAULTS (); + MEMFAULT_PRINT_LEAKS (); + } + + goto REPEAT; + } +#endif + + /* Then, check all the different ways it could fail. */ + if (status) { + cairo_test_log (ctx, "Error: Function under test failed\n"); + ret = status; + goto UNWIND_CAIRO; + } + +#if HAVE_MEMFAULT + if (MEMFAULT_COUNT_FAULTS () - last_fault_count > 0 && + MEMFAULT_HAS_FAULTS ()) + { + VALGRIND_PRINTF ("Unreported memfaults..."); + MEMFAULT_PRINT_FAULTS (); + } +#endif + + if (target->finish_surface != NULL) { +#if HAVE_MEMFAULT + /* We need to re-enable faults as most recording-surface processing + * is done during cairo_surface_finish(). + */ + MEMFAULT_CLEAR_FAULTS (); + last_fault_count = MEMFAULT_COUNT_FAULTS (); + MEMFAULT_ENABLE_FAULTS (); +#endif + + /* also check for infinite loops whilst replaying */ + alarm (ctx->timeout); + status = target->finish_surface (surface); + alarm (0); + +#if HAVE_MEMFAULT + MEMFAULT_DISABLE_FAULTS (); + + if (ctx->malloc_failure && + MEMFAULT_COUNT_FAULTS () - last_fault_count > 0 && + status == CAIRO_STATUS_NO_MEMORY) + { + cairo_destroy (cr); + cairo_surface_destroy (surface); + if (target->cleanup) + target->cleanup (closure); + cairo_debug_reset_static_data (); +#if HAVE_FCFINI + FcFini (); +#endif + if (MEMFAULT_COUNT_LEAKS () > 0) { + MEMFAULT_PRINT_FAULTS (); + MEMFAULT_PRINT_LEAKS (); + } + + goto REPEAT; + } +#endif + if (status) { + cairo_test_log (ctx, "Error: Failed to finish surface: %s\n", + cairo_status_to_string (status)); + ret = CAIRO_TEST_FAILURE; + goto UNWIND_CAIRO; + } + } + + /* Skip image check for tests with no image (width,height == 0,0) */ + if (ctx->test->width != 0 && ctx->test->height != 0) { + cairo_surface_t *ref_image; + cairo_surface_t *test_image; + cairo_surface_t *diff_image; + buffer_diff_result_t result; + cairo_status_t diff_status; + + if (ref_png_path == NULL) { + cairo_test_log (ctx, "Error: Cannot find reference image for %s\n", + base_name); + + /* we may be running this test to generate reference images */ + _xunlink (ctx, out_png_path); + /* be more generous as we may need to use external renderers */ + alarm (4 * ctx->timeout); + test_image = target->get_image_surface (surface, 0, + ctx->test->width, + ctx->test->height); + alarm (0); + diff_status = cairo_surface_write_to_png (test_image, out_png_path); + cairo_surface_destroy (test_image); + if (diff_status) { + if (cairo_surface_status (test_image) == CAIRO_STATUS_INVALID_STATUS) + ret = CAIRO_TEST_CRASHED; + else + ret = CAIRO_TEST_FAILURE; + cairo_test_log (ctx, + "Error: Failed to write output image: %s\n", + cairo_status_to_string (diff_status)); + } + have_output = TRUE; + + ret = CAIRO_TEST_XFAILURE; + goto UNWIND_CAIRO; + } + + if (target->file_extension != NULL) { /* compare vector surfaces */ + char *filenames[] = { + ref_png_path, + ref_path, + new_png_path, + new_path, + xfail_png_path, + xfail_path, + base_ref_png_path, + base_new_png_path, + base_xfail_png_path, + }; + + xasprintf (&test_filename, "%s.out%s", + base_path, target->file_extension); + xasprintf (&pass_filename, "%s.pass%s", + base_path, target->file_extension); + xasprintf (&fail_filename, "%s.fail%s", + base_path, target->file_extension); + + if (cairo_test_file_is_older (pass_filename, + filenames, + ARRAY_LENGTH (filenames))) + { + _xunlink (ctx, pass_filename); + } + if (cairo_test_file_is_older (fail_filename, + filenames, + ARRAY_LENGTH (filenames))) + { + _xunlink (ctx, fail_filename); + } + + if (cairo_test_files_equal (out_png_path, ref_path)) { + cairo_test_log (ctx, "Vector surface matches reference.\n"); + have_output = FALSE; + ret = CAIRO_TEST_SUCCESS; + goto UNWIND_CAIRO; + } + if (cairo_test_files_equal (out_png_path, new_path)) { + cairo_test_log (ctx, "Vector surface matches current failure.\n"); + have_output = FALSE; + ret = CAIRO_TEST_NEW; + goto UNWIND_CAIRO; + } + if (cairo_test_files_equal (out_png_path, xfail_path)) { + cairo_test_log (ctx, "Vector surface matches known failure.\n"); + have_output = FALSE; + ret = CAIRO_TEST_XFAILURE; + goto UNWIND_CAIRO; + } + + if (cairo_test_files_equal (test_filename, pass_filename)) { + /* identical output as last known PASS */ + cairo_test_log (ctx, "Vector surface matches last pass.\n"); + have_output = TRUE; + ret = CAIRO_TEST_SUCCESS; + goto UNWIND_CAIRO; + } + if (cairo_test_files_equal (test_filename, fail_filename)) { + /* identical output as last known FAIL, fail */ + cairo_test_log (ctx, "Vector surface matches last fail.\n"); + have_result = TRUE; /* presume these were kept around as well */ + have_output = TRUE; + ret = CAIRO_TEST_FAILURE; + goto UNWIND_CAIRO; + } + } + + /* be more generous as we may need to use external renderers */ + alarm (4 * ctx->timeout); + test_image = target->get_image_surface (surface, 0, + ctx->test->width, + ctx->test->height); + alarm (0); + if (cairo_surface_status (test_image)) { + cairo_test_log (ctx, "Error: Failed to extract image: %s\n", + cairo_status_to_string (cairo_surface_status (test_image))); + if (cairo_surface_status (test_image) == CAIRO_STATUS_INVALID_STATUS) + ret = CAIRO_TEST_CRASHED; + else + ret = CAIRO_TEST_FAILURE; + cairo_surface_destroy (test_image); + goto UNWIND_CAIRO; + } + + _xunlink (ctx, out_png_path); + diff_status = cairo_surface_write_to_png (test_image, out_png_path); + if (diff_status) { + cairo_test_log (ctx, "Error: Failed to write output image: %s\n", + cairo_status_to_string (diff_status)); + cairo_surface_destroy (test_image); + ret = CAIRO_TEST_FAILURE; + goto UNWIND_CAIRO; + } + have_output = TRUE; + + /* binary compare png files (no decompression) */ + if (target->file_extension == NULL) { + char *filenames[] = { + ref_png_path, + new_png_path, + xfail_png_path, + base_ref_png_path, + base_new_png_path, + base_xfail_png_path, + }; + + xasprintf (&test_filename, "%s", out_png_path); + xasprintf (&pass_filename, "%s.pass.png", base_path); + xasprintf (&fail_filename, "%s.fail.png", base_path); + + if (cairo_test_file_is_older (pass_filename, + filenames, + ARRAY_LENGTH (filenames))) + { + _xunlink (ctx, pass_filename); + } + if (cairo_test_file_is_older (fail_filename, + filenames, + ARRAY_LENGTH (filenames))) + { + _xunlink (ctx, fail_filename); + } + + if (cairo_test_files_equal (test_filename, pass_filename)) { + cairo_test_log (ctx, "PNG file exactly matches last pass.\n"); + have_result = TRUE; + cairo_surface_destroy (test_image); + ret = CAIRO_TEST_SUCCESS; + goto UNWIND_CAIRO; + } + if (cairo_test_files_equal (out_png_path, ref_png_path)) { + cairo_test_log (ctx, "PNG file exactly matches reference image.\n"); + have_result = TRUE; + cairo_surface_destroy (test_image); + ret = CAIRO_TEST_SUCCESS; + goto UNWIND_CAIRO; + } + if (cairo_test_files_equal (out_png_path, new_png_path)) { + cairo_test_log (ctx, "PNG file exactly matches current failure image.\n"); + have_result = TRUE; + cairo_surface_destroy (test_image); + ret = CAIRO_TEST_NEW; + goto UNWIND_CAIRO; + } + if (cairo_test_files_equal (out_png_path, xfail_png_path)) { + cairo_test_log (ctx, "PNG file exactly matches known failure image.\n"); + have_result = TRUE; + cairo_surface_destroy (test_image); + ret = CAIRO_TEST_XFAILURE; + goto UNWIND_CAIRO; + } + if (cairo_test_files_equal (test_filename, fail_filename)) { + cairo_test_log (ctx, "PNG file exactly matches last fail.\n"); + have_result = TRUE; /* presume these were kept around as well */ + cairo_surface_destroy (test_image); + ret = CAIRO_TEST_FAILURE; + goto UNWIND_CAIRO; + } + } else { + if (cairo_test_files_equal (out_png_path, ref_png_path)) { + cairo_test_log (ctx, "PNG file exactly matches reference image.\n"); + have_result = TRUE; + cairo_surface_destroy (test_image); + ret = CAIRO_TEST_SUCCESS; + goto UNWIND_CAIRO; + } + if (cairo_test_files_equal (out_png_path, new_png_path)) { + cairo_test_log (ctx, "PNG file exactly matches current failure image.\n"); + have_result = TRUE; + cairo_surface_destroy (test_image); + ret = CAIRO_TEST_NEW; + goto UNWIND_CAIRO; + } + if (cairo_test_files_equal (out_png_path, xfail_png_path)) { + cairo_test_log (ctx, "PNG file exactly matches known failure image.\n"); + have_result = TRUE; + cairo_surface_destroy (test_image); + ret = CAIRO_TEST_XFAILURE; + goto UNWIND_CAIRO; + } + } + + if (cairo_test_files_equal (out_png_path, base_ref_png_path)) { + cairo_test_log (ctx, "PNG file exactly reference image.\n"); + have_result = TRUE; + cairo_surface_destroy (test_image); + ret = CAIRO_TEST_SUCCESS; + goto UNWIND_CAIRO; + } + if (cairo_test_files_equal (out_png_path, base_new_png_path)) { + cairo_test_log (ctx, "PNG file exactly current failure image.\n"); + have_result = TRUE; + cairo_surface_destroy (test_image); + ret = CAIRO_TEST_NEW; + goto UNWIND_CAIRO; + } + if (cairo_test_files_equal (out_png_path, base_xfail_png_path)) { + cairo_test_log (ctx, "PNG file exactly known failure image.\n"); + have_result = TRUE; + cairo_surface_destroy (test_image); + ret = CAIRO_TEST_XFAILURE; + goto UNWIND_CAIRO; + } + + /* first compare against the ideal reference */ + ref_image = cairo_test_get_reference_image (ctx, base_ref_png_path, + target->content == CAIRO_TEST_CONTENT_COLOR_ALPHA_FLATTENED); + if (cairo_surface_status (ref_image)) { + cairo_test_log (ctx, "Error: Cannot open reference image for %s: %s\n", + base_ref_png_path, + cairo_status_to_string (cairo_surface_status (ref_image))); + cairo_surface_destroy (test_image); + ret = CAIRO_TEST_FAILURE; + goto UNWIND_CAIRO; + } + + diff_image = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, + ctx->test->width, + ctx->test->height); + + cmp_png_path = base_ref_png_path; + diff_status = image_diff (ctx, + test_image, ref_image, diff_image, + &result); + _xunlink (ctx, diff_png_path); + if (diff_status || + image_diff_is_failure (&result, target->error_tolerance)) + { + /* that failed, so check against the specific backend */ + ref_image = cairo_test_get_reference_image (ctx, ref_png_path, + target->content == CAIRO_TEST_CONTENT_COLOR_ALPHA_FLATTENED); + if (cairo_surface_status (ref_image)) { + cairo_test_log (ctx, "Error: Cannot open reference image for %s: %s\n", + ref_png_path, + cairo_status_to_string (cairo_surface_status (ref_image))); + cairo_surface_destroy (test_image); + ret = CAIRO_TEST_FAILURE; + goto UNWIND_CAIRO; + } + + cmp_png_path = ref_png_path; + diff_status = image_diff (ctx, + test_image, ref_image, + diff_image, + &result); + if (diff_status) + { + cairo_test_log (ctx, "Error: Failed to compare images: %s\n", + cairo_status_to_string (diff_status)); + ret = CAIRO_TEST_FAILURE; + } + else if (image_diff_is_failure (&result, target->error_tolerance)) + { + ret = CAIRO_TEST_FAILURE; + + diff_status = cairo_surface_write_to_png (diff_image, + diff_png_path); + if (diff_status) { + cairo_test_log (ctx, "Error: Failed to write differences image: %s\n", + cairo_status_to_string (diff_status)); + } else { + have_result = TRUE; + } + + cairo_test_copy_file (test_filename, fail_filename); + } + else + { /* success */ + cairo_test_copy_file (test_filename, pass_filename); + } + } + else + { /* success */ + cairo_test_copy_file (test_filename, pass_filename); + } + + /* If failed, compare against the current image output, + * and attempt to detect systematic failures. + */ + if (ret == CAIRO_TEST_FAILURE) { + char *image_out_path; + + image_out_path = + cairo_test_reference_filename (ctx, + base_name, + ctx->test_name, + "image", + "image", + format, + CAIRO_TEST_OUT_SUFFIX, + CAIRO_TEST_PNG_EXTENSION); + if (image_out_path != NULL) { + if (cairo_test_files_equal (out_png_path, + image_out_path)) + { + ret = CAIRO_TEST_XFAILURE; + } + else + { + ref_image = + cairo_image_surface_create_from_png (image_out_path); + if (cairo_surface_status (ref_image) == CAIRO_STATUS_SUCCESS) + { + diff_status = image_diff (ctx, + test_image, ref_image, + diff_image, + &result); + if (diff_status == CAIRO_STATUS_SUCCESS && + !image_diff_is_failure (&result, target->error_tolerance)) + { + ret = CAIRO_TEST_XFAILURE; + } + + cairo_surface_destroy (ref_image); + } + } + + free (image_out_path); + } + } + + cairo_surface_destroy (test_image); + cairo_surface_destroy (diff_image); + } + + if (cairo_status (cr) != CAIRO_STATUS_SUCCESS) { + cairo_test_log (ctx, "Error: Function under test left cairo status in an error state: %s\n", + cairo_status_to_string (cairo_status (cr))); + ret = CAIRO_TEST_ERROR; + goto UNWIND_CAIRO; + } + +UNWIND_CAIRO: + free (test_filename); + free (fail_filename); + free (pass_filename); + + test_filename = fail_filename = pass_filename = NULL; + +#if HAVE_MEMFAULT + if (ret == CAIRO_TEST_FAILURE) + MEMFAULT_PRINT_FAULTS (); +#endif + cairo_destroy (cr); +UNWIND_SURFACE: + cairo_surface_destroy (surface); + + if (target->cleanup) + target->cleanup (closure); + +#if HAVE_MEMFAULT + cairo_debug_reset_static_data (); + +#if HAVE_FCFINI + FcFini (); +#endif + + if (MEMFAULT_COUNT_LEAKS () > 0) { + if (ret != CAIRO_TEST_FAILURE) + MEMFAULT_PRINT_FAULTS (); + MEMFAULT_PRINT_LEAKS (); + } + + if (ret == CAIRO_TEST_SUCCESS && --malloc_failure_iterations > 0) + goto REPEAT; +#endif + + if (have_output) + cairo_test_log (ctx, "OUTPUT: %s\n", out_png_path); + + if (have_result) { + if (cmp_png_path == NULL) { + /* XXX presume we matched the normal ref last time */ + cmp_png_path = ref_png_path; + } + cairo_test_log (ctx, + "REFERENCE: %s\nDIFFERENCE: %s\n", + cmp_png_path, diff_png_path); + } + +UNWIND_STRINGS: + free (out_png_path); + free (ref_png_path); + free (base_ref_png_path); + free (ref_path); + free (new_png_path); + free (base_new_png_path); + free (new_path); + free (xfail_png_path); + free (base_xfail_png_path); + free (xfail_path); + free (diff_png_path); + free (base_path); + free (base_name); + + return ret; +} + +#if defined(HAVE_SIGNAL_H) && defined(HAVE_SETJMP_H) +#include <signal.h> +#include <setjmp.h> +/* Used to catch crashes in a test, so that we report it as such and + * continue testing, although one crasher may already have corrupted memory in + * an nonrecoverable fashion. */ +static jmp_buf jmpbuf; + +static void +segfault_handler (int signal) +{ + longjmp (jmpbuf, signal); +} +#endif + +cairo_test_status_t +_cairo_test_context_run_for_target (cairo_test_context_t *ctx, + const cairo_boilerplate_target_t *target, + cairo_bool_t similar, + int dev_offset, int dev_scale) +{ + cairo_test_status_t status; + + if (target->get_image_surface == NULL) + return CAIRO_TEST_UNTESTED; + + if (similar && ! cairo_test_target_has_similar (ctx, target)) + return CAIRO_TEST_UNTESTED; + + cairo_test_log (ctx, + "Testing %s with %s%s target (dev offset %d scale: %d)\n", + ctx->test_name, + similar ? " (similar) " : "", + target->name, + dev_offset, dev_scale); + + printf ("%s.%s.%s [%dx%d]%s:\t", ctx->test_name, target->name, + cairo_boilerplate_content_name (target->content), + dev_offset, dev_scale, + similar ? " (similar)": ""); + fflush (stdout); + +#if defined(HAVE_SIGNAL_H) && defined(HAVE_SETJMP_H) + if (! RUNNING_ON_VALGRIND) { + void (* volatile old_segfault_handler)(int); + void (* volatile old_segfpe_handler)(int); + void (* volatile old_sigpipe_handler)(int); + void (* volatile old_sigabrt_handler)(int); + void (* volatile old_sigalrm_handler)(int); + + /* Set up a checkpoint to get back to in case of segfaults. */ +#ifdef SIGSEGV + old_segfault_handler = signal (SIGSEGV, segfault_handler); +#endif +#ifdef SIGFPE + old_segfpe_handler = signal (SIGFPE, segfault_handler); +#endif +#ifdef SIGPIPE + old_sigpipe_handler = signal (SIGPIPE, segfault_handler); +#endif +#ifdef SIGABRT + old_sigabrt_handler = signal (SIGABRT, segfault_handler); +#endif +#ifdef SIGALRM + old_sigalrm_handler = signal (SIGALRM, segfault_handler); +#endif + if (0 == setjmp (jmpbuf)) + status = cairo_test_for_target (ctx, target, dev_offset, dev_scale, similar); + else + status = CAIRO_TEST_CRASHED; +#ifdef SIGSEGV + signal (SIGSEGV, old_segfault_handler); +#endif +#ifdef SIGFPE + signal (SIGFPE, old_segfpe_handler); +#endif +#ifdef SIGPIPE + signal (SIGPIPE, old_sigpipe_handler); +#endif +#ifdef SIGABRT + signal (SIGABRT, old_sigabrt_handler); +#endif +#ifdef SIGALRM + signal (SIGALRM, old_sigalrm_handler); +#endif + } else { + status = cairo_test_for_target (ctx, target, dev_offset, dev_scale, similar); + } +#else + status = cairo_test_for_target (ctx, target, dev_offset, dev_scale, similar); +#endif + + cairo_test_log (ctx, + "TEST: %s TARGET: %s FORMAT: %s OFFSET: %d SCALE: %d SIMILAR: %d RESULT: ", + ctx->test_name, target->name, + cairo_boilerplate_content_name (target->content), + dev_offset, dev_scale, similar); + switch (status) { + case CAIRO_TEST_SUCCESS: + printf ("PASS\n"); + cairo_test_log (ctx, "PASS\n"); + break; + + case CAIRO_TEST_UNTESTED: + printf ("UNTESTED\n"); + cairo_test_log (ctx, "UNTESTED\n"); + break; + + default: + case CAIRO_TEST_CRASHED: + if (print_fail_on_stdout) { + printf ("!!!CRASHED!!!\n"); + } else { + /* eat the test name */ + printf ("\r"); + fflush (stdout); + } + cairo_test_log (ctx, "CRASHED\n"); + fprintf (stderr, "%s.%s.%s [%dx%d]%s:\t%s!!!CRASHED!!!%s\n", + ctx->test_name, target->name, + cairo_boilerplate_content_name (target->content), dev_offset, dev_scale, similar ? " (similar)" : "", + fail_face, normal_face); + break; + + case CAIRO_TEST_ERROR: + if (print_fail_on_stdout) { + printf ("!!!ERROR!!!\n"); + } else { + /* eat the test name */ + printf ("\r"); + fflush (stdout); + } + cairo_test_log (ctx, "ERROR\n"); + fprintf (stderr, "%s.%s.%s [%dx%d]%s:\t%s!!!ERROR!!!%s\n", + ctx->test_name, target->name, + cairo_boilerplate_content_name (target->content), dev_offset, dev_scale, similar ? " (similar)" : "", + fail_face, normal_face); + break; + + case CAIRO_TEST_XFAILURE: + if (print_fail_on_stdout) { + printf ("XFAIL\n"); + } else { + /* eat the test name */ + printf ("\r"); + fflush (stdout); + } + fprintf (stderr, "%s.%s.%s [%dx%d]%s:\t%sXFAIL%s\n", + ctx->test_name, target->name, + cairo_boilerplate_content_name (target->content), dev_offset, dev_scale, similar ? " (similar)" : "", + xfail_face, normal_face); + cairo_test_log (ctx, "XFAIL\n"); + break; + + case CAIRO_TEST_NEW: + if (print_fail_on_stdout) { + printf ("NEW\n"); + } else { + /* eat the test name */ + printf ("\r"); + fflush (stdout); + } + fprintf (stderr, "%s.%s.%s [%dx%d]%s:\t%sNEW%s\n", + ctx->test_name, target->name, + cairo_boilerplate_content_name (target->content), dev_offset, dev_scale, similar ? " (similar)" : "", + fail_face, normal_face); + cairo_test_log (ctx, "NEW\n"); + break; + + case CAIRO_TEST_NO_MEMORY: + case CAIRO_TEST_FAILURE: + if (print_fail_on_stdout) { + printf ("FAIL\n"); + } else { + /* eat the test name */ + printf ("\r"); + fflush (stdout); + } + fprintf (stderr, "%s.%s.%s [%dx%d]%s:\t%sFAIL%s\n", + ctx->test_name, target->name, + cairo_boilerplate_content_name (target->content), dev_offset, dev_scale, similar ? " (similar)" : "", + fail_face, normal_face); + cairo_test_log (ctx, "FAIL\n"); + break; + } + fflush (stdout); + + return status; +} + +const cairo_test_context_t * +cairo_test_get_context (cairo_t *cr) +{ + return cairo_get_user_data (cr, &_cairo_test_context_key); +} + +cairo_surface_t * +cairo_test_create_surface_from_png (const cairo_test_context_t *ctx, + const char *filename) +{ + cairo_surface_t *image; + cairo_status_t status; + char *unique_id; + + image = cairo_image_surface_create_from_png (filename); + status = cairo_surface_status (image); + if (status == CAIRO_STATUS_FILE_NOT_FOUND) { + /* expect not found when running with srcdir != builddir + * such as when 'make distcheck' is run + */ + if (ctx->srcdir) { + char *srcdir_filename; + xasprintf (&srcdir_filename, "%s/%s", ctx->srcdir, filename); + cairo_surface_destroy (image); + image = cairo_image_surface_create_from_png (srcdir_filename); + free (srcdir_filename); + } + } + unique_id = strdup(filename); + cairo_surface_set_mime_data (image, CAIRO_MIME_TYPE_UNIQUE_ID, + (unsigned char *)unique_id, strlen(unique_id), + free, unique_id); + + return image; +} + +cairo_pattern_t * +cairo_test_create_pattern_from_png (const cairo_test_context_t *ctx, + const char *filename) +{ + cairo_surface_t *image; + cairo_pattern_t *pattern; + + image = cairo_test_create_surface_from_png (ctx, filename); + + pattern = cairo_pattern_create_for_surface (image); + + cairo_pattern_set_extend (pattern, CAIRO_EXTEND_REPEAT); + + cairo_surface_destroy (image); + + return pattern; +} + +static cairo_surface_t * +_draw_check (int width, int height) +{ + cairo_surface_t *surface; + cairo_t *cr; + + surface = cairo_image_surface_create (CAIRO_FORMAT_RGB24, 12, 12); + cr = cairo_create (surface); + cairo_surface_destroy (surface); + + cairo_set_source_rgb (cr, 0.75, 0.75, 0.75); /* light gray */ + cairo_paint (cr); + + cairo_set_source_rgb (cr, 0.25, 0.25, 0.25); /* dark gray */ + cairo_rectangle (cr, width / 2, 0, width / 2, height / 2); + cairo_rectangle (cr, 0, height / 2, width / 2, height / 2); + cairo_fill (cr); + + surface = cairo_surface_reference (cairo_get_target (cr)); + cairo_destroy (cr); + + return surface; +} + +void +cairo_test_paint_checkered (cairo_t *cr) +{ + cairo_surface_t *check; + + check = _draw_check (12, 12); + + cairo_save (cr); + cairo_set_source_surface (cr, check, 0, 0); + cairo_surface_destroy (check); + + cairo_pattern_set_filter (cairo_get_source (cr), CAIRO_FILTER_NEAREST); + cairo_pattern_set_extend (cairo_get_source (cr), CAIRO_EXTEND_REPEAT); + cairo_paint (cr); + + cairo_restore (cr); +} + +cairo_bool_t +cairo_test_is_target_enabled (const cairo_test_context_t *ctx, + const char *target) +{ + size_t i; + + for (i = 0; i < ctx->num_targets; i++) { + const cairo_boilerplate_target_t *t = ctx->targets_to_test[i]; + if (strcmp (t->name, target) == 0) { + /* XXX ask the target whether is it possible to run? + * e.g. the xlib backend could check whether it is able to connect + * to the Display. + */ + return t->get_image_surface != NULL; + } + } + + return FALSE; +} + +cairo_bool_t +cairo_test_malloc_failure (const cairo_test_context_t *ctx, + cairo_status_t status) +{ + if (! ctx->malloc_failure) + return FALSE; + + if (status != CAIRO_STATUS_NO_MEMORY) + return FALSE; + +#if HAVE_MEMFAULT + { + int n_faults; + + /* prevent infinite loops... */ + n_faults = MEMFAULT_COUNT_FAULTS (); + if (n_faults == ctx->last_fault_count) + return FALSE; + + ((cairo_test_context_t *) ctx)->last_fault_count = n_faults; + } +#endif + + return TRUE; +} + +cairo_test_status_t +cairo_test_status_from_status (const cairo_test_context_t *ctx, + cairo_status_t status) +{ + if (status == CAIRO_STATUS_SUCCESS) + return CAIRO_TEST_SUCCESS; + + if (cairo_test_malloc_failure (ctx, status)) + return CAIRO_TEST_NO_MEMORY; + + return CAIRO_TEST_FAILURE; +} |