static cairo_test_status_t
preamble (cairo_test_context_t *ctx)
{
cairo_t *cr;
const char *filename = "svg-clip.out.svg";
cairo_surface_t *surface;
if (! cairo_test_is_target_enabled (ctx, "svg11") &&
! cairo_test_is_target_enabled (ctx, "svg12"))
{
return CAIRO_TEST_UNTESTED;
}
surface = cairo_svg_surface_create (filename,
WIDTH_IN_POINTS, HEIGHT_IN_POINTS);
if (cairo_surface_status (surface)) {
cairo_test_log (ctx,
"Failed to create svg surface for file %s: %s\n",
filename, cairo_status_to_string (cairo_surface_status (surface)));
return CAIRO_TEST_FAILURE;
}
cr = cairo_create (surface);
test_clip (cr, WIDTH_IN_POINTS, HEIGHT_IN_POINTS);
cairo_show_page (cr);
cairo_destroy (cr);
cairo_surface_destroy (surface);
printf ("svg-clip: Please check %s to make sure it looks happy.\n",
filename);
return CAIRO_TEST_SUCCESS;
}
static cairo_test_status_t
preamble (cairo_test_context_t *ctx)
{
cairo_surface_t *surface;
cairo_t *cr;
cairo_status_t status;
size_t i;
char *filename;
const char *path = cairo_test_mkdir (CAIRO_TEST_OUTPUT_DIR) ? CAIRO_TEST_OUTPUT_DIR : ".";
if (! cairo_test_is_target_enabled (ctx, "pdf"))
return CAIRO_TEST_UNTESTED;
xasprintf (&filename, "%s/%s.pdf", path, BASENAME);
/* The initial size passed here is the default size that will be
* inheritable by each page. That is, any page for which this
* initial size applies will not have its own /MediaBox entry in
* its dictionary. */
surface = cairo_pdf_surface_create (filename,
INCHES_TO_POINTS(8.5),
INCHES_TO_POINTS(11));
cr = cairo_create (surface);
cairo_select_font_face (cr, CAIRO_TEST_FONT_FAMILY " Sans",
CAIRO_FONT_SLANT_NORMAL,
CAIRO_FONT_WEIGHT_NORMAL);
cairo_set_font_size (cr, TEXT_SIZE);
for (i = 0; i < ARRAY_LENGTH (pages); i++) {
cairo_pdf_surface_set_size (surface,
pages[i].width_in_points,
pages[i].height_in_points);
cairo_move_to (cr, TEXT_SIZE, TEXT_SIZE);
cairo_show_text (cr, pages[i].page_size);
cairo_show_text (cr, " - ");
cairo_show_text (cr, pages[i].orientation);
cairo_show_page (cr);
}
status = cairo_status (cr);
cairo_destroy (cr);
cairo_surface_destroy (surface);
free (filename);
if (status) {
cairo_test_log (ctx, "Failed to create pdf surface for file %s: %s\n",
filename, cairo_status_to_string (status));
return CAIRO_TEST_FAILURE;
}
printf ("pdf-features: Please check %s to ensure it looks/prints correctly.\n", filename);
return CAIRO_TEST_SUCCESS;
}
int
main (void)
{
cairo_test_context_t ctx;
cairo_t *cr;
const char *filename = "svg-surface.svg";
cairo_surface_t *surface;
cairo_test_init (&ctx, "svg-surface");
if (! (cairo_test_is_target_enabled (&ctx, "svg11") ||
cairo_test_is_target_enabled (&ctx, "svg12")))
{
cairo_test_fini (&ctx);
return CAIRO_TEST_UNTESTED;
}
surface = cairo_svg_surface_create (filename,
WIDTH_IN_POINTS, HEIGHT_IN_POINTS);
if (cairo_surface_status (surface)) {
cairo_test_log (&ctx,
"Failed to create svg surface for file %s: %s\n",
filename,
cairo_status_to_string (cairo_surface_status (surface)));
cairo_test_fini (&ctx);
return CAIRO_TEST_FAILURE;
}
cr = cairo_create (surface);
draw (cr, WIDTH_IN_POINTS, HEIGHT_IN_POINTS);
cairo_show_page (cr);
cairo_destroy (cr);
cairo_surface_destroy (surface);
printf ("svg-surface: Please check svg-surface.svg to make sure it looks happy.\n");
cairo_test_fini (&ctx);
return CAIRO_TEST_SUCCESS;
}
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,
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;
}
static cairo_test_status_t
preamble (cairo_test_context_t *ctx)
{
cairo_t *cr;
cairo_test_status_t ret = CAIRO_TEST_UNTESTED;
struct {
double x, y;
} ppi[] = {
{ 600, 600 },
{ 600, 72 },
{ 300, 300 },
{ 300, 72 },
{ 150, 150 },
{ 150, 72 },
{ 75, 75 },
{ 75, 72 },
{ 72, 600 },
{ 72, 300 },
{ 72, 150 },
{ 72, 75 },
{ 72, 72 },
{ 72, 37.5 },
{ 37.5, 72 },
{ 37.5, 37.5 },
};
unsigned int i;
int n, num_ppi;
num_ppi = sizeof (ppi) / sizeof (ppi[0]);
#if GENERATE_REFERENCE
for (n = 0; n < num_ppi; n++) {
char *ref_name;
xasprintf (&ref_name, "fallback-resolution.ppi%gx%g.ref.png",
ppi[n].x, ppi[n].y);
generate_reference (ppi[n].x, ppi[n].y, ref_name);
free (ref_name);
}
#endif
for (i = 0; i < ctx->num_targets; i++) {
const cairo_boilerplate_target_t *target = ctx->targets_to_test[i];
cairo_surface_t *surface = NULL;
char *base_name;
void *closure;
const char *format;
cairo_status_t status;
if (! target->is_vector)
continue;
if (! cairo_test_is_target_enabled (ctx, target->name))
continue;
format = cairo_boilerplate_content_name (target->content);
xasprintf (&base_name, "fallback-resolution.%s.%s",
target->name,
format);
surface = (target->create_surface) (base_name,
target->content,
SIZE, SIZE,
SIZE, SIZE,
CAIRO_BOILERPLATE_MODE_TEST,
0,
&closure);
if (surface == NULL) {
free (base_name);
continue;
}
if (ret == CAIRO_TEST_UNTESTED)
ret = CAIRO_TEST_SUCCESS;
cairo_surface_destroy (surface);
if (target->cleanup)
target->cleanup (closure);
free (base_name);
/* we need to recreate the surface for each resolution as we include
* SVG in testing which does not support the paginated interface.
*/
for (n = 0; n < num_ppi; n++) {
char *test_name;
cairo_bool_t pass;
xasprintf (&test_name, "fallback-resolution.ppi%gx%g",
ppi[n].x, ppi[n].y);
xasprintf (&base_name, "%s.%s.%s",
test_name,
target->name,
format);
surface = (target->create_surface) (base_name,
target->content,
SIZE + 25, SIZE + 25,
SIZE + 25, SIZE + 25,
CAIRO_BOILERPLATE_MODE_TEST,
0,
&closure);
if (surface == NULL || cairo_surface_status (surface)) {
cairo_test_log (ctx, "Failed to generate surface: %s.%s\n",
target->name,
format);
free (base_name);
free (test_name);
ret = CAIRO_TEST_FAILURE;
continue;
}
cairo_test_log (ctx,
"Testing fallback-resolution %gx%g with %s target\n",
ppi[n].x, ppi[n].y, target->name);
printf ("%s:\t", base_name);
fflush (stdout);
if (target->force_fallbacks != NULL)
target->force_fallbacks (surface, ~0U);
cr = cairo_create (surface);
#if SET_TOLERANCE
cairo_set_tolerance (cr, 3.0);
#endif
cairo_surface_set_device_offset (surface, 25, 25);
cairo_surface_set_fallback_resolution (surface,
ppi[n].x, ppi[n].y);
cairo_save (cr); {
cairo_set_source_rgb (cr, 1, 1, 1);
cairo_paint (cr);
} cairo_restore (cr);
/* First draw the top half in a conventional way. */
cairo_save (cr); {
cairo_rectangle (cr, 0, 0, SIZE, SIZE / 2.0);
cairo_clip (cr);
draw (cr, SIZE, SIZE);
} cairo_restore (cr);
/* Then draw the bottom half in a separate group,
* (exposing a bug in 1.6.4 with the group not being
* rendered with the correct fallback resolution). */
cairo_save (cr); {
cairo_rectangle (cr, 0, SIZE / 2.0, SIZE, SIZE / 2.0);
cairo_clip (cr);
cairo_push_group (cr); {
draw (cr, SIZE, SIZE);
} cairo_pop_group_to_source (cr);
cairo_paint (cr);
} cairo_restore (cr);
status = cairo_status (cr);
cairo_destroy (cr);
pass = FALSE;
if (status) {
cairo_test_log (ctx, "Error: Failed to create target surface: %s\n",
cairo_status_to_string (status));
ret = CAIRO_TEST_FAILURE;
} else {
/* extract the image and compare it to our reference */
if (! check_result (ctx, target, test_name, base_name, surface))
ret = CAIRO_TEST_FAILURE;
else
pass = TRUE;
}
cairo_surface_destroy (surface);
if (target->cleanup)
target->cleanup (closure);
free (base_name);
free (test_name);
if (pass) {
printf ("PASS\n");
} else {
printf ("FAIL\n");
}
fflush (stdout);
}
}
return ret;
}
static cairo_test_status_t
preamble (cairo_test_context_t *ctx)
{
Display *dpy;
XRenderPictFormat *orig_format, *format;
cairo_surface_t *surface;
Pixmap pixmap;
int screen;
cairo_test_status_t result;
result = CAIRO_TEST_UNTESTED;
if (! cairo_test_is_target_enabled (ctx, "xlib"))
goto CLEANUP_TEST;
dpy = XOpenDisplay (NULL);
if (! dpy) {
cairo_test_log (ctx, "Error: Cannot open display: %s, skipping.\n",
XDisplayName (NULL));
goto CLEANUP_TEST;
}
result = CAIRO_TEST_FAILURE;
screen = DefaultScreen (dpy);
cairo_test_log (ctx, "Testing with image surface.\n");
surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, 1, 1);
format = cairo_xlib_surface_get_xrender_format (surface);
if (format != NULL) {
cairo_test_log (ctx, "Error: expected NULL for image surface\n");
goto CLEANUP_SURFACE;
}
cairo_surface_destroy (surface);
cairo_test_log (ctx, "Testing with non-xrender xlib surface.\n");
pixmap = XCreatePixmap (dpy, DefaultRootWindow (dpy),
1, 1, DefaultDepth (dpy, screen));
surface = cairo_xlib_surface_create (dpy, pixmap,
DefaultVisual (dpy, screen),
1, 1);
orig_format = XRenderFindVisualFormat (dpy, DefaultVisual (dpy, screen));
format = cairo_xlib_surface_get_xrender_format (surface);
if (format != orig_format) {
cairo_test_log (ctx, "Error: did not receive the same format as XRenderFindVisualFormat\n");
goto CLEANUP_PIXMAP;
}
cairo_surface_destroy (surface);
XFreePixmap (dpy, pixmap);
cairo_test_log (ctx, "Testing with xlib xrender surface.\n");
orig_format = XRenderFindStandardFormat (dpy, PictStandardARGB32);
pixmap = XCreatePixmap (dpy, DefaultRootWindow (dpy),
1, 1, 32);
surface = cairo_xlib_surface_create_with_xrender_format (dpy,
pixmap,
DefaultScreenOfDisplay (dpy),
orig_format,
1, 1);
format = cairo_xlib_surface_get_xrender_format (surface);
if (format != orig_format) {
cairo_test_log (ctx, "Error: did not receive the same format originally set\n");
goto CLEANUP_PIXMAP;
}
cairo_test_log (ctx, "Testing without the X Render extension.\n");
cairo_boilerplate_xlib_surface_disable_render (surface);
format = cairo_xlib_surface_get_xrender_format (surface);
if (format != NULL) {
cairo_test_log (ctx, "Error: did not receive a NULL format as expected\n");
goto CLEANUP_PIXMAP;
}
result = CAIRO_TEST_SUCCESS;
CLEANUP_PIXMAP:
XFreePixmap (dpy, pixmap);
CLEANUP_SURFACE:
cairo_surface_destroy (surface);
XCloseDisplay (dpy);
CLEANUP_TEST:
return result;
}
int
main (void)
{
cairo_test_context_t ctx;
cairo_surface_t *surface;
cairo_t *cr;
cairo_status_t status;
const char *filename;
size_t i;
char dsc[255];
cairo_test_init (&ctx, "ps-features");
if (! cairo_test_is_target_enabled (&ctx, "ps")) {
cairo_test_fini (&ctx);
return CAIRO_TEST_UNTESTED;
}
filename = "ps-features.ps";
/* We demonstrate that the initial size doesn't matter (we're
* passing 0,0), if we use cairo_ps_surface_set_size on the first
* page. */
surface = cairo_ps_surface_create (filename, 0, 0);
cairo_ps_surface_dsc_comment (surface, "%%Title: ps-features");
cairo_ps_surface_dsc_comment (surface, "%%Copyright: Copyright (C) 2006 Red Hat, Inc.");
cairo_ps_surface_dsc_begin_setup (surface);
cairo_ps_surface_dsc_comment (surface, "%%IncludeFeature: *PageSize letter");
cairo_ps_surface_dsc_comment (surface, "%%IncludeFeature: *MediaColor White");
cr = cairo_create (surface);
cairo_select_font_face (cr, "Bitstream Vera Sans",
CAIRO_FONT_SLANT_NORMAL,
CAIRO_FONT_WEIGHT_NORMAL);
cairo_set_font_size (cr, TEXT_SIZE);
for (i=0; i < ARRAY_SIZE(pages); i++) {
cairo_ps_surface_set_size (surface,
pages[i].width_in_points,
pages[i].height_in_points);
cairo_ps_surface_dsc_begin_page_setup (surface);
snprintf (dsc, 255, "%%IncludeFeature: *PageSize %s", pages[i].page_size_alias);
cairo_ps_surface_dsc_comment (surface, dsc);
if (i % 2) {
snprintf (dsc, 255, "%%IncludeFeature: *MediaType Glossy");
cairo_ps_surface_dsc_comment (surface, dsc);
}
cairo_move_to (cr, TEXT_SIZE, TEXT_SIZE);
cairo_show_text (cr, pages[i].page_size);
cairo_show_text (cr, " - ");
cairo_show_text (cr, pages[i].orientation);
cairo_show_page (cr);
}
status = cairo_status (cr);
cairo_destroy (cr);
cairo_surface_destroy (surface);
if (status) {
cairo_test_log (&ctx, "Failed to create ps surface for file %s: %s\n",
filename, cairo_status_to_string (status));
return CAIRO_TEST_FAILURE;
}
printf ("ps-features: Please check %s to ensure it looks/prints correctly.\n", filename);
cairo_test_fini (&ctx);
return CAIRO_TEST_SUCCESS;
}