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_format_t format = CAIRO_FORMAT_ARGB32;
cairo_t *cr_src;
cairo_surface_t *png, *src;
uint8_t *data;
int stride;
png = cairo_test_create_surface_from_png (ctx, png_filename);
stride = cairo_format_stride_for_width (format, width) + 12;
data = xcalloc (stride, height);
src = cairo_image_surface_create_for_data (data, format,
width, height, stride);
cr_src = cairo_create (src);
cairo_set_source_surface (cr_src, png, 0, 0);
cairo_paint (cr_src);
cairo_destroy (cr_src);
cairo_set_source_surface (cr, src, 0, 0);
cairo_paint (cr);
cairo_surface_destroy (png);
cairo_surface_finish (src);
cairo_surface_destroy (src);
free (data);
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_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)
{
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_pattern_t *pattern;
cairo_set_source_rgb (cr, 1., 1., 1.);
cairo_paint (cr);
cairo_set_source_rgb (cr, 0., 0., 0.);
cairo_select_font_face (cr, CAIRO_TEST_FONT_FAMILY " Sans",
CAIRO_FONT_SLANT_NORMAL,
CAIRO_FONT_WEIGHT_NORMAL);
draw_text (cr);
cairo_translate (cr, SIZE, SIZE);
cairo_rotate (cr, M_PI);
pattern = cairo_test_create_pattern_from_png (ctx, png_filename);
cairo_pattern_set_extend (pattern, CAIRO_EXTEND_REPEAT);
cairo_set_source (cr, pattern);
cairo_pattern_destroy (pattern);
draw_text (cr);
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);
cairo_glyph_t *glyphs = xmalloc (NUM_GLYPHS * sizeof (cairo_glyph_t));
cairo_scaled_font_t *scaled_font;
const char *characters[] = { /* try to exercise different widths of index */
"m", /* Latin letter m, index=0x50 */
"μ", /* Greek letter mu, index=0x349 */
NULL,
}, **utf8;
int i, j;
cairo_status_t status;
/* Paint white background. */
cairo_set_source_rgb (cr, 1, 1, 1);
cairo_paint (cr);
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);
scaled_font = cairo_get_scaled_font (cr);
for (utf8 = characters; *utf8 != NULL; utf8++) {
status = get_glyph (ctx, scaled_font, *utf8, &glyphs[0]);
if (status)
goto BAIL;
if (glyphs[0].index) {
glyphs[0].x = 1.0;
glyphs[0].y = height - 1;
for (i=1; i < NUM_GLYPHS; i++)
glyphs[i] = glyphs[0];
cairo_show_glyphs (cr, glyphs, NUM_GLYPHS);
}
}
/* we can pack ~21k 1-byte glyphs into a single XRenderCompositeGlyphs8 */
status = get_glyph (ctx, scaled_font, "m", &glyphs[0]);
if (status)
goto BAIL;
for (i=1; i < 21500; i++)
glyphs[i] = glyphs[0];
/* so check expanding the current 1-byte request for 2-byte glyphs */
status = get_glyph (ctx, scaled_font, "μ", &glyphs[i]);
if (status)
goto BAIL;
for (j=i+1; j < NUM_GLYPHS; j++)
glyphs[j] = glyphs[i];
cairo_show_glyphs (cr, glyphs, NUM_GLYPHS);
BAIL:
free(glyphs);
return status;
}
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
draw (cairo_t *cr, int width, int height)
{
const cairo_test_context_t *ctx = cairo_test_get_context (cr);
cairo_surface_t *image;
cairo_set_source_rgb (cr, 1, 1, 1);
cairo_paint (cr);
image = cairo_test_create_surface_from_png (ctx, png_filename);
cairo_set_source_surface (cr, image, 0, 0);
/* simple clip */
cairo_save (cr);
cairo_rectangle (cr, 2, 2, 16, 16);
cairo_clip (cr);
cairo_paint (cr);
cairo_restore (cr);
cairo_translate (cr, WIDTH, 0);
/* unaligned clip */
cairo_save (cr);
cairo_rectangle (cr, 2.5, 2.5, 15, 15);
cairo_clip (cr);
cairo_paint (cr);
cairo_restore (cr);
cairo_translate (cr, -WIDTH, HEIGHT);
/* aligned-clip */
cairo_save (cr);
cairo_set_fill_rule (cr, CAIRO_FILL_RULE_EVEN_ODD);
cairo_rectangle (cr, 0, 0, 20, 20);
cairo_rectangle (cr, 3, 3, 10, 10);
cairo_rectangle (cr, 7, 7, 10, 10);
cairo_clip (cr);
cairo_paint (cr);
cairo_restore (cr);
cairo_translate (cr, WIDTH, 0);
/* force a clip-mask */
cairo_save (cr);
cairo_arc (cr, 10, 10, 10, 0, 2 * M_PI);
cairo_new_sub_path (cr);
cairo_arc_negative (cr, 10, 10, 5, 2 * M_PI, 0);
cairo_new_sub_path (cr);
cairo_arc (cr, 10, 10, 2, 0, 2 * M_PI);
cairo_clip (cr);
cairo_paint (cr);
cairo_restore (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);
cairo_surface_t *surface;
surface = cairo_test_create_surface_from_png (ctx, png_filename);
cairo_set_source_surface (cr, surface, 32, 32);
cairo_pattern_set_extend (cairo_get_source (cr), CAIRO_EXTEND_REFLECT);
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 cairo_test_context_t *ctx = cairo_test_get_context (cr);
size_t i, j, x, y;
cairo_pattern_t *pattern;
cairo_select_font_face (cr, "Bitstream Vera Sans",
CAIRO_FONT_SLANT_NORMAL,
CAIRO_FONT_WEIGHT_NORMAL);
for (j = 0; j < ARRAY_SIZE (draw_funcs); j++) {
for (i = 0; i < ARRAY_SIZE (operators); i++) {
x = i * (WIDTH + PAD) + PAD;
y = j * (HEIGHT + PAD) + PAD;
cairo_save (cr);
pattern = cairo_pattern_create_linear (x + WIDTH, y,
x, y + HEIGHT);
cairo_pattern_add_color_stop_rgba (pattern, 0.2,
0.0, 0.0, 1.0, 1.0); /* Solid blue */
cairo_pattern_add_color_stop_rgba (pattern, 0.8,
0.0, 0.0, 1.0, 0.0); /* Transparent blue */
cairo_set_source (cr, pattern);
cairo_pattern_destroy (pattern);
cairo_rectangle (cr, x, y, WIDTH, HEIGHT);
cairo_fill_preserve (cr);
cairo_clip (cr);
cairo_set_operator (cr, operators[i]);
cairo_set_source_rgb (cr, 1.0, 0.0, 0.0);
draw_funcs[j] (cr, x, y);
if (cairo_status (cr))
cairo_test_log (ctx, "%d %d HERE!\n", (int)i, (int)j);
cairo_restore (cr);
}
}
if (cairo_status (cr) != CAIRO_STATUS_SUCCESS)
cairo_test_log (ctx, "%d %d .HERE!\n", (int)i, (int)j);
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_func (cairo_t *cr, int width, int height)
{
cairo_rectangle_t region[4];
const cairo_test_context_t *ctx;
int i, j;
ctx = cairo_test_get_context (cr);
cairo_push_group_with_content (cr, CAIRO_CONTENT_COLOR);
draw (ctx, cr, NULL, 0);
for (i = 0; i < NLOOPS; i++) {
for (j = 0; j < NLOOPS; j++) {
region[0].x = i * SIZE / NLOOPS;
region[0].y = i * SIZE / NLOOPS;
region[0].width = SIZE / 4;
region[0].height = SIZE / 4;
region[1].x = j * SIZE / NLOOPS;
region[1].y = j * SIZE / NLOOPS;
region[1].width = SIZE / 4;
region[1].height = SIZE / 4;
region[2].x = i * SIZE / NLOOPS;
region[2].y = j * SIZE / NLOOPS;
region[2].width = SIZE / 4;
region[2].height = SIZE / 4;
region[3].x = j * SIZE / NLOOPS;
region[3].y = i * SIZE / NLOOPS;
region[3].width = SIZE / 4;
region[3].height = SIZE / 4;
draw (ctx, cr, region, 4);
}
}
cairo_pop_group_to_source (cr);
cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
cairo_paint (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);
cairo_surface_t *image;
image = cairo_test_create_surface_from_png (ctx, png_filename);
cairo_set_source_rgba (cr, 0, 0, 0, 1);
cairo_rectangle (cr, 0, 0, SIZE, SIZE);
cairo_fill (cr);
cairo_translate (cr, OFFSET, OFFSET);
cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
cairo_set_source_surface (cr, image, 0, 0);
cairo_rectangle (cr, 0, 0, SIZE - OFFSET, SIZE - OFFSET);
cairo_fill (cr);
cairo_surface_destroy (image);
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 *image, *mask;
image = cairo_test_create_surface_from_png (ctx, png_filename);
mask = create_mask (cr, 40, 40);
/* opaque background */
cairo_paint (cr);
/* center */
cairo_translate (cr,
(width - cairo_image_surface_get_width (image)) / 2.,
(height - cairo_image_surface_get_height (image)) / 2.);
/* rotate 30 degree around the center */
cairo_translate (cr, width/2., height/2.);
cairo_rotate (cr, -30 * 2 * M_PI / 360);
cairo_translate (cr, -width/2., -height/2.);
/* place the image on our surface */
cairo_set_source_surface (cr, image, 0, 0);
/* reset the drawing matrix */
cairo_identity_matrix (cr);
/* fill nicely */
cairo_scale (cr, width / 40., height / 40.);
/* apply the mask */
cairo_mask_surface (cr, mask, 0, 0);
cairo_surface_destroy (mask);
cairo_surface_destroy (image);
return CAIRO_TEST_SUCCESS;
}
/* Draw an image scaled down, with antialiasing disabled */
static cairo_test_status_t
draw (cairo_t *cr, int width, int height, cairo_filter_t filter)
{
const cairo_test_context_t *ctx = cairo_test_get_context (cr);
cairo_surface_t *image;
double x_scale, y_scale, scale;
cairo_set_source_rgb (cr, 1, 1, 1);
image = cairo_test_create_surface_from_png (ctx, png_filename);
x_scale = width * 1.0 / cairo_image_surface_get_width (image);
y_scale = height * 1.0 / cairo_image_surface_get_height (image);
scale = x_scale < y_scale ? x_scale : y_scale;
cairo_save (cr);
cairo_scale (cr, scale, scale);
cairo_set_source_surface (cr, image, 0, 0);
cairo_pattern_set_filter (cairo_get_source (cr), filter);
cairo_paint (cr);
cairo_restore (cr);
cairo_surface_destroy (image);
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
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);
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 cairo_test_context_t *ctx = cairo_test_get_context (cr);
cairo_surface_t *similar, *target;
cairo_test_status_t test_status;
cairo_status_t status;
unsigned int i;
target = cairo_get_target (cr);
/* Test a finished similar surface */
for (i = 0; i < ARRAY_LENGTH (tests); i++) {
similar = cairo_surface_create_similar (target,
cairo_surface_get_content (target),
10, 10);
cairo_surface_finish (similar);
test_status = tests[i].func (similar);
status = cairo_surface_status (similar);
cairo_surface_destroy (similar);
if (test_status != CAIRO_TEST_SUCCESS) {
cairo_test_log (ctx,
"Failed test %s with %d\n",
tests[i].name, (int) test_status);
return test_status;
}
if (tests[i].modifies_surface &&
strcmp (tests[i].name, "cairo_surface_finish") &&
strcmp (tests[i].name, "cairo_surface_flush") &&
status != CAIRO_STATUS_SURFACE_FINISHED) {
cairo_test_log (ctx,
"Failed test %s: Finished surface not set into error state\n",
tests[i].name);
return CAIRO_TEST_ERROR;
}
}
/* Test a normal surface for functions that have the wrong type */
for (i = 0; i < ARRAY_LENGTH (tests); i++) {
cairo_status_t desired_status;
if (tests[i].surface_type == -1)
continue;
similar = cairo_surface_create_similar (target,
cairo_surface_get_content (target),
10, 10);
if (cairo_surface_get_type (similar) == (cairo_surface_type_t) tests[i].surface_type) {
cairo_surface_destroy (similar);
continue;
}
test_status = tests[i].func (similar);
status = cairo_surface_status (similar);
cairo_surface_destroy (similar);
if (test_status != CAIRO_TEST_SUCCESS) {
cairo_test_log (ctx,
"Failed test %s with %d\n",
tests[i].name, (int) test_status);
return test_status;
}
desired_status = tests[i].modifies_surface ? CAIRO_STATUS_SURFACE_TYPE_MISMATCH : CAIRO_STATUS_SUCCESS;
if (status != desired_status) {
cairo_test_log (ctx,
"Failed test %s: Surface status should be %u (%s), but is %u (%s)\n",
tests[i].name,
desired_status, cairo_status_to_string (desired_status),
status, cairo_status_to_string (status));
return CAIRO_TEST_ERROR;
}
}
/* 565-compatible gray background */
cairo_set_source_rgb (cr, 0.51613, 0.55555, 0.51613);
cairo_paint (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);
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
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
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);
cairo_text_extents_t extents, nil_extents;
cairo_font_extents_t font_extents, nil_font_extents;
cairo_scaled_font_t *scaled_font;
cairo_select_font_face (cr, "Bitstream Vera Sans",
CAIRO_FONT_SLANT_NORMAL,
CAIRO_FONT_WEIGHT_NORMAL);
cairo_set_font_size (cr, 16);
cairo_move_to (cr, 10, 25);
cairo_show_text (cr, NULL);
cairo_show_text (cr, "");
cairo_show_glyphs (cr, NULL, 0);
cairo_show_glyphs (cr, (void*)8, 0);
cairo_move_to (cr, 10, 55);
cairo_text_path (cr, NULL);
cairo_text_path (cr, "");
cairo_glyph_path (cr, (void*)8, 0);
cairo_fill (cr);
memset (&nil_extents, 0, sizeof (cairo_text_extents_t));
memset (&extents, 0xff, sizeof (cairo_text_extents_t));
cairo_text_extents (cr, "", &extents);
if (! text_extents_equal (&extents, &nil_extents)) {
cairo_test_log (ctx, "Error: cairo_text_extents(\"\"); extents (%g, %g, %g, %g, %g, %g)\n",
extents.x_bearing, extents.y_bearing,
extents.width, extents.height,
extents.x_advance, extents.y_advance);
return CAIRO_TEST_FAILURE;
}
memset (&extents, 0xff, sizeof (cairo_text_extents_t));
cairo_text_extents (cr, NULL, &extents);
if (! text_extents_equal (&extents, &nil_extents)) {
cairo_test_log (ctx, "Error: cairo_text_extents(NULL); extents (%g, %g, %g, %g, %g, %g)\n",
extents.x_bearing, extents.y_bearing,
extents.width, extents.height,
extents.x_advance, extents.y_advance);
return CAIRO_TEST_FAILURE;
}
memset (&extents, 0xff, sizeof (cairo_text_extents_t));
cairo_glyph_extents (cr, (void*)8, 0, &extents);
if (! text_extents_equal (&extents, &nil_extents)) {
cairo_test_log (ctx, "Error: cairo_glyph_extents(); extents (%g, %g, %g, %g, %g, %g)\n",
extents.x_bearing, extents.y_bearing,
extents.width, extents.height,
extents.x_advance, extents.y_advance);
return CAIRO_TEST_FAILURE;
}
scaled_font = cairo_get_scaled_font (cr);
memset (&extents, 0xff, sizeof (cairo_text_extents_t));
cairo_scaled_font_text_extents (scaled_font, "", &extents);
if (! text_extents_equal (&extents, &nil_extents)) {
cairo_test_log (ctx, "Error: cairo_scaled_font_text_extents(\"\"); extents (%g, %g, %g, %g, %g, %g)\n",
extents.x_bearing, extents.y_bearing,
extents.width, extents.height,
extents.x_advance, extents.y_advance);
return CAIRO_TEST_FAILURE;
}
memset (&extents, 0xff, sizeof (cairo_text_extents_t));
cairo_scaled_font_text_extents (scaled_font, NULL, &extents);
if (! text_extents_equal (&extents, &nil_extents)) {
cairo_test_log (ctx, "Error: cairo_scaled_font_text_extents(NULL); extents (%g, %g, %g, %g, %g, %g)\n",
extents.x_bearing, extents.y_bearing,
extents.width, extents.height,
extents.x_advance, extents.y_advance);
return CAIRO_TEST_FAILURE;
}
memset (&extents, 0xff, sizeof (cairo_text_extents_t));
cairo_scaled_font_glyph_extents (scaled_font, (void*)8, 0, &extents);
if (! text_extents_equal (&extents, &nil_extents)) {
cairo_test_log (ctx, "Error: cairo_scaled_font_glyph_extents(NULL); extents (%g, %g, %g, %g, %g, %g)\n",
extents.x_bearing, extents.y_bearing,
extents.width, extents.height,
extents.x_advance, extents.y_advance);
return CAIRO_TEST_FAILURE;
}
/* Lets also try font size 0 while here */
cairo_set_font_size (cr, 0);
memset (&extents, 0xff, sizeof (cairo_text_extents_t));
cairo_text_extents (cr, "test", &extents);
if (! text_extents_equal (&extents, &nil_extents)) {
cairo_test_log (ctx, "Error: cairo_set_font_size(0); cairo_text_extents(\"test\"); extents (%g, %g, %g, %g, %g, %g)\n",
extents.x_bearing, extents.y_bearing,
extents.width, extents.height,
extents.x_advance, extents.y_advance);
return CAIRO_TEST_FAILURE;
}
memset (&nil_font_extents, 0, sizeof (cairo_font_extents_t));
memset (&font_extents, 0xff, sizeof (cairo_font_extents_t));
cairo_font_extents (cr, &font_extents);
if (! font_extents_equal (&font_extents, &nil_font_extents)) {
cairo_test_log (ctx, "Error: cairo_set_font_size(0); cairo_font_extents(); extents (%g, %g, %g, %g, %g)\n",
font_extents.ascent, font_extents.descent,
font_extents.height,
font_extents.max_x_advance, font_extents.max_y_advance);
return CAIRO_TEST_FAILURE;
}
scaled_font = cairo_get_scaled_font (cr);
memset (&font_extents, 0xff, sizeof (cairo_font_extents_t));
cairo_scaled_font_extents (scaled_font, &font_extents);
if (! font_extents_equal (&font_extents, &nil_font_extents)) {
cairo_test_log (ctx, "Error: cairo_set_font_size(0); cairo_scaled_font_extents(); extents (%g, %g, %g, %g, %g)\n",
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 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
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;
cairo_rectangle_list_t *rectangle_list;
const char *phase;
cairo_bool_t uses_clip_rects;
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);
/* Check the surface type so we ignore cairo_copy_clip_rectangle_list failures
* on surface types that don't use rectangle lists for clipping.
* Default to FALSE for the internal surface types, (meta, test-fallback, etc.)
*/
switch (cairo_surface_get_type (surface)) {
case CAIRO_SURFACE_TYPE_IMAGE:
case CAIRO_SURFACE_TYPE_XLIB:
case CAIRO_SURFACE_TYPE_XCB:
case CAIRO_SURFACE_TYPE_GLITZ:
case CAIRO_SURFACE_TYPE_WIN32:
case CAIRO_SURFACE_TYPE_BEOS:
case CAIRO_SURFACE_TYPE_DIRECTFB:
uses_clip_rects = TRUE;
break;
case CAIRO_SURFACE_TYPE_QUARTZ:
case CAIRO_SURFACE_TYPE_PDF:
case CAIRO_SURFACE_TYPE_PS:
case CAIRO_SURFACE_TYPE_SVG:
case CAIRO_SURFACE_TYPE_OS2:
default:
uses_clip_rects = FALSE;
break;
}
/* 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 (cr2);
if (!check_count (ctx, phase, uses_clip_rects, rectangle_list, 1) ||
!check_clip_extents (ctx, phase, cr2, 0, 0, 100, 100) ||
!check_rectangles_contain (ctx, phase, uses_clip_rects, rectangle_list, 0, 0, 100, 100)) {
cairo_rectangle_list_destroy (rectangle_list);
return CAIRO_TEST_FAILURE;
}
cairo_rectangle_list_destroy (rectangle_list);
/* Test simple clip rect. */
phase = "Simple clip rect";
cairo_save (cr2);
cairo_rectangle (cr2, 10, 10, 80, 80);
cairo_clip (cr2);
rectangle_list = cairo_copy_clip_rectangle_list (cr2);
if (!check_count (ctx, phase, uses_clip_rects, rectangle_list, 1) ||
!check_clip_extents (ctx, phase, cr2, 10, 10, 80, 80) ||
!check_rectangles_contain (ctx, phase, uses_clip_rects, rectangle_list, 10, 10, 80, 80)) {
cairo_rectangle_list_destroy (rectangle_list);
return CAIRO_TEST_FAILURE;
}
cairo_rectangle_list_destroy (rectangle_list);
cairo_restore (cr2);
/* Test everything clipped out. */
phase = "All clipped out";
cairo_save (cr2);
cairo_clip (cr2);
rectangle_list = cairo_copy_clip_rectangle_list (cr2);
if (!check_count (ctx, phase, uses_clip_rects, rectangle_list, 0)) {
cairo_rectangle_list_destroy (rectangle_list);
return CAIRO_TEST_FAILURE;
}
cairo_rectangle_list_destroy (rectangle_list);
cairo_restore (cr2);
/* test two clip rects */
phase = "Two clip rects";
cairo_save (cr2);
cairo_rectangle (cr2, 10, 10, 10, 10);
cairo_rectangle (cr2, 20, 20, 10, 10);
cairo_clip (cr2);
cairo_rectangle (cr2, 15, 15, 10, 10);
cairo_clip (cr2);
rectangle_list = cairo_copy_clip_rectangle_list (cr2);
if (!check_count (ctx, phase, uses_clip_rects, rectangle_list, 2) ||
!check_clip_extents (ctx, phase, cr2, 15, 15, 10, 10) ||
!check_rectangles_contain (ctx, phase, uses_clip_rects, rectangle_list, 15, 15, 5, 5) ||
!check_rectangles_contain (ctx, phase, uses_clip_rects, rectangle_list, 20, 20, 5, 5)) {
cairo_rectangle_list_destroy (rectangle_list);
return CAIRO_TEST_FAILURE;
}
cairo_rectangle_list_destroy (rectangle_list);
cairo_restore (cr2);
/* test non-rectangular clip */
phase = "Nonrectangular clip";
cairo_save (cr2);
cairo_move_to (cr2, 0, 0);
cairo_line_to (cr2, 100, 100);
cairo_line_to (cr2, 100, 0);
cairo_close_path (cr2);
cairo_clip (cr2);
rectangle_list = cairo_copy_clip_rectangle_list (cr2);
/* can't get this in one tight user-space rectangle */
if (!check_unrepresentable (ctx, phase, rectangle_list) ||
!check_clip_extents (ctx, phase, cr2, 0, 0, 100, 100)) {
cairo_rectangle_list_destroy (rectangle_list);
return CAIRO_TEST_FAILURE;
}
cairo_rectangle_list_destroy (rectangle_list);
cairo_restore (cr2);
phase = "User space, simple scale, getting clip with same transform";
cairo_save (cr2);
cairo_scale (cr2, 2, 2);
cairo_rectangle (cr2, 5, 5, 40, 40);
cairo_clip (cr2);
rectangle_list = cairo_copy_clip_rectangle_list (cr2);
if (!check_count (ctx, phase, uses_clip_rects, rectangle_list, 1) ||
!check_clip_extents (ctx, phase, cr2, 5, 5, 40, 40) ||
!check_rectangles_contain (ctx, phase, uses_clip_rects, rectangle_list, 5, 5, 40, 40)) {
cairo_rectangle_list_destroy (rectangle_list);
return CAIRO_TEST_FAILURE;
}
cairo_rectangle_list_destroy (rectangle_list);
cairo_restore (cr2);
phase = "User space, simple scale, getting clip with no transform";
cairo_save (cr2);
cairo_save (cr2);
cairo_scale (cr2, 2, 2);
cairo_rectangle (cr2, 5, 5, 40, 40);
cairo_restore (cr2);
cairo_clip (cr2);
rectangle_list = cairo_copy_clip_rectangle_list (cr2);
if (!check_count (ctx, phase, uses_clip_rects, rectangle_list, 1) ||
!check_clip_extents (ctx, phase, cr2, 10, 10, 80, 80) ||
!check_rectangles_contain (ctx, phase, uses_clip_rects, rectangle_list, 10, 10, 80, 80)) {
cairo_rectangle_list_destroy (rectangle_list);
return CAIRO_TEST_FAILURE;
}
cairo_rectangle_list_destroy (rectangle_list);
cairo_restore (cr2);
phase = "User space, rotation, getting clip with no transform";
cairo_save (cr2);
cairo_save (cr2);
cairo_rotate (cr2, 12);
cairo_rectangle (cr2, 5, 5, 40, 40);
cairo_restore (cr2);
cairo_clip (cr2);
rectangle_list = cairo_copy_clip_rectangle_list (cr2);
if (!check_unrepresentable (ctx, phase, rectangle_list)) {
cairo_rectangle_list_destroy (rectangle_list);
return CAIRO_TEST_FAILURE;
}
cairo_rectangle_list_destroy (rectangle_list);
cairo_restore (cr2);
cairo_destroy (cr2);
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);
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);
cairo_surface_t *surface;
cairo_pattern_t *pattern;
cairo_t *cr2;
/*
* 1. Test file-not-found from surface->pattern->cairo_t
*/
/* Make a custom context to not interfere with the one passed in. */
cr2 = cairo_create (cairo_get_target (cr));
/* First, let's make a nil surface. */
surface = cairo_image_surface_create_from_png ("___THIS_FILE_DOES_NOT_EXIST___");
/* Let the error propagate into a nil pattern. */
pattern = cairo_pattern_create_for_surface (surface);
/* Then let it propagate into the cairo_t. */
cairo_set_source (cr2, pattern);
cairo_paint (cr2);
cairo_pattern_destroy (pattern);
cairo_surface_destroy (surface);
/* Check that the error made it all that way. */
if (cairo_status (cr2) != CAIRO_STATUS_FILE_NOT_FOUND) {
cairo_test_log (ctx, "Error: Received status of \"%s\" rather than expected \"%s\"\n",
cairo_status_to_string (cairo_status (cr2)),
cairo_status_to_string (CAIRO_STATUS_FILE_NOT_FOUND));
cairo_destroy (cr2);
return CAIRO_TEST_FAILURE;
}
cairo_destroy (cr2);
/*
* 2. Test NULL pointer pattern->cairo_t
*/
cr2 = cairo_create (cairo_get_target (cr));
/* First, trigger the NULL pointer status. */
pattern = cairo_pattern_create_for_surface (NULL);
/* Then let it propagate into the cairo_t. */
cairo_set_source (cr2, pattern);
cairo_paint (cr2);
cairo_pattern_destroy (pattern);
/* Check that the error made it all that way. */
if (cairo_status (cr2) != CAIRO_STATUS_NULL_POINTER) {
cairo_test_log (ctx, "Error: Received status of \"%s\" rather than expected \"%s\"\n",
cairo_status_to_string (cairo_status (cr2)),
cairo_status_to_string (CAIRO_STATUS_NULL_POINTER));
cairo_destroy (cr2);
return CAIRO_TEST_FAILURE;
}
cairo_destroy (cr2);
/*
* 3. Test that cairo_surface_finish can accept NULL or a nil
* surface without crashing.
*/
cairo_surface_finish (NULL);
surface = cairo_image_surface_create_from_png ("___THIS_FILE_DOES_NOT_EXIST___");
cairo_surface_finish (surface);
cairo_surface_destroy (surface);
/*
* 4. OK, we're straying from the original name, but it's still a
* similar kind of testing of error paths. Here we're making sure
* we can still call a cairo_get_* function after triggering an
* INVALID_RESTORE error.
*/
cr2 = cairo_create (cairo_get_target (cr));
/* Trigger invalid restore. */
cairo_restore (cr2);
if (cairo_status (cr2) != CAIRO_STATUS_INVALID_RESTORE) {
cairo_test_log (ctx, "Error: Received status of \"%s\" rather than expected \"%s\"\n",
cairo_status_to_string (cairo_status (cr2)),
cairo_status_to_string (CAIRO_STATUS_INVALID_RESTORE));
cairo_destroy (cr2);
return CAIRO_TEST_FAILURE;
}
/* Test that we can still call cairo_get_fill_rule without crashing. */
cairo_get_fill_rule (cr2);
cairo_destroy (cr2);
/*
* 5. Create a cairo_t for the NULL surface.
*/
cr2 = cairo_create (NULL);
if (cairo_status (cr2) != CAIRO_STATUS_NULL_POINTER) {
cairo_test_log (ctx, "Error: Received status of \"%s\" rather than expected \"%s\"\n",
cairo_status_to_string (cairo_status (cr2)),
cairo_status_to_string (CAIRO_STATUS_NULL_POINTER));
cairo_destroy (cr2);
return CAIRO_TEST_FAILURE;
}
/* Test that get_target returns something valid */
if (cairo_get_target (cr2) == NULL) {
cairo_test_log (ctx, "Error: cairo_get_target() returned NULL\n");
cairo_destroy (cr2);
return CAIRO_TEST_FAILURE;
}
/* Test that push_group doesn't crash */
cairo_push_group (cr2);
cairo_stroke (cr2);
cairo_pop_group (cr2);
cairo_destroy (cr2);
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;
cairo_pattern_t *pat;
/* Test pattern_get_rgba */
{
double r, g, b, a;
pat = cairo_pattern_create_rgba (0.2, 0.3, 0.4, 0.5);
status = cairo_pattern_get_rgba (pat, &r, &g, &b, &a);
CHECK_SUCCESS;
if (!CAIRO_TEST_DOUBLE_EQUALS(r,0.2) ||
!CAIRO_TEST_DOUBLE_EQUALS(g,0.3) ||
!CAIRO_TEST_DOUBLE_EQUALS(b,0.4) ||
!CAIRO_TEST_DOUBLE_EQUALS(a,0.5)) {
cairo_test_log (ctx, "Error: cairo_pattern_get_rgba returned unexepcted results: %g, %g, %g, %g\n",
r, g, b, a);
return CAIRO_TEST_FAILURE;
}
cairo_pattern_destroy (pat);
}
/* Test pattern_get_surface */
{
cairo_surface_t *surf;
pat = cairo_pattern_create_for_surface (cairo_get_target (cr));
status = cairo_pattern_get_surface (pat, &surf);
CHECK_SUCCESS;
if (surf != cairo_get_target (cr)) {
cairo_test_log (ctx, "Error: cairo_pattern_get_resurface returned wrong surface\n");
return CAIRO_TEST_FAILURE;
}
cairo_pattern_destroy (pat);
}
/* Test get_color_stops & linear_get_points */
{
int i;
double x0, y0, x1, y1;
double expected_values[15] = { 0.0, 0.2, 0.4, 0.2, 1.0,
0.5, 0.4, 0.5, 0.2, 0.5,
1.0, 0.2, 0.4, 0.5, 0.2
};
double new_buf[15];
pat = cairo_pattern_create_linear (1.0, 2.0, 3.0, 4.0);
for (i = 0; i < 3; i++) {
cairo_pattern_add_color_stop_rgba (pat,
expected_values[i*5+0],
expected_values[i*5+1],
expected_values[i*5+2],
expected_values[i*5+3],
expected_values[i*5+4]);
}
status = cairo_pattern_get_linear_points (pat, &x0, &y0, &x1, &y1);
CHECK_SUCCESS;
if (!CAIRO_TEST_DOUBLE_EQUALS(x0,1.0) ||
!CAIRO_TEST_DOUBLE_EQUALS(y0,2.0) ||
!CAIRO_TEST_DOUBLE_EQUALS(x1,3.0) ||
!CAIRO_TEST_DOUBLE_EQUALS(y1,4.0))
return CAIRO_TEST_FAILURE;
status = cairo_pattern_get_color_stop_count (pat, &i);
CHECK_SUCCESS;
if (i != 3)
return CAIRO_TEST_FAILURE;
for (i = 0; i < 3; i++) {
status = cairo_pattern_get_color_stop_rgba (pat, i,
&new_buf[i*5+0],
&new_buf[i*5+1],
&new_buf[i*5+2],
&new_buf[i*5+3],
&new_buf[i*5+4]);
CHECK_SUCCESS;
}
status = cairo_pattern_get_color_stop_rgba (pat, 5, NULL, NULL, NULL, NULL, NULL);
if (status != CAIRO_STATUS_INVALID_INDEX)
return CAIRO_TEST_FAILURE;
if (!double_buf_equal (ctx, new_buf, expected_values, sizeof(expected_values)/sizeof(double)) != 0)
return CAIRO_TEST_FAILURE;
cairo_pattern_destroy (pat);
}
/* Test radial_get_circles */
{
double a, b, c, d, e, f;
pat = cairo_pattern_create_radial (1, 2, 3,
4, 5, 6);
status = cairo_pattern_get_radial_circles (pat, &a, &b, &c, &d, &e, &f);
CHECK_SUCCESS;
if (!CAIRO_TEST_DOUBLE_EQUALS(a,1.0) ||
!CAIRO_TEST_DOUBLE_EQUALS(b,2.0) ||
!CAIRO_TEST_DOUBLE_EQUALS(c,3.0) ||
!CAIRO_TEST_DOUBLE_EQUALS(d,4.0) ||
!CAIRO_TEST_DOUBLE_EQUALS(e,5.0) ||
!CAIRO_TEST_DOUBLE_EQUALS(f,6.0))
return CAIRO_TEST_FAILURE;
cairo_pattern_destroy (pat);
}
cairo_set_source_rgb (cr, 0, 1, 0);
cairo_paint (cr);
return CAIRO_TEST_SUCCESS;
}
