diff options
Diffstat (limited to 'test/api-special-cases.c')
| -rw-r--r-- | test/api-special-cases.c | 1174 |
1 files changed, 1153 insertions, 21 deletions
diff --git a/test/api-special-cases.c b/test/api-special-cases.c index 53891bd7b..e8611525f 100644 --- a/test/api-special-cases.c +++ b/test/api-special-cases.c @@ -28,8 +28,8 @@ * * This test tests that for all public APIs Cairo behaves correct, consistent * and most of all doesn't crash. It does this by calling all APIs that take - * surfaces and calling them on specially prepared surfaces that should fail - * when called on this function. + * surfaces or contexts and calling them on specially prepared arguments that + * should fail when called on this function. * * ADDING NEW FUNCTIONS * @@ -100,6 +100,894 @@ #define surface_has_type(surface,type) (cairo_surface_get_type (surface) == (type)) typedef cairo_test_status_t (* surface_test_func_t) (cairo_surface_t *surface); +typedef cairo_test_status_t (* context_test_func_t) (cairo_t *cr); + +static cairo_test_status_t +test_cairo_reference (cairo_t *cr) +{ + cairo_destroy (cairo_reference (cr)); + + return CAIRO_TEST_SUCCESS; +} + +static cairo_test_status_t +test_cairo_get_reference_count (cairo_t *cr) +{ + unsigned int refcount = cairo_get_reference_count (cr); + if (refcount > 0) + return CAIRO_TEST_SUCCESS; + /* inert error context have a refcount of 0 */ + return cairo_status (cr) ? CAIRO_TEST_SUCCESS : CAIRO_TEST_ERROR; +} + +static cairo_test_status_t +test_cairo_set_user_data (cairo_t *cr) +{ + static cairo_user_data_key_t key; + cairo_status_t status; + + status = cairo_set_user_data (cr, &key, &key, NULL); + if (status == CAIRO_STATUS_NO_MEMORY) + return CAIRO_TEST_NO_MEMORY; + else if (status) + return CAIRO_TEST_SUCCESS; + + if (cairo_get_user_data (cr, &key) != &key) + return CAIRO_TEST_ERROR; + + return CAIRO_TEST_SUCCESS; +} + +static cairo_test_status_t +test_cairo_save (cairo_t *cr) +{ + cairo_save (cr); + cairo_restore (cr); + + return CAIRO_TEST_SUCCESS; +} + +static cairo_test_status_t +test_cairo_push_group (cairo_t *cr) +{ + cairo_pattern_t *pattern; + cairo_status_t status; + + cairo_push_group (cr); + pattern = cairo_pop_group (cr); + status = cairo_pattern_status (pattern); + cairo_pattern_destroy (pattern); + + return status == CAIRO_STATUS_SUCCESS || status == cairo_status (cr) ? CAIRO_TEST_SUCCESS : CAIRO_TEST_ERROR; +} + +static cairo_test_status_t +test_cairo_push_group_with_content (cairo_t *cr) +{ + cairo_push_group_with_content (cr, CAIRO_CONTENT_COLOR_ALPHA); + cairo_pop_group_to_source (cr); + + return CAIRO_TEST_SUCCESS; +} + +static cairo_test_status_t +test_cairo_set_operator (cairo_t *cr) +{ + cairo_set_operator (cr, CAIRO_OPERATOR_OVER); + + return CAIRO_TEST_SUCCESS; +} + +static cairo_test_status_t +test_cairo_set_source (cairo_t *cr) +{ + cairo_set_source (cr, cairo_pattern_create_rgb (0, 0, 0)); + + return CAIRO_TEST_SUCCESS; +} + +static cairo_test_status_t +test_cairo_set_source_rgb (cairo_t *cr) +{ + cairo_set_source_rgb (cr, 0, 0, 0); + + return CAIRO_TEST_SUCCESS; +} + +static cairo_test_status_t +test_cairo_set_source_rgba (cairo_t *cr) +{ + cairo_set_source_rgba (cr, 0, 0, 0, 1); + + return CAIRO_TEST_SUCCESS; +} + +static cairo_test_status_t +test_cairo_set_source_surface (cairo_t *cr) +{ + cairo_surface_t *surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, 1, 1); + cairo_set_source_surface (cr, surface, 0, 0); + cairo_surface_destroy (surface); + + return CAIRO_TEST_SUCCESS; +} + +static cairo_test_status_t +test_cairo_set_tolerance (cairo_t *cr) +{ + cairo_set_tolerance (cr, 42); + + return CAIRO_TEST_SUCCESS; +} + +static cairo_test_status_t +test_cairo_set_antialias (cairo_t *cr) +{ + cairo_set_antialias (cr, CAIRO_ANTIALIAS_BEST); + + return CAIRO_TEST_SUCCESS; +} + +static cairo_test_status_t +test_cairo_set_fill_rule (cairo_t *cr) +{ + cairo_set_fill_rule (cr, CAIRO_FILL_RULE_EVEN_ODD); + + return CAIRO_TEST_SUCCESS; +} + +static cairo_test_status_t +test_cairo_set_line_width (cairo_t *cr) +{ + cairo_set_line_width (cr, 42); + + return CAIRO_TEST_SUCCESS; +} + +static cairo_test_status_t +test_cairo_set_line_cap (cairo_t *cr) +{ + cairo_set_line_cap (cr, CAIRO_LINE_CAP_ROUND); + + return CAIRO_TEST_SUCCESS; +} + +static cairo_test_status_t +test_cairo_set_line_join (cairo_t *cr) +{ + cairo_set_line_join (cr, CAIRO_LINE_JOIN_BEVEL); + + return CAIRO_TEST_SUCCESS; +} + +static cairo_test_status_t +test_cairo_set_dash (cairo_t *cr) +{ + cairo_set_dash (cr, NULL, 0, 0); + + return CAIRO_TEST_SUCCESS; +} + +static cairo_test_status_t +test_cairo_set_miter_limit (cairo_t *cr) +{ + cairo_set_miter_limit (cr, 2); + + return CAIRO_TEST_SUCCESS; +} + +static cairo_test_status_t +test_cairo_translate (cairo_t *cr) +{ + cairo_translate (cr, 2, 2); + + return CAIRO_TEST_SUCCESS; +} + +static cairo_test_status_t +test_cairo_scale (cairo_t *cr) +{ + cairo_scale (cr, 2, 2); + + return CAIRO_TEST_SUCCESS; +} + +static cairo_test_status_t +test_cairo_rotate (cairo_t *cr) +{ + cairo_rotate (cr, 2); + + return CAIRO_TEST_SUCCESS; +} + +static cairo_test_status_t +test_cairo_transform (cairo_t *cr) +{ + cairo_matrix_t matrix; + + cairo_matrix_init_translate (&matrix, 1, 1); + cairo_transform (cr, &matrix); + + return CAIRO_TEST_SUCCESS; +} + +static cairo_test_status_t +test_cairo_set_matrix (cairo_t *cr) +{ + cairo_matrix_t matrix; + + cairo_matrix_init_translate (&matrix, 1, 1); + cairo_set_matrix (cr, &matrix); + + return CAIRO_TEST_SUCCESS; +} + +static cairo_test_status_t +test_cairo_identity_matrix (cairo_t *cr) +{ + cairo_identity_matrix (cr); + + return CAIRO_TEST_SUCCESS; +} + +static cairo_test_status_t +test_cairo_user_to_device (cairo_t *cr) +{ + double x = 42, y = 42; + + cairo_user_to_device (cr, &x, &y); + + return CAIRO_TEST_SUCCESS; +} + +static cairo_test_status_t +test_cairo_user_to_device_distance (cairo_t *cr) +{ + double x = 42, y = 42; + + cairo_user_to_device_distance (cr, &x, &y); + + return CAIRO_TEST_SUCCESS; +} + +static cairo_test_status_t +test_cairo_device_to_user (cairo_t *cr) +{ + double x = 42, y = 42; + + cairo_device_to_user (cr, &x, &y); + + return CAIRO_TEST_SUCCESS; +} + +static cairo_test_status_t +test_cairo_device_to_user_distance (cairo_t *cr) +{ + double x = 42, y = 42; + + cairo_device_to_user_distance (cr, &x, &y); + + return CAIRO_TEST_SUCCESS; +} + +static cairo_test_status_t +test_cairo_new_path (cairo_t *cr) +{ + cairo_new_path (cr); + + return CAIRO_TEST_SUCCESS; +} + +static cairo_test_status_t +test_cairo_move_to (cairo_t *cr) +{ + cairo_move_to (cr, 2, 2); + + return CAIRO_TEST_SUCCESS; +} + +static cairo_test_status_t +test_cairo_new_sub_path (cairo_t *cr) +{ + cairo_new_sub_path (cr); + + return CAIRO_TEST_SUCCESS; +} + +static cairo_test_status_t +test_cairo_line_to (cairo_t *cr) +{ + cairo_line_to (cr, 2, 2); + + return CAIRO_TEST_SUCCESS; +} + +static cairo_test_status_t +test_cairo_curve_to (cairo_t *cr) +{ + cairo_curve_to (cr, 2, 2, 3, 3, 4, 4); + + return CAIRO_TEST_SUCCESS; +} + +static cairo_test_status_t +test_cairo_arc (cairo_t *cr) +{ + cairo_arc (cr, 2, 2, 3, 0, 2 * M_PI); + + return CAIRO_TEST_SUCCESS; +} + +static cairo_test_status_t +test_cairo_arc_negative (cairo_t *cr) +{ + cairo_arc_negative (cr, 2, 2, 3, 0, 2 * M_PI); + + return CAIRO_TEST_SUCCESS; +} + +static cairo_test_status_t +test_cairo_rel_move_to (cairo_t *cr) +{ + cairo_rel_move_to (cr, 2, 2); + + return CAIRO_TEST_SUCCESS; +} + +static cairo_test_status_t +test_cairo_rel_line_to (cairo_t *cr) +{ + cairo_rel_line_to (cr, 2, 2); + + return CAIRO_TEST_SUCCESS; +} + +static cairo_test_status_t +test_cairo_rel_curve_to (cairo_t *cr) +{ + cairo_rel_curve_to (cr, 2, 2, 3, 3, 4, 4); + + return CAIRO_TEST_SUCCESS; +} + +static cairo_test_status_t +test_cairo_rectangle (cairo_t *cr) +{ + cairo_rectangle (cr, 2, 2, 3, 3); + + return CAIRO_TEST_SUCCESS; +} + +static cairo_test_status_t +test_cairo_close_path (cairo_t *cr) +{ + cairo_close_path (cr); + + return CAIRO_TEST_SUCCESS; +} + +static cairo_test_status_t +test_cairo_path_extents (cairo_t *cr) +{ + double x1, y1, x2, y2; + cairo_path_extents (cr, &x1, &y1, &x2, &y2); + + return CAIRO_TEST_SUCCESS; +} + +static cairo_test_status_t +test_cairo_paint (cairo_t *cr) +{ + cairo_paint (cr); + + return CAIRO_TEST_SUCCESS; +} + +static cairo_test_status_t +test_cairo_paint_with_alpha (cairo_t *cr) +{ + cairo_paint_with_alpha (cr, 0.5); + + return CAIRO_TEST_SUCCESS; +} + +static cairo_test_status_t +test_cairo_mask (cairo_t *cr) +{ + cairo_pattern_t *pattern; + + pattern = cairo_pattern_create_rgb (0.5, 0.5, 0.5); + cairo_mask (cr, pattern); + + cairo_pattern_destroy (pattern); + return CAIRO_TEST_SUCCESS; +} + +static cairo_test_status_t +test_cairo_mask_surface (cairo_t *cr) +{ + cairo_surface_t *surface; + + surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, 1, 1); + cairo_mask_surface (cr, surface, 0, 0); + + cairo_surface_destroy (surface); + return CAIRO_TEST_SUCCESS; +} + +static cairo_test_status_t +test_cairo_stroke (cairo_t *cr) +{ + cairo_stroke (cr); + + return CAIRO_TEST_SUCCESS; +} + +static cairo_test_status_t +test_cairo_stroke_preserve (cairo_t *cr) +{ + cairo_stroke_preserve (cr); + + return CAIRO_TEST_SUCCESS; +} + +static cairo_test_status_t +test_cairo_fill (cairo_t *cr) +{ + cairo_fill (cr); + + return CAIRO_TEST_SUCCESS; +} + +static cairo_test_status_t +test_cairo_fill_preserve (cairo_t *cr) +{ + cairo_fill_preserve (cr); + + return CAIRO_TEST_SUCCESS; +} + +static cairo_test_status_t +test_cairo_copy_page (cairo_t *cr) +{ + cairo_copy_page (cr); + + return CAIRO_TEST_SUCCESS; +} + +static cairo_test_status_t +test_cairo_show_page (cairo_t *cr) +{ + cairo_show_page (cr); + + return CAIRO_TEST_SUCCESS; +} + +static cairo_test_status_t +test_cairo_in_stroke (cairo_t *cr) +{ + cairo_in_stroke (cr, 1, 1); + + return CAIRO_TEST_SUCCESS; +} + +static cairo_test_status_t +test_cairo_in_fill (cairo_t *cr) +{ + cairo_in_fill (cr, 1, 1); + + return CAIRO_TEST_SUCCESS; +} + +static cairo_test_status_t +test_cairo_in_clip (cairo_t *cr) +{ + cairo_in_clip (cr, 1, 1); + + return CAIRO_TEST_SUCCESS; +} + +static cairo_test_status_t +test_cairo_stroke_extents (cairo_t *cr) +{ + double x1, y1, x2, y2; + cairo_stroke_extents (cr, &x1, &y1, &x2, &y2); + + return CAIRO_TEST_SUCCESS; +} + +static cairo_test_status_t +test_cairo_fill_extents (cairo_t *cr) +{ + double x1, y1, x2, y2; + cairo_fill_extents (cr, &x1, &y1, &x2, &y2); + + return CAIRO_TEST_SUCCESS; +} + +static cairo_test_status_t +test_cairo_reset_clip (cairo_t *cr) +{ + cairo_reset_clip (cr); + + return CAIRO_TEST_SUCCESS; +} + +static cairo_test_status_t +test_cairo_clip (cairo_t *cr) +{ + cairo_clip (cr); + + return CAIRO_TEST_SUCCESS; +} + +static cairo_test_status_t +test_cairo_clip_preserve (cairo_t *cr) +{ + cairo_clip_preserve (cr); + + return CAIRO_TEST_SUCCESS; +} + +static cairo_test_status_t +test_cairo_clip_extents (cairo_t *cr) +{ + double x1, y1, x2, y2; + cairo_clip_extents (cr, &x1, &y1, &x2, &y2); + + return CAIRO_TEST_SUCCESS; +} + +static cairo_test_status_t +test_cairo_copy_clip_rectangle_list (cairo_t *cr) +{ + cairo_rectangle_list_destroy (cairo_copy_clip_rectangle_list (cr)); + + return CAIRO_TEST_SUCCESS; +} + +static cairo_test_status_t +test_cairo_select_font_face (cairo_t *cr) +{ + cairo_select_font_face (cr, "Arial", CAIRO_FONT_SLANT_ITALIC, CAIRO_FONT_WEIGHT_BOLD); + + return CAIRO_TEST_SUCCESS; +} + +static cairo_test_status_t +test_cairo_set_font_size (cairo_t *cr) +{ + cairo_set_font_size (cr, 42); + + return CAIRO_TEST_SUCCESS; +} + +static cairo_test_status_t +test_cairo_set_font_matrix (cairo_t *cr) +{ + cairo_matrix_t matrix; + + cairo_matrix_init_translate (&matrix, 1, 1); + cairo_set_font_matrix (cr, &matrix); + + return CAIRO_TEST_SUCCESS; +} + +static cairo_test_status_t +test_cairo_get_font_matrix (cairo_t *cr) +{ + cairo_matrix_t matrix; + + cairo_get_font_matrix (cr, &matrix); + + return CAIRO_TEST_SUCCESS; +} + +static cairo_test_status_t +test_cairo_set_font_options (cairo_t *cr) +{ + cairo_font_options_t *opt = cairo_font_options_create (); + cairo_set_font_options (cr, opt); + cairo_font_options_destroy (opt); + + return CAIRO_TEST_SUCCESS; +} + +static cairo_test_status_t +test_cairo_get_font_options (cairo_t *cr) +{ + cairo_font_options_t *opt = cairo_font_options_create (); + cairo_get_font_options (cr, opt); + cairo_font_options_destroy (opt); + + return CAIRO_TEST_SUCCESS; +} + +static cairo_test_status_t +test_cairo_set_font_face (cairo_t *cr) +{ + cairo_set_font_face (cr, cairo_get_font_face (cr)); + + return CAIRO_TEST_SUCCESS; +} + +static cairo_test_status_t +test_cairo_set_scaled_font (cairo_t *cr) +{ + cairo_set_scaled_font (cr, cairo_get_scaled_font (cr)); + + return CAIRO_TEST_SUCCESS; +} + +static cairo_test_status_t +test_cairo_show_text (cairo_t *cr) +{ + cairo_show_text (cr, "Cairo"); + + return CAIRO_TEST_SUCCESS; +} + +static cairo_test_status_t +test_cairo_show_glyphs (cairo_t *cr) +{ + cairo_glyph_t glyph; + + glyph.index = 65; + glyph.x = 0; + glyph.y = 0; + + cairo_show_glyphs (cr, &glyph, 1); + + return CAIRO_TEST_SUCCESS; +} + +static cairo_test_status_t +test_cairo_show_text_glyphs (cairo_t *cr) +{ + cairo_glyph_t glyph; + cairo_text_cluster_t cluster; + + glyph.index = 65; + glyph.x = 0; + glyph.y = 0; + + cluster.num_bytes = 1; + cluster.num_glyphs = 1; + + cairo_show_text_glyphs (cr, "a", -1, &glyph, 1, &cluster, 1, 0); + + return CAIRO_TEST_SUCCESS; +} + +static cairo_test_status_t +test_cairo_text_path (cairo_t *cr) +{ + cairo_text_path (cr, "Cairo"); + + return CAIRO_TEST_SUCCESS; +} + +static cairo_test_status_t +test_cairo_glyph_path (cairo_t *cr) +{ + cairo_glyph_t glyph; + + glyph.index = 65; + glyph.x = 0; + glyph.y = 0; + + cairo_glyph_path (cr, &glyph, 1); + + return CAIRO_TEST_SUCCESS; +} + +static cairo_test_status_t +test_cairo_text_extents (cairo_t *cr) +{ + cairo_text_extents_t extents; + + cairo_text_extents (cr, "Cairo", &extents); + + return CAIRO_TEST_SUCCESS; +} + +static cairo_test_status_t +test_cairo_glyph_extents (cairo_t *cr) +{ + cairo_glyph_t glyph; + cairo_text_extents_t extents; + + glyph.index = 65; + glyph.x = 0; + glyph.y = 0; + + cairo_glyph_extents (cr, &glyph, 1, &extents); + + return CAIRO_TEST_SUCCESS; +} + +static cairo_test_status_t +test_cairo_font_extents (cairo_t *cr) +{ + cairo_font_extents_t extents; + + cairo_font_extents (cr, &extents); + + return CAIRO_TEST_SUCCESS; +} + +static cairo_test_status_t +test_cairo_get_operator (cairo_t *cr) +{ + cairo_get_operator (cr); + + return CAIRO_TEST_SUCCESS; +} + +static cairo_test_status_t +test_cairo_get_source (cairo_t *cr) +{ + cairo_get_source (cr); + + return CAIRO_TEST_SUCCESS; +} + +static cairo_test_status_t +test_cairo_get_tolerance (cairo_t *cr) +{ + cairo_get_tolerance (cr); + + return CAIRO_TEST_SUCCESS; +} + +static cairo_test_status_t +test_cairo_get_antialias (cairo_t *cr) +{ + cairo_get_antialias (cr); + + return CAIRO_TEST_SUCCESS; +} + +static cairo_test_status_t +test_cairo_has_current_point (cairo_t *cr) +{ + cairo_has_current_point (cr); + + return CAIRO_TEST_SUCCESS; +} + +static cairo_test_status_t +test_cairo_get_current_point (cairo_t *cr) +{ + double x, y; + + cairo_get_current_point (cr, &x, &y); + + return CAIRO_TEST_SUCCESS; +} + +static cairo_test_status_t +test_cairo_get_fill_rule (cairo_t *cr) +{ + cairo_get_fill_rule (cr); + + return CAIRO_TEST_SUCCESS; +} + +static cairo_test_status_t +test_cairo_get_line_width (cairo_t *cr) +{ + cairo_get_line_width (cr); + + return CAIRO_TEST_SUCCESS; +} + +static cairo_test_status_t +test_cairo_get_line_cap (cairo_t *cr) +{ + cairo_get_line_cap (cr); + + return CAIRO_TEST_SUCCESS; +} + +static cairo_test_status_t +test_cairo_get_line_join (cairo_t *cr) +{ + cairo_get_line_join (cr); + + return CAIRO_TEST_SUCCESS; +} + +static cairo_test_status_t +test_cairo_get_miter_limit (cairo_t *cr) +{ + cairo_get_miter_limit (cr); + + return CAIRO_TEST_SUCCESS; +} + +static cairo_test_status_t +test_cairo_get_dash_count (cairo_t *cr) +{ + cairo_get_dash_count (cr); + + return CAIRO_TEST_SUCCESS; +} + +static cairo_test_status_t +test_cairo_get_dash (cairo_t *cr) +{ + double dashes[42]; + double offset; + + cairo_get_dash (cr, &dashes[0], &offset); + + return CAIRO_TEST_SUCCESS; +} + +static cairo_test_status_t +test_cairo_get_matrix (cairo_t *cr) +{ + cairo_matrix_t matrix; + + cairo_get_matrix (cr, &matrix); + + return CAIRO_TEST_SUCCESS; +} + +static cairo_test_status_t +test_cairo_get_target (cairo_t *cr) +{ + cairo_get_target (cr); + + return CAIRO_TEST_SUCCESS; +} + +static cairo_test_status_t +test_cairo_get_group_target (cairo_t *cr) +{ + cairo_get_group_target (cr); + + return CAIRO_TEST_SUCCESS; +} + +static cairo_test_status_t +test_cairo_copy_path (cairo_t *cr) +{ + cairo_path_destroy (cairo_copy_path (cr)); + + return CAIRO_TEST_SUCCESS; +} + +static cairo_test_status_t +test_cairo_copy_path_flat (cairo_t *cr) +{ + cairo_path_destroy (cairo_copy_path_flat (cr)); + + return CAIRO_TEST_SUCCESS; +} + +static cairo_test_status_t +test_cairo_append_path (cairo_t *cr) +{ + cairo_path_data_t data[3]; + cairo_path_t path; + + path.status = CAIRO_STATUS_SUCCESS; + path.data = &data[0]; + path.num_data = ARRAY_LENGTH(data); + + data[0].header.type = CAIRO_PATH_MOVE_TO; + data[0].header.length = 2; + data[1].point.x = 1; + data[1].point.y = 2; + data[2].header.type = CAIRO_PATH_CLOSE_PATH; + data[2].header.length = 1; + + cairo_append_path (cr, &path); + + return CAIRO_TEST_SUCCESS; +} static cairo_test_status_t test_cairo_surface_create_similar (cairo_surface_t *surface) @@ -637,6 +1525,112 @@ test_cairo_xlib_surface_get_height (cairo_surface_t *surface) #endif +#define TEST(name) { #name, test_ ## name } + +struct { + const char *name; + context_test_func_t func; +} context_tests[] = { + TEST (cairo_reference), + TEST (cairo_get_reference_count), + TEST (cairo_set_user_data), + TEST (cairo_save), + TEST (cairo_push_group), + TEST (cairo_push_group_with_content), + TEST (cairo_set_operator), + TEST (cairo_set_source), + TEST (cairo_set_source_rgb), + TEST (cairo_set_source_rgba), + TEST (cairo_set_source_surface), + TEST (cairo_set_tolerance), + TEST (cairo_set_antialias), + TEST (cairo_set_fill_rule), + TEST (cairo_set_line_width), + TEST (cairo_set_line_cap), + TEST (cairo_set_line_join), + TEST (cairo_set_dash), + TEST (cairo_set_miter_limit), + TEST (cairo_translate), + TEST (cairo_scale), + TEST (cairo_rotate), + TEST (cairo_transform), + TEST (cairo_set_matrix), + TEST (cairo_identity_matrix), + TEST (cairo_user_to_device), + TEST (cairo_user_to_device_distance), + TEST (cairo_device_to_user), + TEST (cairo_device_to_user_distance), + TEST (cairo_new_path), + TEST (cairo_move_to), + TEST (cairo_new_sub_path), + TEST (cairo_line_to), + TEST (cairo_curve_to), + TEST (cairo_arc), + TEST (cairo_arc_negative), + TEST (cairo_rel_move_to), + TEST (cairo_rel_line_to), + TEST (cairo_rel_curve_to), + TEST (cairo_rectangle), + TEST (cairo_close_path), + TEST (cairo_path_extents), + TEST (cairo_paint), + TEST (cairo_paint_with_alpha), + TEST (cairo_mask), + TEST (cairo_mask_surface), + TEST (cairo_stroke), + TEST (cairo_stroke_preserve), + TEST (cairo_fill), + TEST (cairo_fill_preserve), + TEST (cairo_copy_page), + TEST (cairo_show_page), + TEST (cairo_in_stroke), + TEST (cairo_in_fill), + TEST (cairo_in_clip), + TEST (cairo_stroke_extents), + TEST (cairo_fill_extents), + TEST (cairo_reset_clip), + TEST (cairo_clip), + TEST (cairo_clip_preserve), + TEST (cairo_clip_extents), + TEST (cairo_copy_clip_rectangle_list), + TEST (cairo_select_font_face), + TEST (cairo_set_font_size), + TEST (cairo_set_font_matrix), + TEST (cairo_get_font_matrix), + TEST (cairo_set_font_options), + TEST (cairo_get_font_options), + TEST (cairo_set_font_face), + TEST (cairo_set_scaled_font), + TEST (cairo_show_text), + TEST (cairo_show_glyphs), + TEST (cairo_show_text_glyphs), + TEST (cairo_text_path), + TEST (cairo_glyph_path), + TEST (cairo_text_extents), + TEST (cairo_glyph_extents), + TEST (cairo_font_extents), + TEST (cairo_get_operator), + TEST (cairo_get_source), + TEST (cairo_get_tolerance), + TEST (cairo_get_antialias), + TEST (cairo_has_current_point), + TEST (cairo_get_current_point), + TEST (cairo_get_fill_rule), + TEST (cairo_get_line_width), + TEST (cairo_get_line_cap), + TEST (cairo_get_line_join), + TEST (cairo_get_miter_limit), + TEST (cairo_get_dash_count), + TEST (cairo_get_dash), + TEST (cairo_get_matrix), + TEST (cairo_get_target), + TEST (cairo_get_group_target), + TEST (cairo_copy_path), + TEST (cairo_copy_path_flat), + TEST (cairo_append_path), +}; + +#undef TEST #define TEST(name, surface_type, sets_status) { #name, test_ ## name, surface_type, sets_status } @@ -645,7 +1639,7 @@ struct { surface_test_func_t func; int surface_type; /* cairo_surface_type_t or -1 */ cairo_bool_t modifies_surface; -} tests[] = { +} surface_tests[] = { TEST (cairo_surface_create_similar, -1, FALSE), TEST (cairo_surface_create_for_rectangle, -1, FALSE), TEST (cairo_surface_reference, -1, FALSE), @@ -730,17 +1724,18 @@ static cairo_test_status_t preamble (cairo_test_context_t *ctx) { cairo_surface_t *surface; + cairo_t *cr; cairo_test_status_t test_status; cairo_status_t status_before, status_after; unsigned int i; /* Test an error surface */ - for (i = 0; i < ARRAY_LENGTH (tests); i++) { + for (i = 0; i < ARRAY_LENGTH (surface_tests); i++) { surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, INT_MAX, INT_MAX); status_before = cairo_surface_status (surface); assert (status_before); - test_status = tests[i].func (surface); + test_status = surface_tests[i].func (surface); status_after = cairo_surface_status (surface); cairo_surface_destroy (surface); @@ -748,14 +1743,72 @@ preamble (cairo_test_context_t *ctx) if (test_status != CAIRO_TEST_SUCCESS) { cairo_test_log (ctx, "Failed test %s with %d\n", - tests[i].name, (int) test_status); + surface_tests[i].name, (int) test_status); return test_status; } if (status_before != status_after) { cairo_test_log (ctx, "Failed test %s: Modified surface status from %u (%s) to %u (%s)\n", - tests[i].name, + surface_tests[i].name, + status_before, cairo_status_to_string (status_before), + status_after, cairo_status_to_string (status_after)); + return CAIRO_TEST_ERROR; + } + } + + /* Test an error context */ + for (i = 0; i < ARRAY_LENGTH (context_tests); i++) { + cr = cairo_create (NULL); + status_before = cairo_status (cr); + assert (status_before); + + test_status = context_tests[i].func (cr); + + status_after = cairo_status (cr); + cairo_destroy (cr); + + if (test_status != CAIRO_TEST_SUCCESS) { + cairo_test_log (ctx, + "Failed test %s with %d\n", + context_tests[i].name, (int) test_status); + return test_status; + } + + if (status_before != status_after) { + cairo_test_log (ctx, + "Failed test %s: Modified context status from %u (%s) to %u (%s)\n", + context_tests[i].name, + status_before, cairo_status_to_string (status_before), + status_after, cairo_status_to_string (status_after)); + return CAIRO_TEST_ERROR; + } + } + + /* Test a context for an error surface */ + for (i = 0; i < ARRAY_LENGTH (context_tests); i++) { + surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, INT_MAX, INT_MAX); + cr = cairo_create (surface); + cairo_surface_destroy (surface); + status_before = cairo_status (cr); + assert (status_before); + + test_status = context_tests[i].func (cr); + + status_after = cairo_status (cr); + cairo_destroy (cr); + + if (test_status != CAIRO_TEST_SUCCESS) { + cairo_test_log (ctx, + "Failed test %s with %d\n", + context_tests[i].name, (int) test_status); + return test_status; + } + + if (status_before != status_after) { + cairo_test_log (ctx, + "Failed test %s: Modified context status from %u (%s) to %u (%s)\n", + context_tests[i].name, status_before, cairo_status_to_string (status_before), status_after, cairo_status_to_string (status_after)); return CAIRO_TEST_ERROR; @@ -766,74 +1819,153 @@ preamble (cairo_test_context_t *ctx) } static cairo_test_status_t +test_context (const cairo_test_context_t *ctx, cairo_t *cr, const char *name, unsigned int i) +{ + cairo_test_status_t test_status; + cairo_status_t status_before, status_after; + + /* Make sure that there is a current point */ + cairo_move_to (cr, 0, 0); + + status_before = cairo_status (cr); + test_status = context_tests[i].func (cr); + status_after = cairo_status (cr); + + if (test_status != CAIRO_TEST_SUCCESS) { + cairo_test_log (ctx, + "Failed test %s on %s with %d\n", + context_tests[i].name, name, (int) test_status); + return test_status; + } + + if (status_after != CAIRO_STATUS_SURFACE_FINISHED && status_before != status_after) { + cairo_test_log (ctx, + "Failed test %s on %s: Modified context status from %u (%s) to %u (%s)\n", + context_tests[i].name, name, + status_before, cairo_status_to_string (status_before), + status_after, cairo_status_to_string (status_after)); + return CAIRO_TEST_ERROR; + } + + 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; + cairo_t *cr2; unsigned int i; target = cairo_get_target (cr); /* Test a finished similar surface */ - for (i = 0; i < ARRAY_LENGTH (tests); i++) { + for (i = 0; i < ARRAY_LENGTH (surface_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); + test_status = surface_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); + surface_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") && + if (surface_tests[i].modifies_surface && + strcmp (surface_tests[i].name, "cairo_surface_finish") && + strcmp (surface_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); + surface_tests[i].name); return CAIRO_TEST_ERROR; } } + /* Test a context for a finished similar surface */ + for (i = 0; i < ARRAY_LENGTH (context_tests); i++) { + similar = cairo_surface_create_similar (target, + cairo_surface_get_content (target), + 10, 10); + cairo_surface_finish (similar); + cr2 = cairo_create (similar); + test_status = test_context (ctx, cr2, "finished surface", i); + cairo_surface_destroy (similar); + cairo_destroy (cr2); + + if (test_status != CAIRO_TEST_SUCCESS) + return test_status; + } + + /* Test a context for a similar surface finished later */ + for (i = 0; i < ARRAY_LENGTH (context_tests); i++) { + similar = cairo_surface_create_similar (target, + cairo_surface_get_content (target), + 10, 10); + cr2 = cairo_create (similar); + cairo_surface_finish (similar); + test_status = test_context (ctx, cr2, "finished surface after create", i); + cairo_surface_destroy (similar); + cairo_destroy (cr2); + + if (test_status != CAIRO_TEST_SUCCESS) + return test_status; + } + + /* Test a context for a similar surface finished later with a path */ + for (i = 0; i < ARRAY_LENGTH (context_tests); i++) { + similar = cairo_surface_create_similar (target, + cairo_surface_get_content (target), + 10, 10); + cr2 = cairo_create (similar); + cairo_rectangle (cr2, 2, 2, 4, 4); + cairo_surface_finish (similar); + test_status = test_context (ctx, cr2, "finished surface with path", i); + cairo_surface_destroy (similar); + cairo_destroy (cr2); + + if (test_status != CAIRO_TEST_SUCCESS) + return test_status; + } + /* Test a normal surface for functions that have the wrong type */ - for (i = 0; i < ARRAY_LENGTH (tests); i++) { + for (i = 0; i < ARRAY_LENGTH (surface_tests); i++) { cairo_status_t desired_status; - if (tests[i].surface_type == -1) + if (surface_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) { + if (cairo_surface_get_type (similar) == (cairo_surface_type_t) surface_tests[i].surface_type) { cairo_surface_destroy (similar); continue; } - test_status = tests[i].func (similar); + test_status = surface_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); + surface_tests[i].name, (int) test_status); return test_status; } - desired_status = tests[i].modifies_surface ? CAIRO_STATUS_SURFACE_TYPE_MISMATCH : CAIRO_STATUS_SUCCESS; + desired_status = surface_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, + surface_tests[i].name, desired_status, cairo_status_to_string (desired_status), status, cairo_status_to_string (status)); return CAIRO_TEST_ERROR; |