From c803a13a7a903d381c7822dc81cfbbb0b0d2469d Mon Sep 17 00:00:00 2001 From: Rico Tzschichholz Date: Fri, 5 Nov 2021 11:08:23 +0100 Subject: tests: Add more "declaration" tests for genie to increase coverage --- tests/genie/class-field.c-expected | 330 +++++++++++++++++++++++++++++++ tests/genie/class-field.gs | 10 + tests/genie/class-init.c-expected | 164 ++++++++++++++++ tests/genie/class-init.gs | 18 ++ tests/genie/class-signal.c-expected | 376 ++++++++++++++++++++++++++++++++++++ tests/genie/class-signal.gs | 11 ++ tests/genie/constant.c-expected | 31 +++ tests/genie/constant.gs | 4 + tests/genie/exception.c-expected | 55 ++++++ tests/genie/exception.gs | 7 + tests/genie/interface.c-expected | 208 ++++++++++++++++++++ tests/genie/interface.gs | 10 + 12 files changed, 1224 insertions(+) create mode 100644 tests/genie/class-field.c-expected create mode 100644 tests/genie/class-field.gs create mode 100644 tests/genie/class-init.c-expected create mode 100644 tests/genie/class-init.gs create mode 100644 tests/genie/class-signal.c-expected create mode 100644 tests/genie/class-signal.gs create mode 100644 tests/genie/constant.c-expected create mode 100644 tests/genie/constant.gs create mode 100644 tests/genie/exception.c-expected create mode 100644 tests/genie/exception.gs create mode 100644 tests/genie/interface.c-expected create mode 100644 tests/genie/interface.gs (limited to 'tests/genie') diff --git a/tests/genie/class-field.c-expected b/tests/genie/class-field.c-expected new file mode 100644 index 000000000..f591e31f4 --- /dev/null +++ b/tests/genie/class-field.c-expected @@ -0,0 +1,330 @@ +/* genie_class_field.c generated by valac, the Vala compiler + * generated from genie_class_field.gs, do not modify */ + +#include +#include +#include +#include +#include + +#if !defined(VALA_EXTERN) +#if defined(_MSC_VER) +#define VALA_EXTERN __declspec(dllexport) extern +#elif __GNUC__ >= 4 +#define VALA_EXTERN __attribute__((visibility("default"))) extern +#else +#define VALA_EXTERN extern +#endif +#endif + +#define TYPE_TEST (test_get_type ()) +#define TEST(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_TEST, Test)) +#define TEST_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_TEST, TestClass)) +#define IS_TEST(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_TEST)) +#define IS_TEST_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_TEST)) +#define TEST_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_TEST, TestClass)) + +typedef struct _Test Test; +typedef struct _TestClass TestClass; +typedef struct _TestPrivate TestPrivate; +#define _test_unref0(var) ((var == NULL) ? NULL : (var = (test_unref (var), NULL))) +#define _g_free0(var) (var = (g_free (var), NULL)) +typedef struct _ParamSpecTest ParamSpecTest; +#define _vala_assert(expr, msg) if G_LIKELY (expr) ; else g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, msg); +#define _vala_return_if_fail(expr, msg) if G_LIKELY (expr) ; else { g_return_if_fail_warning (G_LOG_DOMAIN, G_STRFUNC, msg); return; } +#define _vala_return_val_if_fail(expr, msg, val) if G_LIKELY (expr) ; else { g_return_if_fail_warning (G_LOG_DOMAIN, G_STRFUNC, msg); return val; } +#define _vala_warn_if_fail(expr, msg) if G_LIKELY (expr) ; else g_warn_message (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, msg); + +struct _Test { + GTypeInstance parent_instance; + volatile int ref_count; + TestPrivate * priv; + gchar* a; +}; + +struct _TestClass { + GTypeClass parent_class; + void (*finalize) (Test *self); + gchar* b; +}; + +struct _ParamSpecTest { + GParamSpec parent_instance; +}; + +VALA_EXTERN gchar* test_c; +static gpointer test_parent_class = NULL; +gchar* test_c = NULL; + +static void _vala_main (gchar** args, + gint args_length1); +VALA_EXTERN gpointer test_ref (gpointer instance); +VALA_EXTERN void test_unref (gpointer instance); +VALA_EXTERN GParamSpec* param_spec_test (const gchar* name, + const gchar* nick, + const gchar* blurb, + GType object_type, + GParamFlags flags); +VALA_EXTERN void value_set_test (GValue* value, + gpointer v_object); +VALA_EXTERN void value_take_test (GValue* value, + gpointer v_object); +VALA_EXTERN gpointer value_get_test (const GValue* value); +VALA_EXTERN GType test_get_type (void) G_GNUC_CONST ; +G_DEFINE_AUTOPTR_CLEANUP_FUNC (Test, test_unref) +VALA_EXTERN Test* test_new (void); +VALA_EXTERN Test* test_construct (GType object_type); +static void test_finalize (Test * obj); +static GType test_get_type_once (void); + +static void +_vala_main (gchar** args, + gint args_length1) +{ + Test* a = NULL; + Test* _tmp0_; + const gchar* _tmp1_; + const gchar* _tmp2_; + const gchar* _tmp3_; + _tmp0_ = test_new (); + a = _tmp0_; + _tmp1_ = a->a; + _vala_assert (g_strcmp0 (_tmp1_, "a") == 0, "a.a == \"a\""); + _tmp2_ = TEST_GET_CLASS (a)->b; + _vala_assert (g_strcmp0 (_tmp2_, "b") == 0, "a.b == \"b\""); + _tmp3_ = test_c; + _vala_assert (g_strcmp0 (_tmp3_, "c") == 0, "a.c == \"c\""); + _test_unref0 (a); +} + +int +main (int argc, + char ** argv) +{ + _vala_main (argv, argc); + return 0; +} + +Test* +test_construct (GType object_type) +{ + Test* self = NULL; + self = (Test*) g_type_create_instance (object_type); + return self; +} + +Test* +test_new (void) +{ + return test_construct (TYPE_TEST); +} + +static void +value_test_init (GValue* value) +{ + value->data[0].v_pointer = NULL; +} + +static void +value_test_free_value (GValue* value) +{ + if (value->data[0].v_pointer) { + test_unref (value->data[0].v_pointer); + } +} + +static void +value_test_copy_value (const GValue* src_value, + GValue* dest_value) +{ + if (src_value->data[0].v_pointer) { + dest_value->data[0].v_pointer = test_ref (src_value->data[0].v_pointer); + } else { + dest_value->data[0].v_pointer = NULL; + } +} + +static gpointer +value_test_peek_pointer (const GValue* value) +{ + return value->data[0].v_pointer; +} + +static gchar* +value_test_collect_value (GValue* value, + guint n_collect_values, + GTypeCValue* collect_values, + guint collect_flags) +{ + if (collect_values[0].v_pointer) { + Test * object; + object = collect_values[0].v_pointer; + if (object->parent_instance.g_class == NULL) { + return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL); + } else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) { + return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL); + } + value->data[0].v_pointer = test_ref (object); + } else { + value->data[0].v_pointer = NULL; + } + return NULL; +} + +static gchar* +value_test_lcopy_value (const GValue* value, + guint n_collect_values, + GTypeCValue* collect_values, + guint collect_flags) +{ + Test ** object_p; + object_p = collect_values[0].v_pointer; + if (!object_p) { + return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value)); + } + if (!value->data[0].v_pointer) { + *object_p = NULL; + } else if (collect_flags & G_VALUE_NOCOPY_CONTENTS) { + *object_p = value->data[0].v_pointer; + } else { + *object_p = test_ref (value->data[0].v_pointer); + } + return NULL; +} + +GParamSpec* +param_spec_test (const gchar* name, + const gchar* nick, + const gchar* blurb, + GType object_type, + GParamFlags flags) +{ + ParamSpecTest* spec; + g_return_val_if_fail (g_type_is_a (object_type, TYPE_TEST), NULL); + spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags); + G_PARAM_SPEC (spec)->value_type = object_type; + return G_PARAM_SPEC (spec); +} + +gpointer +value_get_test (const GValue* value) +{ + g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_TEST), NULL); + return value->data[0].v_pointer; +} + +void +value_set_test (GValue* value, + gpointer v_object) +{ + Test * old; + g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_TEST)); + old = value->data[0].v_pointer; + if (v_object) { + g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_TEST)); + g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value))); + value->data[0].v_pointer = v_object; + test_ref (value->data[0].v_pointer); + } else { + value->data[0].v_pointer = NULL; + } + if (old) { + test_unref (old); + } +} + +void +value_take_test (GValue* value, + gpointer v_object) +{ + Test * old; + g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_TEST)); + old = value->data[0].v_pointer; + if (v_object) { + g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_TEST)); + g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value))); + value->data[0].v_pointer = v_object; + } else { + value->data[0].v_pointer = NULL; + } + if (old) { + test_unref (old); + } +} + +static void +test_class_init (TestClass * klass, + gpointer klass_data) +{ + gchar* _tmp0_; + gchar* _tmp1_; + test_parent_class = g_type_class_peek_parent (klass); + ((TestClass *) klass)->finalize = test_finalize; + _tmp0_ = g_strdup ("b"); + klass->b = _tmp0_; + _tmp1_ = g_strdup ("c"); + test_c = _tmp1_; +} + +static void +test_instance_init (Test * self, + gpointer klass) +{ + gchar* _tmp0_; + _tmp0_ = g_strdup ("a"); + self->a = _tmp0_; + self->ref_count = 1; +} + +static void +test_finalize (Test * obj) +{ + Test * self; + self = G_TYPE_CHECK_INSTANCE_CAST (obj, TYPE_TEST, Test); + g_signal_handlers_destroy (self); + _g_free0 (self->a); +} + +static GType +test_get_type_once (void) +{ + static const GTypeValueTable g_define_type_value_table = { value_test_init, value_test_free_value, value_test_copy_value, value_test_peek_pointer, "p", value_test_collect_value, "p", value_test_lcopy_value }; + static const GTypeInfo g_define_type_info = { sizeof (TestClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) test_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (Test), 0, (GInstanceInitFunc) test_instance_init, &g_define_type_value_table }; + static const GTypeFundamentalInfo g_define_type_fundamental_info = { (G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE) }; + GType test_type_id; + test_type_id = g_type_register_fundamental (g_type_fundamental_next (), "Test", &g_define_type_info, &g_define_type_fundamental_info, 0); + return test_type_id; +} + +GType +test_get_type (void) +{ + static volatile gsize test_type_id__volatile = 0; + if (g_once_init_enter (&test_type_id__volatile)) { + GType test_type_id; + test_type_id = test_get_type_once (); + g_once_init_leave (&test_type_id__volatile, test_type_id); + } + return test_type_id__volatile; +} + +gpointer +test_ref (gpointer instance) +{ + Test * self; + self = instance; + g_atomic_int_inc (&self->ref_count); + return instance; +} + +void +test_unref (gpointer instance) +{ + Test * self; + self = instance; + if (g_atomic_int_dec_and_test (&self->ref_count)) { + TEST_GET_CLASS (self)->finalize (self); + g_type_free_instance ((GTypeInstance *) self); + } +} + diff --git a/tests/genie/class-field.gs b/tests/genie/class-field.gs new file mode 100644 index 000000000..f6d93ac70 --- /dev/null +++ b/tests/genie/class-field.gs @@ -0,0 +1,10 @@ +init + var a = new Test() + assert( a.a == "a" ) + assert( a.b == "b" ) + assert( a.c == "c" ) + +class Test + a:string = "a" + b:class string = "b" + c:static string = "c" diff --git a/tests/genie/class-init.c-expected b/tests/genie/class-init.c-expected new file mode 100644 index 000000000..236a2301e --- /dev/null +++ b/tests/genie/class-init.c-expected @@ -0,0 +1,164 @@ +/* genie_class_init.c generated by valac, the Vala compiler + * generated from genie_class_init.gs, do not modify */ + +#include +#include +#include +#include + +#if !defined(VALA_EXTERN) +#if defined(_MSC_VER) +#define VALA_EXTERN __declspec(dllexport) extern +#elif __GNUC__ >= 4 +#define VALA_EXTERN __attribute__((visibility("default"))) extern +#else +#define VALA_EXTERN extern +#endif +#endif + +#define TYPE_TEST (test_get_type ()) +#define TEST(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_TEST, Test)) +#define TEST_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_TEST, TestClass)) +#define IS_TEST(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_TEST)) +#define IS_TEST_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_TEST)) +#define TEST_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_TEST, TestClass)) + +typedef struct _Test Test; +typedef struct _TestClass TestClass; +#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL))) +typedef struct _TestPrivate TestPrivate; +enum { + TEST_0_PROPERTY, + TEST_NUM_PROPERTIES +}; +static GParamSpec* test_properties[TEST_NUM_PROPERTIES]; + +struct _Test { + GObject parent_instance; + TestPrivate * priv; +}; + +struct _TestClass { + GObjectClass parent_class; +}; + +static gpointer test_parent_class = NULL; + +static void _vala_main (gchar** args, + gint args_length1); +VALA_EXTERN GType test_get_type (void) G_GNUC_CONST ; +G_DEFINE_AUTOPTR_CLEANUP_FUNC (Test, g_object_unref) +VALA_EXTERN Test* test_new (void); +VALA_EXTERN Test* test_construct (GType object_type); +VALA_EXTERN void nothing (void); +static GObject * test_constructor (GType type, + guint n_construct_properties, + GObjectConstructParam * construct_properties); +static void test_finalize (GObject * obj); +static GType test_get_type_once (void); + +static void +_vala_main (gchar** args, + gint args_length1) +{ + Test* a = NULL; + Test* _tmp0_; + _tmp0_ = test_new (); + a = _tmp0_; + _g_object_unref0 (a); +} + +int +main (int argc, + char ** argv) +{ + _vala_main (argv, argc); + return 0; +} + +void +nothing (void) +{ +} + +Test* +test_construct (GType object_type) +{ + Test * self = NULL; + self = (Test*) g_object_new (object_type, NULL); + return self; +} + +Test* +test_new (void) +{ + return test_construct (TYPE_TEST); +} + +static GObject * +test_constructor (GType type, + guint n_construct_properties, + GObjectConstructParam * construct_properties) +{ + GObject * obj; + GObjectClass * parent_class; + Test * self; + parent_class = G_OBJECT_CLASS (test_parent_class); + obj = parent_class->constructor (type, n_construct_properties, construct_properties); + self = G_TYPE_CHECK_INSTANCE_CAST (obj, TYPE_TEST, Test); + nothing (); + return obj; +} + +static void +test_base_init (TestClass * klass) +{ + nothing (); +} + +static void +test_class_init (TestClass * klass, + gpointer klass_data) +{ + test_parent_class = g_type_class_peek_parent (klass); + G_OBJECT_CLASS (klass)->constructor = test_constructor; + G_OBJECT_CLASS (klass)->finalize = test_finalize; + nothing (); +} + +static void +test_instance_init (Test * self, + gpointer klass) +{ +} + +static void +test_finalize (GObject * obj) +{ + Test * self; + self = G_TYPE_CHECK_INSTANCE_CAST (obj, TYPE_TEST, Test); + nothing (); + G_OBJECT_CLASS (test_parent_class)->finalize (obj); +} + +static GType +test_get_type_once (void) +{ + static const GTypeInfo g_define_type_info = { sizeof (TestClass), (GBaseInitFunc) test_base_init, (GBaseFinalizeFunc) NULL, (GClassInitFunc) test_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (Test), 0, (GInstanceInitFunc) test_instance_init, NULL }; + GType test_type_id; + test_type_id = g_type_register_static (G_TYPE_OBJECT, "Test", &g_define_type_info, 0); + return test_type_id; +} + +GType +test_get_type (void) +{ + static volatile gsize test_type_id__volatile = 0; + if (g_once_init_enter (&test_type_id__volatile)) { + GType test_type_id; + test_type_id = test_get_type_once (); + g_once_init_leave (&test_type_id__volatile, test_type_id); + } + return test_type_id__volatile; +} + diff --git a/tests/genie/class-init.gs b/tests/genie/class-init.gs new file mode 100644 index 000000000..edbe01b4d --- /dev/null +++ b/tests/genie/class-init.gs @@ -0,0 +1,18 @@ +init + var a = new Test() + +def nothing() + pass + +class Test:Object + init + nothing() + + init class + nothing() + + init static + nothing() + + final + nothing() diff --git a/tests/genie/class-signal.c-expected b/tests/genie/class-signal.c-expected new file mode 100644 index 000000000..ce9dde3de --- /dev/null +++ b/tests/genie/class-signal.c-expected @@ -0,0 +1,376 @@ +/* genie_class_signal.c generated by valac, the Vala compiler + * generated from genie_class_signal.gs, do not modify */ + +#include +#include +#include +#include +#include + +#if !defined(VALA_EXTERN) +#if defined(_MSC_VER) +#define VALA_EXTERN __declspec(dllexport) extern +#elif __GNUC__ >= 4 +#define VALA_EXTERN __attribute__((visibility("default"))) extern +#else +#define VALA_EXTERN extern +#endif +#endif + +#define TYPE_TEST (test_get_type ()) +#define TEST(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_TEST, Test)) +#define TEST_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_TEST, TestClass)) +#define IS_TEST(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_TEST)) +#define IS_TEST_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_TEST)) +#define TEST_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_TEST, TestClass)) + +typedef struct _Test Test; +typedef struct _TestClass TestClass; +#define _test_unref0(var) ((var == NULL) ? NULL : (var = (test_unref (var), NULL))) +typedef struct _TestPrivate TestPrivate; +typedef struct _ParamSpecTest ParamSpecTest; +enum { + TEST_FOO_SIGNAL, + TEST_NUM_SIGNALS +}; +static guint test_signals[TEST_NUM_SIGNALS] = {0}; +#define _vala_assert(expr, msg) if G_LIKELY (expr) ; else g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, msg); +#define _vala_return_if_fail(expr, msg) if G_LIKELY (expr) ; else { g_return_if_fail_warning (G_LOG_DOMAIN, G_STRFUNC, msg); return; } +#define _vala_return_val_if_fail(expr, msg, val) if G_LIKELY (expr) ; else { g_return_if_fail_warning (G_LOG_DOMAIN, G_STRFUNC, msg); return val; } +#define _vala_warn_if_fail(expr, msg) if G_LIKELY (expr) ; else g_warn_message (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, msg); + +struct _Test { + GTypeInstance parent_instance; + volatile int ref_count; + TestPrivate * priv; +}; + +struct _TestClass { + GTypeClass parent_class; + void (*finalize) (Test *self); +}; + +struct _ParamSpecTest { + GParamSpec parent_instance; +}; + +static gpointer test_parent_class = NULL; + +static void _vala_main (gchar** args, + gint args_length1); +VALA_EXTERN gpointer test_ref (gpointer instance); +VALA_EXTERN void test_unref (gpointer instance); +VALA_EXTERN GParamSpec* param_spec_test (const gchar* name, + const gchar* nick, + const gchar* blurb, + GType object_type, + GParamFlags flags); +VALA_EXTERN void value_set_test (GValue* value, + gpointer v_object); +VALA_EXTERN void value_take_test (GValue* value, + gpointer v_object); +VALA_EXTERN gpointer value_get_test (const GValue* value); +VALA_EXTERN GType test_get_type (void) G_GNUC_CONST ; +G_DEFINE_AUTOPTR_CLEANUP_FUNC (Test, test_unref) +VALA_EXTERN Test* test_new (void); +VALA_EXTERN Test* test_construct (GType object_type); +VALA_EXTERN gboolean test (gint a); +static gboolean _test_test_foo (Test* _sender, + gint a, + gpointer self); +static void g_cclosure_user_marshal_BOOLEAN__INT (GClosure * closure, + GValue * return_value, + guint n_param_values, + const GValue * param_values, + gpointer invocation_hint, + gpointer marshal_data); +static void test_finalize (Test * obj); +static GType test_get_type_once (void); + +static gboolean +_test_test_foo (Test* _sender, + gint a, + gpointer self) +{ + gboolean result; + result = test (a); + return result; +} + +static void +_vala_main (gchar** args, + gint args_length1) +{ + Test* a = NULL; + Test* _tmp0_; + gboolean _tmp1_ = FALSE; + guint _tmp2_; + _tmp0_ = test_new (); + a = _tmp0_; + g_signal_connect (a, "foo", (GCallback) _test_test_foo, NULL); + g_signal_emit (a, test_signals[TEST_FOO_SIGNAL], 0, 23, &_tmp1_); + _vala_assert (_tmp1_, "a.foo(23)"); + g_signal_parse_name ("foo", TYPE_TEST, &_tmp2_, NULL, FALSE); + g_signal_handlers_disconnect_matched (a, G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, _tmp2_, 0, NULL, (GCallback) _test_test_foo, NULL); + _test_unref0 (a); +} + +int +main (int argc, + char ** argv) +{ + _vala_main (argv, argc); + return 0; +} + +gboolean +test (gint a) +{ + gboolean result = FALSE; + result = a == 23; + return result; +} + +Test* +test_construct (GType object_type) +{ + Test* self = NULL; + self = (Test*) g_type_create_instance (object_type); + return self; +} + +Test* +test_new (void) +{ + return test_construct (TYPE_TEST); +} + +static void +g_cclosure_user_marshal_BOOLEAN__INT (GClosure * closure, + GValue * return_value, + guint n_param_values, + const GValue * param_values, + gpointer invocation_hint, + gpointer marshal_data) +{ + typedef gboolean (*GMarshalFunc_BOOLEAN__INT) (gpointer data1, gint arg_1, gpointer data2); + register GMarshalFunc_BOOLEAN__INT callback; + register GCClosure * cc; + register gpointer data1; + register gpointer data2; + gboolean v_return; + cc = (GCClosure *) closure; + g_return_if_fail (return_value != NULL); + g_return_if_fail (n_param_values == 2); + if (G_CCLOSURE_SWAP_DATA (closure)) { + data1 = closure->data; + data2 = param_values->data[0].v_pointer; + } else { + data1 = param_values->data[0].v_pointer; + data2 = closure->data; + } + callback = (GMarshalFunc_BOOLEAN__INT) (marshal_data ? marshal_data : cc->callback); + v_return = callback (data1, g_value_get_int (param_values + 1), data2); + g_value_set_boolean (return_value, v_return); +} + +static void +value_test_init (GValue* value) +{ + value->data[0].v_pointer = NULL; +} + +static void +value_test_free_value (GValue* value) +{ + if (value->data[0].v_pointer) { + test_unref (value->data[0].v_pointer); + } +} + +static void +value_test_copy_value (const GValue* src_value, + GValue* dest_value) +{ + if (src_value->data[0].v_pointer) { + dest_value->data[0].v_pointer = test_ref (src_value->data[0].v_pointer); + } else { + dest_value->data[0].v_pointer = NULL; + } +} + +static gpointer +value_test_peek_pointer (const GValue* value) +{ + return value->data[0].v_pointer; +} + +static gchar* +value_test_collect_value (GValue* value, + guint n_collect_values, + GTypeCValue* collect_values, + guint collect_flags) +{ + if (collect_values[0].v_pointer) { + Test * object; + object = collect_values[0].v_pointer; + if (object->parent_instance.g_class == NULL) { + return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL); + } else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) { + return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL); + } + value->data[0].v_pointer = test_ref (object); + } else { + value->data[0].v_pointer = NULL; + } + return NULL; +} + +static gchar* +value_test_lcopy_value (const GValue* value, + guint n_collect_values, + GTypeCValue* collect_values, + guint collect_flags) +{ + Test ** object_p; + object_p = collect_values[0].v_pointer; + if (!object_p) { + return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value)); + } + if (!value->data[0].v_pointer) { + *object_p = NULL; + } else if (collect_flags & G_VALUE_NOCOPY_CONTENTS) { + *object_p = value->data[0].v_pointer; + } else { + *object_p = test_ref (value->data[0].v_pointer); + } + return NULL; +} + +GParamSpec* +param_spec_test (const gchar* name, + const gchar* nick, + const gchar* blurb, + GType object_type, + GParamFlags flags) +{ + ParamSpecTest* spec; + g_return_val_if_fail (g_type_is_a (object_type, TYPE_TEST), NULL); + spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags); + G_PARAM_SPEC (spec)->value_type = object_type; + return G_PARAM_SPEC (spec); +} + +gpointer +value_get_test (const GValue* value) +{ + g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_TEST), NULL); + return value->data[0].v_pointer; +} + +void +value_set_test (GValue* value, + gpointer v_object) +{ + Test * old; + g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_TEST)); + old = value->data[0].v_pointer; + if (v_object) { + g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_TEST)); + g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value))); + value->data[0].v_pointer = v_object; + test_ref (value->data[0].v_pointer); + } else { + value->data[0].v_pointer = NULL; + } + if (old) { + test_unref (old); + } +} + +void +value_take_test (GValue* value, + gpointer v_object) +{ + Test * old; + g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_TEST)); + old = value->data[0].v_pointer; + if (v_object) { + g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_TEST)); + g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value))); + value->data[0].v_pointer = v_object; + } else { + value->data[0].v_pointer = NULL; + } + if (old) { + test_unref (old); + } +} + +static void +test_class_init (TestClass * klass, + gpointer klass_data) +{ + test_parent_class = g_type_class_peek_parent (klass); + ((TestClass *) klass)->finalize = test_finalize; + test_signals[TEST_FOO_SIGNAL] = g_signal_new ("foo", TYPE_TEST, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_user_marshal_BOOLEAN__INT, G_TYPE_BOOLEAN, 1, G_TYPE_INT); +} + +static void +test_instance_init (Test * self, + gpointer klass) +{ + self->ref_count = 1; +} + +static void +test_finalize (Test * obj) +{ + Test * self; + self = G_TYPE_CHECK_INSTANCE_CAST (obj, TYPE_TEST, Test); + g_signal_handlers_destroy (self); +} + +static GType +test_get_type_once (void) +{ + static const GTypeValueTable g_define_type_value_table = { value_test_init, value_test_free_value, value_test_copy_value, value_test_peek_pointer, "p", value_test_collect_value, "p", value_test_lcopy_value }; + static const GTypeInfo g_define_type_info = { sizeof (TestClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) test_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (Test), 0, (GInstanceInitFunc) test_instance_init, &g_define_type_value_table }; + static const GTypeFundamentalInfo g_define_type_fundamental_info = { (G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE) }; + GType test_type_id; + test_type_id = g_type_register_fundamental (g_type_fundamental_next (), "Test", &g_define_type_info, &g_define_type_fundamental_info, 0); + return test_type_id; +} + +GType +test_get_type (void) +{ + static volatile gsize test_type_id__volatile = 0; + if (g_once_init_enter (&test_type_id__volatile)) { + GType test_type_id; + test_type_id = test_get_type_once (); + g_once_init_leave (&test_type_id__volatile, test_type_id); + } + return test_type_id__volatile; +} + +gpointer +test_ref (gpointer instance) +{ + Test * self; + self = instance; + g_atomic_int_inc (&self->ref_count); + return instance; +} + +void +test_unref (gpointer instance) +{ + Test * self; + self = instance; + if (g_atomic_int_dec_and_test (&self->ref_count)) { + TEST_GET_CLASS (self)->finalize (self); + g_type_free_instance ((GTypeInstance *) self); + } +} + diff --git a/tests/genie/class-signal.gs b/tests/genie/class-signal.gs new file mode 100644 index 000000000..718bbe164 --- /dev/null +++ b/tests/genie/class-signal.gs @@ -0,0 +1,11 @@ +init + var a = new Test() + a.foo.connect( test ) + assert( a.foo(23) ) + a.foo.disconnect( test ) + +def test( a:int ):bool + return a == 23 + +class Test + event foo( a:int ):bool diff --git a/tests/genie/constant.c-expected b/tests/genie/constant.c-expected new file mode 100644 index 000000000..66743ce3b --- /dev/null +++ b/tests/genie/constant.c-expected @@ -0,0 +1,31 @@ +/* genie_constant.c generated by valac, the Vala compiler + * generated from genie_constant.gs, do not modify */ + +#include +#include +#include + +#define _vala_assert(expr, msg) if G_LIKELY (expr) ; else g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, msg); +#define _vala_return_if_fail(expr, msg) if G_LIKELY (expr) ; else { g_return_if_fail_warning (G_LOG_DOMAIN, G_STRFUNC, msg); return; } +#define _vala_return_val_if_fail(expr, msg, val) if G_LIKELY (expr) ; else { g_return_if_fail_warning (G_LOG_DOMAIN, G_STRFUNC, msg); return val; } +#define _vala_warn_if_fail(expr, msg) if G_LIKELY (expr) ; else g_warn_message (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, msg); + +static void _vala_main (gchar** args, + gint args_length1); +#define TEST 23 + +static void +_vala_main (gchar** args, + gint args_length1) +{ + _vala_assert (TEST == 23, "TEST == 23"); +} + +int +main (int argc, + char ** argv) +{ + _vala_main (argv, argc); + return 0; +} + diff --git a/tests/genie/constant.gs b/tests/genie/constant.gs new file mode 100644 index 000000000..9b4d445ab --- /dev/null +++ b/tests/genie/constant.gs @@ -0,0 +1,4 @@ +init + assert( TEST == 23 ) + +const TEST:int = 23 diff --git a/tests/genie/exception.c-expected b/tests/genie/exception.c-expected new file mode 100644 index 000000000..976e2c579 --- /dev/null +++ b/tests/genie/exception.c-expected @@ -0,0 +1,55 @@ +/* genie_exception.c generated by valac, the Vala compiler + * generated from genie_exception.gs, do not modify */ + +#include +#include +#include + +#if !defined(VALA_EXTERN) +#if defined(_MSC_VER) +#define VALA_EXTERN __declspec(dllexport) extern +#elif __GNUC__ >= 4 +#define VALA_EXTERN __attribute__((visibility("default"))) extern +#else +#define VALA_EXTERN extern +#endif +#endif + +#define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL))) + +typedef enum { + TEST_ERROR_FAIL, + TEST_ERROR_BAD, + TEST_ERROR_WORSE +} TestError; +#define TEST_ERROR test_error_quark () + +static void _vala_main (gchar** args, + gint args_length1); +VALA_EXTERN GQuark test_error_quark (void); + +static void +_vala_main (gchar** args, + gint args_length1) +{ + GError* e = NULL; + GError* _tmp0_; + _tmp0_ = g_error_new_literal (TEST_ERROR, TEST_ERROR_BAD, "not so good"); + e = _tmp0_; + _g_error_free0 (e); +} + +int +main (int argc, + char ** argv) +{ + _vala_main (argv, argc); + return 0; +} + +GQuark +test_error_quark (void) +{ + return g_quark_from_static_string ("test-error-quark"); +} + diff --git a/tests/genie/exception.gs b/tests/genie/exception.gs new file mode 100644 index 000000000..eb52d229b --- /dev/null +++ b/tests/genie/exception.gs @@ -0,0 +1,7 @@ +init + e:TestError = new TestError.BAD( "not so good" ) + +exception TestError + FAIL + BAD + WORSE diff --git a/tests/genie/interface.c-expected b/tests/genie/interface.c-expected new file mode 100644 index 000000000..77b98c6fc --- /dev/null +++ b/tests/genie/interface.c-expected @@ -0,0 +1,208 @@ +/* genie_interface.c generated by valac, the Vala compiler + * generated from genie_interface.gs, do not modify */ + +#include +#include +#include +#include + +#if !defined(VALA_EXTERN) +#if defined(_MSC_VER) +#define VALA_EXTERN __declspec(dllexport) extern +#elif __GNUC__ >= 4 +#define VALA_EXTERN __attribute__((visibility("default"))) extern +#else +#define VALA_EXTERN extern +#endif +#endif + +#define TYPE_TEST (test_get_type ()) +#define TEST(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_TEST, Test)) +#define TEST_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_TEST, TestClass)) +#define IS_TEST(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_TEST)) +#define IS_TEST_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_TEST)) +#define TEST_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_TEST, TestClass)) + +typedef struct _Test Test; +typedef struct _TestClass TestClass; + +#define TYPE_ITEST (itest_get_type ()) +#define ITEST(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_ITEST, ITest)) +#define IS_ITEST(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_ITEST)) +#define ITEST_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), TYPE_ITEST, ITestIface)) + +typedef struct _ITest ITest; +typedef struct _ITestIface ITestIface; +#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL))) +typedef struct _TestPrivate TestPrivate; +enum { + TEST_0_PROPERTY, + TEST_NUM_PROPERTIES +}; +static GParamSpec* test_properties[TEST_NUM_PROPERTIES]; +#define _vala_assert(expr, msg) if G_LIKELY (expr) ; else g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, msg); +#define _vala_return_if_fail(expr, msg) if G_LIKELY (expr) ; else { g_return_if_fail_warning (G_LOG_DOMAIN, G_STRFUNC, msg); return; } +#define _vala_return_val_if_fail(expr, msg, val) if G_LIKELY (expr) ; else { g_return_if_fail_warning (G_LOG_DOMAIN, G_STRFUNC, msg); return val; } +#define _vala_warn_if_fail(expr, msg) if G_LIKELY (expr) ; else g_warn_message (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, msg); + +struct _ITestIface { + GTypeInterface parent_iface; + gboolean (*test) (ITest* self, gint a); +}; + +struct _Test { + GObject parent_instance; + TestPrivate * priv; +}; + +struct _TestClass { + GObjectClass parent_class; +}; + +static gpointer test_parent_class = NULL; +static ITestIface * test_itest_parent_iface = NULL; + +static void _vala_main (gchar** args, + gint args_length1); +VALA_EXTERN GType test_get_type (void) G_GNUC_CONST ; +G_DEFINE_AUTOPTR_CLEANUP_FUNC (Test, g_object_unref) +VALA_EXTERN Test* test_new (void); +VALA_EXTERN Test* test_construct (GType object_type); +VALA_EXTERN GType itest_get_type (void) G_GNUC_CONST ; +VALA_EXTERN gboolean itest_test (ITest* self, + gint a); +static GType itest_get_type_once (void); +static gboolean test_real_test (ITest* base, + gint a); +static GType test_get_type_once (void); + +static void +_vala_main (gchar** args, + gint args_length1) +{ + Test* a = NULL; + Test* _tmp0_; + _tmp0_ = test_new (); + a = _tmp0_; + _vala_assert (itest_test (G_TYPE_CHECK_INSTANCE_CAST (a, TYPE_ITEST, ITest), 42), "a.test(42)"); + _g_object_unref0 (a); +} + +int +main (int argc, + char ** argv) +{ + _vala_main (argv, argc); + return 0; +} + +gboolean +itest_test (ITest* self, + gint a) +{ + ITestIface* _iface_; + g_return_val_if_fail (IS_ITEST (self), FALSE); + _iface_ = ITEST_GET_INTERFACE (self); + if (_iface_->test) { + return _iface_->test (self, a); + } + return FALSE; +} + +static void +itest_default_init (ITestIface * iface, + gpointer iface_data) +{ +} + +static GType +itest_get_type_once (void) +{ + static const GTypeInfo g_define_type_info = { sizeof (ITestIface), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) itest_default_init, (GClassFinalizeFunc) NULL, NULL, 0, 0, (GInstanceInitFunc) NULL, NULL }; + GType itest_type_id; + itest_type_id = g_type_register_static (G_TYPE_INTERFACE, "ITest", &g_define_type_info, 0); + g_type_interface_add_prerequisite (itest_type_id, G_TYPE_OBJECT); + return itest_type_id; +} + +GType +itest_get_type (void) +{ + static volatile gsize itest_type_id__volatile = 0; + if (g_once_init_enter (&itest_type_id__volatile)) { + GType itest_type_id; + itest_type_id = itest_get_type_once (); + g_once_init_leave (&itest_type_id__volatile, itest_type_id); + } + return itest_type_id__volatile; +} + +static gboolean +test_real_test (ITest* base, + gint a) +{ + Test * self; + gboolean result = FALSE; + self = G_TYPE_CHECK_INSTANCE_CAST (base, TYPE_TEST, Test); + result = a == 42; + return result; +} + +Test* +test_construct (GType object_type) +{ + Test * self = NULL; + self = (Test*) g_object_new (object_type, NULL); + return self; +} + +Test* +test_new (void) +{ + return test_construct (TYPE_TEST); +} + +static void +test_class_init (TestClass * klass, + gpointer klass_data) +{ + test_parent_class = g_type_class_peek_parent (klass); +} + +static void +test_itest_interface_init (ITestIface * iface, + gpointer iface_data) +{ + test_itest_parent_iface = g_type_interface_peek_parent (iface); + iface->test = (gboolean (*) (ITest*, gint)) test_real_test; +} + +static void +test_instance_init (Test * self, + gpointer klass) +{ +} + +static GType +test_get_type_once (void) +{ + static const GTypeInfo g_define_type_info = { sizeof (TestClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) test_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (Test), 0, (GInstanceInitFunc) test_instance_init, NULL }; + static const GInterfaceInfo itest_info = { (GInterfaceInitFunc) test_itest_interface_init, (GInterfaceFinalizeFunc) NULL, NULL}; + GType test_type_id; + test_type_id = g_type_register_static (G_TYPE_OBJECT, "Test", &g_define_type_info, 0); + g_type_add_interface_static (test_type_id, TYPE_ITEST, &itest_info); + return test_type_id; +} + +GType +test_get_type (void) +{ + static volatile gsize test_type_id__volatile = 0; + if (g_once_init_enter (&test_type_id__volatile)) { + GType test_type_id; + test_type_id = test_get_type_once (); + g_once_init_leave (&test_type_id__volatile, test_type_id); + } + return test_type_id__volatile; +} + diff --git a/tests/genie/interface.gs b/tests/genie/interface.gs new file mode 100644 index 000000000..cb90d5cd7 --- /dev/null +++ b/tests/genie/interface.gs @@ -0,0 +1,10 @@ +init + var a = new Test() + assert( a.test(42) ) + +interface ITest:Object + def abstract test( a:int ):bool + +class Test:Object implements ITest + def test( a:int ):bool + return a == 42 -- cgit v1.2.1