diff options
author | Tomeu Vizoso <tomeu@sugarlabs.org> | 2010-04-13 18:58:34 -0400 |
---|---|---|
committer | Tomeu Vizoso <tomeu@sugarlabs.org> | 2010-04-13 19:08:24 -0400 |
commit | d9e09987e2e7ec2624f7db7721e751d062da7cab (patch) | |
tree | 7080ffc2f2bf5cef4f7ed5e7e0598f22cc69332d | |
parent | bf4fcea96ffb1f34bc13a9cd7fed5fdb2fa212ff (diff) | |
download | gobject-introspection-d9e09987e2e7ec2624f7db7721e751d062da7cab.tar.gz |
Add GIMarshallingTests typelib
Fixes #615299
-rw-r--r-- | .gitignore | 2 | ||||
-rw-r--r-- | gir/Makefile.am | 21 | ||||
-rw-r--r-- | gir/gimarshallingtests.c | 2924 | ||||
-rw-r--r-- | gir/gimarshallingtests.h | 631 |
4 files changed, 3578 insertions, 0 deletions
@@ -40,6 +40,8 @@ docs/reference/xml docs/reference/tmpl gir/Everything-1.0.gir gir/Everything-1.0.typelib +gir/GIMarshallingTests-1.0.gir +gir/GIMarshallingTests-1.0.typelib gir/GIRepository-2.0.gir gir/GIRepository-2.0.typelib gir/GL-1.0.typelib diff --git a/gir/Makefile.am b/gir/Makefile.am index f1eb4999..7cdbed81 100644 --- a/gir/Makefile.am +++ b/gir/Makefile.am @@ -177,6 +177,27 @@ Everything_1_0_gir_FILES = $(srcdir)/everything.h $(srcdir)/everything.c INTROSPECTION_GIRS += Everything-$(TYPELIB_VERSION).gir EXPECTEDGIRS += Everything-$(TYPELIB_VERSION)-expected.gir +# marshalling tests +lib_LTLIBRARIES += libgirepository-gimarshallingtests-1.0.la + +libgirepository_gimarshallingtests_1_0_la_SOURCES = $(srcdir)/gimarshallingtests.c $(srcdir)/gimarshallingtests.h +libgirepository_gimarshallingtests_1_0_la_CFLAGS = $(GOBJECT_CFLAGS) +libgirepository_gimarshallingtests_1_0_la_LDFLAGS = -version-info $(LT_VERSION) +libgirepository_gimarshallingtests_1_0_la_LIBADD = $(GOBJECT_LIBS) + +if OS_WIN32 +libgirepository_gimarshallingtests_1_0_la_LDFLAGS += -no-undefined +endif + +GIMarshallingTests-1.0.gir: libgirepository-gimarshallingtests-1.0.la + +GIMarshallingTests_1_0_gir_LIBS = libgirepository-gimarshallingtests-1.0.la +GIMarshallingTests_1_0_gir_PACKAGES = gobject-2.0 +GIMarshallingTests_1_0_gir_INCLUDES = GObject-2.0 +GIMarshallingTests_1_0_gir_FILES = $(srcdir)/gimarshallingtests.h $(srcdir)/gimarshallingtests.c + +INTROSPECTION_GIRS += GIMarshallingTests-$(TYPELIB_VERSION).gir + # Generic rules CLEANFILES += $(INTROSPECTION_GIRS) diff --git a/gir/gimarshallingtests.c b/gir/gimarshallingtests.c new file mode 100644 index 00000000..f631173f --- /dev/null +++ b/gir/gimarshallingtests.c @@ -0,0 +1,2924 @@ +/* -*- Mode: C; c-basic-offset: 4 -*- + * vim: tabstop=4 shiftwidth=4 expandtab + */ + +#include "gimarshallingtests.h" + +#include <string.h> + + +/* Booleans */ + +gboolean +g_i_marshalling_tests_boolean_return_true (void) +{ + return TRUE; +} + +gboolean +g_i_marshalling_tests_boolean_return_false (void) +{ + return FALSE; +} + +void +g_i_marshalling_tests_boolean_in_true (gboolean bool_) +{ + g_assert (bool_ == TRUE); +} + +void +g_i_marshalling_tests_boolean_in_false (gboolean bool_) +{ + g_assert (bool_ == FALSE); +} + +/** + * g_i_marshalling_tests_boolean_out_true: + * bool_: (out): + */ +void +g_i_marshalling_tests_boolean_out_true (gboolean *bool_) +{ + *bool_ = TRUE; +} + +/** + * g_i_marshalling_tests_boolean_out_false: + * bool_: (out): + */ +void +g_i_marshalling_tests_boolean_out_false (gboolean *bool_) +{ + *bool_ = FALSE; +} + +/** + * g_i_marshalling_tests_boolean_inout_true_false: + * bool_: (inout): + */ +void +g_i_marshalling_tests_boolean_inout_true_false (gboolean *bool_) +{ + g_assert (*bool_ == TRUE); + *bool_ = FALSE; +} + +/** + * g_i_marshalling_tests_boolean_inout_false_true: + * bool_: (inout): + */ +void +g_i_marshalling_tests_boolean_inout_false_true (gboolean *bool_) +{ + g_assert (*bool_ == FALSE); + *bool_ = TRUE; +} + + +/* Integers */ + +gint8 +g_i_marshalling_tests_int8_return_max (void) +{ + return G_MAXINT8; +} + +gint8 +g_i_marshalling_tests_int8_return_min (void) +{ + return G_MININT8; +} + +void +g_i_marshalling_tests_int8_in_max (gint8 int8) +{ + g_assert(int8 == G_MAXINT8); +} + +void +g_i_marshalling_tests_int8_in_min (gint8 int8) +{ + g_assert(int8 == G_MININT8); +} + +/** + * g_i_marshalling_tests_int8_out_max: + * int8: (out): + */ +void +g_i_marshalling_tests_int8_out_max (gint8 *int8) +{ + *int8 = G_MAXINT8; +} + +/** + * g_i_marshalling_tests_int8_out_min: + * int8: (out): + */ +void +g_i_marshalling_tests_int8_out_min (gint8 *int8) +{ + *int8 = G_MININT8; +} + +/** + * g_i_marshalling_tests_int8_inout_max_min: + * int8: (inout): + */ +void +g_i_marshalling_tests_int8_inout_max_min (gint8 *int8) +{ + g_assert(*int8 == G_MAXINT8); + *int8 = G_MININT8; +} + +/** + * g_i_marshalling_tests_int8_inout_min_max: + * int8: (inout): + */ +void +g_i_marshalling_tests_int8_inout_min_max (gint8 *int8) +{ + g_assert(*int8 == G_MININT8); + *int8 = G_MAXINT8; +} + + +guint8 +g_i_marshalling_tests_uint8_return (void) +{ + return G_MAXUINT8; +} + +void +g_i_marshalling_tests_uint8_in (guint8 uint8) +{ + g_assert(uint8 == G_MAXUINT8); +} + +/** + * g_i_marshalling_tests_uint8_out: + * uint8: (out): + */ +void +g_i_marshalling_tests_uint8_out (guint8 *uint8) +{ + *uint8 = G_MAXUINT8; +} + +/** + * g_i_marshalling_tests_uint8_inout: + * uint8: (inout): + */ +void +g_i_marshalling_tests_uint8_inout (guint8 *uint8) +{ + g_assert(*uint8 == G_MAXUINT8); + *uint8 = 0; +} + + +gint16 +g_i_marshalling_tests_int16_return_max (void) +{ + return G_MAXINT16; +} + +gint16 +g_i_marshalling_tests_int16_return_min (void) +{ + return G_MININT16; +} + +void +g_i_marshalling_tests_int16_in_max (gint16 int16) +{ + g_assert(int16 == G_MAXINT16); +} + +void +g_i_marshalling_tests_int16_in_min (gint16 int16) +{ + g_assert(int16 == G_MININT16); +} + +/** + * g_i_marshalling_tests_int16_out_max: + * int16: (out): + */ +void +g_i_marshalling_tests_int16_out_max (gint16 *int16) +{ + *int16 = G_MAXINT16; +} + +/** + * g_i_marshalling_tests_int16_out_min: + * int16: (out): + */ +void +g_i_marshalling_tests_int16_out_min (gint16 *int16) +{ + *int16 = G_MININT16; +} + +/** + * g_i_marshalling_tests_int16_inout_max_min: + * int16: (inout): + */ +void +g_i_marshalling_tests_int16_inout_max_min (gint16 *int16) +{ + g_assert(*int16 == G_MAXINT16); + *int16 = G_MININT16; +} + +/** + * g_i_marshalling_tests_int16_inout_min_max: + * int16: (inout): + */ +void +g_i_marshalling_tests_int16_inout_min_max (gint16 *int16) +{ + g_assert(*int16 == G_MININT16); + *int16 = G_MAXINT16; +} + + +guint16 +g_i_marshalling_tests_uint16_return (void) +{ + return G_MAXUINT16; +} + +void +g_i_marshalling_tests_uint16_in (guint16 uint16) +{ + g_assert(uint16 == G_MAXUINT16); +} + +/** + * g_i_marshalling_tests_uint16_out: + * uint16: (out): + */ +void +g_i_marshalling_tests_uint16_out (guint16 *uint16) +{ + *uint16 = G_MAXUINT16; +} + +/** + * g_i_marshalling_tests_uint16_inout: + * uint16: (inout): + */ +void +g_i_marshalling_tests_uint16_inout (guint16 *uint16) +{ + g_assert(*uint16 == G_MAXUINT16); + *uint16 = 0; +} + + +gint32 +g_i_marshalling_tests_int32_return_max (void) +{ + return G_MAXINT32; +} + +gint32 +g_i_marshalling_tests_int32_return_min (void) +{ + return G_MININT32; +} + +void +g_i_marshalling_tests_int32_in_max (gint32 int32) +{ + g_assert(int32 == G_MAXINT32); +} + +void +g_i_marshalling_tests_int32_in_min (gint32 int32) +{ + g_assert(int32 == G_MININT32); +} + +/** + * g_i_marshalling_tests_int32_out_max: + * int32: (out): + */ +void +g_i_marshalling_tests_int32_out_max (gint32 *int32) +{ + *int32 = G_MAXINT32; +} + +/** + * g_i_marshalling_tests_int32_out_min: + * int32: (out): + */ +void +g_i_marshalling_tests_int32_out_min (gint32 *int32) +{ + *int32 = G_MININT32; +} + +/** + * g_i_marshalling_tests_int32_inout_max_min: + * int32: (inout): + */ +void +g_i_marshalling_tests_int32_inout_max_min (gint32 *int32) +{ + g_assert(*int32 == G_MAXINT32); + *int32 = G_MININT32; +} + +/** + * g_i_marshalling_tests_int32_inout_min_max: + * int32: (inout): + */ +void +g_i_marshalling_tests_int32_inout_min_max (gint32 *int32) +{ + g_assert(*int32 == G_MININT32); + *int32 = G_MAXINT32; +} + + +guint32 +g_i_marshalling_tests_uint32_return (void) +{ + return G_MAXUINT32; +} + +void +g_i_marshalling_tests_uint32_in (guint32 uint32) +{ + g_assert(uint32 == G_MAXUINT32); +} + +/** + * g_i_marshalling_tests_uint32_out: + * uint32: (out): + */ +void +g_i_marshalling_tests_uint32_out (guint32 *uint32) +{ + *uint32 = G_MAXUINT32; +} + +/** + * g_i_marshalling_tests_uint32_inout: + * uint32: (inout): + */ +void +g_i_marshalling_tests_uint32_inout (guint32 *uint32) +{ + g_assert(*uint32 == G_MAXUINT32); + *uint32 = 0; +} + + +gint64 +g_i_marshalling_tests_int64_return_max (void) +{ + return G_MAXINT64; +} + +gint64 +g_i_marshalling_tests_int64_return_min (void) +{ + return G_MININT64; +} + +void +g_i_marshalling_tests_int64_in_max (gint64 int64) +{ + g_assert(int64 == G_MAXINT64); +} + +void +g_i_marshalling_tests_int64_in_min (gint64 int64) +{ + g_assert(int64 == G_MININT64); +} + +/** + * g_i_marshalling_tests_int64_out_max: + * int64: (out): + */ +void +g_i_marshalling_tests_int64_out_max (gint64 *int64) +{ + *int64 = G_MAXINT64; +} + +/** + * g_i_marshalling_tests_int64_out_min: + * int64: (out): + */ +void +g_i_marshalling_tests_int64_out_min (gint64 *int64) +{ + *int64 = G_MININT64; +} + +/** + * g_i_marshalling_tests_int64_inout_max_min: + * int64: (inout): + */ +void +g_i_marshalling_tests_int64_inout_max_min (gint64 *int64) +{ + g_assert(*int64 == G_MAXINT64); + *int64 = G_MININT64; +} + +/** + * g_i_marshalling_tests_int64_inout_min_max: + * int64: (inout): + */ +void +g_i_marshalling_tests_int64_inout_min_max (gint64 *int64) +{ + g_assert(*int64 == G_MININT64); + *int64 = G_MAXINT64; +} + + +guint64 +g_i_marshalling_tests_uint64_return (void) +{ + return G_MAXUINT64; +} + +void +g_i_marshalling_tests_uint64_in (guint64 uint64) +{ + g_assert(uint64 == G_MAXUINT64); +} + +/** + * g_i_marshalling_tests_uint64_out: + * uint64: (out): + */ +void +g_i_marshalling_tests_uint64_out (guint64 *uint64) +{ + *uint64 = G_MAXUINT64; +} + +/** + * g_i_marshalling_tests_uint64_inout: + * uint64: (inout): + */ +void +g_i_marshalling_tests_uint64_inout (guint64 *uint64) +{ + g_assert(*uint64 == G_MAXUINT64); + *uint64 = 0; +} + + +gshort +g_i_marshalling_tests_short_return_max (void) +{ + return G_MAXSHORT; +} + +gshort +g_i_marshalling_tests_short_return_min (void) +{ + return G_MINSHORT; +} + +void +g_i_marshalling_tests_short_in_max (gshort short_) +{ + g_assert(short_ == G_MAXSHORT); +} + +void +g_i_marshalling_tests_short_in_min (gshort short_) +{ + g_assert(short_ == G_MINSHORT); +} + +/** + * g_i_marshalling_tests_short_out_max: + * short_: (out): + */ +void +g_i_marshalling_tests_short_out_max (gshort *short_) +{ + *short_ = G_MAXSHORT; +} + +/** + * g_i_marshalling_tests_short_out_min: + * short_: (out): + */ +void +g_i_marshalling_tests_short_out_min (gshort *short_) +{ + *short_ = G_MINSHORT; +} + +/** + * g_i_marshalling_tests_short_inout_max_min: + * short_: (inout): + */ +void +g_i_marshalling_tests_short_inout_max_min (gshort *short_) +{ + g_assert(*short_ == G_MAXSHORT); + *short_ = G_MINSHORT; +} + +/** + * g_i_marshalling_tests_short_inout_min_max: + * short_: (inout): + */ +void +g_i_marshalling_tests_short_inout_min_max (gshort *short_) +{ + g_assert(*short_ == G_MINSHORT); + *short_ = G_MAXSHORT; +} + + +gushort +g_i_marshalling_tests_ushort_return (void) +{ + return G_MAXUSHORT; +} + +void +g_i_marshalling_tests_ushort_in (gushort ushort) +{ + g_assert(ushort == G_MAXUSHORT); +} + +/** + * g_i_marshalling_tests_ushort_out: + * ushort: (out): + */ +void +g_i_marshalling_tests_ushort_out (gushort *ushort) +{ + *ushort = G_MAXUSHORT; +} + +/** + * g_i_marshalling_tests_ushort_inout: + * ushort: (inout): + */ +void +g_i_marshalling_tests_ushort_inout (gushort *ushort) +{ + g_assert(*ushort == G_MAXUSHORT); + *ushort = 0; +} + + +gint +g_i_marshalling_tests_int_return_max (void) +{ + return G_MAXINT; +} + +gint +g_i_marshalling_tests_int_return_min (void) +{ + return G_MININT; +} + +void +g_i_marshalling_tests_int_in_max (gint int_) +{ + g_assert(int_ == G_MAXINT); +} + +void +g_i_marshalling_tests_int_in_min (gint int_) +{ + g_assert(int_ == G_MININT); +} + +/** + * g_i_marshalling_tests_int_out_max: + * int_: (out): + */ +void +g_i_marshalling_tests_int_out_max (gint *int_) +{ + *int_ = G_MAXINT; +} + +/** + * g_i_marshalling_tests_int_out_min: + * int_: (out): + */ +void +g_i_marshalling_tests_int_out_min (gint *int_) +{ + *int_ = G_MININT; +} + +/** + * g_i_marshalling_tests_int_inout_max_min: + * int_: (inout): + */ +void +g_i_marshalling_tests_int_inout_max_min (gint *int_) +{ + g_assert(*int_ == G_MAXINT); + *int_ = G_MININT; +} + +/** + * g_i_marshalling_tests_int_inout_min_max: + * int_: (inout): + */ +void +g_i_marshalling_tests_int_inout_min_max (gint *int_) +{ + g_assert(*int_ == G_MININT); + *int_ = G_MAXINT; +} + + +guint +g_i_marshalling_tests_uint_return (void) +{ + return G_MAXUINT; +} + +void +g_i_marshalling_tests_uint_in (guint uint) +{ + g_assert(uint == G_MAXUINT); +} + +/** + * g_i_marshalling_tests_uint_out: + * uint: (out): + */ +void +g_i_marshalling_tests_uint_out (guint *uint) +{ + *uint = G_MAXUINT; +} + +/** + * g_i_marshalling_tests_uint_inout: + * uint: (inout): + */ +void +g_i_marshalling_tests_uint_inout (guint *uint) +{ + g_assert(*uint == G_MAXUINT); + *uint = 0; +} + + +glong +g_i_marshalling_tests_long_return_max (void) +{ + return G_MAXLONG; +} + +glong +g_i_marshalling_tests_long_return_min (void) +{ + return G_MINLONG; +} + +void +g_i_marshalling_tests_long_in_max (glong long_) +{ + g_assert(long_ == G_MAXLONG); +} + +void +g_i_marshalling_tests_long_in_min (glong long_) +{ + g_assert(long_ == G_MINLONG); +} + +/** + * g_i_marshalling_tests_long_out_max: + * long_: (out): + */ +void +g_i_marshalling_tests_long_out_max (glong *long_) +{ + *long_ = G_MAXLONG; +} + +/** + * g_i_marshalling_tests_long_out_min: + * long_: (out): + */ +void +g_i_marshalling_tests_long_out_min (glong *long_) +{ + *long_ = G_MINLONG; +} + +/** + * g_i_marshalling_tests_long_inout_max_min: + * long_: (inout): + */ +void +g_i_marshalling_tests_long_inout_max_min (glong *long_) +{ + g_assert(*long_ == G_MAXLONG); + *long_ = G_MINLONG; +} + +/** + * g_i_marshalling_tests_long_inout_min_max: + * long_: (inout): + */ +void +g_i_marshalling_tests_long_inout_min_max (glong *long_) +{ + g_assert(*long_ == G_MINLONG); + *long_ = G_MAXLONG; +} + + +gulong +g_i_marshalling_tests_ulong_return (void) +{ + return G_MAXULONG; +} + +void +g_i_marshalling_tests_ulong_in (gulong ulong) +{ + g_assert(ulong == G_MAXULONG); +} + +/** + * g_i_marshalling_tests_ulong_out: + * ulong: (out): + */ +void +g_i_marshalling_tests_ulong_out (gulong *ulong) +{ + *ulong = G_MAXULONG; +} + +/** + * g_i_marshalling_tests_ulong_inout: + * ulong: (inout): + */ +void +g_i_marshalling_tests_ulong_inout (gulong *ulong) +{ + g_assert(*ulong == G_MAXULONG); + *ulong = 0; +} + + +gssize +g_i_marshalling_tests_ssize_return_max (void) +{ + return G_MAXSSIZE; +} + +gssize +g_i_marshalling_tests_ssize_return_min (void) +{ + return G_MINSSIZE; +} + +void +g_i_marshalling_tests_ssize_in_max (gssize ssize) +{ + g_assert(ssize == G_MAXSSIZE); +} + +void +g_i_marshalling_tests_ssize_in_min (gssize ssize) +{ + g_assert(ssize == G_MINSSIZE); +} + +/** + * g_i_marshalling_tests_ssize_out_max: + * ssize: (out): + */ +void +g_i_marshalling_tests_ssize_out_max (gssize *ssize) +{ + *ssize = G_MAXSSIZE; +} + +/** + * g_i_marshalling_tests_ssize_out_min: + * ssize: (out): + */ +void +g_i_marshalling_tests_ssize_out_min (gssize *ssize) +{ + *ssize = G_MINSSIZE; +} + +/** + * g_i_marshalling_tests_ssize_inout_max_min: + * ssize: (inout): + */ +void +g_i_marshalling_tests_ssize_inout_max_min (gssize *ssize) +{ + g_assert(*ssize == G_MAXSSIZE); + *ssize = G_MINSSIZE; +} + +/** + * g_i_marshalling_tests_ssize_inout_min_max: + * ssize: (inout): + */ +void +g_i_marshalling_tests_ssize_inout_min_max (gssize *ssize) +{ + g_assert(*ssize == G_MINSSIZE); + *ssize = G_MAXSSIZE; +} + + +gsize +g_i_marshalling_tests_size_return (void) +{ + return G_MAXSIZE; +} + +void +g_i_marshalling_tests_size_in (gsize size) +{ + g_assert(size == G_MAXSIZE); +} + +/** + * g_i_marshalling_tests_size_out: + * size: (out): + */ +void +g_i_marshalling_tests_size_out (gsize *size) +{ + *size = G_MAXSIZE; +} + +/** + * g_i_marshalling_tests_size_inout: + * size: (inout): + */ +void +g_i_marshalling_tests_size_inout (gsize *size) +{ + g_assert(*size == G_MAXSIZE); + *size = 0; +} + + +gfloat +g_i_marshalling_tests_float_return (void) +{ + return G_MAXFLOAT; +} + +void +g_i_marshalling_tests_float_in (gfloat float_) +{ + g_assert(float_ == G_MAXFLOAT); +} + +/** + * g_i_marshalling_tests_float_out: + * float_: (out): + */ +void +g_i_marshalling_tests_float_out (gfloat *float_) +{ + *float_ = G_MAXFLOAT; +} + +/** + * g_i_marshalling_tests_float_inout: + * float_: (inout): + */ +void +g_i_marshalling_tests_float_inout (gfloat *float_) +{ + g_assert(*float_ == G_MAXFLOAT); + *float_ = G_MINFLOAT; +} + + +gdouble +g_i_marshalling_tests_double_return (void) +{ + return G_MAXDOUBLE; +} + +void +g_i_marshalling_tests_double_in (gdouble double_) +{ + g_assert(double_ == G_MAXDOUBLE); +} + +/** + * g_i_marshalling_tests_double_out: + * double_: (out): + */ +void +g_i_marshalling_tests_double_out (gdouble *double_) +{ + *double_ = G_MAXDOUBLE; +} + +/** + * g_i_marshalling_tests_double_inout: + * double_: (inout): + */ +void +g_i_marshalling_tests_double_inout (gdouble *double_) +{ + g_assert(*double_ == G_MAXDOUBLE); + *double_ = G_MINDOUBLE; +} + + +time_t +g_i_marshalling_tests_time_t_return (void) +{ + return 1234567890; +} + +void +g_i_marshalling_tests_time_t_in (time_t time_t_) +{ + g_assert(time_t_ == 1234567890); +} + +/** + * g_i_marshalling_tests_time_t_out: + * time_t_: (out): + */ +void +g_i_marshalling_tests_time_t_out (time_t *time_t_) +{ + *time_t_ = 1234567890; +} + +/** + * g_i_marshalling_tests_time_t_inout: + * time_t_: (inout): + */ +void +g_i_marshalling_tests_time_t_inout (time_t *time_t_) +{ + g_assert(*time_t_ == 1234567890); + *time_t_ = 0; +} + + +GType +g_i_marshalling_tests_gtype_return (void) +{ + return G_TYPE_NONE; +} + +void +g_i_marshalling_tests_gtype_in (GType gtype) +{ + g_assert(gtype == G_TYPE_NONE); +} + +/** + * g_i_marshalling_tests_gtype_out: + * gtype: (out): + */ +void +g_i_marshalling_tests_gtype_out (GType *gtype) +{ + *gtype = G_TYPE_NONE; +} + +/** + * g_i_marshalling_tests_gtype_inout: + * gtype: (inout): + */ +void +g_i_marshalling_tests_gtype_inout (GType *gtype) +{ + g_assert(*gtype == G_TYPE_NONE); + *gtype = G_TYPE_INT; +} + + +const gchar * +g_i_marshalling_tests_utf8_none_return (void) +{ + return G_I_MARSHALLING_TESTS_CONSTANT_UTF8; +} + +gchar * +g_i_marshalling_tests_utf8_full_return (void) +{ + return g_strdup(G_I_MARSHALLING_TESTS_CONSTANT_UTF8); +} + +void +g_i_marshalling_tests_utf8_none_in (const gchar *utf8) +{ + g_assert(strcmp(G_I_MARSHALLING_TESTS_CONSTANT_UTF8, utf8) == 0); +} + +void +g_i_marshalling_tests_utf8_full_in (gchar *utf8) +{ + g_assert(strcmp(G_I_MARSHALLING_TESTS_CONSTANT_UTF8, utf8) == 0); + g_free(utf8); +} + +/** + * g_i_marshalling_tests_utf8_none_out: + * utf8: (out) (transfer none): + */ +void +g_i_marshalling_tests_utf8_none_out (gchar **utf8) +{ + *utf8 = G_I_MARSHALLING_TESTS_CONSTANT_UTF8; +} + +/** + * g_i_marshalling_tests_utf8_full_out: + * utf8: (out) (transfer full): + */ +void +g_i_marshalling_tests_utf8_full_out (gchar **utf8) +{ + *utf8 = g_strdup(G_I_MARSHALLING_TESTS_CONSTANT_UTF8); +} + +/** + * g_i_marshalling_tests_utf8_none_inout: + * utf8: (inout) (transfer none): + */ +void +g_i_marshalling_tests_utf8_none_inout (gchar **utf8) +{ + g_assert(strcmp(G_I_MARSHALLING_TESTS_CONSTANT_UTF8, *utf8) == 0); + *utf8 = ""; +} + +/** + * g_i_marshalling_tests_utf8_full_inout: + * utf8: (inout) (transfer full): + */ +void +g_i_marshalling_tests_utf8_full_inout (gchar **utf8) +{ + g_assert(strcmp(G_I_MARSHALLING_TESTS_CONSTANT_UTF8, *utf8) == 0); + g_free(*utf8); + *utf8 = g_strdup(""); +} + + +/** + * g_i_marshalling_tests_array_fixed_int_return: + * Returns: (array fixed-size=4): + */ +const gint * +g_i_marshalling_tests_array_fixed_int_return (void) +{ + static gint ints[] = {-1, 0, 1, 2}; + return ints; +} + +/** + * g_i_marshalling_tests_array_fixed_short_return: + * Returns: (array fixed-size=4): + */ +const gshort * +g_i_marshalling_tests_array_fixed_short_return (void) +{ + static gshort shorts[] = {-1, 0, 1, 2}; + return shorts; +} + +/** + * g_i_marshalling_tests_array_fixed_int_in: + * @ints: (array fixed-size=4): + */ +void +g_i_marshalling_tests_array_fixed_int_in (const gint *ints) +{ + g_assert(ints[0] == -1); + g_assert(ints[1] == 0); + g_assert(ints[2] == 1); + g_assert(ints[3] == 2); +} + +/** + * g_i_marshalling_tests_array_fixed_short_in: + * @shorts: (array fixed-size=4): + */ +void +g_i_marshalling_tests_array_fixed_short_in (const gshort *shorts) +{ + g_assert(shorts[0] == -1); + g_assert(shorts[1] == 0); + g_assert(shorts[2] == 1); + g_assert(shorts[3] == 2); +} + +/** + * g_i_marshalling_tests_array_fixed_out: + * @ints: (out) (array fixed-size=4) (transfer none): + */ +void +g_i_marshalling_tests_array_fixed_out (gint **ints) +{ + static gint values[] = {-1, 0, 1, 2}; + *ints = values; +} + +/** + * g_i_marshalling_tests_array_fixed_out_struct: + * @structs: (out) (array fixed-size=2) (transfer none): + */ +void +g_i_marshalling_tests_array_fixed_out_struct (GIMarshallingTestsSimpleStruct **structs) +{ + static GIMarshallingTestsSimpleStruct *values; + + if (values == NULL) { + values = g_new(GIMarshallingTestsSimpleStruct, 2); + + values[0].long_ = 7; + values[0].int8 = 6; + + values[1].long_ = 6; + values[1].int8 = 7; + } + + *structs = values; +} + +/** + * g_i_marshalling_tests_array_fixed_inout: + * @ints: (inout) (array fixed-size=4) (transfer none): + */ +void +g_i_marshalling_tests_array_fixed_inout (gint **ints) +{ + static gint values[] = {2, 1, 0, -1}; + + g_assert((*ints)[0] == -1); + g_assert((*ints)[1] == 0); + g_assert((*ints)[2] == 1); + g_assert((*ints)[3] == 2); + + *ints = values; +} + + +/** + * g_i_marshalling_tests_array_return: + * Returns: (array length=length): + */ +const gint * +g_i_marshalling_tests_array_return (gint *length) +{ + static gint ints[] = {-1, 0, 1, 2}; + + *length = 4; + return ints; +} + +/** + * g_i_marshalling_tests_array_in: + * @ints: (array length=length): + */ +void +g_i_marshalling_tests_array_in (const gint *ints, gint length) +{ + g_assert(length == 4); + g_assert(ints[0] == -1); + g_assert(ints[1] == 0); + g_assert(ints[2] == 1); + g_assert(ints[3] == 2); +} + +/** + * g_i_marshalling_tests_array_out: + * @ints: (out) (array length=length) (transfer none): + */ +void +g_i_marshalling_tests_array_out (gint **ints, gint *length) +{ + static gint values[] = {-1, 0, 1, 2}; + + *length = 4; + *ints = values; +} + +/** + * g_i_marshalling_tests_array_inout: + * @ints: (inout) (array length=length) (transfer none): + * @length: (inout): + */ +void +g_i_marshalling_tests_array_inout (gint **ints, gint *length) +{ + static gint values[] = {-2, -1, 0, 1, 2}; + + g_assert(*length == 4); + g_assert((*ints)[0] == -1); + g_assert((*ints)[1] == 0); + g_assert((*ints)[2] == 1); + g_assert((*ints)[3] == 2); + + *length = 5; + *ints = values; +} + +/** + * g_i_marshalling_tests_array_zero_terminated_return: + * Returns: (array zero-terminated=1) (transfer none): + */ +gchar ** +g_i_marshalling_tests_array_zero_terminated_return (void) +{ + static gchar *values[] = {"0", "1", "2", NULL}; + return values; +} + +/** + * g_i_marshalling_tests_array_zero_terminated_in: + * @utf8s: (array zero-terminated=1) (transfer none): + */ +void +g_i_marshalling_tests_array_zero_terminated_in (gchar **utf8s) +{ + g_assert(g_strv_length(utf8s)); + g_assert(strcmp(utf8s[0], "0") == 0); + g_assert(strcmp(utf8s[1], "1") == 0); + g_assert(strcmp(utf8s[2], "2") == 0); +} + +/** + * g_i_marshalling_tests_array_zero_terminated_out: + * @utf8s: (out) (array zero-terminated=1) (transfer none): + */ +void +g_i_marshalling_tests_array_zero_terminated_out (gchar ***utf8s) +{ + static gchar *values[] = {"0", "1", "2", NULL}; + *utf8s = values; +} + +/** + * g_i_marshalling_tests_array_zero_terminated_inout: + * @utf8s: (inout) (array zero-terminated=1) (transfer none): + */ +void +g_i_marshalling_tests_array_zero_terminated_inout (gchar ***utf8s) +{ + static gchar *values[] = {"-1", "0", "1", "2", NULL}; + + g_assert(g_strv_length(*utf8s)); + g_assert(strcmp((*utf8s)[0], "0") == 0); + g_assert(strcmp((*utf8s)[1], "1") == 0); + g_assert(strcmp((*utf8s)[2], "2") == 0); + + *utf8s = values; +} + + +/** + * g_i_marshalling_tests_glist_int_none_return: + * Returns: (element-type gint) (transfer none): + */ +GList * +g_i_marshalling_tests_glist_int_none_return (void) +{ + static GList *list = NULL; + + if (list == NULL) { + list = g_list_append(list, GINT_TO_POINTER(-1)); + list = g_list_append(list, GINT_TO_POINTER(0)); + list = g_list_append(list, GINT_TO_POINTER(1)); + list = g_list_append(list, GINT_TO_POINTER(2)); + } + + return list; +} + +/** + * g_i_marshalling_tests_glist_utf8_none_return: + * Returns: (element-type utf8) (transfer none): + */ +GList * +g_i_marshalling_tests_glist_utf8_none_return (void) +{ + static GList *list = NULL; + + if (list == NULL) { + list = g_list_append(list, "0"); + list = g_list_append(list, "1"); + list = g_list_append(list, "2"); + } + + return list; +} + +/** + * g_i_marshalling_tests_glist_utf8_container_return: + * Returns: (element-type utf8) (transfer container): + */ +GList * +g_i_marshalling_tests_glist_utf8_container_return (void) +{ + GList *list = NULL; + + list = g_list_append(list, "0"); + list = g_list_append(list, "1"); + list = g_list_append(list, "2"); + + return list; +} + +/** + * g_i_marshalling_tests_glist_utf8_full_return: + * Returns: (element-type utf8) (transfer full): + */ +GList * +g_i_marshalling_tests_glist_utf8_full_return (void) +{ + GList *list = NULL; + + list = g_list_append(list, g_strdup("0")); + list = g_list_append(list, g_strdup("1")); + list = g_list_append(list, g_strdup("2")); + + return list; +} + +/** + * g_i_marshalling_tests_glist_int_none_in: + * @list: (element-type gint) (transfer none): + */ +void +g_i_marshalling_tests_glist_int_none_in (GList *list) +{ + g_assert(g_list_length(list) == 4); + g_assert(GPOINTER_TO_INT(g_list_nth_data(list, 0)) == -1); + g_assert(GPOINTER_TO_INT(g_list_nth_data(list, 1)) == 0); + g_assert(GPOINTER_TO_INT(g_list_nth_data(list, 2)) == 1); + g_assert(GPOINTER_TO_INT(g_list_nth_data(list, 3)) == 2); +} + +/** + * g_i_marshalling_tests_glist_utf8_none_in: + * @list: (element-type utf8) (transfer none): + */ +void +g_i_marshalling_tests_glist_utf8_none_in (GList *list) +{ + g_assert(g_list_length(list) == 3); + g_assert(strcmp(g_list_nth_data(list, 0), "0") == 0); + g_assert(strcmp(g_list_nth_data(list, 1), "1") == 0); + g_assert(strcmp(g_list_nth_data(list, 2), "2") == 0); +} + +/** + * g_i_marshalling_tests_glist_utf8_container_in: + * @list: (element-type utf8) (transfer container): + */ +void +g_i_marshalling_tests_glist_utf8_container_in (GList *list) +{ + g_assert(g_list_length(list) == 3); + g_assert(strcmp(g_list_nth_data(list, 0), "0") == 0); + g_assert(strcmp(g_list_nth_data(list, 1), "1") == 0); + g_assert(strcmp(g_list_nth_data(list, 2), "2") == 0); + g_list_free(list); +} + +/** + * g_i_marshalling_tests_glist_utf8_full_in: + * @list: (element-type utf8) (transfer full): + */ +void +g_i_marshalling_tests_glist_utf8_full_in (GList *list) +{ + g_assert(g_list_length(list) == 3); + g_assert(strcmp(g_list_nth_data(list, 0), "0") == 0); + g_assert(strcmp(g_list_nth_data(list, 1), "1") == 0); + g_assert(strcmp(g_list_nth_data(list, 2), "2") == 0); + g_free(g_list_nth_data(list, 0)); + g_free(g_list_nth_data(list, 1)); + g_free(g_list_nth_data(list, 2)); + g_list_free(list); +} + +/** + * g_i_marshalling_tests_glist_utf8_none_out: + * @list: (out) (element-type utf8) (transfer none): + */ +void +g_i_marshalling_tests_glist_utf8_none_out (GList **list) +{ + static GList *values = NULL; + + if (values == NULL) { + values = g_list_append(values, "0"); + values = g_list_append(values, "1"); + values = g_list_append(values, "2"); + } + + *list = values; +} + +/** + * g_i_marshalling_tests_glist_utf8_container_out: + * @list: (out) (element-type utf8) (transfer container): + */ +void +g_i_marshalling_tests_glist_utf8_container_out (GList **list) +{ + *list = NULL; + + *list = g_list_append(*list, "0"); + *list = g_list_append(*list, "1"); + *list = g_list_append(*list, "2"); +} + +/** + * g_i_marshalling_tests_glist_utf8_full_out: + * @list: (out) (element-type utf8) (transfer full): + */ +void +g_i_marshalling_tests_glist_utf8_full_out (GList **list) +{ + *list = NULL; + + *list = g_list_append(*list, g_strdup("0")); + *list = g_list_append(*list, g_strdup("1")); + *list = g_list_append(*list, g_strdup("2")); +} + +/** + * g_i_marshalling_tests_glist_utf8_none_inout: + * @list: (inout) (element-type utf8) (transfer none): + */ +void +g_i_marshalling_tests_glist_utf8_none_inout (GList **list) +{ + static GList *values = NULL; + + g_assert(g_list_length(*list) == 3); + g_assert(strcmp(g_list_nth_data(*list, 0), "0") == 0); + g_assert(strcmp(g_list_nth_data(*list, 1), "1") == 0); + g_assert(strcmp(g_list_nth_data(*list, 2), "2") == 0); + + if (values == NULL) { + values = g_list_append(values, "-2"); + values = g_list_append(values, "-1"); + values = g_list_append(values, "0"); + values = g_list_append(values, "1"); + } + + *list = values; +} + +/** + * g_i_marshalling_tests_glist_utf8_container_inout: + * @list: (inout) (element-type utf8) (transfer container): + */ +void +g_i_marshalling_tests_glist_utf8_container_inout (GList **list) +{ + g_assert(g_list_length(*list) == 3); + g_assert(strcmp(g_list_nth_data(*list, 0), "0") == 0); + g_assert(strcmp(g_list_nth_data(*list, 1), "1") == 0); + g_assert(strcmp(g_list_nth_data(*list, 2), "2") == 0); + + *list = g_list_remove_link(*list, g_list_last(*list)); + + *list = g_list_prepend(*list, "-1"); + *list = g_list_prepend(*list, "-2"); +} + +/** + * g_i_marshalling_tests_glist_utf8_full_inout: + * @list: (inout) (element-type utf8) (transfer full): + */ +void +g_i_marshalling_tests_glist_utf8_full_inout (GList **list) +{ + gpointer *data; + + g_assert(g_list_length(*list) == 3); + g_assert(strcmp(g_list_nth_data(*list, 0), "0") == 0); + g_assert(strcmp(g_list_nth_data(*list, 1), "1") == 0); + g_assert(strcmp(g_list_nth_data(*list, 2), "2") == 0); + + data = g_list_last(*list)->data; + *list = g_list_remove(*list, data); + g_free(data); + + *list = g_list_prepend(*list, g_strdup("-1")); + *list = g_list_prepend(*list, g_strdup("-2")); +} + + +/** + * g_i_marshalling_tests_gslist_int_none_return: + * Returns: (element-type gint) (transfer none): + */ +GSList * +g_i_marshalling_tests_gslist_int_none_return (void) +{ + static GSList *list = NULL; + + if (list == NULL) { + list = g_slist_prepend(list, GINT_TO_POINTER(-1)); + list = g_slist_prepend(list, GINT_TO_POINTER(0)); + list = g_slist_prepend(list, GINT_TO_POINTER(1)); + list = g_slist_prepend(list, GINT_TO_POINTER(2)); + list = g_slist_reverse(list); + } + + return list; +} + +/** + * g_i_marshalling_tests_gslist_utf8_none_return: + * Returns: (element-type utf8) (transfer none): + */ +GSList * +g_i_marshalling_tests_gslist_utf8_none_return (void) +{ + static GSList *list = NULL; + + if (list == NULL) { + list = g_slist_prepend(list, "0"); + list = g_slist_prepend(list, "1"); + list = g_slist_prepend(list, "2"); + list = g_slist_reverse(list); + } + + return list; +} + +/** + * g_i_marshalling_tests_gslist_utf8_container_return: + * Returns: (element-type utf8) (transfer container): + */ +GSList * +g_i_marshalling_tests_gslist_utf8_container_return (void) +{ + GSList *list = NULL; + + list = g_slist_prepend(list, "0"); + list = g_slist_prepend(list, "1"); + list = g_slist_prepend(list, "2"); + list = g_slist_reverse(list); + + return list; +} + +/** + * g_i_marshalling_tests_gslist_utf8_full_return: + * Returns: (element-type utf8) (transfer full): + */ +GSList * +g_i_marshalling_tests_gslist_utf8_full_return (void) +{ + GSList *list = NULL; + + list = g_slist_prepend(list, g_strdup("0")); + list = g_slist_prepend(list, g_strdup("1")); + list = g_slist_prepend(list, g_strdup("2")); + list = g_slist_reverse(list); + + return list; +} + +/** + * g_i_marshalling_tests_gslist_int_none_in: + * @list: (element-type gint) (transfer none): + */ +void +g_i_marshalling_tests_gslist_int_none_in (GSList *list) +{ + g_assert(g_slist_length(list) == 4); + g_assert(GPOINTER_TO_INT(g_slist_nth_data(list, 0)) == -1); + g_assert(GPOINTER_TO_INT(g_slist_nth_data(list, 1)) == 0); + g_assert(GPOINTER_TO_INT(g_slist_nth_data(list, 2)) == 1); + g_assert(GPOINTER_TO_INT(g_slist_nth_data(list, 3)) == 2); +} + +/** + * g_i_marshalling_tests_gslist_utf8_none_in: + * @list: (element-type utf8) (transfer none): + */ +void +g_i_marshalling_tests_gslist_utf8_none_in (GSList *list) +{ + g_assert(g_slist_length(list) == 3); + g_assert(strcmp(g_slist_nth_data(list, 0), "0") == 0); + g_assert(strcmp(g_slist_nth_data(list, 1), "1") == 0); + g_assert(strcmp(g_slist_nth_data(list, 2), "2") == 0); +} + +/** + * g_i_marshalling_tests_gslist_utf8_container_in: + * @list: (element-type utf8) (transfer container): + */ +void +g_i_marshalling_tests_gslist_utf8_container_in (GSList *list) +{ + g_assert(g_slist_length(list) == 3); + g_assert(strcmp(g_slist_nth_data(list, 0), "0") == 0); + g_assert(strcmp(g_slist_nth_data(list, 1), "1") == 0); + g_assert(strcmp(g_slist_nth_data(list, 2), "2") == 0); + g_slist_free(list); +} + +/** + * g_i_marshalling_tests_gslist_utf8_full_in: + * @list: (element-type utf8) (transfer full): + */ +void +g_i_marshalling_tests_gslist_utf8_full_in (GSList *list) +{ + g_assert(g_slist_length(list) == 3); + g_assert(strcmp(g_slist_nth_data(list, 0), "0") == 0); + g_assert(strcmp(g_slist_nth_data(list, 1), "1") == 0); + g_assert(strcmp(g_slist_nth_data(list, 2), "2") == 0); + g_free(g_slist_nth_data(list, 0)); + g_free(g_slist_nth_data(list, 1)); + g_free(g_slist_nth_data(list, 2)); + g_slist_free(list); +} + +/** + * g_i_marshalling_tests_gslist_utf8_none_out: + * @list: (out) (element-type utf8) (transfer none): + */ +void +g_i_marshalling_tests_gslist_utf8_none_out (GSList **list) +{ + static GSList *values = NULL; + + if (values == NULL) { + values = g_slist_prepend(values, "0"); + values = g_slist_prepend(values, "1"); + values = g_slist_prepend(values, "2"); + values = g_slist_reverse(values); + } + + *list = values; +} + +/** + * g_i_marshalling_tests_gslist_utf8_container_out: + * @list: (out) (element-type utf8) (transfer container): + */ +void +g_i_marshalling_tests_gslist_utf8_container_out (GSList **list) +{ + *list = NULL; + + *list = g_slist_prepend(*list, "0"); + *list = g_slist_prepend(*list, "1"); + *list = g_slist_prepend(*list, "2"); + *list = g_slist_reverse(*list); +} + +/** + * g_i_marshalling_tests_gslist_utf8_full_out: + * @list: (out) (element-type utf8) (transfer full): + */ +void +g_i_marshalling_tests_gslist_utf8_full_out (GSList **list) +{ + *list = NULL; + + *list = g_slist_prepend(*list, g_strdup("0")); + *list = g_slist_prepend(*list, g_strdup("1")); + *list = g_slist_prepend(*list, g_strdup("2")); + *list = g_slist_reverse(*list); +} + +/** + * g_i_marshalling_tests_gslist_utf8_none_inout: + * @list: (inout) (element-type utf8) (transfer none): + */ +void +g_i_marshalling_tests_gslist_utf8_none_inout (GSList **list) +{ + static GSList *values = NULL; + + g_assert(g_slist_length(*list) == 3); + g_assert(strcmp(g_slist_nth_data(*list, 0), "0") == 0); + g_assert(strcmp(g_slist_nth_data(*list, 1), "1") == 0); + g_assert(strcmp(g_slist_nth_data(*list, 2), "2") == 0); + + if (values == NULL) { + values = g_slist_prepend(values, "-2"); + values = g_slist_prepend(values, "-1"); + values = g_slist_prepend(values, "0"); + values = g_slist_prepend(values, "1"); + values = g_slist_reverse(values); + } + + *list = values; +} + +/** + * g_i_marshalling_tests_gslist_utf8_container_inout: + * @list: (inout) (element-type utf8) (transfer container): + */ +void +g_i_marshalling_tests_gslist_utf8_container_inout (GSList **list) +{ + g_assert(g_slist_length(*list) == 3); + g_assert(strcmp(g_slist_nth_data(*list, 0), "0") == 0); + g_assert(strcmp(g_slist_nth_data(*list, 1), "1") == 0); + g_assert(strcmp(g_slist_nth_data(*list, 2), "2") == 0); + + *list = g_slist_remove_link(*list, g_slist_last(*list)); + + *list = g_slist_prepend(*list, "-1"); + *list = g_slist_prepend(*list, "-2"); +} + +/** + * g_i_marshalling_tests_gslist_utf8_full_inout: + * @list: (inout) (element-type utf8) (transfer full): + */ +void +g_i_marshalling_tests_gslist_utf8_full_inout (GSList **list) +{ + gpointer *data; + + g_assert(g_slist_length(*list) == 3); + g_assert(strcmp(g_slist_nth_data(*list, 0), "0") == 0); + g_assert(strcmp(g_slist_nth_data(*list, 1), "1") == 0); + g_assert(strcmp(g_slist_nth_data(*list, 2), "2") == 0); + + data = g_slist_last(*list)->data; + *list = g_slist_remove(*list, data); + g_free(data); + + *list = g_slist_prepend(*list, g_strdup("-1")); + *list = g_slist_prepend(*list, g_strdup("-2")); +} + + +/** + * g_i_marshalling_tests_ghashtable_int_none_return: + * Returns: (element-type gint gint) (transfer none): + */ +GHashTable * +g_i_marshalling_tests_ghashtable_int_none_return (void) +{ + static GHashTable *hash_table = NULL; + + if (hash_table == NULL) { + hash_table = g_hash_table_new(NULL, NULL); + g_hash_table_insert(hash_table, GINT_TO_POINTER(-1), GINT_TO_POINTER(1)); + g_hash_table_insert(hash_table, GINT_TO_POINTER(0), GINT_TO_POINTER(0)); + g_hash_table_insert(hash_table, GINT_TO_POINTER(1), GINT_TO_POINTER(-1)); + g_hash_table_insert(hash_table, GINT_TO_POINTER(2), GINT_TO_POINTER(-2)); + } + + return hash_table; +} + +/** + * g_i_marshalling_tests_ghashtable_utf8_none_return: + * Returns: (element-type utf8 utf8) (transfer none): + */ +GHashTable * +g_i_marshalling_tests_ghashtable_utf8_none_return (void) +{ + static GHashTable *hash_table = NULL; + + if (hash_table == NULL) { + hash_table = g_hash_table_new(g_str_hash, g_str_equal); + g_hash_table_insert(hash_table, "-1", "1"); + g_hash_table_insert(hash_table, "0", "0"); + g_hash_table_insert(hash_table, "1", "-1"); + g_hash_table_insert(hash_table, "2", "-2"); + } + + return hash_table; +} + +/** + * g_i_marshalling_tests_ghashtable_utf8_container_return: + * Returns: (element-type utf8 utf8) (transfer container): + */ +GHashTable * +g_i_marshalling_tests_ghashtable_utf8_container_return (void) +{ + GHashTable *hash_table = NULL; + + hash_table = g_hash_table_new(g_str_hash, g_str_equal); + g_hash_table_insert(hash_table, "-1", "1"); + g_hash_table_insert(hash_table, "0", "0"); + g_hash_table_insert(hash_table, "1", "-1"); + g_hash_table_insert(hash_table, "2", "-2"); + + return hash_table; +} + +/** + * g_i_marshalling_tests_ghashtable_utf8_full_return: + * Returns: (element-type utf8 utf8) (transfer full): + */ +GHashTable * +g_i_marshalling_tests_ghashtable_utf8_full_return (void) +{ + GHashTable *hash_table = NULL; + + hash_table = g_hash_table_new(g_str_hash, g_str_equal); + g_hash_table_insert(hash_table, g_strdup("-1"), g_strdup("1")); + g_hash_table_insert(hash_table, g_strdup("0"), g_strdup("0")); + g_hash_table_insert(hash_table, g_strdup("1"), g_strdup("-1")); + g_hash_table_insert(hash_table, g_strdup("2"), g_strdup("-2")); + + return hash_table; +} + +/** + * g_i_marshalling_tests_ghashtable_int_none_in: + * @hash_table: (element-type gint gint) (transfer none): + */ +void +g_i_marshalling_tests_ghashtable_int_none_in (GHashTable *hash_table) +{ + g_assert(GPOINTER_TO_INT(g_hash_table_lookup(hash_table, GINT_TO_POINTER(-1))) == 1); + g_assert(GPOINTER_TO_INT(g_hash_table_lookup(hash_table, GINT_TO_POINTER(0))) == 0); + g_assert(GPOINTER_TO_INT(g_hash_table_lookup(hash_table, GINT_TO_POINTER(1))) == -1); + g_assert(GPOINTER_TO_INT(g_hash_table_lookup(hash_table, GINT_TO_POINTER(2))) == -2); +} + +/** + * g_i_marshalling_tests_ghashtable_utf8_none_in: + * @hash_table: (element-type utf8 utf8) (transfer none): + */ +void +g_i_marshalling_tests_ghashtable_utf8_none_in (GHashTable *hash_table) +{ + g_assert(strcmp(g_hash_table_lookup(hash_table, "-1"), "1") == 0); + g_assert(strcmp(g_hash_table_lookup(hash_table, "0"), "0") == 0); + g_assert(strcmp(g_hash_table_lookup(hash_table, "1"), "-1") == 0); + g_assert(strcmp(g_hash_table_lookup(hash_table, "2"), "-2") == 0); +} + +/** + * g_i_marshalling_tests_ghashtable_utf8_container_in: + * @hash_table: (element-type utf8 utf8) (transfer container): + */ +void +g_i_marshalling_tests_ghashtable_utf8_container_in (GHashTable *hash_table) +{ + g_assert(strcmp(g_hash_table_lookup(hash_table, "-1"), "1") == 0); + g_assert(strcmp(g_hash_table_lookup(hash_table, "0"), "0") == 0); + g_assert(strcmp(g_hash_table_lookup(hash_table, "1"), "-1") == 0); + g_assert(strcmp(g_hash_table_lookup(hash_table, "2"), "-2") == 0); + g_hash_table_steal_all(hash_table); + g_hash_table_unref(hash_table); +} + +/** + * g_i_marshalling_tests_ghashtable_utf8_full_in: + * @hash_table: (element-type utf8 utf8) (transfer full): + */ +void +g_i_marshalling_tests_ghashtable_utf8_full_in (GHashTable *hash_table) +{ + GHashTableIter hash_table_iter; + gpointer key, value; + + g_assert(strcmp(g_hash_table_lookup(hash_table, "-1"), "1") == 0); + g_assert(strcmp(g_hash_table_lookup(hash_table, "0"), "0") == 0); + g_assert(strcmp(g_hash_table_lookup(hash_table, "1"), "-1") == 0); + g_assert(strcmp(g_hash_table_lookup(hash_table, "2"), "-2") == 0); + + g_hash_table_iter_init(&hash_table_iter, hash_table); + while (g_hash_table_iter_next(&hash_table_iter, &key, &value)) { + g_free(key); + g_free(value); + g_hash_table_iter_steal(&hash_table_iter); + } + + g_hash_table_unref(hash_table); +} + +/** + * g_i_marshalling_tests_ghashtable_utf8_none_out: + * @hash_table: (out) (element-type utf8 utf8) (transfer none): + */ +void +g_i_marshalling_tests_ghashtable_utf8_none_out (GHashTable **hash_table) +{ + static GHashTable *new_hash_table = NULL; + + if (new_hash_table == NULL) { + new_hash_table = g_hash_table_new(g_str_hash, g_str_equal); + g_hash_table_insert(new_hash_table, "-1", "1"); + g_hash_table_insert(new_hash_table, "0", "0"); + g_hash_table_insert(new_hash_table, "1", "-1"); + g_hash_table_insert(new_hash_table, "2", "-2"); + } + + *hash_table = new_hash_table; +} + +/** + * g_i_marshalling_tests_ghashtable_utf8_container_out: + * @hash_table: (out) (element-type utf8 utf8) (transfer container): + */ +void +g_i_marshalling_tests_ghashtable_utf8_container_out (GHashTable **hash_table) +{ + *hash_table = g_hash_table_new(g_str_hash, g_str_equal); + g_hash_table_insert(*hash_table, "-1", "1"); + g_hash_table_insert(*hash_table, "0", "0"); + g_hash_table_insert(*hash_table, "1", "-1"); + g_hash_table_insert(*hash_table, "2", "-2"); +} + +/** + * g_i_marshalling_tests_ghashtable_utf8_full_out: + * @hash_table: (out) (element-type utf8 utf8) (transfer full): + */ +void +g_i_marshalling_tests_ghashtable_utf8_full_out (GHashTable **hash_table) +{ + *hash_table = g_hash_table_new(g_str_hash, g_str_equal); + g_hash_table_insert(*hash_table, g_strdup("-1"), g_strdup("1")); + g_hash_table_insert(*hash_table, g_strdup("0"), g_strdup("0")); + g_hash_table_insert(*hash_table, g_strdup("1"), g_strdup("-1")); + g_hash_table_insert(*hash_table, g_strdup("2"), g_strdup("-2")); +} + +/** + * g_i_marshalling_tests_ghashtable_utf8_none_inout: + * @hash_table: (inout) (element-type utf8 utf8) (transfer none): + */ +void +g_i_marshalling_tests_ghashtable_utf8_none_inout (GHashTable **hash_table) +{ + static GHashTable *new_hash_table = NULL; + + g_assert(strcmp(g_hash_table_lookup(*hash_table, "-1"), "1") == 0); + g_assert(strcmp(g_hash_table_lookup(*hash_table, "0"), "0") == 0); + g_assert(strcmp(g_hash_table_lookup(*hash_table, "1"), "-1") == 0); + g_assert(strcmp(g_hash_table_lookup(*hash_table, "2"), "-2") == 0); + + if (new_hash_table == NULL) { + new_hash_table = g_hash_table_new(g_str_hash, g_str_equal); + g_hash_table_insert(new_hash_table, "-1", "1"); + g_hash_table_insert(new_hash_table, "0", "0"); + g_hash_table_insert(new_hash_table, "1", "1"); + } + + *hash_table = new_hash_table; +} + +/** + * g_i_marshalling_tests_ghashtable_utf8_container_inout: + * @hash_table: (inout) (element-type utf8 utf8) (transfer container): + */ +void +g_i_marshalling_tests_ghashtable_utf8_container_inout (GHashTable **hash_table) +{ + g_assert(strcmp(g_hash_table_lookup(*hash_table, "-1"), "1") == 0); + g_assert(strcmp(g_hash_table_lookup(*hash_table, "0"), "0") == 0); + g_assert(strcmp(g_hash_table_lookup(*hash_table, "1"), "-1") == 0); + g_assert(strcmp(g_hash_table_lookup(*hash_table, "2"), "-2") == 0); + + g_hash_table_steal(*hash_table, "2"); + g_hash_table_steal(*hash_table, "1"); + g_hash_table_insert(*hash_table, "1", "1"); +} + +/** + * g_i_marshalling_tests_ghashtable_utf8_full_inout: + * @hash_table: (inout) (element-type utf8 utf8) (transfer full): + */ +void +g_i_marshalling_tests_ghashtable_utf8_full_inout (GHashTable **hash_table) +{ + g_assert(strcmp(g_hash_table_lookup(*hash_table, "-1"), "1") == 0); + g_assert(strcmp(g_hash_table_lookup(*hash_table, "0"), "0") == 0); + g_assert(strcmp(g_hash_table_lookup(*hash_table, "1"), "-1") == 0); + g_assert(strcmp(g_hash_table_lookup(*hash_table, "2"), "-2") == 0); + + g_hash_table_steal(*hash_table, "2"); + g_hash_table_steal(*hash_table, "1"); + g_hash_table_insert(*hash_table, "1", g_strdup("1")); +} + + +/** + * g_i_marshalling_tests_gvalue_return: + * Returns: (transfer none): + */ +GValue * +g_i_marshalling_tests_gvalue_return (void) +{ + static GValue *value = NULL; + + if (value == NULL) { + value = g_new0(GValue, 1); + g_value_init(value, G_TYPE_INT); + g_value_set_int(value, 42); + } + + return value; +} + +/** + * g_i_marshalling_tests_gvalue_in: + * @value: (transfer none): + */ +void +g_i_marshalling_tests_gvalue_in (GValue *value) +{ + g_assert(g_value_get_int(value) == 42); +} + +/** + * g_i_marshalling_tests_gvalue_out: + * @value: (out) (transfer none): + */ +void +g_i_marshalling_tests_gvalue_out (GValue **value) +{ + static GValue *new_value = NULL; + + if (new_value == NULL) { + new_value = g_new0(GValue, 1); + g_value_init(new_value, G_TYPE_INT); + g_value_set_int(new_value, 42); + } + + *value = new_value; +} + +/** + * g_i_marshalling_tests_gvalue_inout: + * @value: (inout) (transfer none): + */ +void +g_i_marshalling_tests_gvalue_inout (GValue **value) +{ + g_assert(g_value_get_int(*value) == 42); + g_value_unset(*value); + g_value_init(*value, G_TYPE_STRING); + g_value_set_string(*value, "42"); +} + + +/** + * g_i_marshalling_tests_gclosure_in: + * @closure: (transfer none): + */ +void +g_i_marshalling_tests_gclosure_in (GClosure *closure) +{ + GValue return_value = {0, }; + + g_value_init (&return_value, G_TYPE_INT); + + g_closure_invoke (closure, + &return_value, + 0, NULL, + NULL); + + g_assert(g_value_get_int (&return_value) == 42); + + g_value_unset(&return_value); +} + +gpointer +g_i_marshalling_tests_pointer_in_return (gpointer pointer) +{ + return pointer; +} + +GType +g_i_marshalling_tests_enum_get_type (void) +{ + static GType type = 0; + if (G_UNLIKELY(type == 0)) { + static const GEnumValue values[] = { + { G_I_MARSHALLING_TESTS_ENUM_VALUE1, "G_I_MARSHALLING_TESTS_ENUM_VALUE1", "value1" }, + { G_I_MARSHALLING_TESTS_ENUM_VALUE2, "G_I_MARSHALLING_TESTS_ENUM_VALUE2", "value2" }, + { G_I_MARSHALLING_TESTS_ENUM_VALUE3, "G_I_MARSHALLING_TESTS_ENUM_VALUE3", "value3" }, + { 0, NULL, NULL } + }; + type = g_enum_register_static (g_intern_static_string ("GIMarshallingTestsEnum"), values); + } + + return type; +} + +GIMarshallingTestsEnum +g_i_marshalling_tests_enum_return (void) +{ + return G_I_MARSHALLING_TESTS_ENUM_VALUE3; +} + +void +g_i_marshalling_tests_enum_in (GIMarshallingTestsEnum enum_) +{ + g_assert(enum_ == G_I_MARSHALLING_TESTS_ENUM_VALUE3); +} + +/** + * g_i_marshalling_tests_enum_out: + * @enum_: (out): + */ +void +g_i_marshalling_tests_enum_out (GIMarshallingTestsEnum *enum_) +{ + *enum_ = G_I_MARSHALLING_TESTS_ENUM_VALUE3; +} + +/** + * g_i_marshalling_tests_enum_inout: + * @enum_: (inout): + */ +void +g_i_marshalling_tests_enum_inout (GIMarshallingTestsEnum *enum_) +{ + g_assert(*enum_ == G_I_MARSHALLING_TESTS_ENUM_VALUE3); + *enum_ = G_I_MARSHALLING_TESTS_ENUM_VALUE1; +} + + +GType +g_i_marshalling_tests_flags_get_type (void) +{ + static GType type = 0; + if (G_UNLIKELY(type == 0)) { + static const GFlagsValue values[] = { + { G_I_MARSHALLING_TESTS_FLAGS_VALUE1, "G_I_MARSHALLING_TESTS_FLAGS_VALUE1", "value1" }, + { G_I_MARSHALLING_TESTS_FLAGS_VALUE2, "G_I_MARSHALLING_TESTS_FLAGS_VALUE2", "value2" }, + { G_I_MARSHALLING_TESTS_FLAGS_VALUE3, "G_I_MARSHALLING_TESTS_FLAGS_VALUE3", "value3" }, + { 0, NULL, NULL } + }; + type = g_flags_register_static (g_intern_static_string ("GIMarshallingTestsFlags"), values); + } + + return type; +} + +GIMarshallingTestsFlags +g_i_marshalling_tests_flags_return (void) +{ + return G_I_MARSHALLING_TESTS_FLAGS_VALUE2; +} + +void +g_i_marshalling_tests_flags_in (GIMarshallingTestsFlags flags_) +{ + g_assert(flags_ == G_I_MARSHALLING_TESTS_FLAGS_VALUE2); +} + +void +g_i_marshalling_tests_flags_in_zero (GIMarshallingTestsFlags flags) +{ + g_assert(flags == 0); +} + +/** + * g_i_marshalling_tests_flags_out: + * @flags_: (out): + */ +void +g_i_marshalling_tests_flags_out (GIMarshallingTestsFlags *flags_) +{ + *flags_ = G_I_MARSHALLING_TESTS_FLAGS_VALUE2; +} + +/** + * g_i_marshalling_tests_flags_inout: + * @flags_: (inout): + */ +void +g_i_marshalling_tests_flags_inout (GIMarshallingTestsFlags *flags_) +{ + g_assert(*flags_ == G_I_MARSHALLING_TESTS_FLAGS_VALUE2); + *flags_ = G_I_MARSHALLING_TESTS_FLAGS_VALUE1; +} + + +/** + * g_i_marshalling_tests__simple_struct_return: + * Returns: (transfer none): + */ +GIMarshallingTestsSimpleStruct * +g_i_marshalling_tests__simple_struct_return (void) +{ + static GIMarshallingTestsSimpleStruct *struct_ = NULL; + + if (struct_ == NULL) { + struct_ = g_new(GIMarshallingTestsSimpleStruct, 1); + + struct_->long_ = 6; + struct_->int8 = 7; + } + + return struct_; +} + +/** + * g_i_marshalling_tests__simple_struct_in: + * @struct_: (transfer none): + */ +void +g_i_marshalling_tests__simple_struct_in (GIMarshallingTestsSimpleStruct *struct_) +{ + g_assert(struct_->long_ == 6); + g_assert(struct_->int8 == 7); +} + +/** + * g_i_marshalling_tests__simple_struct_out: + * @struct_: (out) (transfer none): + */ +void +g_i_marshalling_tests__simple_struct_out (GIMarshallingTestsSimpleStruct **struct_) +{ + static GIMarshallingTestsSimpleStruct *new_struct = NULL; + + if (new_struct == NULL) { + new_struct = g_new(GIMarshallingTestsSimpleStruct, 1); + + new_struct->long_ = 6; + new_struct->int8 = 7; + } + + *struct_ = new_struct; +} + +/** + * g_i_marshalling_tests__simple_struct_inout: + * @struct_: (inout) (transfer none): + */ +void +g_i_marshalling_tests__simple_struct_inout (GIMarshallingTestsSimpleStruct **struct_) +{ + g_assert((*struct_)->long_ == 6); + g_assert((*struct_)->int8 == 7); + + (*struct_)->long_ = 7; + (*struct_)->int8 = 6; +} + +void +g_i_marshalling_tests_simple_struct_method (GIMarshallingTestsSimpleStruct *struct_) +{ + g_assert(struct_->long_ == 6); + g_assert(struct_->int8 == 7); +} + + +GType +g_i_marshalling_tests_pointer_struct_get_type (void) +{ + static GType type = 0; + + if (type == 0) { + type = g_pointer_type_register_static ("GIMarshallingTestsPointerStruct"); + } + + return type; +} + +/** + * g_i_marshalling_tests__pointer_struct_return: + * Returns: (transfer none): + */ +GIMarshallingTestsPointerStruct * +g_i_marshalling_tests__pointer_struct_return (void) +{ + static GIMarshallingTestsPointerStruct *struct_ = NULL; + + if (struct_ == NULL) { + struct_ = g_new(GIMarshallingTestsPointerStruct, 1); + + struct_->long_ = 42; + } + + return struct_; +} + +/** + * g_i_marshalling_tests__pointer_struct_in: + * @struct_: (transfer none): + */ +void +g_i_marshalling_tests__pointer_struct_in (GIMarshallingTestsPointerStruct *struct_) +{ + g_assert(struct_->long_ == 42); +} + +/** + * g_i_marshalling_tests__pointer_struct_out: + * @struct_: (out) (transfer none): + */ +void +g_i_marshalling_tests__pointer_struct_out (GIMarshallingTestsPointerStruct **struct_) +{ + static GIMarshallingTestsPointerStruct *new_struct = NULL; + + if (new_struct == NULL) { + new_struct = g_new(GIMarshallingTestsPointerStruct, 1); + + new_struct->long_ = 42; + } + + *struct_ = new_struct; +} + +/** + * g_i_marshalling_tests__pointer_struct_inout: + * @struct_: (inout) (transfer none): + */ +void +g_i_marshalling_tests__pointer_struct_inout (GIMarshallingTestsPointerStruct **struct_) +{ + g_assert((*struct_)->long_ == 42); + + (*struct_)->long_ = 0; +} + + +static GIMarshallingTestsBoxedStruct * +g_i_marshalling_tests_boxed_struct_copy (GIMarshallingTestsBoxedStruct *struct_) +{ + GIMarshallingTestsBoxedStruct *new_struct; + + new_struct = g_slice_new (GIMarshallingTestsBoxedStruct); + + *new_struct = *struct_; + + return new_struct; +} + +static void +g_i_marshalling_tests_boxed_struct_free (GIMarshallingTestsBoxedStruct *struct_) +{ + g_slice_free (GIMarshallingTestsBoxedStruct, struct_); +} + +GType +g_i_marshalling_tests_boxed_struct_get_type (void) +{ + static GType type = 0; + + if (type == 0) { + type = g_boxed_type_register_static ("GIMarshallingTestsBoxedStruct", + (GBoxedCopyFunc) g_i_marshalling_tests_boxed_struct_copy, + (GBoxedFreeFunc) g_i_marshalling_tests_boxed_struct_free); + } + + return type; +} + +GIMarshallingTestsBoxedStruct * +g_i_marshalling_tests_boxed_struct_new (void) +{ + return g_slice_new (GIMarshallingTestsBoxedStruct); +} + +/** + * g_i_marshalling_tests__boxed_struct_return: + * Returns: (transfer none): + */ +GIMarshallingTestsBoxedStruct * +g_i_marshalling_tests__boxed_struct_return (void) +{ + static GIMarshallingTestsBoxedStruct *struct_ = NULL; + + if (struct_ == NULL) { + struct_ = g_new(GIMarshallingTestsBoxedStruct, 1); + + struct_->long_ = 42; + } + + return struct_; +} + +/** + * g_i_marshalling_tests__boxed_struct_in: + * @struct_: (transfer none): + */ +void +g_i_marshalling_tests__boxed_struct_in (GIMarshallingTestsBoxedStruct *struct_) +{ + g_assert(struct_->long_ == 42); +} + +/** + * g_i_marshalling_tests__boxed_struct_out: + * @struct_: (out) (transfer none): + */ +void +g_i_marshalling_tests__boxed_struct_out (GIMarshallingTestsBoxedStruct **struct_) +{ + static GIMarshallingTestsBoxedStruct *new_struct = NULL; + + if (new_struct == NULL) { + new_struct = g_new(GIMarshallingTestsBoxedStruct, 1); + + new_struct->long_ = 42; + } + + *struct_ = new_struct; +} + +/** + * g_i_marshalling_tests__boxed_struct_inout: + * @struct_: (inout) (transfer none): + */ +void +g_i_marshalling_tests__boxed_struct_inout (GIMarshallingTestsBoxedStruct **struct_) +{ + g_assert((*struct_)->long_ == 42); + + (*struct_)->long_ = 0; +} + + +enum +{ + PROP_0, + PROP_INT_ +}; + +G_DEFINE_TYPE (GIMarshallingTestsObject, g_i_marshalling_tests_object, G_TYPE_OBJECT); + +static void +g_i_marshalling_tests_object_init (GIMarshallingTestsObject *object) +{ +} + +static void +g_i_marshalling_tests_object_finalize (GObject *object) +{ + G_OBJECT_CLASS (g_i_marshalling_tests_object_parent_class)->finalize (object); +} + +static void +g_i_marshalling_tests_object_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec) +{ + g_return_if_fail (G_I_MARSHALLING_TESTS_IS_OBJECT (object)); + + switch (prop_id) { + case PROP_INT_: + G_I_MARSHALLING_TESTS_OBJECT (object)->int_ = g_value_get_int (value); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +static void +g_i_marshalling_tests_object_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec) +{ + g_return_if_fail (G_I_MARSHALLING_TESTS_IS_OBJECT (object)); + + switch (prop_id) { + case PROP_INT_: + g_value_set_int (value, G_I_MARSHALLING_TESTS_OBJECT (object)->int_); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +static void +g_i_marshalling_tests_object_class_init (GIMarshallingTestsObjectClass *klass) +{ + GObjectClass* object_class = G_OBJECT_CLASS (klass); +#if 0 + GObjectClass* parent_class = G_OBJECT_CLASS (klass); +#endif + + object_class->finalize = g_i_marshalling_tests_object_finalize; + object_class->set_property = g_i_marshalling_tests_object_set_property; + object_class->get_property = g_i_marshalling_tests_object_get_property; + + g_object_class_install_property (object_class, PROP_INT_, + g_param_spec_int ("int", "Integer", "An integer", G_MININT, G_MAXINT, 0, + G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT)); +} + + +void +g_i_marshalling_tests_object_static_method (void) +{ +} + +void +g_i_marshalling_tests_object_method (GIMarshallingTestsObject *object) +{ + g_return_if_fail (G_I_MARSHALLING_TESTS_IS_OBJECT (object)); + g_assert (object->int_ == 42); +} + +void +g_i_marshalling_tests_object_overridden_method (GIMarshallingTestsObject *object) +{ + g_return_if_fail (G_I_MARSHALLING_TESTS_IS_OBJECT (object)); + g_assert (object->int_ == 0); +} + +GIMarshallingTestsObject * +g_i_marshalling_tests_object_new (gint int_) +{ + return g_object_new (G_I_MARSHALLING_TESTS_TYPE_OBJECT, "int", int_, NULL); +} + +/** + * g_i_marshalling_tests_object_method_array_in: + * @ints: (array length=length): + */ +void +g_i_marshalling_tests_object_method_array_in (GIMarshallingTestsObject *object, const gint *ints, gint length) +{ + g_assert(length == 4); + g_assert(ints[0] == -1); + g_assert(ints[1] == 0); + g_assert(ints[2] == 1); + g_assert(ints[3] == 2); +} + +/** + * g_i_marshalling_tests_object_method_array_out: + * @ints: (out) (array length=length) (transfer none): + */ +void +g_i_marshalling_tests_object_method_array_out (GIMarshallingTestsObject *object, gint **ints, gint *length) +{ + static gint values[] = {-1, 0, 1, 2}; + + *length = 4; + *ints = values; +} + +/** + * g_i_marshalling_tests_object_method_array_inout: + * @ints: (inout) (array length=length) (transfer none): + * @length: (inout): + */ +void +g_i_marshalling_tests_object_method_array_inout (GIMarshallingTestsObject *object, gint **ints, gint *length) +{ + static gint values[] = {-2, -1, 0, 1, 2}; + + g_assert(*length == 4); + g_assert((*ints)[0] == -1); + g_assert((*ints)[1] == 0); + g_assert((*ints)[2] == 1); + g_assert((*ints)[3] == 2); + + *length = 5; + *ints = values; +} + +/** + * g_i_marshalling_tests_object_method_array_return: + * Returns: (array length=length): + */ +const gint * +g_i_marshalling_tests_object_method_array_return (GIMarshallingTestsObject *object, gint *length) +{ + static gint ints[] = {-1, 0, 1, 2}; + + *length = 4; + return ints; +} + + +/** + * g_i_marshalling_tests__object_none_return: + * Returns: (transfer none): + */ +GIMarshallingTestsObject * +g_i_marshalling_tests__object_none_return (void) +{ + static GIMarshallingTestsObject *object = NULL; + + if (object == NULL) { + object = g_object_new(G_I_MARSHALLING_TESTS_TYPE_OBJECT, NULL); + } + + return object; +} + +/** + * g_i_marshalling_tests__object_full_return: + * Returns: (transfer full): + */ +GIMarshallingTestsObject * +g_i_marshalling_tests__object_full_return (void) +{ + return g_object_new(G_I_MARSHALLING_TESTS_TYPE_OBJECT, NULL); +} + +/** + * g_i_marshalling_tests__object_none_in: + * @object: (transfer none): + */ +void +g_i_marshalling_tests__object_none_in (GIMarshallingTestsObject *object) +{ + g_assert(object->int_ == 42); +} + +/** + * g_i_marshalling_tests__object_full_in: + * @object: (transfer full): + */ +void +g_i_marshalling_tests__object_full_in (GIMarshallingTestsObject *object) +{ + g_assert(object->int_ == 42); + g_object_unref(object); +} + +/** + * g_i_marshalling_tests__object_none_out: + * @object: (out) (transfer none): + */ +void +g_i_marshalling_tests__object_none_out (GIMarshallingTestsObject **object) +{ + static GIMarshallingTestsObject *new_object = NULL; + + if (new_object == NULL) { + new_object = g_object_new(G_I_MARSHALLING_TESTS_TYPE_OBJECT, NULL); + } + + *object = new_object; +} + +/** + * g_i_marshalling_tests__object_full_out: + * @object: (out) (transfer full): + */ +void +g_i_marshalling_tests__object_full_out (GIMarshallingTestsObject **object) +{ + *object = g_object_new(G_I_MARSHALLING_TESTS_TYPE_OBJECT, NULL); +} + +/** + * g_i_marshalling_tests__object_none_inout: + * @object: (inout) (transfer none): + */ +void +g_i_marshalling_tests__object_none_inout (GIMarshallingTestsObject **object) +{ + static GIMarshallingTestsObject *new_object = NULL; + + g_assert((*object)->int_ == 42); + + if (new_object == NULL) { + new_object = g_object_new(G_I_MARSHALLING_TESTS_TYPE_OBJECT, NULL); + new_object->int_ = 0; + } + + *object = new_object; +} + +/** + * g_i_marshalling_tests__object_full_inout: + * @object: (inout) (transfer full): + */ +void +g_i_marshalling_tests__object_full_inout (GIMarshallingTestsObject **object) +{ + g_assert((*object)->int_ == 42); + g_object_unref(*object); + + *object = g_object_new(G_I_MARSHALLING_TESTS_TYPE_OBJECT, NULL); +} + +/** + * g_i_marshalling_tests__object_inout_same: + * @object: (inout): + */ +void +g_i_marshalling_tests__object_inout_same (GIMarshallingTestsObject **object) +{ + g_assert((*object)->int_ == 42); + (*object)->int_ = 0; +} + + +G_DEFINE_TYPE (GIMarshallingTestsSubObject, g_i_marshalling_tests_sub_object, G_I_MARSHALLING_TESTS_TYPE_OBJECT); + +static void +g_i_marshalling_tests_sub_object_init (GIMarshallingTestsSubObject *object) +{ +} + +static void +g_i_marshalling_tests_sub_object_finalize (GObject *object) +{ + G_OBJECT_CLASS(g_i_marshalling_tests_sub_object_parent_class)->finalize(object); +} + +static void +g_i_marshalling_tests_sub_object_class_init (GIMarshallingTestsSubObjectClass *klass) +{ + G_OBJECT_CLASS(klass)->finalize = g_i_marshalling_tests_sub_object_finalize; +} + +void +g_i_marshalling_tests_sub_object_sub_method (GIMarshallingTestsSubObject *object) +{ + g_assert(G_I_MARSHALLING_TESTS_OBJECT(object)->int_ == 0); +} + +void +g_i_marshalling_tests_sub_object_overwritten_method (GIMarshallingTestsSubObject *object) +{ + g_assert(G_I_MARSHALLING_TESTS_OBJECT(object)->int_ == 0); +} + +/* Interfaces */ + +static void +g_i_marshalling_tests_interface_class_init(void *g_iface) +{ +} + +GType +g_i_marshalling_tests_interface_get_type(void) +{ + static GType type = 0; + if (type == 0) { + type = g_type_register_static_simple (G_TYPE_INTERFACE, + "GIMarshallingTestsInterface", + sizeof (GIMarshallingTestsInterfaceIface), + (GClassInitFunc) g_i_marshalling_tests_interface_class_init, + 0, NULL, 0); + } + + return type; +} + + +/** + * g_i_marshalling_tests_int_out_out: + * int0: (out): + * int1: (out): + */ +void +g_i_marshalling_tests_int_out_out (gint *int0, gint *int1) +{ + *int0 = 6; + *int1 = 7; +} + +/** + * g_i_marshalling_tests_int_return_out: + * int_: (out): + */ +gint +g_i_marshalling_tests_int_return_out (gint *int_) +{ + *int_ = 7; + return 6; +} + + +static GIMarshallingTestsOverridesStruct * +g_i_marshalling_tests_overrides_struct_copy (GIMarshallingTestsOverridesStruct *struct_) +{ + GIMarshallingTestsOverridesStruct *new_struct; + + new_struct = g_slice_new (GIMarshallingTestsOverridesStruct); + + *new_struct = *struct_; + + return new_struct; +} + +static void +g_i_marshalling_tests_overrides_struct_free (GIMarshallingTestsOverridesStruct *struct_) +{ + g_slice_free (GIMarshallingTestsOverridesStruct, struct_); +} + +GType +g_i_marshalling_tests_overrides_struct_get_type (void) +{ + static GType type = 0; + + if (type == 0) { + type = g_boxed_type_register_static ("GIMarshallingTestsOverridesStruct", + (GBoxedCopyFunc) g_i_marshalling_tests_overrides_struct_copy, + (GBoxedFreeFunc) g_i_marshalling_tests_overrides_struct_free); + } + + return type; +} + +GIMarshallingTestsOverridesStruct * +g_i_marshalling_tests_overrides_struct_new (void) +{ + return g_slice_new (GIMarshallingTestsOverridesStruct); +} + +glong +g_i_marshalling_tests_overrides_struct_method (GIMarshallingTestsOverridesStruct *struct_) +{ + return 42; +} + + +/** + * g_i_marshalling_tests__overrides_struct_return: + * + * Returns: (transfer full): + */ +GIMarshallingTestsOverridesStruct * +g_i_marshalling_tests__overrides_struct_return (void) +{ + return g_i_marshalling_tests_overrides_struct_new(); +} + + +G_DEFINE_TYPE (GIMarshallingTestsOverridesObject, g_i_marshalling_tests_overrides_object, G_TYPE_OBJECT); + +static void +g_i_marshalling_tests_overrides_object_init (GIMarshallingTestsOverridesObject *object) +{ +} + +static void +g_i_marshalling_tests_overrides_object_finalize (GObject *object) +{ + G_OBJECT_CLASS (g_i_marshalling_tests_overrides_object_parent_class)->finalize (object); +} + +static void +g_i_marshalling_tests_overrides_object_class_init (GIMarshallingTestsOverridesObjectClass *klass) +{ + GObjectClass* object_class = G_OBJECT_CLASS (klass); +#if 0 + GObjectClass* parent_class = G_OBJECT_CLASS (klass); +#endif + + object_class->finalize = g_i_marshalling_tests_overrides_object_finalize; +} + +GIMarshallingTestsOverridesObject * +g_i_marshalling_tests_overrides_object_new (void) +{ + return g_object_new (G_I_MARSHALLING_TESTS_TYPE_OVERRIDES_OBJECT, NULL); +} + +glong +g_i_marshalling_tests_overrides_object_method (GIMarshallingTestsOverridesObject *object) +{ + return 42; +} + + +/** + * g_i_marshalling_tests__overrides_object_return: + * + * Returns: (transfer full): + */ +GIMarshallingTestsOverridesObject * +g_i_marshalling_tests__overrides_object_return (void) +{ + return g_object_new (G_I_MARSHALLING_TESTS_TYPE_OVERRIDES_OBJECT, NULL); +} diff --git a/gir/gimarshallingtests.h b/gir/gimarshallingtests.h new file mode 100644 index 00000000..87f9f92f --- /dev/null +++ b/gir/gimarshallingtests.h @@ -0,0 +1,631 @@ +/* -*- Mode: C; c-basic-offset: 4 -*- + * vim: tabstop=4 shiftwidth=4 expandtab + */ + +#include <glib-object.h> + +#ifndef __G_I_MARSHALLING_TESTS_H__ +#define __G_I_MARSHALLING_TESTS_H__ + +typedef struct _GIMarshallingTestsSimpleStruct GIMarshallingTestsSimpleStruct; + +/* Constants */ + +#define G_I_MARSHALLING_TESTS_CONSTANT_NUMBER 42 +#define G_I_MARSHALLING_TESTS_CONSTANT_UTF8 "const \xe2\x99\xa5 utf8" + + +/* Booleans */ + +gboolean g_i_marshalling_tests_boolean_return_true (void); +gboolean g_i_marshalling_tests_boolean_return_false (void); + +void g_i_marshalling_tests_boolean_in_true (gboolean bool_); +void g_i_marshalling_tests_boolean_in_false (gboolean bool_); + +void g_i_marshalling_tests_boolean_out_true (gboolean *bool_); +void g_i_marshalling_tests_boolean_out_false (gboolean *bool_); + +void g_i_marshalling_tests_boolean_inout_true_false (gboolean *bool_); +void g_i_marshalling_tests_boolean_inout_false_true (gboolean *bool_); + + +/* Integers */ + +gint8 g_i_marshalling_tests_int8_return_max (void); +gint8 g_i_marshalling_tests_int8_return_min (void); + +void g_i_marshalling_tests_int8_in_max (gint8 int8); +void g_i_marshalling_tests_int8_in_min (gint8 int8); + +void g_i_marshalling_tests_int8_out_max (gint8 *int8); +void g_i_marshalling_tests_int8_out_min (gint8 *int8); + +void g_i_marshalling_tests_int8_inout_max_min (gint8 *int8); +void g_i_marshalling_tests_int8_inout_min_max (gint8 *int8); + + +guint8 g_i_marshalling_tests_uint8_return (void); + +void g_i_marshalling_tests_uint8_in (guint8 uint8); + +void g_i_marshalling_tests_uint8_out (guint8 *uint8); +void g_i_marshalling_tests_uint8_inout (guint8 *uint8); + + +gint16 g_i_marshalling_tests_int16_return_max (void); +gint16 g_i_marshalling_tests_int16_return_min (void); + +void g_i_marshalling_tests_int16_in_max (gint16 int16); +void g_i_marshalling_tests_int16_in_min (gint16 int16); + +void g_i_marshalling_tests_int16_out_max (gint16 *int16); +void g_i_marshalling_tests_int16_out_min (gint16 *int16); + +void g_i_marshalling_tests_int16_inout_max_min (gint16 *int16); +void g_i_marshalling_tests_int16_inout_min_max (gint16 *int16); + + +guint16 g_i_marshalling_tests_uint16_return (void); + +void g_i_marshalling_tests_uint16_in (guint16 uint16); + +void g_i_marshalling_tests_uint16_out (guint16 *uint16); +void g_i_marshalling_tests_uint16_inout (guint16 *uint16); + + +gint32 g_i_marshalling_tests_int32_return_max (void); +gint32 g_i_marshalling_tests_int32_return_min (void); + +void g_i_marshalling_tests_int32_in_max (gint32 int32); +void g_i_marshalling_tests_int32_in_min (gint32 int32); + +void g_i_marshalling_tests_int32_out_max (gint32 *int32); +void g_i_marshalling_tests_int32_out_min (gint32 *int32); + +void g_i_marshalling_tests_int32_inout_max_min (gint32 *int32); +void g_i_marshalling_tests_int32_inout_min_max (gint32 *int32); + + +guint32 g_i_marshalling_tests_uint32_return (void); + +void g_i_marshalling_tests_uint32_in (guint32 uint32); + +void g_i_marshalling_tests_uint32_out (guint32 *uint32); +void g_i_marshalling_tests_uint32_inout (guint32 *uint32); + + +gint64 g_i_marshalling_tests_int64_return_max (void); +gint64 g_i_marshalling_tests_int64_return_min (void); + +void g_i_marshalling_tests_int64_in_max (gint64 int64); +void g_i_marshalling_tests_int64_in_min (gint64 int64); + +void g_i_marshalling_tests_int64_out_max (gint64 *int64); +void g_i_marshalling_tests_int64_out_min (gint64 *int64); + +void g_i_marshalling_tests_int64_inout_max_min (gint64 *int64); +void g_i_marshalling_tests_int64_inout_min_max (gint64 *int64); + + +guint64 g_i_marshalling_tests_uint64_return (void); + +void g_i_marshalling_tests_uint64_in (guint64 uint64); + +void g_i_marshalling_tests_uint64_out (guint64 *uint64); +void g_i_marshalling_tests_uint64_inout (guint64 *uint64); + + +gshort g_i_marshalling_tests_short_return_max (void); +gshort g_i_marshalling_tests_short_return_min (void); + +void g_i_marshalling_tests_short_in_max (gshort short_); +void g_i_marshalling_tests_short_in_min (gshort short_); + +void g_i_marshalling_tests_short_out_max (gshort *short_); +void g_i_marshalling_tests_short_out_min (gshort *short_); + +void g_i_marshalling_tests_short_inout_max_min (gshort *short_); +void g_i_marshalling_tests_short_inout_min_max (gshort *short_); + + +gushort g_i_marshalling_tests_ushort_return (void); + +void g_i_marshalling_tests_ushort_in (gushort ushort); + +void g_i_marshalling_tests_ushort_out (gushort *ushort); +void g_i_marshalling_tests_ushort_inout (gushort *ushort); + + +gint g_i_marshalling_tests_int_return_max (void); +gint g_i_marshalling_tests_int_return_min (void); + +void g_i_marshalling_tests_int_in_max (gint int_); +void g_i_marshalling_tests_int_in_min (gint int_); + +void g_i_marshalling_tests_int_out_max (gint *int_); +void g_i_marshalling_tests_int_out_min (gint *int_); + +void g_i_marshalling_tests_int_inout_max_min (gint *int_); +void g_i_marshalling_tests_int_inout_min_max (gint *int_); + + +guint g_i_marshalling_tests_uint_return (void); + +void g_i_marshalling_tests_uint_in (guint uint); + +void g_i_marshalling_tests_uint_out (guint *uint); +void g_i_marshalling_tests_uint_inout (guint *uint); + + +glong g_i_marshalling_tests_long_return_max (void); +glong g_i_marshalling_tests_long_return_min (void); + +void g_i_marshalling_tests_long_in_max (glong long_); +void g_i_marshalling_tests_long_in_min (glong long_); + +void g_i_marshalling_tests_long_out_max (glong *long_); +void g_i_marshalling_tests_long_out_min (glong *long_); + +void g_i_marshalling_tests_long_inout_max_min (glong *long_); +void g_i_marshalling_tests_long_inout_min_max (glong *long_); + + +gulong g_i_marshalling_tests_ulong_return (void); + +void g_i_marshalling_tests_ulong_in (gulong ulong); + +void g_i_marshalling_tests_ulong_out (gulong *ulong); +void g_i_marshalling_tests_ulong_inout (gulong *ulong); + + +gssize g_i_marshalling_tests_ssize_return_max (void); +gssize g_i_marshalling_tests_ssize_return_min (void); + +void g_i_marshalling_tests_ssize_in_max (gssize ssize); +void g_i_marshalling_tests_ssize_in_min (gssize ssize); + +void g_i_marshalling_tests_ssize_out_max (gssize *ssize); +void g_i_marshalling_tests_ssize_out_min (gssize *ssize); + +void g_i_marshalling_tests_ssize_inout_max_min (gssize *ssize); +void g_i_marshalling_tests_ssize_inout_min_max (gssize *ssize); + + +gsize g_i_marshalling_tests_size_return (void); + +void g_i_marshalling_tests_size_in (gsize size); + +void g_i_marshalling_tests_size_out (gsize *size); +void g_i_marshalling_tests_size_inout (gsize *size); + + +/* Floating-point */ + +gfloat g_i_marshalling_tests_float_return (void); + +void g_i_marshalling_tests_float_in (gfloat float_); + +void g_i_marshalling_tests_float_out (gfloat *float_); + +void g_i_marshalling_tests_float_inout (gfloat *float_); + + +gdouble g_i_marshalling_tests_double_return (void); + +void g_i_marshalling_tests_double_in (gdouble double_); + +void g_i_marshalling_tests_double_out (gdouble *double_); + +void g_i_marshalling_tests_double_inout (gdouble *double_); + + +/* Timestamps */ + +time_t g_i_marshalling_tests_time_t_return (void); + +void g_i_marshalling_tests_time_t_in (time_t time_t_); + +void g_i_marshalling_tests_time_t_out (time_t *time_t_); + +void g_i_marshalling_tests_time_t_inout (time_t *time_t_); + + +/* GType */ + +GType g_i_marshalling_tests_gtype_return (void); + +void g_i_marshalling_tests_gtype_in (GType gtype); + +void g_i_marshalling_tests_gtype_out (GType *gtype); + +void g_i_marshalling_tests_gtype_inout (GType *gtype); + + +/* UTF-8 */ + +const gchar *g_i_marshalling_tests_utf8_none_return (void); +gchar *g_i_marshalling_tests_utf8_full_return (void); + +void g_i_marshalling_tests_utf8_none_in (const gchar *utf8); +void g_i_marshalling_tests_utf8_full_in (gchar *utf8); + +void g_i_marshalling_tests_utf8_none_out (gchar **utf8); +void g_i_marshalling_tests_utf8_full_out (gchar **utf8); + +void g_i_marshalling_tests_utf8_none_inout (gchar **utf8); +void g_i_marshalling_tests_utf8_full_inout (gchar **utf8); + +GSList *g_i_marshalling_tests_filename_list_return (void); + +/* Arrays */ + +/* Fixed-size */ +const gint *g_i_marshalling_tests_array_fixed_int_return (void); +const gshort *g_i_marshalling_tests_array_fixed_short_return (void); + +void g_i_marshalling_tests_array_fixed_int_in (const gint *ints); +void g_i_marshalling_tests_array_fixed_short_in (const gshort *shorts); + +void g_i_marshalling_tests_array_fixed_out (gint **ints); + +void g_i_marshalling_tests_array_fixed_out_struct (GIMarshallingTestsSimpleStruct **structs); + +void g_i_marshalling_tests_array_fixed_inout (gint **ints); + +/* Variable-size */ + +const gint *g_i_marshalling_tests_array_return (gint *length); + +void g_i_marshalling_tests_array_in (const gint *ints, gint length); + +void g_i_marshalling_tests_array_out (gint **ints, gint *length); + +void g_i_marshalling_tests_array_inout (gint **ints, gint *length); + +/* Zero-terminated */ + +gchar **g_i_marshalling_tests_array_zero_terminated_return (void); + +void g_i_marshalling_tests_array_zero_terminated_in (gchar **utf8s); + +void g_i_marshalling_tests_array_zero_terminated_out (gchar ***utf8s); + +void g_i_marshalling_tests_array_zero_terminated_inout (gchar ***utf8s); + + +/* GList */ + +GList *g_i_marshalling_tests_glist_int_none_return (void); +GList *g_i_marshalling_tests_glist_utf8_none_return (void); +GList *g_i_marshalling_tests_glist_utf8_container_return (void); +GList *g_i_marshalling_tests_glist_utf8_full_return (void); + +void g_i_marshalling_tests_glist_int_none_in (GList *list); +void g_i_marshalling_tests_glist_utf8_none_in (GList *list); +void g_i_marshalling_tests_glist_utf8_container_in (GList *list); +void g_i_marshalling_tests_glist_utf8_full_in (GList *list); + +void g_i_marshalling_tests_glist_utf8_none_out (GList **list); +void g_i_marshalling_tests_glist_utf8_container_out (GList **list); +void g_i_marshalling_tests_glist_utf8_full_out (GList **list); + +void g_i_marshalling_tests_glist_utf8_none_inout (GList **list); +void g_i_marshalling_tests_glist_utf8_container_inout (GList **list); +void g_i_marshalling_tests_glist_utf8_full_inout (GList **list); + + +/* GSList */ + +GSList *g_i_marshalling_tests_gslist_int_none_return (void); +GSList *g_i_marshalling_tests_gslist_utf8_none_return (void); +GSList *g_i_marshalling_tests_gslist_utf8_container_return (void); +GSList *g_i_marshalling_tests_gslist_utf8_full_return (void); + +void g_i_marshalling_tests_gslist_int_none_in (GSList *list); +void g_i_marshalling_tests_gslist_utf8_none_in (GSList *list); +void g_i_marshalling_tests_gslist_utf8_container_in (GSList *list); +void g_i_marshalling_tests_gslist_utf8_full_in (GSList *list); + +void g_i_marshalling_tests_gslist_utf8_none_out (GSList **list); +void g_i_marshalling_tests_gslist_utf8_container_out (GSList **list); +void g_i_marshalling_tests_gslist_utf8_full_out (GSList **list); + +void g_i_marshalling_tests_gslist_utf8_none_inout (GSList **list); +void g_i_marshalling_tests_gslist_utf8_container_inout (GSList **list); +void g_i_marshalling_tests_gslist_utf8_full_inout (GSList **list); + + +/* GHashTable */ + +GHashTable *g_i_marshalling_tests_ghashtable_int_none_return (void); +GHashTable *g_i_marshalling_tests_ghashtable_utf8_none_return (void); +GHashTable *g_i_marshalling_tests_ghashtable_utf8_container_return (void); +GHashTable *g_i_marshalling_tests_ghashtable_utf8_full_return (void); + +void g_i_marshalling_tests_ghashtable_int_none_in (GHashTable *hash_table); +void g_i_marshalling_tests_ghashtable_utf8_none_in (GHashTable *hash_table); +void g_i_marshalling_tests_ghashtable_utf8_container_in (GHashTable *hash_table); +void g_i_marshalling_tests_ghashtable_utf8_full_in (GHashTable *hash_table); + +void g_i_marshalling_tests_ghashtable_utf8_none_out (GHashTable **hash_table); +void g_i_marshalling_tests_ghashtable_utf8_container_out (GHashTable **hash_table); +void g_i_marshalling_tests_ghashtable_utf8_full_out (GHashTable **hash_table); + +void g_i_marshalling_tests_ghashtable_utf8_none_inout (GHashTable **hash_table); +void g_i_marshalling_tests_ghashtable_utf8_container_inout (GHashTable **hash_table); +void g_i_marshalling_tests_ghashtable_utf8_full_inout (GHashTable **hash_table); + + +/* GValue */ + +GValue *g_i_marshalling_tests_gvalue_return (void); + +void g_i_marshalling_tests_gvalue_in (GValue *value); + +void g_i_marshalling_tests_gvalue_out (GValue **value); + +void g_i_marshalling_tests_gvalue_inout (GValue **value); + + +/* GClosure */ + +void g_i_marshalling_tests_gclosure_in (GClosure *closure); + + +/* Pointer */ + +gpointer g_i_marshalling_tests_pointer_in_return (gpointer pointer); + + +/* GEnum */ + +typedef enum +{ + G_I_MARSHALLING_TESTS_ENUM_VALUE1, + G_I_MARSHALLING_TESTS_ENUM_VALUE2, + G_I_MARSHALLING_TESTS_ENUM_VALUE3 = 42 +} GIMarshallingTestsEnum; + +GType g_i_marshalling_tests_enum_get_type (void) G_GNUC_CONST; +#define G_I_MARSHALLING_TESTS_TYPE_ENUM (g_i_marshalling_tests_enum_get_type ()) + +GIMarshallingTestsEnum g_i_marshalling_tests_enum_return (void); + +void g_i_marshalling_tests_enum_in (GIMarshallingTestsEnum enum_); + +void g_i_marshalling_tests_enum_out (GIMarshallingTestsEnum *enum_); + +void g_i_marshalling_tests_enum_inout (GIMarshallingTestsEnum *enum_); + + +/* GFlags */ + +typedef enum +{ + G_I_MARSHALLING_TESTS_FLAGS_VALUE1 = 1 << 0, + G_I_MARSHALLING_TESTS_FLAGS_VALUE2 = 1 << 1, + G_I_MARSHALLING_TESTS_FLAGS_VALUE3 = 1 << 2 +} GIMarshallingTestsFlags; + +GType g_i_marshalling_tests_flags_get_type (void) G_GNUC_CONST; +#define G_I_MARSHALLING_TESTS_TYPE_FLAGS (g_i_marshalling_tests_flags_get_type ()) + +GIMarshallingTestsFlags g_i_marshalling_tests_flags_return (void); + +void g_i_marshalling_tests_flags_in (GIMarshallingTestsFlags flags_); +void g_i_marshalling_tests_flags_in_zero (GIMarshallingTestsFlags flags); + +void g_i_marshalling_tests_flags_out (GIMarshallingTestsFlags *flags_); + +void g_i_marshalling_tests_flags_inout (GIMarshallingTestsFlags *flags_); + + +/* Structure */ + +struct _GIMarshallingTestsSimpleStruct { + glong long_; + gint8 int8; +}; + +typedef struct { + GIMarshallingTestsSimpleStruct simple_struct; +} GIMarshallingTestsNestedStruct; + +typedef struct { + gpointer pointer; +} GIMarshallingTestsNotSimpleStruct; + + +GIMarshallingTestsSimpleStruct *g_i_marshalling_tests__simple_struct_return (void); + +void g_i_marshalling_tests__simple_struct_in (GIMarshallingTestsSimpleStruct *struct_); + +void g_i_marshalling_tests__simple_struct_out (GIMarshallingTestsSimpleStruct **struct_); + +void g_i_marshalling_tests__simple_struct_inout (GIMarshallingTestsSimpleStruct **struct_); + +void g_i_marshalling_tests_simple_struct_method (GIMarshallingTestsSimpleStruct *struct_); + + +typedef struct { + glong long_; +} GIMarshallingTestsPointerStruct; + +GType g_i_marshalling_tests_pointer_struct_get_type (void) G_GNUC_CONST; + +GIMarshallingTestsPointerStruct *g_i_marshalling_tests__pointer_struct_return (void); + +void g_i_marshalling_tests__pointer_struct_in (GIMarshallingTestsPointerStruct *struct_); + +void g_i_marshalling_tests__pointer_struct_out (GIMarshallingTestsPointerStruct **struct_); + +void g_i_marshalling_tests__pointer_struct_inout (GIMarshallingTestsPointerStruct **struct_); + + +typedef struct { + glong long_; +} GIMarshallingTestsBoxedStruct; + +GType g_i_marshalling_tests_boxed_struct_get_type (void) G_GNUC_CONST; + +GIMarshallingTestsBoxedStruct *g_i_marshalling_tests_boxed_struct_new (void); + +GIMarshallingTestsBoxedStruct *g_i_marshalling_tests__boxed_struct_return (void); + +void g_i_marshalling_tests__boxed_struct_in (GIMarshallingTestsBoxedStruct *struct_); + +void g_i_marshalling_tests__boxed_struct_out (GIMarshallingTestsBoxedStruct **struct_); + +void g_i_marshalling_tests__boxed_struct_inout (GIMarshallingTestsBoxedStruct **struct_); + + +/* Object */ + +#define G_I_MARSHALLING_TESTS_TYPE_OBJECT (g_i_marshalling_tests_object_get_type ()) +#define G_I_MARSHALLING_TESTS_OBJECT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), G_I_MARSHALLING_TESTS_TYPE_OBJECT, GIMarshallingTestsObject)) +#define G_I_MARSHALLING_TESTS_OBJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), G_I_MARSHALLING_TESTS_TYPE_OBJECT, GIMarshallingTestsObjectClass)) +#define G_I_MARSHALLING_TESTS_IS_OBJECT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), G_I_MARSHALLING_TESTS_TYPE_OBJECT)) +#define G_I_MARSHALLING_TESTS_IS_OBJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), G_I_MARSHALLING_TESTS_TYPE_OBJECT)) +#define G_I_MARSHALLING_TESTS_OBJECT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), G_I_MARSHALLING_TESTS_TYPE_OBJECT, GIMarshallingTestsObjectClass)) + +typedef struct _GIMarshallingTestsObjectClass GIMarshallingTestsObjectClass; +typedef struct _GIMarshallingTestsObject GIMarshallingTestsObject; + +struct _GIMarshallingTestsObjectClass +{ + GObjectClass parent_class; +}; + +struct _GIMarshallingTestsObject +{ + GObject parent_instance; + + gint int_; +}; + +GType g_i_marshalling_tests_object_get_type (void) G_GNUC_CONST; +void g_i_marshalling_tests_object_static_method (void); +void g_i_marshalling_tests_object_method (GIMarshallingTestsObject *object); +void g_i_marshalling_tests_object_overridden_method (GIMarshallingTestsObject *object); +GIMarshallingTestsObject *g_i_marshalling_tests_object_new (gint int_); + +void g_i_marshalling_tests_object_method_array_in (GIMarshallingTestsObject *object, const gint *ints, gint length); +void g_i_marshalling_tests_object_method_array_out (GIMarshallingTestsObject *object, gint **ints, gint *length); +void g_i_marshalling_tests_object_method_array_inout (GIMarshallingTestsObject *object, gint **ints, gint *length); +const gint *g_i_marshalling_tests_object_method_array_return (GIMarshallingTestsObject *object, gint *length); + +GIMarshallingTestsObject *g_i_marshalling_tests__object_none_return (void); +GIMarshallingTestsObject *g_i_marshalling_tests__object_full_return (void); + +void g_i_marshalling_tests__object_none_in (GIMarshallingTestsObject *object); +void g_i_marshalling_tests__object_full_in (GIMarshallingTestsObject *object); + +void g_i_marshalling_tests__object_none_out (GIMarshallingTestsObject **object); +void g_i_marshalling_tests__object_full_out (GIMarshallingTestsObject **object); + +void g_i_marshalling_tests__object_none_inout (GIMarshallingTestsObject **object); +void g_i_marshalling_tests__object_full_inout (GIMarshallingTestsObject **object); +void g_i_marshalling_tests__object_inout_same (GIMarshallingTestsObject **object); + + +#define G_I_MARSHALLING_TESTS_TYPE_SUB_OBJECT (g_i_marshalling_tests_sub_object_get_type ()) +#define G_I_MARSHALLING_TESTS_SUB_OBJECT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), G_I_MARSHALLING_TESTS_TYPE_SUB_OBJECT, GIMarshallingTestsSubObject)) +#define G_I_MARSHALLING_TESTS_SUB_OBJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), G_I_MARSHALLING_TESTS_TYPE_SUB_OBJECT, GIMarshallingTestsSubObjectClass)) +#define G_I_MARSHALLING_TESTS_IS_SUB_OBJECT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), G_I_MARSHALLING_TESTS_TYPE_SUB_OBJECT)) +#define G_I_MARSHALLING_TESTS_IS_SUB_OBJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), G_I_MARSHALLING_TESTS_TYPE_SUB_OBJECT)) +#define G_I_MARSHALLING_TESTS_SUB_OBJECT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), G_I_MARSHALLING_TESTS_TYPE_SUB_OBJECT, GIMarshallingTestsSubObjectClass)) + +typedef struct _GIMarshallingTestsSubObjectClass GIMarshallingTestsSubObjectClass; +typedef struct _GIMarshallingTestsSubObject GIMarshallingTestsSubObject; + +struct _GIMarshallingTestsSubObjectClass +{ + GIMarshallingTestsObjectClass parent_class; +}; + +struct _GIMarshallingTestsSubObject +{ + GIMarshallingTestsObject parent_instance; +}; + +GType g_i_marshalling_tests_sub_object_get_type (void) G_GNUC_CONST; + +void g_i_marshalling_tests_sub_object_sub_method (GIMarshallingTestsSubObject *object); +void g_i_marshalling_tests_sub_object_overwritten_method (GIMarshallingTestsSubObject *object); + +/* Interfaces */ + +#define G_I_MARSHALLING_TESTS_TYPE_INTERFACE (g_i_marshalling_tests_interface_get_type ()) +#define G_I_MARSHALLING_TESTS_INTERFACE(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), G_I_MARSHALLING_TESTS_TYPE_INTERFACE, GIMarshallingTestsInterface)) +#define G_I_MARSHALLING_TESTS_IS_INTERFACE(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), G_I_MARSHALLING_TESTS_TYPE_INTERFACE)) +#define G_I_MARSHALLING_TESTS_INTERFACE_GET_IFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), G_I_MARSHALLING_TESTS_TYPE_INTERFACE, GIMarshallingTestsInterfaceIface)) + +typedef struct _GIMarshallingTestsInterface GIMarshallingTestsInterface; +typedef struct _GIMarshallingTestsInterfaceIface GIMarshallingTestsInterfaceIface; + +struct _GIMarshallingTestsInterfaceIface { + GTypeInterface base_iface; +}; + +GType g_i_marshalling_tests_interface_get_type (void) G_GNUC_CONST; + + +/* Multiple output arguments */ + +void g_i_marshalling_tests_int_out_out (gint *int0, gint *int1); +void g_i_marshalling_tests_int_out_in (gint *int0, gint int1); +gint g_i_marshalling_tests_int_return_out (gint *int_); +void g_i_marshalling_tests_utf8_full_out_out (gchar **utf80, gchar **utf82); + + +/* Overrides */ + +#define G_I_MARSHALLING_TESTS_OVERRIDES_CONSTANT 42 + + +typedef struct { + glong long_; +} GIMarshallingTestsOverridesStruct; + +GType g_i_marshalling_tests_overrides_struct_get_type (void) G_GNUC_CONST; + +GIMarshallingTestsOverridesStruct *g_i_marshalling_tests_overrides_struct_new (void); + +glong g_i_marshalling_tests_overrides_struct_method (GIMarshallingTestsOverridesStruct *struct_); + +GIMarshallingTestsOverridesStruct *g_i_marshalling_tests__overrides_struct_return (void); + + +#define G_I_MARSHALLING_TESTS_TYPE_OVERRIDES_OBJECT (g_i_marshalling_tests_overrides_object_get_type ()) +#define G_I_MARSHALLING_TESTS_OVERRIDES_OBJECT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), G_I_MARSHALLING_TESTS_TYPE_OVERRIDES_OBJECT, GIMarshallingTestsOverridesObject)) +#define G_I_MARSHALLING_TESTS_OVERRIDES_OBJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), G_I_MARSHALLING_TESTS_TYPE_OVERRIDES_OBJECT, GIMarshallingTestsOverridesObjectClass)) +#define G_I_MARSHALLING_TESTS_IS_OVERRIDES_OBJECT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), G_I_MARSHALLING_TESTS_TYPE_OVERRIDES_OBJECT)) +#define G_I_MARSHALLING_TESTS_IS_OVERRIDES_OBJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), G_I_MARSHALLING_TESTS_TYPE_OVERRIDES_OBJECT)) +#define G_I_MARSHALLING_TESTS_OVERRIDES_OBJECT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), G_I_MARSHALLING_TESTS_TYPE_OVERRIDES_OBJECT, GIMarshallingTestsOverridesObjectClass)) + +typedef struct _GIMarshallingTestsOverridesObjectClass GIMarshallingTestsOverridesObjectClass; +typedef struct _GIMarshallingTestsOverridesObject GIMarshallingTestsOverridesObject; + +struct _GIMarshallingTestsOverridesObjectClass +{ + GObjectClass parent_class; +}; + +struct _GIMarshallingTestsOverridesObject +{ + GObject parent_instance; + + glong long_; +}; + +GType g_i_marshalling_tests_overrides_object_get_type (void) G_GNUC_CONST; + +GIMarshallingTestsOverridesObject *g_i_marshalling_tests_overrides_object_new (void); + +glong g_i_marshalling_tests_overrides_object_method (GIMarshallingTestsOverridesObject *object); + + +GIMarshallingTestsOverridesObject *g_i_marshalling_tests__overrides_object_return (void); + +#endif /* __G_I_MARSHALLING_TESTS_H__ */ |