diff options
Diffstat (limited to 'librsvg-c/tests-c/api.c')
| -rw-r--r-- | librsvg-c/tests-c/api.c | 1709 |
1 files changed, 1709 insertions, 0 deletions
diff --git a/librsvg-c/tests-c/api.c b/librsvg-c/tests-c/api.c new file mode 100644 index 00000000..f7b01c2e --- /dev/null +++ b/librsvg-c/tests-c/api.c @@ -0,0 +1,1709 @@ +/* -*- Mode: C; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* vim: set ts=4 nowrap ai expandtab sw=4: */ + +/* These are the C API tests for librsvg. These test the complete C + * API, especially its historical peculiarities to ensure ABI + * compatibility. + * + * These tests are not meant to exhaustively test librsvg's features. + * For those, you should look at the Rust integration tests. See + * tests/README.md for details. + */ + +#include "config.h" + +#include <stdio.h> +#include <glib.h> +#include <cairo.h> + +#define RSVG_DISABLE_DEPRECATION_WARNINGS /* so we can test deprecated API */ +#include <librsvg/rsvg.h> +#include "test-utils.h" + +/* + Untested: + rsvg_handle_internal_set_testing +*/ + +static void +handle_has_correct_type_info (void) +{ + GTypeQuery q; + RsvgHandle *handle; + + g_type_query (RSVG_TYPE_HANDLE, &q); + g_assert (q.type == RSVG_TYPE_HANDLE); + g_assert (q.type == rsvg_handle_get_type ()); + + g_assert_cmpstr (q.type_name, ==, "RsvgHandle"); + + /* These test that the sizes of the structs in the header file actually match the + * sizes of structs and the glib-subclass machinery in the Rust side. + */ + g_assert (sizeof (RsvgHandleClass) == (gsize) q.class_size); + g_assert (sizeof (RsvgHandle) == (gsize) q.instance_size); + + handle = rsvg_handle_new(); + g_assert (G_OBJECT_TYPE (handle) == RSVG_TYPE_HANDLE); + g_object_unref (handle); +} + +static void +assert_flags_value_matches (GFlagsValue *v, + guint value, + const char *value_name, + const char *value_nick) +{ + g_assert_cmpint(v->value, ==, value); + g_assert_cmpstr(v->value_name, ==, value_name); + g_assert_cmpstr(v->value_nick, ==, value_nick); +} + +static void +flags_registration (void) +{ + GType ty; + GTypeQuery q; + GTypeClass *type_class; + GFlagsClass *flags_class; + + ty = RSVG_TYPE_HANDLE_FLAGS; + + g_assert (ty != G_TYPE_INVALID); + + g_type_query (RSVG_TYPE_HANDLE_FLAGS, &q); + g_assert (q.type == ty); + g_assert (G_TYPE_IS_FLAGS (q.type)); + g_assert_cmpstr (q.type_name, ==, "RsvgHandleFlags"); + + type_class = g_type_class_ref (ty); + g_assert (G_IS_FLAGS_CLASS (type_class)); + g_assert (G_FLAGS_CLASS_TYPE (type_class) == ty); + + flags_class = G_FLAGS_CLASS (type_class); + g_assert_cmpint (flags_class->n_values, ==, 3); + + assert_flags_value_matches(&flags_class->values[0], + RSVG_HANDLE_FLAGS_NONE, + "RSVG_HANDLE_FLAGS_NONE", + "flags-none"); + + assert_flags_value_matches(&flags_class->values[1], + RSVG_HANDLE_FLAG_UNLIMITED, + "RSVG_HANDLE_FLAG_UNLIMITED", + "flag-unlimited"); + + assert_flags_value_matches(&flags_class->values[2], + RSVG_HANDLE_FLAG_KEEP_IMAGE_DATA, + "RSVG_HANDLE_FLAG_KEEP_IMAGE_DATA", + "flag-keep-image-data"); + + g_type_class_unref (type_class); +} + +static void +assert_enum_value_matches (GEnumValue *v, + gint value, + const char *value_name, + const char *value_nick) +{ + g_assert_cmpint (v->value, ==, value); + g_assert_cmpstr (v->value_name, ==, value_name); + g_assert_cmpstr (v->value_nick, ==, value_nick); +} + +static void +error_registration (void) +{ + GType ty; + GTypeQuery q; + GTypeClass *type_class; + GEnumClass *enum_class; + + g_assert_cmpint (RSVG_ERROR, !=, 0); + + ty = RSVG_TYPE_ERROR; + + g_assert (ty != G_TYPE_INVALID); + + g_type_query (ty, &q); + g_assert (q.type == ty); + g_assert (G_TYPE_IS_ENUM (q.type)); + g_assert_cmpstr (q.type_name, ==, "RsvgError"); + + type_class = g_type_class_ref (ty); + g_assert (G_IS_ENUM_CLASS (type_class)); + g_assert (G_ENUM_CLASS_TYPE (type_class) == ty); + + enum_class = G_ENUM_CLASS (type_class); + g_assert_cmpint (enum_class->n_values, ==, 1); + + assert_enum_value_matches (&enum_class->values[0], + RSVG_ERROR_FAILED, + "RSVG_ERROR_FAILED", + "failed"); + + g_type_class_unref (type_class); +} + +static char * +get_test_filename (const char *basename) { + return g_build_filename (test_utils_get_test_data_path (), + "api", + basename, + NULL); +} + +static RsvgHandle * +load_test_document (const char *basename) { + char *filename = get_test_filename (basename); + GError *error = NULL; + + RsvgHandle *handle = rsvg_handle_new_from_file (filename, &error); + g_free (filename); + + g_assert_nonnull (handle); + g_assert_no_error (error); + + return handle; +} + +#define EXAMPLE_WIDTH 100 +#define EXAMPLE_HEIGHT 400 + +#define XZOOM 2 +#define YZOOM 3 + +#define MAX_WIDTH 10 +#define MAX_HEIGHT 40 + +#define MAX_ZOOMED_WIDTH 20 +#define MAX_ZOOMED_HEIGHT 120 + +#define EXAMPLE_ONE_ID "#one" +#define EXAMPLE_TWO_ID "#two" +#define EXAMPLE_NONEXISTENT_ID "#nonexistent" + +#define EXAMPLE_ONE_X 0 +#define EXAMPLE_ONE_Y 0 +#define EXAMPLE_ONE_W 100 +#define EXAMPLE_ONE_H 200 + +#define EXAMPLE_TWO_X 0 +#define EXAMPLE_TWO_Y 200 +#define EXAMPLE_TWO_W 100 +#define EXAMPLE_TWO_H 200 + +static GdkPixbuf * +pixbuf_from_file (const char *filename, GError **error) +{ + return rsvg_pixbuf_from_file (filename, error); +} + +static GdkPixbuf * +pixbuf_from_file_at_zoom (const char *filename, GError **error) +{ + return rsvg_pixbuf_from_file_at_zoom (filename, (double) XZOOM, (double) YZOOM, error); +} + +static GdkPixbuf * +pixbuf_from_file_at_size (const char *filename, GError **error) +{ + return rsvg_pixbuf_from_file_at_size (filename, EXAMPLE_WIDTH * XZOOM, EXAMPLE_HEIGHT * YZOOM, error); +} + +static GdkPixbuf * +pixbuf_from_file_at_max_size (const char *filename, GError **error) +{ + return rsvg_pixbuf_from_file_at_max_size (filename, MAX_WIDTH, MAX_HEIGHT, error); +} + +static GdkPixbuf * +pixbuf_from_file_at_zoom_with_max (const char *filename, GError **error) +{ + return rsvg_pixbuf_from_file_at_zoom_with_max (filename, + XZOOM, YZOOM, + MAX_ZOOMED_WIDTH, MAX_ZOOMED_HEIGHT, + error); +} + +typedef GdkPixbuf *(* PixbufCreateFn) (const char *filename, GError **error); + +typedef struct { + const char *test_name; + PixbufCreateFn pixbuf_create_fn; + int expected_width; + int expected_height; +} PixbufTest; + +static const PixbufTest pixbuf_tests[] = { + { + "/api/pixbuf_from_file", + pixbuf_from_file, + EXAMPLE_WIDTH, + EXAMPLE_HEIGHT + }, + { + "/api/pixbuf_from_file_at_zoom", + pixbuf_from_file_at_zoom, + EXAMPLE_WIDTH * XZOOM, + EXAMPLE_HEIGHT * YZOOM + }, + { + "/api/pixbuf_from_file_at_size", + pixbuf_from_file_at_size, + EXAMPLE_WIDTH * XZOOM, + EXAMPLE_HEIGHT * YZOOM + }, + { + "/api/pixbuf_from_file_at_max_size", + pixbuf_from_file_at_max_size, + MAX_WIDTH, + MAX_HEIGHT + }, + { + "/api/pixbuf_from_file_at_zoom_with_max", + pixbuf_from_file_at_zoom_with_max, + MAX_ZOOMED_WIDTH, + MAX_ZOOMED_HEIGHT + }, +}; + +static void +test_pixbuf (gconstpointer data) +{ + const PixbufTest *test = data; + + char *filename = get_test_filename ("example.svg"); + GError *error = NULL; + + GdkPixbuf *pixbuf = test->pixbuf_create_fn (filename, &error); + + g_free (filename); + + g_assert_nonnull (pixbuf); + g_assert_no_error (error); + g_assert_cmpint (gdk_pixbuf_get_width (pixbuf), ==, test->expected_width); + g_assert_cmpint (gdk_pixbuf_get_height (pixbuf), ==, test->expected_height); + + g_object_unref (pixbuf); +} + +static void +pixbuf_overflow (void) +{ + char *filename = get_test_filename ("example.svg"); + GError *error = NULL; + + g_assert (!rsvg_pixbuf_from_file_at_zoom (filename, 1000000.0, 1000000.0, &error)); + g_assert_error (error, RSVG_ERROR, RSVG_ERROR_FAILED); + g_error_free (error); + g_free (filename); +} + +static void +noops (void) +{ + /* Just to test that these functions are present in the binary, I guess */ + rsvg_init (); + rsvg_term (); + rsvg_cleanup (); +} + +static void +noops_return_null (void) +{ + RsvgHandle *handle = rsvg_handle_new (); + + g_assert_null (rsvg_handle_get_title (handle)); + g_assert_null (rsvg_handle_get_desc (handle)); + g_assert_null (rsvg_handle_get_metadata (handle)); + + g_object_unref (handle); +} + +static void +set_dpi (void) +{ + RsvgHandle *handle; + RsvgDimensionData dim; + + rsvg_set_default_dpi (100.0); + + handle = load_test_document ("dpi.svg"); + + rsvg_handle_get_dimensions (handle, &dim); + g_assert_cmpint (dim.width, ==, 100); + g_assert_cmpint (dim.height, ==, 400); + + rsvg_handle_set_dpi (handle, 200.0); + rsvg_handle_get_dimensions (handle, &dim); + g_assert_cmpint (dim.width, ==, 200); + g_assert_cmpint (dim.height, ==, 800); + g_object_unref (handle); + + handle = load_test_document ("dpi.svg"); + + rsvg_handle_set_dpi_x_y (handle, 400.0, 300.0); + rsvg_handle_get_dimensions (handle, &dim); + g_assert_cmpint (dim.width, ==, 400); + g_assert_cmpint (dim.height, ==, 1200); + g_object_unref (handle); +} + +static void +base_uri (void) +{ + RsvgHandle *handle = rsvg_handle_new (); + const char *uri; + + uri = rsvg_handle_get_base_uri (handle); + g_assert_null (uri); + + rsvg_handle_set_base_uri (handle, "file:///foo/bar.svg"); + uri = rsvg_handle_get_base_uri (handle); + + g_assert_cmpstr (uri, ==, "file:///foo/bar.svg"); + + g_object_unref (handle); +} + +static void +base_gfile (void) +{ + RsvgHandle *handle = rsvg_handle_new (); + GFile *file; + const char *uri; + + uri = rsvg_handle_get_base_uri (handle); + g_assert_null (uri); + + file = g_file_new_for_uri ("file:///foo/bar.svg"); + + rsvg_handle_set_base_gfile (handle, file); + uri = rsvg_handle_get_base_uri (handle); + + g_assert_cmpstr (uri, ==, "file:///foo/bar.svg"); + + g_object_unref (file); + g_object_unref (handle); +} + +static void +handle_write_close_free (void) +{ + char *filename = get_test_filename ("dpi.svg"); + char *data; + gsize length; + gsize i; + GError *error = NULL; + + g_assert (g_file_get_contents (filename, &data, &length, &error)); + g_free (filename); + + g_assert_nonnull (data); + g_assert_no_error (error); + + RsvgHandle *handle = rsvg_handle_new_with_flags (RSVG_HANDLE_FLAGS_NONE); + + for (i = 0; i < length; i++) { + g_assert (rsvg_handle_write (handle, (guchar *) &data[i], 1, &error)); + g_assert_no_error (error); + } + + g_assert (rsvg_handle_close (handle, &error)); + g_assert_no_error (error); + + /* Test that close() is idempotent in the happy case */ + g_assert (rsvg_handle_close (handle, &error)); + g_assert_no_error (error); + + rsvg_handle_free (handle); + g_free (data); +} + +static void +handle_new_from_file (void) +{ + char *filename = get_test_filename ("dpi.svg"); + char *uri = g_strconcat ("file://", filename, NULL); + + RsvgHandle *handle; + GError *error = NULL; + + /* rsvg_handle_new_from_file() can take both filenames and URIs */ + + handle = rsvg_handle_new_from_file (filename, &error); + g_assert_nonnull (handle); + g_assert_no_error (error); + g_object_unref (handle); + + handle = rsvg_handle_new_from_file (uri, &error); + g_assert_nonnull (handle); + g_assert_no_error (error); + g_object_unref (handle); + + g_free (filename); + g_free (uri); +} + +static void +handle_new_from_data (void) +{ + char *filename = get_test_filename ("dpi.svg"); + char *data; + gsize length; + GError *error = NULL; + + g_assert (g_file_get_contents (filename, &data, &length, &error)); + g_free (filename); + + g_assert_nonnull (data); + g_assert_no_error (error); + + RsvgHandle *handle = rsvg_handle_new_from_data ((guint8 *) data, length, &error); + g_assert_nonnull (handle); + g_assert_no_error (error); + + g_object_unref (handle); + g_free (data); +} + +static void +handle_new_from_gfile_sync (void) +{ + char *filename = get_test_filename ("dpi.svg"); + GError *error = NULL; + GFile *file = g_file_new_for_path (filename); + g_assert_nonnull (file); + + g_free (filename); + + RsvgHandle *handle = rsvg_handle_new_from_gfile_sync (file, + RSVG_HANDLE_FLAGS_NONE, + NULL, + &error); + + g_assert_nonnull (handle); + g_assert_no_error (error); + + g_object_unref (handle); + g_object_unref (file); +} + +static void +handle_new_from_stream_sync (void) +{ + char *filename = get_test_filename ("dpi.svg"); + GError *error = NULL; + GFile *file = g_file_new_for_path (filename); + g_assert_nonnull (file); + + g_free (filename); + + GFileInputStream *stream = g_file_read (file, NULL, &error); + g_assert (stream != NULL); + g_assert_no_error (error); + + RsvgHandle *handle = rsvg_handle_new_from_stream_sync (G_INPUT_STREAM (stream), + file, + RSVG_HANDLE_FLAGS_NONE, + NULL, + &error); + + g_assert_nonnull (handle); + g_assert_no_error (error); + + g_object_unref (handle); + g_object_unref (file); + g_object_unref (stream); +} + +static void +handle_read_stream_sync (void) +{ + char *filename = get_test_filename ("dpi.svg"); + GError *error = NULL; + GFile *file = g_file_new_for_path (filename); + g_assert_nonnull (file); + + g_free (filename); + + GFileInputStream *stream = g_file_read (file, NULL, &error); + g_assert_nonnull (stream); + g_assert_no_error (error); + + RsvgHandle *handle = rsvg_handle_new (); + + g_assert (rsvg_handle_read_stream_sync (handle, G_INPUT_STREAM (stream), NULL, &error)); + g_assert_no_error (error); + + g_object_unref (handle); + g_object_unref (file); + g_object_unref (stream); +} + +static void +handle_has_sub (void) +{ + RsvgHandle *handle = load_test_document ("example.svg"); + + g_assert (rsvg_handle_has_sub (handle, EXAMPLE_ONE_ID)); + g_assert (rsvg_handle_has_sub (handle, EXAMPLE_TWO_ID)); + g_assert (!rsvg_handle_has_sub (handle, "#foo")); + + g_object_unref (handle); +} + +static void +test_get_pixbuf (gboolean sub) +{ + RsvgHandle *handle = load_test_document ("example.svg"); + + GdkPixbuf *pixbuf; + if (sub) { + pixbuf = rsvg_handle_get_pixbuf_sub (handle, EXAMPLE_ONE_ID); + } else { + pixbuf = rsvg_handle_get_pixbuf (handle); + } + + g_assert_nonnull (pixbuf); + + /* Note that rsvg_handle_get_pixbuf_sub() creates a surface the size of the + * whole SVG, not just the size of the sub-element. + */ + g_assert_cmpint (gdk_pixbuf_get_width (pixbuf), ==, EXAMPLE_WIDTH); + g_assert_cmpint (gdk_pixbuf_get_height (pixbuf), ==, EXAMPLE_HEIGHT); + + cairo_surface_t *surface_a = test_utils_cairo_surface_from_pixbuf (pixbuf); + cairo_surface_t *surface_b = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, EXAMPLE_WIDTH, EXAMPLE_HEIGHT); + cairo_surface_t *surface_diff = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, EXAMPLE_WIDTH, EXAMPLE_HEIGHT); + + g_object_unref (pixbuf); + + g_assert_nonnull (surface_a); + g_assert_nonnull (surface_b); + g_assert_nonnull (surface_diff); + + cairo_t *cr = cairo_create (surface_b); + if (sub) { + g_assert (rsvg_handle_render_cairo_sub (handle, cr, EXAMPLE_ONE_ID)); + } else { + g_assert (rsvg_handle_render_cairo (handle, cr)); + } + cairo_destroy (cr); + + g_object_unref (handle); + + TestUtilsBufferDiffResult result = {0, 0}; + test_utils_compare_surfaces (surface_a, surface_b, surface_diff, &result); + + if (result.pixels_changed && result.max_diff > 0) { + g_test_fail (); + } + + cairo_surface_destroy (surface_a); + cairo_surface_destroy (surface_b); + cairo_surface_destroy (surface_diff); +} + +static void +handle_get_pixbuf (void) +{ + test_get_pixbuf (FALSE); +} + +static void +handle_get_pixbuf_sub (void) +{ + test_get_pixbuf (TRUE); +} + +static void +dimensions_and_position (void) +{ + RsvgHandle *handle = load_test_document ("example.svg"); + RsvgDimensionData dim; + + g_assert (rsvg_handle_get_dimensions_sub (handle, &dim, EXAMPLE_TWO_ID)); + g_assert_cmpint (dim.width, ==, EXAMPLE_TWO_W); + g_assert_cmpint (dim.height, ==, EXAMPLE_TWO_H); + + RsvgPositionData pos; + g_assert (rsvg_handle_get_position_sub (handle, &pos, EXAMPLE_TWO_ID)); + g_assert_cmpint (pos.x, ==, EXAMPLE_TWO_X); + g_assert_cmpint (pos.y, ==, EXAMPLE_TWO_Y); + + g_assert_false (rsvg_handle_get_position_sub (handle, &pos, EXAMPLE_NONEXISTENT_ID)); + g_assert_false (rsvg_handle_get_dimensions_sub (handle, &dim, EXAMPLE_NONEXISTENT_ID)); + + /* Asking for "position of the whole SVG" (id=NULL) always returns (0, 0) */ + g_assert (rsvg_handle_get_position_sub (handle, &pos, NULL)); + g_assert_cmpint (pos.x, ==, 0); + g_assert_cmpint (pos.y, ==, 0); + + g_object_unref (handle); +} + +struct size_func_data +{ + gboolean called; + gboolean destroyed; + gboolean testing_size_func_calls; +}; + +static void +size_func (gint *width, gint *height, gpointer user_data) +{ + struct size_func_data *data = user_data; + + if (data->testing_size_func_calls) { + g_assert_false (data->called); + data->called = TRUE; + + g_assert_false (data->destroyed); + } + + *width = 42; + *height = 43; +} + +static void +size_func_destroy (gpointer user_data) +{ + struct size_func_data *data = user_data; + + if (data->testing_size_func_calls) { + g_assert_false (data->destroyed); + data->destroyed = TRUE; + } +} + +static void +set_size_callback (void) +{ + RsvgHandle *handle; + struct size_func_data data; + RsvgDimensionData dim; + + handle = load_test_document ("example.svg"); + + data.called = FALSE; + data.destroyed = FALSE; + data.testing_size_func_calls = TRUE; + + rsvg_handle_set_size_callback (handle, size_func, &data, size_func_destroy); + + rsvg_handle_get_dimensions (handle, &dim); + g_assert_cmpint (dim.width, ==, 42); + g_assert_cmpint (dim.height, ==, 43); + + g_object_unref (handle); + + g_assert_true (data.called); + g_assert_true (data.destroyed); +} + +static void +reset_size_callback (void) +{ + RsvgHandle *handle; + struct size_func_data data_1; + struct size_func_data data_2; + + handle = load_test_document ("example.svg"); + + data_1.called = FALSE; + data_1.destroyed = FALSE; + data_1.testing_size_func_calls = TRUE; + + rsvg_handle_set_size_callback (handle, size_func, &data_1, size_func_destroy); + + data_2.called = FALSE; + data_2.destroyed = FALSE; + data_2.testing_size_func_calls = TRUE; + + rsvg_handle_set_size_callback (handle, size_func, &data_2, size_func_destroy); + g_assert_true (data_1.destroyed); + + g_object_unref (handle); + + g_assert_true (data_2.destroyed); +} + +static void +zero_size_func (gint *width, gint *height, gpointer user_data) +{ + *width = 0; + *height = 0; +} + +static void +render_with_zero_size_callback (void) +{ + /* gdk_pixbuf_get_file_info() uses a GdkPixbufLoader, but in its + * "size-prepared" callback it saves the computed size, and then calls + * gdk_pixbuf_loader_set_size(loader, 0, 0). Presumably it does to tell + * loaders that it only wanted to know the size, but that they shouldn't + * decode or render the image to a pixbuf buffer. + * + * Librsvg used to panic when getting (0, 0) from the size_callback; this + * test is to check that there is no such crash now. Instead, librsvg + * will return a 1x1 transparent pixbuf. + */ + RsvgHandle *handle; + GdkPixbuf *pixbuf; + + handle = load_test_document ("example.svg"); + + rsvg_handle_set_size_callback (handle, zero_size_func, NULL, NULL); + + pixbuf = rsvg_handle_get_pixbuf (handle); + g_assert_nonnull (pixbuf); + g_assert_cmpint (gdk_pixbuf_get_width (pixbuf), ==, 1); + g_assert_cmpint (gdk_pixbuf_get_height (pixbuf), ==, 1); + + g_object_unref (pixbuf); + g_object_unref (handle); +} + +static void +pixbuf_size_func (gint *width, gint *height, gpointer user_data) +{ + *width = 420; + *height = 430; +} + +static void +get_pixbuf_with_size_callback (void) +{ + RsvgHandle *handle = rsvg_handle_new (); + + rsvg_handle_set_size_callback (handle, pixbuf_size_func, NULL, NULL); + + char *filename = get_test_filename ("example.svg"); + guchar *data = NULL; + gsize length; + GError *error = NULL; + + g_assert (g_file_get_contents (filename, (gchar **) &data, &length, &error)); + g_assert_nonnull (data); + + g_free (filename); + + g_assert (rsvg_handle_write (handle, data, length, &error)); + g_assert_no_error (error); + + g_assert (rsvg_handle_close (handle, &error)); + g_assert_no_error (error); + + GdkPixbuf *pixbuf = rsvg_handle_get_pixbuf (handle); + g_assert_nonnull (pixbuf); + g_assert_cmpint (gdk_pixbuf_get_width (pixbuf), ==, 420); + g_assert_cmpint (gdk_pixbuf_get_height (pixbuf), ==, 430); + + g_object_unref (pixbuf); + g_free (data); + g_object_unref (handle); +} + +static void +detects_cairo_context_in_error (void) +{ + if (g_test_subprocess ()) { + RsvgHandle *handle = load_test_document ("example.svg"); + + /* this is wrong; it is to simulate creating a surface and a cairo_t in error */ + cairo_surface_t *surf = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, -1, -1); + cairo_t *cr = cairo_create (surf); + /* rsvg_handle_render_cairo() should return FALSE when it gets a cr in an error state */ + g_assert_false (rsvg_handle_render_cairo (handle, cr)); + + return; + } + + g_test_trap_subprocess (NULL, 0, 0); + g_test_trap_assert_failed (); + g_test_trap_assert_stderr ("*WARNING*cannot render on a cairo_t with a failure status*"); +} + +static gboolean +matrixes_are_equal (cairo_matrix_t *a, cairo_matrix_t *b) +{ + return (a->xx == b->xx && + a->yx == b->yx && + a->xy == b->xy && + a->yy == b->yy && + a->x0 == b->x0 && + a->y0 == b->y0); +} + +static void +can_draw_to_non_image_surface (void) +{ + cairo_rectangle_t rect; + cairo_surface_t *surface; + cairo_t *cr; + + RsvgHandle *handle = load_test_document ("example.svg"); + + rect.x = 0.0; + rect.y = 0.0; + rect.width = 100.0; + rect.height = 100.0; + + /* We create a surface that is not a Cairo image surface, + * so we can test that in fact we can render to non-image surfaces. + */ + surface = cairo_recording_surface_create (CAIRO_CONTENT_COLOR_ALPHA, &rect); + cr = cairo_create (surface); + + cairo_translate (cr, 42.0, 42.0); + + cairo_matrix_t original_affine; + cairo_get_matrix (cr, &original_affine); + + g_assert (rsvg_handle_render_cairo (handle, cr)); + + cairo_matrix_t new_affine; + cairo_get_matrix (cr, &new_affine); + + g_assert (matrixes_are_equal (&original_affine, &new_affine)); + + g_object_unref (handle); + + cairo_destroy (cr); + cairo_surface_destroy (surface); +} + +/* Test that we preserve the affine transformation in the cr during a call + * to rsvg_handle_render_cairo_sub(). + */ +static void +render_cairo_sub (void) +{ + RsvgHandle *handle = load_test_document ("bug334-element-positions.svg"); + + cairo_surface_t *surf = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, 200, 200); + cairo_t *cr = cairo_create (surf); + + cairo_translate (cr, 42.0, 42.0); + + cairo_matrix_t original_affine; + cairo_get_matrix (cr, &original_affine); + + g_assert (rsvg_handle_render_cairo_sub (handle, cr, "#button5-leader")); + + cairo_matrix_t new_affine; + cairo_get_matrix (cr, &new_affine); + + g_assert (matrixes_are_equal (&original_affine, &new_affine)); + + g_object_unref (handle); + cairo_destroy (cr); + cairo_surface_destroy (surf); +} + +static void +get_intrinsic_dimensions (void) +{ + RsvgHandle *handle = load_test_document ("example.svg"); + + gboolean has_width; + RsvgLength width; + gboolean has_height; + RsvgLength height; + gboolean has_viewbox; + RsvgRectangle viewbox; + + rsvg_handle_get_intrinsic_dimensions (handle, &has_width, &width, &has_height, &height, &has_viewbox, &viewbox); + + g_assert (has_width); + g_assert_cmpfloat (width.length, ==, 100.0); + g_assert (width.unit == RSVG_UNIT_PX); + + g_assert (has_height); + g_assert_cmpfloat (height.length, ==, 400.0); + g_assert (height.unit == RSVG_UNIT_PX); + + g_assert (has_viewbox); + g_assert_cmpfloat (viewbox.x, ==, 0.0); + g_assert_cmpfloat (viewbox.y, ==, 0.0); + g_assert_cmpfloat (viewbox.width, ==, 100.0); + g_assert_cmpfloat (viewbox.height, ==, 400.0); + + g_object_unref (handle); +} + +static void +get_intrinsic_dimensions_missing_values (void) +{ + RsvgHandle *handle = load_test_document ("no-viewbox.svg"); + + gboolean has_width; + RsvgLength width; + gboolean has_height; + RsvgLength height; + gboolean has_viewbox; + RsvgRectangle viewbox; + + rsvg_handle_get_intrinsic_dimensions (handle, &has_width, &width, &has_height, &height, &has_viewbox, &viewbox); + g_assert_true (has_width); + g_assert_true (has_height); + g_assert_false (has_viewbox); + g_object_unref (handle); +} + +static void +get_intrinsic_size_in_pixels_yes (void) +{ + RsvgHandle *handle = load_test_document ("size.svg"); + gdouble width, height; + + rsvg_handle_set_dpi (handle, 96.0); + + /* Test optional parameters */ + g_assert (rsvg_handle_get_intrinsic_size_in_pixels (handle, NULL, NULL)); + + /* Test the actual result */ + g_assert (rsvg_handle_get_intrinsic_size_in_pixels (handle, &width, &height)); + g_assert_cmpfloat (width, ==, 192.0); + g_assert_cmpfloat (height, ==, 288.0); + + g_object_unref (handle); +} + +static void +get_intrinsic_size_in_pixels_no (void) +{ + RsvgHandle *handle = load_test_document ("no-size.svg"); + gdouble width, height; + + rsvg_handle_set_dpi (handle, 96.0); + g_assert (!rsvg_handle_get_intrinsic_size_in_pixels (handle, &width, &height)); + g_assert_cmpfloat (width, ==, 0.0); + g_assert_cmpfloat (height, ==, 0.0); + + g_object_unref (handle); +} + +static void +set_stylesheet (void) +{ + const char *css = "rect { fill: #00ff00; }"; + + RsvgHandle *handle = load_test_document ("stylesheet.svg"); + RsvgHandle *ref_handle = load_test_document ("stylesheet-ref.svg"); + + cairo_surface_t *output = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, 100, 100); + cairo_surface_t *reference = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, 100, 100); + + RsvgRectangle viewport = { 0.0, 0.0, 100.0, 100.0 }; + + cairo_t *output_cr = cairo_create (output); + cairo_t *ref_cr = cairo_create (reference); + + GError *error = NULL; + g_assert (rsvg_handle_set_stylesheet (handle, (const guint8 *) css, strlen (css), &error)); + g_assert_no_error (error); + + g_assert (rsvg_handle_render_document (handle, output_cr, &viewport, &error)); + g_assert_no_error (error); + + g_assert (rsvg_handle_render_document (ref_handle, ref_cr, &viewport, &error)); + g_assert_no_error (error); + + cairo_surface_t *diff = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, 100, 100); + + TestUtilsBufferDiffResult result = {0, 0}; + test_utils_compare_surfaces (output, reference, diff, &result); + + if (result.pixels_changed && result.max_diff > 0) { + g_test_fail (); + } + + cairo_surface_destroy (diff); + cairo_destroy (ref_cr); + cairo_destroy (output_cr); + cairo_surface_destroy (reference); + cairo_surface_destroy (output); + g_object_unref (ref_handle); + g_object_unref (handle); +} + +static void +render_document (void) +{ + RsvgHandle *handle = load_test_document ("document.svg"); + + cairo_surface_t *output = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, 150, 150); + cairo_t *cr = cairo_create (output); + + RsvgRectangle viewport = { 50.0, 50.0, 50.0, 50.0 }; + + GError *error = NULL; + g_assert (rsvg_handle_render_document (handle, cr, &viewport, &error)); + g_assert_no_error (error); + + cairo_destroy (cr); + + cairo_surface_t *expected = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, 150, 150); + cr = cairo_create (expected); + + cairo_translate (cr, 50.0, 50.0); + cairo_rectangle (cr, 10.0, 10.0, 30.0, 30.0); + cairo_set_source_rgba (cr, 0.0, 0.0, 1.0, 0.5); + cairo_fill (cr); + cairo_destroy (cr); + + cairo_surface_t *diff = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, 150, 150); + + TestUtilsBufferDiffResult result = {0, 0}; + test_utils_compare_surfaces (output, expected, diff, &result); + + if (result.pixels_changed && result.max_diff > 0) { + g_test_fail (); + } + + cairo_surface_destroy (diff); + cairo_surface_destroy (expected); + cairo_surface_destroy (output); + g_object_unref (handle); +} + +static void +get_geometry_for_layer (void) +{ + RsvgHandle *handle = load_test_document ("geometry.svg"); + + RsvgRectangle viewport = { 0.0, 0.0, 100.0, 400.0 }; + RsvgRectangle ink_rect; + RsvgRectangle logical_rect; + + GError *error = NULL; + + g_assert_false (rsvg_handle_get_geometry_for_layer (handle, "#nonexistent", &viewport, + &ink_rect, &logical_rect, &error)); + g_assert_nonnull (error); + + g_clear_error (&error); + + g_assert (rsvg_handle_get_geometry_for_layer (handle, "#two", &viewport, + &ink_rect, &logical_rect, &error)); + g_assert_no_error (error); + + g_assert_cmpfloat (ink_rect.x, ==, 5.0); + g_assert_cmpfloat (ink_rect.y, ==, 195.0); + g_assert_cmpfloat (ink_rect.width, ==, 90.0); + g_assert_cmpfloat (ink_rect.height, ==, 110.0); + + g_assert_cmpfloat (logical_rect.x, ==, 10.0); + g_assert_cmpfloat (logical_rect.y, ==, 200.0); + g_assert_cmpfloat (logical_rect.width, ==, 80.0); + g_assert_cmpfloat (logical_rect.height, ==, 100.0); + + g_object_unref (handle); +} + +static void +render_layer (void) +{ + RsvgHandle *handle = load_test_document ("layers.svg"); + + cairo_surface_t *output = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, 300, 300); + cairo_t *cr = cairo_create (output); + + RsvgRectangle viewport = { 100.0, 100.0, 100.0, 100.0 }; + + GError *error = NULL; + + g_assert (rsvg_handle_render_layer (handle, cr, "#bar", &viewport, &error)); + g_assert_no_error (error); + + cairo_destroy (cr); + + cairo_surface_t *expected = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, 300, 300); + cr = cairo_create (expected); + + cairo_translate (cr, 100.0, 100.0); + cairo_rectangle (cr, 20.0, 20.0, 30.0, 30.0); + cairo_set_source_rgba (cr, 0.0, 0.0, 1.0, 1.0); + cairo_fill (cr); + cairo_destroy (cr); + + cairo_surface_t *diff = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, 300, 300); + + TestUtilsBufferDiffResult result = {0, 0}; + test_utils_compare_surfaces (output, expected, diff, &result); + + if (result.pixels_changed && result.max_diff > 0) { + g_test_fail (); + } + + cairo_surface_destroy (diff); + cairo_surface_destroy (expected); + cairo_surface_destroy (output); + g_object_unref (handle); +} + +static void +untransformed_element (void) +{ + RsvgHandle *handle = load_test_document ("geometry-element.svg"); + + RsvgRectangle ink_rect; + RsvgRectangle logical_rect; + + GError *error = NULL; + + g_assert (!rsvg_handle_get_geometry_for_element (handle, "#nonexistent", + &ink_rect, &logical_rect, &error)); + g_assert_nonnull (error); + + g_clear_error (&error); + + g_assert (rsvg_handle_get_geometry_for_element (handle, "#foo", + &ink_rect, &logical_rect, &error)); + g_assert_no_error (error); + + g_assert_cmpfloat (ink_rect.x, ==, 0.0); + g_assert_cmpfloat (ink_rect.y, ==, 0.0); + g_assert_cmpfloat (ink_rect.width, ==, 40.0); + g_assert_cmpfloat (ink_rect.height, ==, 50.0); + + g_assert_cmpfloat (logical_rect.x, ==, 5.0); + g_assert_cmpfloat (logical_rect.y, ==, 5.0); + g_assert_cmpfloat (logical_rect.width, ==, 30.0); + g_assert_cmpfloat (logical_rect.height, ==, 40.0); + + cairo_surface_t *output = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, 300, 300); + cairo_t *cr = cairo_create (output); + + RsvgRectangle viewport = { 100.0, 100.0, 100.0, 100.0 }; + + g_assert (rsvg_handle_render_element (handle, cr, "#foo", &viewport, &error)); + g_assert_no_error (error); + + cairo_destroy (cr); + + cairo_surface_t *expected = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, 300, 300); + cr = cairo_create (expected); + + cairo_translate (cr, 100.0, 100.0); + cairo_rectangle (cr, 10.0, 10.0, 60.0, 80.0); + cairo_set_source_rgba (cr, 0.0, 0.0, 1.0, 1.0); + cairo_fill_preserve (cr); + + cairo_set_line_width (cr, 20.0); + cairo_set_source_rgba (cr, 0.0, 0.0, 0.0, 1.0); + cairo_stroke (cr); + + cairo_destroy (cr); + + cairo_surface_t *diff = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, 300, 300); + + TestUtilsBufferDiffResult result = {0, 0}; + test_utils_compare_surfaces (output, expected, diff, &result); + + if (result.pixels_changed && result.max_diff > 0) { + g_test_fail (); + } + + cairo_surface_destroy (diff); + cairo_surface_destroy (expected); + cairo_surface_destroy (output); + g_object_unref (handle); +} + +/* https://gitlab.gnome.org/GNOME/librsvg/issues/385 */ +static void +no_write_before_close (void) +{ + RsvgHandle *handle = rsvg_handle_new(); + GError *error = NULL; + + g_assert_false (rsvg_handle_close (handle, &error)); + g_assert_error (error, RSVG_ERROR, RSVG_ERROR_FAILED); + g_error_free (error); + error = NULL; + + /* Test that close() is idempotent in the error case */ + g_assert (rsvg_handle_close (handle, &error)); + g_assert_no_error (error); + + g_object_unref (handle); +} + +static void +empty_write_close (void) +{ + RsvgHandle *handle = rsvg_handle_new(); + GError *error = NULL; + guchar buf = 0; + + g_assert_true (rsvg_handle_write (handle, &buf, 0, &error)); + g_assert_no_error (error); + + g_assert_false (rsvg_handle_close (handle, &error)); + g_assert_error (error, RSVG_ERROR, RSVG_ERROR_FAILED); + + g_error_free (error); + + g_object_unref (handle); +} + +static void +cannot_request_external_elements (void) +{ + /* We want to test that using one of the _sub() functions will fail + * if the element's id is within an external file. + */ + + RsvgHandle *handle = load_test_document ("example.svg"); + RsvgPositionData pos; + + g_assert_false (rsvg_handle_get_position_sub (handle, &pos, "dpi.svg#one")); + + g_object_unref (handle); +} + +static void +test_flags (RsvgHandleFlags flags) +{ + guint read_flags; + + RsvgHandle *handle = g_object_new (RSVG_TYPE_HANDLE, + "flags", flags, + NULL); + g_object_get (handle, "flags", &read_flags, NULL); + g_assert (read_flags == flags); + + g_object_unref (handle); +} + +static void +property_flags (void) +{ + test_flags (RSVG_HANDLE_FLAGS_NONE); + test_flags (RSVG_HANDLE_FLAG_UNLIMITED); + test_flags (RSVG_HANDLE_FLAG_KEEP_IMAGE_DATA); + test_flags (RSVG_HANDLE_FLAG_UNLIMITED | RSVG_HANDLE_FLAG_KEEP_IMAGE_DATA); +} + +static void +property_dpi (void) +{ + RsvgHandle *handle = g_object_new (RSVG_TYPE_HANDLE, + "dpi-x", 42.0, + "dpi-y", 43.0, + NULL); + double x, y; + + g_object_get (handle, + "dpi-x", &x, + "dpi-y", &y, + NULL); + + g_assert_cmpfloat (x, ==, 42.0); + g_assert_cmpfloat (y, ==, 43.0); + + g_object_unref (handle); +} + +static void +property_base_uri (void) +{ + RsvgHandle *handle = g_object_new (RSVG_TYPE_HANDLE, + "base-uri", "file:///foo/bar.svg", + NULL); + char *uri; + + g_object_get (handle, + "base-uri", &uri, + NULL); + + g_assert_cmpstr (uri, ==, "file:///foo/bar.svg"); + g_free (uri); + + g_object_unref (handle); +} + +static void +property_dimensions (void) +{ + RsvgHandle *handle = load_test_document ("example.svg"); + + int width; + int height; + double em; + double ex; + + g_object_get (handle, + "width", &width, + "height", &height, + "em", &em, + "ex", &ex, + NULL); + + g_assert_cmpint (width, ==, EXAMPLE_WIDTH); + g_assert_cmpint (height, ==, EXAMPLE_HEIGHT); + + g_assert_cmpfloat (em, ==, (double) EXAMPLE_WIDTH); + g_assert_cmpfloat (ex, ==, (double) EXAMPLE_HEIGHT); + + g_object_unref (handle); +} + +static void +property_deprecated (void) +{ + RsvgHandle *handle = load_test_document ("example.svg"); + + char *title; + char *desc; + char *metadata; + + g_object_get (handle, + "title", &title, + "desc", &desc, + "metadata", &metadata, + NULL); + + g_assert_null (title); + g_assert_null (desc); + g_assert_null (metadata); + + g_object_unref (handle); +} + +static void +return_if_fail (void) +{ + if (g_test_subprocess ()) { + RsvgHandle *handle; + + handle = rsvg_handle_new(); + g_assert_nonnull (handle); + + /* NULL is an invalid argument... */ + rsvg_handle_set_base_uri (handle, NULL); + g_object_unref (handle); + } + + g_test_trap_subprocess (NULL, 0, 0); + /* ... and here we catch that it was validated */ + g_test_trap_assert_stderr ("*rsvg_handle_set_base_uri*assertion*failed*"); +} + +static void +return_if_fail_null_check (void) +{ + if (g_test_subprocess ()) { + /* Pass NULL as an argument, incorrectly... */ + g_assert_null (rsvg_handle_get_base_uri (NULL)); + } + + g_test_trap_subprocess (NULL, 0, 0); + /* ... and here we catch that it was validated */ + g_test_trap_assert_stderr ("*rsvg_handle_get_base_uri*assertion*handle*failed*"); +} + +static void +return_if_fail_type_check (void) +{ + if (g_test_subprocess ()) { + /* Create a random GObject that is not an RsvgHandle... */ + GInputStream *stream = g_memory_input_stream_new(); + + /* Feed it to an RsvgHandle function so it will bail out */ + g_assert_null (rsvg_handle_get_base_uri ((RsvgHandle *) stream)); + + g_object_unref (stream); + } + + g_test_trap_subprocess (NULL, 0, 0); + /* ... and here we catch that it was validated */ + g_test_trap_assert_stderr ("*rsvg_handle_get_base_uri*assertion*handle*failed*"); +} + +static void +library_version_defines (void) +{ + gchar *version = g_strdup_printf ("%u.%u.%u", + LIBRSVG_MAJOR_VERSION, LIBRSVG_MINOR_VERSION, LIBRSVG_MICRO_VERSION); + g_assert_cmpstr (version, ==, LIBRSVG_VERSION); + g_free (version); +} + +static void +library_version_check (void) +{ + g_assert_true(LIBRSVG_CHECK_VERSION(1, 99, 9)); + g_assert_true(LIBRSVG_CHECK_VERSION(2, 0, 0)); + g_assert_true(LIBRSVG_CHECK_VERSION(2, 50, 7)); + g_assert_false(LIBRSVG_CHECK_VERSION(2, 99, 0)); + g_assert_false(LIBRSVG_CHECK_VERSION(3, 0, 0)); +} + +static void +library_version_constants (void) +{ + g_assert_cmpuint (rsvg_major_version, ==, LIBRSVG_MAJOR_VERSION); + g_assert_cmpuint (rsvg_minor_version, ==, LIBRSVG_MINOR_VERSION); + g_assert_cmpuint (rsvg_micro_version, ==, LIBRSVG_MICRO_VERSION); +} + +typedef struct +{ + const gchar *test_name; + const gchar *file_path; + const gchar *id; + gdouble x; + gdouble y; + gdouble width; + gdouble height; + gboolean has_position; + gboolean has_dimensions; +} DimensionsFixtureData; + +static void +test_dimensions (DimensionsFixtureData *fixture) +{ + RsvgHandle *handle; + RsvgPositionData position; + RsvgDimensionData dimension; + gchar *target_file; + GError *error = NULL; + + target_file = g_build_filename (test_utils_get_test_data_path (), + fixture->file_path, NULL); + handle = rsvg_handle_new_from_file (target_file, &error); + g_free (target_file); + g_assert_no_error (error); + + if (fixture->id) { + g_assert (rsvg_handle_has_sub (handle, fixture->id)); + g_assert (rsvg_handle_get_position_sub (handle, &position, fixture->id)); + g_assert (rsvg_handle_get_dimensions_sub (handle, &dimension, fixture->id)); + } else { + rsvg_handle_get_dimensions (handle, &dimension); + } + + if (fixture->has_position) { + g_assert_cmpint (fixture->x, ==, position.x); + g_assert_cmpint (fixture->y, ==, position.y); + } + + if (fixture->has_dimensions) { + g_assert_cmpint (fixture->width, ==, dimension.width); + g_assert_cmpint (fixture->height, ==, dimension.height); + } + + g_object_unref (handle); +} + +static DimensionsFixtureData dimensions_fixtures[] = +{ + { + "/dimensions/viewbox_only", + "dimensions/bug608102.svg", + NULL, + 0, 0, 16, 16, + FALSE, TRUE + }, + { + "/dimensions/hundred_percent_width_and_height", + "dimensions/bug612951.svg", + NULL, + 0, 0, 47, 47.14, + FALSE, TRUE + }, + { + "/dimensions/viewbox_only_2", + "dimensions/bug614018.svg", + NULL, + 0, 0, 972, 546, + FALSE, TRUE + }, + { + "/dimensions/sub/rect_no_unit", + "dimensions/sub-rect-no-unit.svg", + "#rect-no-unit", + 0, 0, 44, 45, + FALSE, TRUE + }, + { + "/dimensions/with_viewbox", + "dimensions/bug521-with-viewbox.svg", + "#foo", + 50.0, 60.0, 70.0, 80.0, + TRUE, TRUE + }, + { + "/dimensions/sub/823", + "dimensions/bug823-position-sub.svg", + "#pad_width", + 444.0, 139.0, 0.0, 0.0, + TRUE, FALSE + }, +}; + +typedef struct +{ + const char *test_name; + const char *fixture; + size_t buf_size; +} LoadingTestData; + +static void +load_n_bytes_at_a_time (gconstpointer data) +{ + const LoadingTestData *fixture_data = data; + char *filename = g_build_filename (test_utils_get_test_data_path (), fixture_data->fixture, NULL); + guchar *buf = g_new (guchar, fixture_data->buf_size); + gboolean done; + + RsvgHandle *handle; + FILE *file; + + file = fopen (filename, "rb"); + g_assert_nonnull (file); + + handle = rsvg_handle_new_with_flags (RSVG_HANDLE_FLAGS_NONE); + + done = FALSE; + + do { + size_t num_read; + + num_read = fread (buf, 1, fixture_data->buf_size, file); + + if (num_read > 0) { + g_assert_true (rsvg_handle_write (handle, buf, num_read, NULL)); + } else { + g_assert_cmpint (ferror (file), ==, 0); + + if (feof (file)) { + done = TRUE; + } + } + } while (!done); + + fclose (file); + g_free (filename); + + g_assert_true (rsvg_handle_close (handle, NULL)); + + g_object_unref (handle); + + g_free (buf); +} + +static LoadingTestData loading_tests[] = { + { "/loading/one-byte-at-a-time", "loading/gnome-cool.svg", 1 }, + { "/loading/compressed-one-byte-at-a-time", "loading/gnome-cool.svgz", 1 }, + { "/loading/compressed-two-bytes-at-a-time", "loading/gnome-cool.svgz", 2 } /* to test reading the entire gzip header */ +}; + +/* Tests for the deprecated GdkPixbuf-based API */ +static void +add_pixbuf_tests (void) +{ + int i; + + for (i = 0; i < G_N_ELEMENTS (pixbuf_tests); i++) { + g_test_add_data_func (pixbuf_tests[i].test_name, &pixbuf_tests[i], test_pixbuf); + } + + g_test_add_func ("/api/pixbuf_overflow", pixbuf_overflow); +} + +/* Tests for the C API of librsvg*/ +static void +add_api_tests (void) +{ + g_test_add_func ("/api/handle_has_correct_type_info", handle_has_correct_type_info); + g_test_add_func ("/api/flags_registration", flags_registration); + g_test_add_func ("/api/error_registration", error_registration); + g_test_add_func ("/api/noops", noops); + g_test_add_func ("/api/noops_return_null", noops_return_null); + g_test_add_func ("/api/set_dpi", set_dpi); + g_test_add_func ("/api/base_uri", base_uri); + g_test_add_func ("/api/base_gfile", base_gfile); + g_test_add_func ("/api/handle_write_close_free", handle_write_close_free); + g_test_add_func ("/api/handle_new_from_file", handle_new_from_file); + g_test_add_func ("/api/handle_new_from_data", handle_new_from_data); + g_test_add_func ("/api/handle_new_from_gfile_sync", handle_new_from_gfile_sync); + g_test_add_func ("/api/handle_new_from_stream_sync", handle_new_from_stream_sync); + g_test_add_func ("/api/handle_read_stream_sync", handle_read_stream_sync); + g_test_add_func ("/api/handle_has_sub", handle_has_sub); + g_test_add_func ("/api/handle_get_pixbuf", handle_get_pixbuf); + g_test_add_func ("/api/handle_get_pixbuf_sub", handle_get_pixbuf_sub); + g_test_add_func ("/api/dimensions_and_position", dimensions_and_position); + g_test_add_func ("/api/set_size_callback", set_size_callback); + g_test_add_func ("/api/reset_size_callback", reset_size_callback); + g_test_add_func ("/api/render_with_zero_size_callback", render_with_zero_size_callback); + g_test_add_func ("/api/get_pixbuf_with_size_callback", get_pixbuf_with_size_callback); + g_test_add_func ("/api/detects_cairo_context_in_error", detects_cairo_context_in_error); + g_test_add_func ("/api/can_draw_to_non_image_surface", can_draw_to_non_image_surface); + g_test_add_func ("/api/render_cairo_sub", render_cairo_sub); + g_test_add_func ("/api/get_intrinsic_dimensions", get_intrinsic_dimensions); + g_test_add_func ("/api/get_intrinsic_dimensions_missing_values", get_intrinsic_dimensions_missing_values); + g_test_add_func ("/api/get_intrinsic_size_in_pixels/yes", get_intrinsic_size_in_pixels_yes); + g_test_add_func ("/api/get_intrinsic_size_in_pixels/no", get_intrinsic_size_in_pixels_no); + g_test_add_func ("/api/set_stylesheet", set_stylesheet); + g_test_add_func ("/api/render_document", render_document); + g_test_add_func ("/api/get_geometry_for_layer", get_geometry_for_layer); + g_test_add_func ("/api/render_layer", render_layer); + g_test_add_func ("/api/untransformed_element", untransformed_element); + g_test_add_func ("/api/no_write_before_close", no_write_before_close); + g_test_add_func ("/api/empty_write_close", empty_write_close); + g_test_add_func ("/api/cannot_request_external_elements", cannot_request_external_elements); + g_test_add_func ("/api/property_flags", property_flags); + g_test_add_func ("/api/property_dpi", property_dpi); + g_test_add_func ("/api/property_base_uri", property_base_uri); + g_test_add_func ("/api/property_dimensions", property_dimensions); + g_test_add_func ("/api/property_deprecated", property_deprecated); + g_test_add_func ("/api/return_if_fail", return_if_fail); + g_test_add_func ("/api/return_if_fail_null_check", return_if_fail_null_check); + g_test_add_func ("/api/return_if_fail_type_check", return_if_fail_type_check); + g_test_add_func ("/api/library_version_defines", library_version_defines); + g_test_add_func ("/api/library_version_check", library_version_check); + g_test_add_func ("/api/library_version_constants", library_version_constants); +} + +/* Tests for the deprecated APIs to get geometries */ +static void +add_geometry_tests (void) +{ + int i; + + for (i = 0; i < G_N_ELEMENTS (dimensions_fixtures); i++) + g_test_add_data_func (dimensions_fixtures[i].test_name, &dimensions_fixtures[i], (void*)test_dimensions); +} + +/* Tests for the deprecated API for loading bytes at a time */ +static void +add_loading_tests (void) +{ + int i; + + for (i = 0; i < G_N_ELEMENTS (loading_tests); i++) { + g_test_add_data_func (loading_tests[i].test_name, &loading_tests[i], load_n_bytes_at_a_time); + } +} + +int +main (int argc, char **argv) +{ + g_test_init (&argc, &argv, NULL); + + test_utils_print_dependency_versions (); + + add_pixbuf_tests (); + add_api_tests (); + add_geometry_tests (); + add_loading_tests (); + + return g_test_run (); +} |