static cairo_test_status_t
draw (cairo_t *cr, int width, int height)
{
const cairo_test_context_t *ctx = cairo_test_get_context (cr);
cairo_surface_t *surface;
cairo_status_t status;
surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, 1, 1);
cairo_surface_finish (surface);
status = cairo_surface_status (surface);
if (status != CAIRO_STATUS_SUCCESS)
return cairo_test_status_from_status (ctx, status);
cairo_surface_finish (surface);
status = cairo_surface_status (surface);
if (status != CAIRO_STATUS_SUCCESS)
return cairo_test_status_from_status (ctx, status);
cairo_surface_finish (surface);
status = cairo_surface_status (surface);
if (status != CAIRO_STATUS_SUCCESS)
return cairo_test_status_from_status (ctx, status);
cairo_surface_destroy (surface);
return CAIRO_TEST_SUCCESS;
}
static cairo_test_status_t
draw (cairo_t *cr, int width, int height)
{
cairo_font_face_t *font_face;
cairo_font_options_t *font_options;
cairo_scaled_font_t *scaled_font;
cairo_matrix_t identity;
cairo_matrix_t zero;
cairo_matrix_init_identity(&identity);
zero = identity;
cairo_matrix_scale(&zero, 0, 0);
font_face = cairo_get_font_face (cr);
font_options = cairo_font_options_create ();
cairo_get_font_options (cr, font_options);
scaled_font = cairo_scaled_font_create (font_face,
&identity,
&zero,
font_options);
cairo_set_scaled_font (cr, scaled_font);
cairo_show_text (cr, "Hello");
cairo_scaled_font_destroy (scaled_font);
cairo_font_options_destroy (font_options);
return cairo_test_status_from_status (cairo_test_get_context (cr),
cairo_status(cr));
}
static cairo_test_status_t
get_glyph (cairo_t *cr, const char *utf8, cairo_glyph_t *glyph)
{
cairo_glyph_t *text_to_glyphs;
cairo_status_t status;
int i;
text_to_glyphs = glyph;
i = 1;
status = cairo_scaled_font_text_to_glyphs (cairo_get_scaled_font (cr),
0, 0,
utf8, -1,
&text_to_glyphs, &i,
NULL, NULL,
0);
if (status != CAIRO_STATUS_SUCCESS)
return cairo_test_status_from_status (cairo_test_get_context (cr),
status);
if (text_to_glyphs != glyph) {
*glyph = text_to_glyphs[0];
cairo_glyph_free (text_to_glyphs);
}
return CAIRO_TEST_SUCCESS;
}
static cairo_test_status_t
draw (cairo_t *cr, int width, int height)
{
const cairo_test_context_t *ctx = cairo_test_get_context (cr);
char *filename;
cairo_surface_t *surface;
xasprintf (&filename, "%s/%s", ctx->srcdir,
"create-from-png.ref.png");
surface = cairo_image_surface_create_from_png (filename);
if (cairo_surface_status (surface)) {
cairo_test_status_t result;
result = cairo_test_status_from_status (ctx,
cairo_surface_status (surface));
if (result == CAIRO_TEST_FAILURE) {
cairo_test_log (ctx, "Error reading PNG image %s: %s\n",
filename,
cairo_status_to_string (cairo_surface_status (surface)));
}
free (filename);
return result;
}
cairo_set_source_surface (cr, surface, 0, 0);
cairo_pattern_set_filter (cairo_get_source (cr), CAIRO_FILTER_NEAREST);
cairo_paint (cr);
cairo_surface_destroy (surface);
free (filename);
return CAIRO_TEST_SUCCESS;
}
static cairo_test_status_t
draw (cairo_t *cr, int width, int height)
{
const cairo_test_context_t *ctx = cairo_test_get_context (cr);
cairo_status_t status;
const double colors[8][3] = {
{ 1.0, 0.0, 0.0 }, /* red */
{ 0.0, 1.0, 0.0 }, /* green */
{ 1.0, 1.0, 0.0 }, /* yellow */
{ 0.0, 0.0, 1.0 }, /* blue */
{ 1.0, 0.0, 1.0 }, /* magenta */
{ 0.0, 1.0, 1.0 }, /* cyan */
{ 1.0, 1.0, 1.0 }, /* white */
{ 0.0, 0.0, 0.0 }, /* black */
};
int i, j, loop;
/* cache a resolved scaled-font */
scaled_font = cairo_get_scaled_font (cr);
for (loop = 0; loop < LOOPS; loop++) {
for (i = 0; i < LOOPS; i++) {
for (j = 0; j < 8; j++) {
use_solid (cr, colors[j][0], colors[j][1], colors[j][2]);
status = cairo_status (cr);
if (status)
return cairo_test_status_from_status (ctx, status);
}
}
for (i = 0; i < NRAND; i++) {
use_solid (cr, drand48 (), drand48 (), drand48 ());
status = cairo_status (cr);
if (status)
return cairo_test_status_from_status (ctx, status);
}
}
/* stress test only, so clear the surface before comparing */
cairo_set_source_rgb (cr, 0, 0, 1);
cairo_paint (cr);
return CAIRO_TEST_SUCCESS;
}
static cairo_test_status_t
draw (cairo_t *cr, int width, int height)
{
cairo_text_extents_t extents;
cairo_scaled_font_t *scaled_font;
cairo_status_t status;
const char text[] = "i-W";
double line_width, x, y;
line_width = cairo_get_line_width (cr);
/* We draw in the default black, so paint white first. */
cairo_save (cr);
cairo_set_source_rgb (cr, 1.0, 1.0, 1.0); /* white */
cairo_paint (cr);
cairo_restore (cr);
status = create_scaled_font (cr, &scaled_font);
if (status) {
return cairo_test_status_from_status (cairo_test_get_context (cr),
status);
}
cairo_set_scaled_font (cr, scaled_font);
cairo_scaled_font_destroy (scaled_font);
cairo_set_line_width (cr, 1.0);
cairo_set_source_rgb (cr, 0, 0, 0); /* black */
cairo_text_extents (cr, text, &extents);
x = width - (extents.width + extents.x_bearing) - 5;
y = height - (extents.height + extents.y_bearing) - 5;
cairo_move_to (cr, x, y);
cairo_show_text (cr, text);
cairo_rectangle (cr,
x + extents.x_bearing - line_width / 2,
y + extents.y_bearing - line_width / 2,
extents.width + line_width,
extents.height + line_width);
cairo_stroke (cr);
cairo_set_source_rgb (cr, 0, 0, 1); /* blue */
cairo_text_extents (cr, text, &extents);
x = -extents.x_bearing + 5;
y = -extents.y_bearing + 5;
cairo_move_to (cr, x, y);
cairo_text_path (cr, text);
cairo_fill (cr);
cairo_rectangle (cr,
x + extents.x_bearing - line_width / 2,
y + extents.y_bearing - line_width / 2,
extents.width + line_width,
extents.height + line_width);
cairo_stroke (cr);
return CAIRO_TEST_SUCCESS;
}
static cairo_test_status_t
paint_file (cairo_t *cr,
const char *filename, const char *mime_type,
int x, int y)
{
const cairo_test_context_t *ctx = cairo_test_get_context (cr);
cairo_surface_t *image;
unsigned char *mime_data;
unsigned int mime_length;
cairo_status_t status;
/* Deliberately use a non-matching MIME images, so that we can identify
* when the MIME representation is used in preference to the plain image
* surface.
*/
status = read_file (ctx, filename, &mime_data, &mime_length);
if (status)
return cairo_test_status_from_status (ctx, status);
image = cairo_image_surface_create (CAIRO_FORMAT_RGB24, 200, 50);
status = cairo_surface_set_mime_data (image, mime_type,
mime_data, mime_length,
free, mime_data);
if (status) {
cairo_surface_destroy (image);
free (mime_data);
return cairo_test_status_from_status (ctx, status);
}
cairo_set_source_surface (cr, image, x, y);
cairo_surface_destroy (image);
cairo_paint (cr);
return CAIRO_TEST_SUCCESS;
}
static cairo_test_status_t
check_font_extents (const cairo_test_context_t *ctx, cairo_t *cr, const char *comment)
{
cairo_font_extents_t font_extents, ref_font_extents = {11, 2, 13, 6, 0};
cairo_status_t status;
memset (&font_extents, 0xff, sizeof (cairo_font_extents_t));
cairo_font_extents (cr, &font_extents);
status = cairo_status (cr);
if (status)
return cairo_test_status_from_status (ctx, status);
if (! font_extents_equal (&font_extents, &ref_font_extents)) {
cairo_test_log (ctx, "Error: %s: cairo_font_extents(); extents (%g, %g, %g, %g, %g)\n",
comment,
font_extents.ascent, font_extents.descent,
font_extents.height,
font_extents.max_x_advance, font_extents.max_y_advance);
return CAIRO_TEST_FAILURE;
}
return CAIRO_TEST_SUCCESS;
}
static cairo_test_status_t
draw (cairo_t *cr, int width, int height)
{
const cairo_test_context_t *ctx = cairo_test_get_context (cr);
cairo_path_t *path;
cairo_t *cr_error;
/* Ensure that calling cairo_copy_path on an in-error cairo_t will
* propagate the error. */
cr_error = cairo_create (NULL);
path = cairo_copy_path (cr_error);
if (path->status != CAIRO_STATUS_NULL_POINTER) {
cairo_test_log (ctx,
"Error: cairo_copy_path returned status of %s rather than propagating %s\n",
cairo_status_to_string (path->status),
cairo_status_to_string (CAIRO_STATUS_NULL_POINTER));
cairo_path_destroy (path);
cairo_destroy (cr_error);
return CAIRO_TEST_FAILURE;
}
cairo_path_destroy (path);
path = cairo_copy_path_flat (cr_error);
if (path->status != CAIRO_STATUS_NULL_POINTER) {
cairo_test_log (ctx,
"Error: cairo_copy_path_flat returned status of %s rather than propagating %s\n",
cairo_status_to_string (path->status),
cairo_status_to_string (CAIRO_STATUS_NULL_POINTER));
cairo_path_destroy (path);
cairo_destroy (cr_error);
return CAIRO_TEST_FAILURE;
}
cairo_path_destroy (path);
cairo_destroy (cr_error);
/* first check that we can copy an empty path */
cairo_new_path (cr);
path = cairo_copy_path (cr);
if (path->status != CAIRO_STATUS_SUCCESS) {
cairo_status_t status = path->status;
cairo_test_log (ctx,
"Error: cairo_copy_path returned status of %s\n",
cairo_status_to_string (status));
cairo_path_destroy (path);
return cairo_test_status_from_status (ctx, status);
}
if (path->num_data != 0) {
cairo_test_log (ctx,
"Error: cairo_copy_path did not copy an empty path, returned path contains %d elements\n",
path->num_data);
cairo_path_destroy (path);
return CAIRO_TEST_FAILURE;
}
cairo_append_path (cr, path);
cairo_path_destroy (path);
if (cairo_status (cr) != CAIRO_STATUS_SUCCESS) {
cairo_test_log (ctx,
"Error: cairo_append_path failed with a copy of an empty path, returned status of %s\n",
cairo_status_to_string (cairo_status (cr)));
return cairo_test_status_from_status (ctx, cairo_status (cr));
}
/* We draw in the default black, so paint white first. */
cairo_save (cr);
cairo_set_source_rgb (cr, 1.0, 1.0, 1.0); /* white */
cairo_paint (cr);
cairo_restore (cr);
/* copy path, munge, and fill */
cairo_translate (cr, 5, 5);
make_path (cr);
path = cairo_copy_path (cr);
cairo_new_path (cr);
munge_and_set_path (cr, path, scale_by_two);
cairo_path_destroy (path);
cairo_fill (cr);
/* copy flattened path, munge, and fill */
cairo_translate (cr, 0, 15);
make_path (cr);
path = cairo_copy_path_flat (cr);
cairo_new_path (cr);
munge_and_set_path (cr, path, scale_by_two);
cairo_path_destroy (path);
cairo_fill (cr);
/* append two copies of path, and fill */
cairo_translate (cr, 0, 15);
cairo_scale (cr, 2.0, 2.0);
make_path (cr);
path = cairo_copy_path (cr);
cairo_new_path (cr);
cairo_append_path (cr, path);
cairo_translate (cr, 2.5, 2.5);
cairo_append_path (cr, path);
cairo_set_fill_rule (cr, CAIRO_FILL_RULE_EVEN_ODD);
cairo_fill (cr);
cairo_path_destroy (path);
return CAIRO_TEST_SUCCESS;
}
static cairo_test_status_t
preamble (cairo_test_context_t *ctx)
{
cairo_t *cr;
cairo_path_data_t data;
cairo_path_t path;
cairo_surface_t *surface;
cairo_status_t status;
surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, 1, 1);
status = cairo_surface_status (surface);
if (status) {
cairo_surface_destroy (surface);
return cairo_test_status_from_status (ctx, status);
}
/* Test a few error cases for cairo_append_path_data */
#define CAIRO_CREATE() do {\
cr = cairo_create (surface); \
status = cairo_status (cr); \
if (status) { \
cairo_destroy (cr); \
cairo_surface_destroy (surface); \
return cairo_test_status_from_status (ctx, status); \
} \
} while (0)
CAIRO_CREATE ();
cairo_append_path (cr, NULL);
status = cairo_status (cr);
cairo_destroy (cr);
if (status != CAIRO_STATUS_NULL_POINTER) {
cairo_surface_destroy (surface);
return cairo_test_status_from_status (ctx, status);
}
CAIRO_CREATE ();
path.status = -1;
cairo_append_path (cr, &path);
status = cairo_status (cr);
cairo_destroy (cr);
if (status != CAIRO_STATUS_INVALID_STATUS) {
cairo_surface_destroy (surface);
return cairo_test_status_from_status (ctx, status);
}
CAIRO_CREATE ();
path.status = CAIRO_STATUS_NO_MEMORY;
cairo_append_path (cr, &path);
status = cairo_status (cr);
cairo_destroy (cr);
if (status != CAIRO_STATUS_NO_MEMORY) {
cairo_surface_destroy (surface);
return cairo_test_status_from_status (ctx, status);
}
CAIRO_CREATE ();
path.data = NULL;
path.num_data = 0;
path.status = CAIRO_STATUS_SUCCESS;
cairo_append_path (cr, &path);
status = cairo_status (cr);
cairo_destroy (cr);
if (status != CAIRO_STATUS_SUCCESS) {
cairo_surface_destroy (surface);
return cairo_test_status_from_status (ctx, status);
}
CAIRO_CREATE ();
path.data = NULL;
path.num_data = 1;
path.status = CAIRO_STATUS_SUCCESS;
cairo_append_path (cr, &path);
status = cairo_status (cr);
cairo_destroy (cr);
if (status != CAIRO_STATUS_NULL_POINTER) {
cairo_surface_destroy (surface);
return cairo_test_status_from_status (ctx, status);
}
CAIRO_CREATE ();
/* Intentionally insert bogus header.length value (otherwise would be 2) */
data.header.type = CAIRO_PATH_MOVE_TO;
data.header.length = 1;
path.data = &data;
path.num_data = 1;
cairo_append_path (cr, &path);
status = cairo_status (cr);
cairo_destroy (cr);
if (status != CAIRO_STATUS_INVALID_PATH_DATA) {
cairo_surface_destroy (surface);
return cairo_test_status_from_status (ctx, status);
}
/* And test the degnerate case */
CAIRO_CREATE ();
path.num_data = 0;
cairo_append_path (cr, &path);
status = cairo_status (cr);
cairo_destroy (cr);
if (status != CAIRO_STATUS_SUCCESS) {
cairo_surface_destroy (surface);
return cairo_test_status_from_status (ctx, status);
}
cairo_surface_destroy (surface);
return CAIRO_TEST_SUCCESS;
}
static cairo_test_status_t
draw (cairo_t *cr, int width, int height)
{
cairo_path_data_t path_data[] = {
{ { CAIRO_PATH_MOVE_TO, 2 }, },
{ { 95.000000, 40.000000 }, },
{ { CAIRO_PATH_LINE_TO, 2 }, },
{ { 94.960533, 41.255810 }, },
{ { CAIRO_PATH_LINE_TO, 2 }, },
{ { 94.842293, 42.50666 }, },
{ { CAIRO_PATH_LINE_TO, 2 }, },
{ { 94.645744, 43.747627 }, },
{ { CAIRO_PATH_LINE_TO, 2 }, },
{ { 94.371666, 44.973797 }, },
};
const cairo_test_context_t *ctx = cairo_test_get_context (cr);
cairo_path_t path, *path_copy;
int i, j, n;
cairo_test_status_t result = CAIRO_TEST_SUCCESS;
path.status = CAIRO_STATUS_SUCCESS;
path.num_data = sizeof (path_data) / sizeof (path_data[0]);
path.data = path_data;
cairo_new_path (cr);
cairo_append_path (cr, &path);
path_copy = cairo_copy_path (cr);
if (path_copy->status)
return cairo_test_status_from_status (ctx, path_copy->status);
for (i = j = n = 0;
i < path.num_data && j < path_copy->num_data;
i += path.data[i].header.length,
j += path_copy->data[j].header.length,
n++)
{
const cairo_path_data_t *src, *dst;
src = &path.data[i];
dst = &path_copy->data[j];
if (src->header.type != dst->header.type) {
cairo_test_log (ctx,
"Paths differ in header type after %d operations.\n"
"Expected path operation %d, found %d.\n",
n, src->header.type, dst->header.type);
result = FAIL;
break;
}
if (memcmp (&src[1].point, &dst[1].point, sizeof (src->point))) {
cairo_test_log (ctx,
"Paths differ in coordinates after %d operations.\n"
"Expected point (%f, %f), found (%f, %f).\n",
n,
src[1].point.x, src[1].point.y,
dst[1].point.x, dst[1].point.y);
result = FAIL;
break;
}
}
cairo_path_destroy (path_copy);
return result;
}
static cairo_test_status_t
draw (cairo_t *cr, int width, int height)
{
const cairo_test_context_t *ctx = cairo_test_get_context (cr);
glyph_array_t glyphs;
cairo_font_options_t *font_options;
cairo_status_t status;
/* paint white so we don't need separate ref images for
* RGB24 and ARGB32 */
cairo_set_source_rgb (cr, 1.0, 1.0, 1.0);
cairo_paint (cr);
cairo_select_font_face (cr, "Bitstream Vera Sans",
CAIRO_FONT_SLANT_NORMAL,
CAIRO_FONT_WEIGHT_NORMAL);
cairo_set_font_size (cr, TEXT_SIZE);
font_options = cairo_font_options_create ();
cairo_get_font_options (cr, font_options);
cairo_font_options_set_hint_metrics (font_options, CAIRO_HINT_METRICS_OFF);
cairo_set_font_options (cr, font_options);
cairo_font_options_destroy (font_options);
cairo_set_source_rgb (cr, 0.0, 0.0, 0.0);
glyph_array_init (&glyphs, 1, TEXT_SIZE);
status = glyph_array_add_text(&glyphs, cr, "AWAY again", 0.0);
if (status)
return cairo_test_status_from_status (ctx, status);
glyph_array_rel_move_to (&glyphs, TEXT_SIZE*1, 0.0);
status = glyph_array_add_text(&glyphs, cr, "character space", TEXT_SIZE*0.3);
if (status)
return cairo_test_status_from_status (ctx, status);
glyph_array_show (&glyphs, cr);
glyph_array_init (&glyphs, 1, TEXT_SIZE*2 + 4);
status = glyph_array_add_text(&glyphs, cr, "Increasing", 0.0);
if (status)
return cairo_test_status_from_status (ctx, status);
glyph_array_rel_move_to (&glyphs, TEXT_SIZE*0.5, 0.0);
status = glyph_array_add_text(&glyphs, cr, "space", 0.0);
if (status)
return cairo_test_status_from_status (ctx, status);
glyph_array_rel_move_to (&glyphs, TEXT_SIZE*1.0, 0.0);
status = glyph_array_add_text(&glyphs, cr, "between", 0.0);
if (status)
return cairo_test_status_from_status (ctx, status);
glyph_array_rel_move_to (&glyphs, TEXT_SIZE*1.5, 0.0);
status = glyph_array_add_text(&glyphs, cr, "words", 0.0);
if (status)
return cairo_test_status_from_status (ctx, status);
glyph_array_show (&glyphs, cr);
return CAIRO_TEST_SUCCESS;
}
static cairo_test_status_t
draw (cairo_t *cr, int width, int height)
{
const cairo_test_context_t *ctx = cairo_test_get_context (cr);
char *filename;
FILE *file;
cairo_surface_t *surface;
cairo_status_t status;
xasprintf (&filename, "%s/reference/%s", ctx->srcdir,
"create-from-png-stream.ref.png");
file = fopen (filename, "rb");
if (file == NULL) {
cairo_test_status_t ret;
ret = CAIRO_TEST_FAILURE;
if (errno == ENOMEM)
ret = cairo_test_status_from_status (ctx, CAIRO_STATUS_NO_MEMORY);
if (ret != CAIRO_TEST_NO_MEMORY)
cairo_test_log (ctx, "Error: failed to open file: %s\n", filename);
free (filename);
return ret;
}
surface = cairo_image_surface_create_from_png_stream (read_png_from_file,
file);
fclose (file);
status = cairo_surface_status (surface);
if (status) {
cairo_test_status_t ret;
cairo_surface_destroy (surface);
ret = cairo_test_status_from_status (ctx, status);
if (ret != CAIRO_TEST_NO_MEMORY) {
cairo_test_log (ctx,
"Error: failed to create surface from PNG: %s - %s\n",
filename,
cairo_status_to_string (status));
}
free (filename);
return ret;
}
free (filename);
/* Pretend we modify the surface data (which detaches the PNG mime data) */
cairo_surface_flush (surface);
cairo_surface_mark_dirty (surface);
cairo_set_source_surface (cr, surface, 0, 0);
cairo_pattern_set_filter (cairo_get_source (cr), CAIRO_FILTER_NEAREST);
cairo_paint (cr);
cairo_surface_destroy (surface);
return CAIRO_TEST_SUCCESS;
}
static cairo_test_status_t
draw (cairo_t *cr, int width, int height)
{
const char text[] = TEXT;
cairo_font_extents_t font_extents;
cairo_text_extents_t extents;
cairo_font_face_t *font_face;
cairo_status_t status;
cairo_set_source_rgb (cr, 1, 1, 1);
cairo_paint (cr);
#ifdef ROTATED
cairo_translate (cr, TEXT_SIZE, 0);
cairo_rotate (cr, .6);
#endif
status = _user_font_face_create (&font_face);
if (status) {
return cairo_test_status_from_status (cairo_test_get_context (cr),
status);
}
cairo_set_font_face (cr, font_face);
cairo_font_face_destroy (font_face);
cairo_set_font_size (cr, TEXT_SIZE);
cairo_font_extents (cr, &font_extents);
cairo_text_extents (cr, text, &extents);
/* logical boundaries in red */
cairo_move_to (cr, 0, BORDER);
cairo_rel_line_to (cr, WIDTH, 0);
cairo_move_to (cr, 0, BORDER + font_extents.ascent);
cairo_rel_line_to (cr, WIDTH, 0);
cairo_move_to (cr, 0, BORDER + font_extents.ascent + font_extents.descent);
cairo_rel_line_to (cr, WIDTH, 0);
cairo_move_to (cr, BORDER, 0);
cairo_rel_line_to (cr, 0, 2*BORDER + TEXT_SIZE);
cairo_move_to (cr, BORDER + extents.x_advance, 0);
cairo_rel_line_to (cr, 0, 2*BORDER + TEXT_SIZE);
cairo_set_source_rgb (cr, 1, 0, 0);
cairo_set_line_width (cr, 2);
cairo_stroke (cr);
/* ink boundaries in green */
cairo_rectangle (cr,
BORDER + extents.x_bearing, BORDER + font_extents.ascent + extents.y_bearing,
extents.width, extents.height);
cairo_set_source_rgb (cr, 0, 1, 0);
cairo_set_line_width (cr, 2);
cairo_stroke (cr);
/* text in gray */
cairo_set_source_rgb (cr, 0, 0, 0);
cairo_move_to (cr, BORDER, BORDER + font_extents.ascent);
cairo_show_text (cr, text);
/* filled version of text in light blue */
cairo_set_source_rgb (cr, 0, 0, 1);
cairo_move_to (cr, BORDER, BORDER + font_extents.height + BORDER + font_extents.ascent);
cairo_text_path (cr, text);
cairo_fill (cr);
return CAIRO_TEST_SUCCESS;
}
static cairo_test_status_t
preamble (cairo_test_context_t *ctx)
{
char *filename;
cairo_surface_t *surface;
cairo_status_t status;
cairo_test_status_t result = CAIRO_TEST_SUCCESS;
surface = cairo_image_surface_create_from_png ("___THIS_FILE_DOES_NOT_EXIST___");
if (cairo_surface_status (surface) != CAIRO_STATUS_FILE_NOT_FOUND) {
result = cairo_test_status_from_status (ctx,
cairo_surface_status (surface));
if (result == CAIRO_TEST_FAILURE) {
cairo_test_log (ctx, "Error: expected \"file not found\", but got: %s\n",
cairo_status_to_string (cairo_surface_status (surface)));
}
}
cairo_surface_destroy (surface);
if (result != CAIRO_TEST_SUCCESS)
return result;
surface = cairo_image_surface_create_from_png_stream (no_memory_error, NULL);
if (cairo_surface_status (surface) != CAIRO_STATUS_NO_MEMORY) {
result = cairo_test_status_from_status (ctx,
cairo_surface_status (surface));
if (result == CAIRO_TEST_FAILURE) {
cairo_test_log (ctx, "Error: expected \"out of memory\", but got: %s\n",
cairo_status_to_string (cairo_surface_status (surface)));
}
}
cairo_surface_destroy (surface);
if (result != CAIRO_TEST_SUCCESS)
return result;
surface = cairo_image_surface_create_from_png_stream (read_error, NULL);
if (cairo_surface_status (surface) != CAIRO_STATUS_READ_ERROR) {
result = cairo_test_status_from_status (ctx,
cairo_surface_status (surface));
if (result == CAIRO_TEST_FAILURE) {
cairo_test_log (ctx, "Error: expected \"read error\", but got: %s\n",
cairo_status_to_string (cairo_surface_status (surface)));
}
}
cairo_surface_destroy (surface);
if (result != CAIRO_TEST_SUCCESS)
return result;
/* cheekily test error propagation from the user write funcs as well ... */
xasprintf (&filename, "%s/%s", ctx->srcdir,
"create-from-png.ref.png");
surface = cairo_image_surface_create_from_png (filename);
if (cairo_surface_status (surface)) {
result = cairo_test_status_from_status (ctx,
cairo_surface_status (surface));
if (result == CAIRO_TEST_FAILURE) {
cairo_test_log (ctx, "Error reading PNG image %s: %s\n",
filename,
cairo_status_to_string (cairo_surface_status (surface)));
}
} else {
status = cairo_surface_write_to_png_stream (surface,
(cairo_write_func_t) no_memory_error,
NULL);
if (status != CAIRO_STATUS_NO_MEMORY) {
result = cairo_test_status_from_status (ctx, status);
if (result == CAIRO_TEST_FAILURE) {
cairo_test_log (ctx, "Error: expected \"out of memory\", but got: %s\n",
cairo_status_to_string (status));
}
}
status = cairo_surface_write_to_png_stream (surface,
(cairo_write_func_t) read_error,
NULL);
if (status != CAIRO_STATUS_READ_ERROR) {
result = cairo_test_status_from_status (ctx, status);
if (result == CAIRO_TEST_FAILURE) {
cairo_test_log (ctx, "Error: expected \"read error\", but got: %s\n",
cairo_status_to_string (status));
}
}
/* and check that error has not propagated to the surface */
if (cairo_surface_status (surface)) {
result = cairo_test_status_from_status (ctx,
cairo_surface_status (surface));
if (result == CAIRO_TEST_FAILURE) {
cairo_test_log (ctx, "Error: user write error propagated to surface: %s",
cairo_status_to_string (cairo_surface_status (surface)));
}
}
}
cairo_surface_destroy (surface);
free (filename);
if (result != CAIRO_TEST_SUCCESS)
return result;
/* check that loading alpha/opaque PNGs generate the correct surfaces */
xasprintf (&filename, "%s/%s", ctx->srcdir,
"create-from-png.alpha.ref.png");
surface = cairo_image_surface_create_from_png (filename);
if (cairo_surface_status (surface)) {
result = cairo_test_status_from_status (ctx,
cairo_surface_status (surface));
if (result == CAIRO_TEST_FAILURE) {
cairo_test_log (ctx, "Error reading PNG image %s: %s\n",
filename,
cairo_status_to_string (cairo_surface_status (surface)));
}
} else if (cairo_image_surface_get_format (surface) != CAIRO_FORMAT_ARGB32) {
cairo_test_log (ctx, "Error reading PNG image %s: did not create an ARGB32 image\n",
filename);
result = CAIRO_TEST_FAILURE;
}
free (filename);
cairo_surface_destroy (surface);
if (result != CAIRO_TEST_SUCCESS)
return result;
xasprintf (&filename, "%s/%s", ctx->srcdir,
"create-from-png.ref.png");
surface = cairo_image_surface_create_from_png (filename);
if (cairo_surface_status (surface)) {
result = cairo_test_status_from_status (ctx,
cairo_surface_status (surface));
if (result == CAIRO_TEST_FAILURE) {
cairo_test_log (ctx, "Error reading PNG image %s: %s\n",
filename,
cairo_status_to_string (cairo_surface_status (surface)));
}
} else if (cairo_image_surface_get_format (surface) != CAIRO_FORMAT_RGB24) {
cairo_test_log (ctx, "Error reading PNG image %s: did not create an RGB24 image\n",
filename);
result = CAIRO_TEST_FAILURE;
}
free (filename);
cairo_surface_destroy (surface);
if (result != CAIRO_TEST_SUCCESS)
return result;
/* check paletted PNGs */
xasprintf (&filename, "%s/%s", ctx->srcdir,
"create-from-png.indexed-alpha.ref.png");
surface = cairo_image_surface_create_from_png (filename);
if (cairo_surface_status (surface)) {
result = cairo_test_status_from_status (ctx,
cairo_surface_status (surface));
if (result == CAIRO_TEST_FAILURE) {
cairo_test_log (ctx, "Error reading PNG image %s: %s\n",
filename,
cairo_status_to_string (cairo_surface_status (surface)));
}
} else if (cairo_image_surface_get_format (surface) != CAIRO_FORMAT_ARGB32) {
cairo_test_log (ctx, "Error reading PNG image %s: did not create an ARGB32 image\n",
filename);
result = CAIRO_TEST_FAILURE;
}
free (filename);
cairo_surface_destroy (surface);
if (result != CAIRO_TEST_SUCCESS)
return result;
xasprintf (&filename, "%s/%s", ctx->srcdir,
"create-from-png.indexed.ref.png");
surface = cairo_image_surface_create_from_png (filename);
if (cairo_surface_status (surface)) {
result = cairo_test_status_from_status (ctx,
cairo_surface_status (surface));
if (result == CAIRO_TEST_FAILURE) {
cairo_test_log (ctx, "Error reading PNG image %s: %s\n",
filename,
cairo_status_to_string (cairo_surface_status (surface)));
}
} else if (cairo_image_surface_get_format (surface) != CAIRO_FORMAT_RGB24) {
cairo_test_log (ctx, "Error reading PNG image %s: did not create an RGB24 image\n",
filename);
result = CAIRO_TEST_FAILURE;
}
free (filename);
cairo_surface_destroy (surface);
if (result != CAIRO_TEST_SUCCESS)
return result;
/* check grayscale PNGs */
xasprintf (&filename, "%s/%s", ctx->srcdir,
"create-from-png.gray-alpha.ref.png");
surface = cairo_image_surface_create_from_png (filename);
if (cairo_surface_status (surface)) {
result = cairo_test_status_from_status (ctx,
cairo_surface_status (surface));
if (result == CAIRO_TEST_FAILURE) {
cairo_test_log (ctx, "Error reading PNG image %s: %s\n",
filename,
cairo_status_to_string (cairo_surface_status (surface)));
}
} else if (cairo_image_surface_get_format (surface) != CAIRO_FORMAT_ARGB32) {
cairo_test_log (ctx, "Error reading PNG image %s: did not create an ARGB32 image\n",
filename);
result = CAIRO_TEST_FAILURE;
}
free (filename);
cairo_surface_destroy (surface);
if (result != CAIRO_TEST_SUCCESS)
return result;
xasprintf (&filename, "%s/%s", ctx->srcdir,
"create-from-png.gray.ref.png");
surface = cairo_image_surface_create_from_png (filename);
if (cairo_surface_status (surface)) {
result = cairo_test_status_from_status (ctx,
cairo_surface_status (surface));
if (result == CAIRO_TEST_FAILURE) {
cairo_test_log (ctx, "Error reading PNG image %s: %s\n",
filename,
cairo_status_to_string (cairo_surface_status (surface)));
}
} else if (cairo_image_surface_get_format (surface) != CAIRO_FORMAT_RGB24) {
cairo_test_log (ctx, "Error reading PNG image %s: did not create an RGB24 image\n",
filename);
result = CAIRO_TEST_FAILURE;
}
free (filename);
cairo_surface_destroy (surface);
return result;
}
static cairo_test_status_t
draw (cairo_t *cr, int width, int height)
{
const cairo_test_context_t *ctx = cairo_test_get_context (cr);
FcPattern *pattern;
cairo_font_face_t *font_face;
cairo_font_extents_t font_extents;
cairo_font_options_t *font_options;
cairo_status_t status;
char *filename;
int face_count;
struct stat stat_buf;
xasprintf (&filename, "%s/%s", ctx->srcdir, FONT);
if (stat (filename, &stat_buf) || ! S_ISREG (stat_buf.st_mode)) {
cairo_test_log (ctx, "Error finding font: %s: file not found?\n", filename);
return CAIRO_TEST_FAILURE;
}
pattern = FcFreeTypeQuery ((unsigned char *)filename, 0, NULL, &face_count);
free (filename);
if (! pattern) {
cairo_test_log (ctx, "FcFreeTypeQuery failed.\n");
return cairo_test_status_from_status (ctx, CAIRO_STATUS_NO_MEMORY);
}
font_face = cairo_ft_font_face_create_for_pattern (pattern);
FcPatternDestroy (pattern);
status = cairo_font_face_status (font_face);
if (status) {
cairo_test_log (ctx, "Error creating font face for %s: %s\n",
filename,
cairo_status_to_string (status));
return cairo_test_status_from_status (ctx, status);
}
if (cairo_font_face_get_type (font_face) != CAIRO_FONT_TYPE_FT) {
cairo_test_log (ctx, "Unexpected value from cairo_font_face_get_type: %d (expected %d)\n",
cairo_font_face_get_type (font_face), CAIRO_FONT_TYPE_FT);
cairo_font_face_destroy (font_face);
return CAIRO_TEST_FAILURE;
}
cairo_set_font_face (cr, font_face);
cairo_font_face_destroy (font_face);
font_options = cairo_font_options_create ();
#define CHECK_FONT_EXTENTS(comment) do {\
cairo_test_status_t test_status; \
test_status = check_font_extents (ctx, cr, (comment)); \
if (test_status != CAIRO_TEST_SUCCESS) { \
cairo_font_options_destroy (font_options); \
return test_status; \
} \
} while (0)
cairo_font_extents (cr, &font_extents);
CHECK_FONT_EXTENTS ("default");
cairo_font_options_set_hint_metrics (font_options, CAIRO_HINT_METRICS_ON);
cairo_set_font_options (cr, font_options);
CHECK_FONT_EXTENTS ("HINT_METRICS_ON");
cairo_move_to (cr, 1, font_extents.ascent - 1);
cairo_set_source_rgb (cr, 0.0, 0.0, 1.0); /* blue */
cairo_font_options_set_hint_style (font_options, CAIRO_HINT_STYLE_NONE);
cairo_set_font_options (cr, font_options);
CHECK_FONT_EXTENTS ("HINT_METRICS_ON HINT_STYLE_NONE");
cairo_show_text (cr, "the ");
cairo_font_options_set_hint_style (font_options, CAIRO_HINT_STYLE_SLIGHT);
cairo_set_font_options (cr, font_options);
CHECK_FONT_EXTENTS ("HINT_METRICS_ON HINT_STYLE_SLIGHT");
cairo_show_text (cr, "quick ");
cairo_font_options_set_hint_style (font_options, CAIRO_HINT_STYLE_MEDIUM);
cairo_set_font_options (cr, font_options);
CHECK_FONT_EXTENTS ("HINT_METRICS_ON HINT_STYLE_MEDIUM");
cairo_show_text (cr, "brown");
cairo_font_options_set_hint_style (font_options, CAIRO_HINT_STYLE_FULL);
cairo_set_font_options (cr, font_options);
CHECK_FONT_EXTENTS ("HINT_METRICS_ON HINT_STYLE_FULL");
cairo_show_text (cr, " fox");
/* Switch from show_text to text_path/fill to exercise bug #7889 */
cairo_text_path (cr, " jumps over a lazy dog");
cairo_fill (cr);
/* And test it rotated as well for the sake of bug #7888 */
cairo_translate (cr, width, height);
cairo_rotate (cr, M_PI);
cairo_font_options_set_hint_style (font_options, CAIRO_HINT_STYLE_DEFAULT);
cairo_font_options_set_hint_metrics (font_options, CAIRO_HINT_METRICS_OFF);
cairo_set_font_options (cr, font_options);
CHECK_FONT_EXTENTS ("HINT_METRICS_OFF");
cairo_move_to (cr, 1, font_extents.height - font_extents.descent - 1);
cairo_font_options_set_hint_style (font_options, CAIRO_HINT_STYLE_NONE);
cairo_set_font_options (cr, font_options);
CHECK_FONT_EXTENTS ("HINT_METRICS_OFF HINT_STYLE_NONE");
cairo_show_text (cr, "the ");
cairo_font_options_set_hint_style (font_options, CAIRO_HINT_STYLE_SLIGHT);
cairo_set_font_options (cr, font_options);
CHECK_FONT_EXTENTS ("HINT_METRICS_OFF HINT_STYLE_SLIGHT");
cairo_show_text (cr, "quick");
cairo_font_options_set_hint_style (font_options, CAIRO_HINT_STYLE_MEDIUM);
cairo_set_font_options (cr, font_options);
CHECK_FONT_EXTENTS ("HINT_METRICS_OFF HINT_STYLE_MEDIUM");
cairo_show_text (cr, " brown");
cairo_font_options_set_hint_style (font_options, CAIRO_HINT_STYLE_FULL);
cairo_set_font_options (cr, font_options);
CHECK_FONT_EXTENTS ("HINT_METRICS_OFF HINT_STYLE_FULL");
cairo_show_text (cr, " fox");
cairo_text_path (cr, " jumps over");
cairo_text_path (cr, " a lazy dog");
cairo_fill (cr);
cairo_font_options_destroy (font_options);
return CAIRO_TEST_SUCCESS;
}
static cairo_test_status_t
draw (cairo_t *cr, int width, int height)
{
const cairo_test_context_t *ctx = cairo_test_get_context (cr);
cairo_surface_t *surface;
cairo_t *cr2;
const char *phase;
const char string[] = "The quick brown fox jumps over the lazy dog.";
cairo_text_extents_t extents, scaled_font_extents;
cairo_status_t status;
int errors = 0;
surface = cairo_surface_create_similar (cairo_get_group_target (cr),
CAIRO_CONTENT_COLOR, 100, 100);
/* don't use cr accidentally */
cr = NULL;
cr2 = cairo_create (surface);
cairo_surface_destroy (surface);
cairo_set_line_width (cr2, 10);
cairo_set_line_join (cr2, CAIRO_LINE_JOIN_MITER);
cairo_set_miter_limit (cr2, 100);
phase = "No path";
errors += !check_extents (ctx, phase, cr2, FILL, EQUALS, 0, 0, 0, 0);
errors += !check_extents (ctx, phase, cr2, STROKE, EQUALS, 0, 0, 0, 0);
errors += !check_extents (ctx, phase, cr2, PATH, EQUALS, 0, 0, 0, 0);
cairo_save (cr2);
cairo_new_path (cr2);
cairo_move_to (cr2, 200, 400);
cairo_rel_line_to (cr2, 0., 0.);
phase = "Degenerate line";
errors += !check_extents (ctx, phase, cr2, FILL, EQUALS, 0, 0, 0, 0);
errors += !check_extents (ctx, phase, cr2, STROKE, EQUALS, 0, 0, 0, 0);
errors += !check_extents (ctx, phase, cr2, PATH, EQUALS, 200, 400, 0, 0);
cairo_new_path (cr2);
cairo_move_to (cr2, 200, 400);
cairo_rel_curve_to (cr2, 0., 0., 0., 0., 0., 0.);
phase = "Degenerate curve";
errors += !check_extents (ctx, phase, cr2, FILL, EQUALS, 0, 0, 0, 0);
errors += !check_extents (ctx, phase, cr2, STROKE, EQUALS, 0, 0, 0, 0);
errors += !check_extents (ctx, phase, cr2, PATH, EQUALS, 200, 400, 0, 0);
cairo_new_path (cr2);
cairo_arc (cr2, 200, 400, 0., 0, 2 * M_PI);
phase = "Degenerate arc (R=0)";
errors += !check_extents (ctx, phase, cr2, FILL, EQUALS, 0, 0, 0, 0);
errors += !check_extents (ctx, phase, cr2, STROKE, EQUALS, 0, 0, 0, 0);
errors += !check_extents (ctx, phase, cr2, PATH, EQUALS, 200, 400, 0, 0);
cairo_new_path (cr2);
cairo_arc (cr2, 200, 400, 10., 0, 0);
phase = "Degenerate arc (Θ=0)";
errors += !check_extents (ctx, phase, cr2, FILL, EQUALS, 0, 0, 0, 0);
errors += !check_extents (ctx, phase, cr2, STROKE, EQUALS, 0, 0, 0, 0);
errors += !check_extents (ctx, phase, cr2, PATH, EQUALS, 200, 400, 0, 0);
cairo_new_path (cr2);
cairo_restore (cr2);
/* Test that with CAIRO_LINE_CAP_ROUND, we get "dots" from
* cairo_move_to; cairo_rel_line_to(0,0) */
cairo_save (cr2);
cairo_set_line_cap (cr2, CAIRO_LINE_CAP_ROUND);
cairo_set_line_width (cr2, 20);
cairo_move_to (cr2, 200, 400);
cairo_rel_line_to (cr2, 0, 0);
phase = "Single 'dot'";
errors += !check_extents (ctx, phase, cr2, FILL, EQUALS, 0, 0, 0, 0);
errors += !check_extents (ctx, phase, cr2, STROKE, EQUALS, 190, 390, 20, 20);
errors += !check_extents (ctx, phase, cr2, PATH, EQUALS, 200, 400, 0, 0);
/* Add another dot without starting a new path */
cairo_move_to (cr2, 100, 500);
cairo_rel_line_to (cr2, 0, 0);
phase = "Multiple 'dots'";
errors += !check_extents (ctx, phase, cr2, FILL, EQUALS, 0, 0, 0, 0);
errors += !check_extents (ctx, phase, cr2, STROKE, EQUALS, 90, 390, 120, 120);
errors += !check_extents (ctx, phase, cr2, PATH, EQUALS, 100, 400, 100, 100);
cairo_new_path (cr2);
cairo_restore (cr2);
/* http://bugs.freedesktop.org/show_bug.cgi?id=7965 */
phase = "A vertical, open path";
cairo_save (cr2);
cairo_set_line_cap (cr2, CAIRO_LINE_CAP_ROUND);
cairo_set_line_join (cr2, CAIRO_LINE_JOIN_ROUND);
cairo_move_to (cr2, 0, 180);
cairo_line_to (cr2, 750, 180);
errors += !check_extents (ctx, phase, cr2, FILL, EQUALS, 0, 0, 0, 0);
errors += !check_extents (ctx, phase, cr2, STROKE, EQUALS, -5, 175, 760, 10);
errors += !check_extents (ctx, phase, cr2, PATH, EQUALS, 0, 180, 755, 0);
cairo_new_path (cr2);
cairo_restore (cr2);
phase = "Simple rect";
cairo_save (cr2);
cairo_rectangle (cr2, 10, 10, 80, 80);
errors += !check_extents (ctx, phase, cr2, FILL, EQUALS, 10, 10, 80, 80);
errors += !check_extents (ctx, phase, cr2, STROKE, EQUALS, 5, 5, 90, 90);
errors += !check_extents (ctx, phase, cr2, PATH, EQUALS, 10, 10, 80, 80);
cairo_new_path (cr2);
cairo_restore (cr2);
phase = "Two rects";
cairo_save (cr2);
cairo_rectangle (cr2, 10, 10, 10, 10);
cairo_rectangle (cr2, 20, 20, 10, 10);
errors += !check_extents (ctx, phase, cr2, FILL, EQUALS, 10, 10, 20, 20);
errors += !check_extents (ctx, phase, cr2, STROKE, EQUALS, 5, 5, 30, 30);
errors += !check_extents (ctx, phase, cr2, PATH, EQUALS, 10, 10, 20, 20);
cairo_new_path (cr2);
cairo_restore (cr2);
phase = "Triangle";
cairo_save (cr2);
cairo_move_to (cr2, 10, 10);
cairo_line_to (cr2, 90, 90);
cairo_line_to (cr2, 90, 10);
cairo_close_path (cr2);
/* miter joins protrude 5*(1+sqrt(2)) above the top-left corner and to
the right of the bottom-right corner */
errors += !check_extents (ctx, phase, cr2, FILL, EQUALS, 10, 10, 80, 80);
errors += !check_extents (ctx, phase, cr2, STROKE, CONTAINS, 0, 5, 95, 95);
errors += !check_extents (ctx, phase, cr2, PATH, CONTAINS, 10, 10, 80, 80);
cairo_new_path (cr2);
cairo_restore (cr2);
cairo_save (cr2);
cairo_set_line_width (cr2, 4);
cairo_rectangle (cr2, 10, 10, 30, 30);
cairo_rectangle (cr2, 25, 10, 15, 30);
cairo_set_fill_rule (cr2, CAIRO_FILL_RULE_EVEN_ODD);
phase = "EVEN_ODD overlapping rectangles";
errors += !check_extents (ctx, phase, cr2, FILL, EQUALS, 10, 10, 15, 30);
errors += !check_extents (ctx, phase, cr2, STROKE, EQUALS, 8, 8, 34, 34);
errors += !check_extents (ctx, phase, cr2, PATH, EQUALS, 10, 10, 30, 30);
/* Test other fill rule with the same path. */
cairo_set_fill_rule (cr2, CAIRO_FILL_RULE_WINDING);
phase = "WINDING overlapping rectangles";
errors += !check_extents (ctx, phase, cr2, FILL, EQUALS, 10, 10, 30, 30);
errors += !check_extents (ctx, phase, cr2, STROKE, EQUALS, 8, 8, 34, 34);
errors += !check_extents (ctx, phase, cr2, PATH, EQUALS, 10, 10, 30, 30);
/* Now, change the direction of the second rectangle and test both
* fill rules again. */
cairo_new_path (cr2);
cairo_rectangle (cr2, 10, 10, 30, 30);
cairo_rectangle (cr2, 25, 40, 15, -30);
cairo_set_fill_rule (cr2, CAIRO_FILL_RULE_EVEN_ODD);
phase = "EVEN_ODD overlapping rectangles";
errors += !check_extents (ctx, phase, cr2, FILL, EQUALS, 10, 10, 15, 30);
errors += !check_extents (ctx, phase, cr2, STROKE, EQUALS, 8, 8, 34, 34);
errors += !check_extents (ctx, phase, cr2, PATH, EQUALS, 10, 10, 30, 30);
/* Test other fill rule with the same path. */
cairo_set_fill_rule (cr2, CAIRO_FILL_RULE_WINDING);
phase = "WINDING overlapping rectangles";
errors += !check_extents (ctx, phase, cr2, FILL, EQUALS, 10, 10, 15, 30);
errors += !check_extents (ctx, phase, cr2, STROKE, EQUALS, 8, 8, 34, 34);
errors += !check_extents (ctx, phase, cr2, PATH, EQUALS, 10, 10, 30, 30);
cairo_new_path (cr2);
cairo_restore (cr2);
/* http://bugs.freedesktop.org/show_bug.cgi?id=7245 */
phase = "Arc";
cairo_save (cr2);
cairo_arc (cr2, 250.0, 250.0, 157.0, 5.147, 3.432);
cairo_set_line_width (cr2, 154.0);
errors += !check_extents (ctx, phase, cr2, STROKE, APPROX_EQUALS, 16, 38, 468, 446);
cairo_new_path (cr2);
cairo_restore (cr2);
phase = "Text";
cairo_save (cr2);
cairo_select_font_face (cr2, "Bitstream Vera Sans",
CAIRO_FONT_SLANT_NORMAL,
CAIRO_FONT_WEIGHT_NORMAL);
cairo_set_font_size (cr2, 12);
cairo_text_extents (cr2, string, &extents);
/* double check that the two methods of measuring the text agree... */
cairo_scaled_font_text_extents (cairo_get_scaled_font (cr2),
string,
&scaled_font_extents);
if (memcmp (&extents, &scaled_font_extents, sizeof (extents))) {
cairo_test_log (ctx, "Error: cairo_text_extents() does not match cairo_scaled_font_text_extents() - font extents (%f, %f) x (%f, %f) should be (%f, %f) x (%f, %f)\n",
scaled_font_extents.x_bearing,
scaled_font_extents.y_bearing,
scaled_font_extents.width,
scaled_font_extents.height,
extents.x_bearing,
extents.y_bearing,
extents.width,
extents.height);
errors++;
}
cairo_move_to (cr2, -extents.x_bearing, -extents.y_bearing);
cairo_text_path (cr2, string);
cairo_set_line_width (cr2, 2.0);
/* XXX: We'd like to be able to use EQUALS here, but currently
* when hinting is enabled freetype returns integer extents. See
* http://cairographics.org/todo */
errors += !check_extents (ctx, phase, cr2, FILL, APPROX_EQUALS,
0, 0, extents.width, extents.height);
errors += !check_extents (ctx, phase, cr2, STROKE, APPROX_EQUALS,
-1, -1, extents.width+2, extents.height+2);
errors += !check_extents (ctx, phase, cr2, PATH, APPROX_EQUALS,
0, 0, extents.width, extents.height);
cairo_new_path (cr2);
cairo_restore (cr2);
phase = "User space, simple scale, getting extents with same transform";
cairo_save (cr2);
cairo_scale (cr2, 2, 2);
cairo_rectangle (cr2, 5, 5, 40, 40);
errors += !check_extents (ctx, phase, cr2, FILL, EQUALS, 5, 5, 40, 40);
errors += !check_extents (ctx, phase, cr2, STROKE, EQUALS, 0, 0, 50, 50);
errors += !check_extents (ctx, phase, cr2, PATH, EQUALS, 5, 5, 40, 40);
cairo_new_path (cr2);
cairo_restore (cr2);
phase = "User space, simple scale, getting extents with no transform";
cairo_save (cr2);
cairo_save (cr2);
cairo_scale (cr2, 2, 2);
cairo_rectangle (cr2, 5, 5, 40, 40);
cairo_restore (cr2);
errors += !check_extents (ctx, phase, cr2, FILL, EQUALS, 10, 10, 80, 80);
errors += !check_extents (ctx, phase, cr2, STROKE, EQUALS, 5, 5, 90, 90);
errors += !check_extents (ctx, phase, cr2, PATH, EQUALS, 10, 10, 80, 80);
cairo_new_path (cr2);
cairo_restore (cr2);
phase = "User space, rotation, getting extents with transform";
cairo_save (cr2);
cairo_rectangle (cr2, -50, -50, 50, 50);
cairo_rotate (cr2, -M_PI/4);
/* the path in user space is now (nearly) the square rotated by
45 degrees about the origin. Thus its x1 and x2 are both nearly 0.
This should show any bugs where we just transform device-space
x1,y1 and x2,y2 to get the extents. */
/* The largest axis-aligned square inside the rotated path has
side lengths 50*sqrt(2), so a bit over 35 on either side of
the axes. With the stroke width added to the rotated path,
the largest axis-aligned square is a bit over 38 on either side of
the axes. */
errors += !check_extents (ctx, phase, cr2, FILL, CONTAINS, -35, -35, 35, 35);
errors += !check_extents (ctx, phase, cr2, STROKE, CONTAINS, -38, -38, 38, 38);
errors += !check_extents (ctx, phase, cr2, PATH, CONTAINS, -35, -35, 35, 35);
cairo_new_path (cr2);
cairo_restore (cr2);
status = cairo_status (cr2);
cairo_destroy (cr2);
if (status)
return cairo_test_status_from_status (ctx, status);
return errors == 0 ? CAIRO_TEST_SUCCESS : CAIRO_TEST_FAILURE;
}
static cairo_test_status_t
preamble (cairo_test_context_t *ctx)
{
cairo_surface_t *surface;
cairo_t *cr;
cairo_rectangle_list_t *rectangle_list;
const char *phase;
cairo_status_t status;
surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, 0, 0);
cr = cairo_create (surface);
cairo_surface_destroy (surface);
/* first, test basic stuff. This should not be clipped, it should
return the surface rectangle. */
phase = "No clip set";
rectangle_list = cairo_copy_clip_rectangle_list (cr);
if (! check_count (ctx, phase, rectangle_list, 1) ||
! check_clip_extents (ctx, phase, cr, 0, 0, 100, 100) ||
! check_rectangles_contain (ctx, phase, rectangle_list, 0, 0, 100, 100))
{
goto FAIL;
}
cairo_rectangle_list_destroy (rectangle_list);
/* Test simple clip rect. */
phase = "Simple clip rect";
cairo_save (cr);
cairo_rectangle (cr, 10, 10, 80, 80);
cairo_clip (cr);
rectangle_list = cairo_copy_clip_rectangle_list (cr);
if (! check_count (ctx, phase, rectangle_list, 1) ||
! check_clip_extents (ctx, phase, cr, 10, 10, 80, 80) ||
! check_rectangles_contain (ctx, phase, rectangle_list, 10, 10, 80, 80))
{
goto FAIL;
}
cairo_rectangle_list_destroy (rectangle_list);
cairo_restore (cr);
/* Test everything clipped out. */
phase = "All clipped out";
cairo_save (cr);
cairo_clip (cr);
rectangle_list = cairo_copy_clip_rectangle_list (cr);
if (! check_count (ctx, phase, rectangle_list, 0))
{
goto FAIL;
}
cairo_rectangle_list_destroy (rectangle_list);
cairo_restore (cr);
/* test two clip rects */
phase = "Two clip rects";
cairo_save (cr);
cairo_rectangle (cr, 10, 10, 10, 10);
cairo_rectangle (cr, 20, 20, 10, 10);
cairo_clip (cr);
cairo_rectangle (cr, 15, 15, 10, 10);
cairo_clip (cr);
rectangle_list = cairo_copy_clip_rectangle_list (cr);
if (! check_count (ctx, phase, rectangle_list, 2) ||
! check_clip_extents (ctx, phase, cr, 15, 15, 10, 10) ||
! check_rectangles_contain (ctx, phase, rectangle_list, 15, 15, 5, 5) ||
! check_rectangles_contain (ctx, phase, rectangle_list, 20, 20, 5, 5))
{
goto FAIL;
}
cairo_rectangle_list_destroy (rectangle_list);
cairo_restore (cr);
/* test non-rectangular clip */
phase = "Nonrectangular clip";
cairo_save (cr);
cairo_move_to (cr, 0, 0);
cairo_line_to (cr, 100, 100);
cairo_line_to (cr, 100, 0);
cairo_close_path (cr);
cairo_clip (cr);
rectangle_list = cairo_copy_clip_rectangle_list (cr);
/* can't get this in one tight user-space rectangle */
if (! check_unrepresentable (ctx, phase, rectangle_list) ||
! check_clip_extents (ctx, phase, cr, 0, 0, 100, 100))
{
goto FAIL;
}
cairo_rectangle_list_destroy (rectangle_list);
cairo_restore (cr);
phase = "User space, simple scale, getting clip with same transform";
cairo_save (cr);
cairo_scale (cr, 2, 2);
cairo_rectangle (cr, 5, 5, 40, 40);
cairo_clip (cr);
rectangle_list = cairo_copy_clip_rectangle_list (cr);
if (! check_count (ctx, phase, rectangle_list, 1) ||
! check_clip_extents (ctx, phase, cr, 5, 5, 40, 40) ||
! check_rectangles_contain (ctx, phase, rectangle_list, 5, 5, 40, 40))
{
goto FAIL;
}
cairo_rectangle_list_destroy (rectangle_list);
cairo_restore (cr);
phase = "User space, simple scale, getting clip with no transform";
cairo_save (cr);
cairo_save (cr);
cairo_scale (cr, 2, 2);
cairo_rectangle (cr, 5, 5, 40, 40);
cairo_restore (cr);
cairo_clip (cr);
rectangle_list = cairo_copy_clip_rectangle_list (cr);
if (! check_count (ctx, phase, rectangle_list, 1) ||
! check_clip_extents (ctx, phase, cr, 10, 10, 80, 80) ||
! check_rectangles_contain (ctx, phase, rectangle_list, 10, 10, 80, 80))
{
goto FAIL;
}
cairo_rectangle_list_destroy (rectangle_list);
cairo_restore (cr);
phase = "User space, rotation, getting clip with no transform";
cairo_save (cr);
cairo_save (cr);
cairo_rotate (cr, 12);
cairo_rectangle (cr, 5, 5, 40, 40);
cairo_restore (cr);
cairo_clip (cr);
rectangle_list = cairo_copy_clip_rectangle_list (cr);
if (! check_unrepresentable (ctx, phase, rectangle_list))
goto FAIL;
FAIL:
cairo_rectangle_list_destroy (rectangle_list);
status = cairo_status (cr);
cairo_destroy (cr);
return cairo_test_status_from_status (ctx, status);
}
static cairo_test_status_t
preamble (cairo_test_context_t *ctx)
{
const char *filename = "png.out.png";
cairo_surface_t *surface0, *surface1;
cairo_status_t status;
uint32_t argb32 = 0xdeadbede;
surface0 = cairo_image_surface_create_for_data ((unsigned char *) &argb32,
CAIRO_FORMAT_ARGB32,
1, 1, 4);
status = cairo_surface_write_to_png (surface0, filename);
if (status) {
cairo_test_log (ctx, "Error writing '%s': %s\n",
filename, cairo_status_to_string (status));
cairo_surface_destroy (surface0);
return cairo_test_status_from_status (ctx, status);
}
surface1 = cairo_image_surface_create_from_png (filename);
status = cairo_surface_status (surface1);
if (status) {
cairo_test_log (ctx, "Error reading '%s': %s\n",
filename, cairo_status_to_string (status));
cairo_surface_destroy (surface1);
cairo_surface_destroy (surface0);
return cairo_test_status_from_status (ctx, status);
}
if (! image_surface_equals (surface0, surface1)) {
cairo_test_log (ctx, "Error surface mismatch.\n");
cairo_test_log (ctx, "to png: "); print_surface (ctx, surface0);
cairo_test_log (ctx, "from png: "); print_surface (ctx, surface1);
cairo_surface_destroy (surface0);
cairo_surface_destroy (surface1);
return CAIRO_TEST_FAILURE;
}
assert (*(uint32_t *) cairo_image_surface_get_data (surface1) == argb32);
cairo_surface_destroy (surface0);
cairo_surface_destroy (surface1);
surface0 = cairo_image_surface_create_for_data ((unsigned char *) &argb32,
CAIRO_FORMAT_RGB24,
1, 1, 4);
status = cairo_surface_write_to_png (surface0, filename);
if (status) {
cairo_test_log (ctx, "Error writing '%s': %s\n",
filename, cairo_status_to_string (status));
cairo_surface_destroy (surface0);
return cairo_test_status_from_status (ctx, status);
}
surface1 = cairo_image_surface_create_from_png (filename);
status = cairo_surface_status (surface1);
if (status) {
cairo_test_log (ctx, "Error reading '%s': %s\n",
filename, cairo_status_to_string (status));
cairo_surface_destroy (surface1);
cairo_surface_destroy (surface0);
return cairo_test_status_from_status (ctx, status);
}
if (! image_surface_equals (surface0, surface1)) {
cairo_test_log (ctx, "Error surface mismatch.\n");
cairo_test_log (ctx, "to png: "); print_surface (ctx, surface0);
cairo_test_log (ctx, "from png: "); print_surface (ctx, surface1);
cairo_surface_destroy (surface0);
cairo_surface_destroy (surface1);
return CAIRO_TEST_FAILURE;
}
assert ((*(uint32_t *) cairo_image_surface_get_data (surface1) & RGB_MASK)
== (argb32 & RGB_MASK));
cairo_surface_destroy (surface0);
cairo_surface_destroy (surface1);
return CAIRO_TEST_SUCCESS;
}