codegen: Set and check GTask source tag

This is the best practice when writing async code in C.

diff --git a/codegen/valagasyncmodule.vala b/codegen/valagasyncmodule.vala
index bbe810496897d385e91dcce9eb567cfa308d813b..7d40ae03ed828c25dca919ee5400f592c9ae2763 100644 (file)
--- a/codegen/valagasyncmodule.vala
+++ b/codegen/valagasyncmodule.vala
@@ -261,6 +261,11 @@ public class Vala.GAsyncModule : GtkModule {
 
                ccode.add_assignment (new CCodeMemberAccess.pointer (data_var, "_async_result"), create_result);
 
+               var set_source_tag_call = new CCodeFunctionCall (new CCodeIdentifier ("g_task_set_source_tag"));
+               set_source_tag_call.add_argument (new CCodeMemberAccess.pointer (data_var, "_async_result"));
+               set_source_tag_call.add_argument (new CCodeIdentifier (get_ccode_real_name (m)));
+               ccode.add_expression (set_source_tag_call);
+
                var attach_data_call = new CCodeFunctionCall (new CCodeIdentifier ("g_task_set_task_data"));
 
                attach_data_call.add_argument (new CCodeMemberAccess.pointer (data_var, "_async_result"));
@@ -575,6 +580,49 @@ public class Vala.GAsyncModule : GtkModule {
                        ccode.add_declaration (get_ccode_name (m.return_type), new CCodeVariableDeclarator ("result"));
                }
 
+               if (context.assert) {
+                       var cdefault = default_value_for_type (return_type, false);
+
+                       var task_is_valid_call = new CCodeFunctionCall ();
+                       task_is_valid_call.add_argument (new CCodeIdentifier ("_res_"));
+
+                       unowned TypeSymbol? t = m.parent_symbol as TypeSymbol;
+                       if (!(m is CreationMethod) && m.binding == MemberBinding.INSTANCE
+                           && get_ccode_finish_instance (m) && t != null && t.is_subtype_of (gobject_type)) {
+                               task_is_valid_call.call = new CCodeIdentifier ("g_task_is_valid");
+                               var instance_param = cparam_map.get (get_param_pos (get_ccode_instance_pos (m)));
+                               var gobject_cast = new CCodeFunctionCall (new CCodeIdentifier ("G_OBJECT"));
+                               gobject_cast.add_argument (new CCodeIdentifier (instance_param.name));
+
+                               task_is_valid_call.add_argument (gobject_cast);
+                       } else {
+                               task_is_valid_call.call = new CCodeIdentifier ("G_IS_TASK");
+                       }
+                       var return_unless_valid_call = new CCodeFunctionCall ();
+                       return_unless_valid_call.add_argument (task_is_valid_call);
+                       if (return_type is VoidType || return_type.is_real_non_null_struct_type ()) {
+                               return_unless_valid_call.call = new CCodeIdentifier ("g_return_if_fail");
+                       } else {
+                               return_unless_valid_call.call = new CCodeIdentifier ("g_return_val_if_fail");
+                               return_unless_valid_call.add_argument (cdefault);
+                       }
+                       ccode.add_expression (return_unless_valid_call);
+
+                       var is_tagged_call = new CCodeFunctionCall (new CCodeIdentifier ("g_async_result_is_tagged"));
+                       is_tagged_call.add_argument (new CCodeIdentifier ("_res_"));
+                       is_tagged_call.add_argument (new CCodeIdentifier (get_ccode_real_name (m)));
+
+                       var return_unless_tagged_call = new CCodeFunctionCall ();
+                       return_unless_tagged_call.add_argument (is_tagged_call);
+                       if (return_type is VoidType || return_type.is_real_non_null_struct_type ()) {
+                               return_unless_tagged_call.call = new CCodeIdentifier ("g_return_if_fail");
+                       } else {
+                               return_unless_tagged_call.call = new CCodeIdentifier ("g_return_val_if_fail");
+                               return_unless_tagged_call.add_argument (cdefault);
+                       }
+                       ccode.add_expression (return_unless_tagged_call);
+               }
+
                var data_var = new CCodeIdentifier ("_data_");
 
                ccode.add_declaration (dataname + "*", new CCodeVariableDeclarator ("_data_"));

diff --git a/tests/asynchronous/bug595735.c-expected b/tests/asynchronous/bug595735.c-expected
index 5256faf657df37c19c3ac5f59076d4f66c8be4ff..7c0b4104c05e5faa1ffad9dba11475ca80b92988 100644 (file)
--- a/tests/asynchronous/bug595735.c-expected
+++ b/tests/asynchronous/bug595735.c-expected
@@ -375,6 +375,7 @@ bar_real_do_foo (Foo* base,
        self = G_TYPE_CHECK_INSTANCE_CAST (base, TYPE_BAR, Bar);
        _data_ = g_slice_new0 (BarDoFooData);
        _data_->_async_result = g_task_new (NULL, NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, bar_real_do_foo);
        g_task_set_task_data (_data_->_async_result, _data_, bar_real_do_foo_data_free);
        _tmp0_ = _foo_ref0 (self);
        _data_->self = _tmp0_;
@@ -386,6 +387,8 @@ bar_do_foo_finish (Foo* base,
                    GAsyncResult* _res_)
 {
        BarDoFooData* _data_;
+       g_return_if_fail (G_IS_TASK (_res_));
+       g_return_if_fail (g_async_result_is_tagged (_res_, bar_real_do_foo));
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
 }
 

diff --git a/tests/asynchronous/bug595755.c-expected b/tests/asynchronous/bug595755.c-expected
index 57734e27524bada801e2ea1232c9e02e1236dbcc..b978c54d8dee4d4bb783f8f718d3c6a09c79c24e 100644 (file)
--- a/tests/asynchronous/bug595755.c-expected
+++ b/tests/asynchronous/bug595755.c-expected
@@ -107,6 +107,7 @@ foo_do_foo (Foo* self,
        g_return_if_fail (IS_FOO (self));
        _data_ = g_slice_new0 (FooDoFooData);
        _data_->_async_result = g_task_new (G_OBJECT (self), NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, foo_do_foo);
        g_task_set_task_data (_data_->_async_result, _data_, foo_do_foo_data_free);
        _tmp0_ = _g_object_ref0 (self);
        _data_->self = _tmp0_;
@@ -118,6 +119,8 @@ foo_do_foo_finish (Foo* self,
                    GAsyncResult* _res_)
 {
        FooDoFooData* _data_;
+       g_return_if_fail (g_task_is_valid (_res_, G_OBJECT (self)));
+       g_return_if_fail (g_async_result_is_tagged (_res_, foo_do_foo));
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
 }
 

diff --git a/tests/asynchronous/bug596177.c-expected b/tests/asynchronous/bug596177.c-expected
index 7f485413dde3dce7a187a64cd7bb5637defa0074..54e57f65583160a9cb519db2d2ed81129b3bc639 100644 (file)
--- a/tests/asynchronous/bug596177.c-expected
+++ b/tests/asynchronous/bug596177.c-expected
@@ -134,6 +134,7 @@ foo_do_foo (Foo* self,
        g_return_if_fail (IS_FOO (self));
        _data_ = g_slice_new0 (FooDoFooData);
        _data_->_async_result = g_task_new (NULL, NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, foo_do_foo);
        g_task_set_task_data (_data_->_async_result, _data_, foo_do_foo_data_free);
        _tmp0_ = _foo_ref0 (self);
        _data_->self = _tmp0_;
@@ -145,6 +146,8 @@ foo_do_foo_finish (Foo* self,
                    GAsyncResult* _res_)
 {
        FooDoFooData* _data_;
+       g_return_if_fail (G_IS_TASK (_res_));
+       g_return_if_fail (g_async_result_is_tagged (_res_, foo_do_foo));
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
 }
 

diff --git a/tests/asynchronous/bug596861.c-expected b/tests/asynchronous/bug596861.c-expected
index 835206f3a5f74888b3a2ee0335b0a039c6b21cc0..858ddb05e4d72f766a26badab45ede44034a84a7 100644 (file)
--- a/tests/asynchronous/bug596861.c-expected
+++ b/tests/asynchronous/bug596861.c-expected
@@ -71,6 +71,7 @@ foo (GAsyncReadyCallback _callback_,
        FooData* _data_;
        _data_ = g_slice_new0 (FooData);
        _data_->_async_result = g_task_new (NULL, NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, foo);
        g_task_set_task_data (_data_->_async_result, _data_, foo_data_free);
        foo_co (_data_);
 }
@@ -81,6 +82,8 @@ foo_finish (GAsyncResult* _res_,
 {
        gint result;
        FooData* _data_;
+       g_return_val_if_fail (G_IS_TASK (_res_), 0);
+       g_return_val_if_fail (g_async_result_is_tagged (_res_, foo), 0);
        _data_ = g_task_propagate_pointer (G_TASK (_res_), error);
        if (NULL == _data_) {
                gint _tmp0_ = 0;

diff --git a/tests/asynchronous/bug597294.c-expected b/tests/asynchronous/bug597294.c-expected
index 69f40014d02c195fa18ae08f0e2f56e86a980559..f35094c917bdbf194345acb0e7e98906742df611 100644 (file)
--- a/tests/asynchronous/bug597294.c-expected
+++ b/tests/asynchronous/bug597294.c-expected
@@ -67,6 +67,7 @@ do_foo (Foo f,
        DoFooData* _data_;
        _data_ = g_slice_new0 (DoFooData);
        _data_->_async_result = g_task_new (NULL, NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, do_foo);
        g_task_set_task_data (_data_->_async_result, _data_, do_foo_data_free);
        (_data_->f_target_destroy_notify == NULL) ? NULL : (_data_->f_target_destroy_notify (_data_->f_target), NULL);
        _data_->f = NULL;
@@ -82,6 +83,8 @@ void
 do_foo_finish (GAsyncResult* _res_)
 {
        DoFooData* _data_;
+       g_return_if_fail (G_IS_TASK (_res_));
+       g_return_if_fail (g_async_result_is_tagged (_res_, do_foo));
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
 }
 

diff --git a/tests/asynchronous/bug598677.c-expected b/tests/asynchronous/bug598677.c-expected
index 06e903ee3e2a0a1b170b49ba36b35f324574c28b..e1ae21752184dbcab9745139ce0c7e1f023c6047 100644 (file)
--- a/tests/asynchronous/bug598677.c-expected
+++ b/tests/asynchronous/bug598677.c-expected
@@ -321,6 +321,7 @@ do_foo (GAsyncReadyCallback _callback_,
        DoFooData* _data_;
        _data_ = g_slice_new0 (DoFooData);
        _data_->_async_result = g_task_new (NULL, NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, do_foo);
        g_task_set_task_data (_data_->_async_result, _data_, do_foo_data_free);
        do_foo_co (_data_);
 }
@@ -330,6 +331,8 @@ do_foo_finish (GAsyncResult* _res_,
                GError** error)
 {
        DoFooData* _data_;
+       g_return_if_fail (G_IS_TASK (_res_));
+       g_return_if_fail (g_async_result_is_tagged (_res_, do_foo));
        _data_ = g_task_propagate_pointer (G_TASK (_res_), error);
        if (NULL == _data_) {
                return;

diff --git a/tests/asynchronous/bug598697.c-expected b/tests/asynchronous/bug598697.c-expected
index 9cc015a56d6e533f1502bb73867d1105c9858795..469b3d054af6d4fc547c0dc2ce4b2eb10a9c644e 100644 (file)
--- a/tests/asynchronous/bug598697.c-expected
+++ b/tests/asynchronous/bug598697.c-expected
@@ -122,6 +122,7 @@ foo_do_foo (Foo* self,
        g_return_if_fail (IS_FOO (self));
        _data_ = g_slice_new0 (FooDoFooData);
        _data_->_async_result = g_task_new (NULL, NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, foo_do_foo);
        g_task_set_task_data (_data_->_async_result, _data_, foo_do_foo_data_free);
        _tmp0_ = _foo_ref0 (self);
        _data_->self = _tmp0_;
@@ -133,6 +134,8 @@ foo_do_foo_finish (Foo* self,
                    GAsyncResult* _res_)
 {
        FooDoFooData* _data_;
+       g_return_if_fail (G_IS_TASK (_res_));
+       g_return_if_fail (g_async_result_is_tagged (_res_, foo_do_foo));
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
 }
 

diff --git a/tests/asynchronous/bug599568.c-expected b/tests/asynchronous/bug599568.c-expected
index 4134f3eb2cb43fb60a8d7174d6960bda7b67b3ce..3146533e974be39613b1b764813ed2c2dca0ff0d 100644 (file)
--- a/tests/asynchronous/bug599568.c-expected
+++ b/tests/asynchronous/bug599568.c-expected
@@ -60,6 +60,7 @@ do_foo (GAsyncReadyCallback _callback_,
        DoFooData* _data_;
        _data_ = g_slice_new0 (DoFooData);
        _data_->_async_result = g_task_new (NULL, NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, do_foo);
        g_task_set_task_data (_data_->_async_result, _data_, do_foo_data_free);
        do_foo_co (_data_);
 }
@@ -68,6 +69,8 @@ void
 do_foo_finish (GAsyncResult* _res_)
 {
        DoFooData* _data_;
+       g_return_if_fail (G_IS_TASK (_res_));
+       g_return_if_fail (g_async_result_is_tagged (_res_, do_foo));
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
 }
 

diff --git a/tests/asynchronous/bug600827.c-expected b/tests/asynchronous/bug600827.c-expected
index acf93931d503757bb8fae7889dd4a7b0c834f1d3..bb48a0eab535f5ac62b7091532697d76e0d8f724 100644 (file)
--- a/tests/asynchronous/bug600827.c-expected
+++ b/tests/asynchronous/bug600827.c-expected
@@ -119,6 +119,7 @@ foo_real_do_foo (Foo* self,
        Foo* _tmp0_;
        _data_ = g_slice_new0 (FooDoFooData);
        _data_->_async_result = g_task_new (NULL, NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, foo_real_do_foo);
        g_task_set_task_data (_data_->_async_result, _data_, foo_real_do_foo_data_free);
        _tmp0_ = _foo_ref0 (self);
        _data_->self = _tmp0_;
@@ -130,6 +131,8 @@ foo_real_do_foo_finish (Foo* self,
                         GAsyncResult* _res_)
 {
        FooDoFooData* _data_;
+       g_return_if_fail (G_IS_TASK (_res_));
+       g_return_if_fail (g_async_result_is_tagged (_res_, foo_real_do_foo));
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
 }
 

diff --git a/tests/asynchronous/bug601558.c-expected b/tests/asynchronous/bug601558.c-expected
index 5e0ee4442f77d3994e794bc55d0846ba7fb4a986..a4e8df8c7778350c9c648acb01893b1aa6486f79 100644 (file)
--- a/tests/asynchronous/bug601558.c-expected
+++ b/tests/asynchronous/bug601558.c-expected
@@ -161,6 +161,7 @@ foo_real_do_foo (Foo* self,
        Foo* _tmp0_;
        _data_ = g_slice_new0 (FooDoFooData);
        _data_->_async_result = g_task_new (NULL, NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, foo_real_do_foo);
        g_task_set_task_data (_data_->_async_result, _data_, foo_real_do_foo_data_free);
        _tmp0_ = _foo_ref0 (self);
        _data_->self = _tmp0_;
@@ -172,6 +173,8 @@ foo_real_do_foo_finish (Foo* self,
                         GAsyncResult* _res_)
 {
        FooDoFooData* _data_;
+       g_return_if_fail (G_IS_TASK (_res_));
+       g_return_if_fail (g_async_result_is_tagged (_res_, foo_real_do_foo));
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
 }
 
@@ -453,6 +456,7 @@ bar_real_do_foo (Foo* base,
        self = G_TYPE_CHECK_INSTANCE_CAST (base, TYPE_BAR, Bar);
        _data_ = g_slice_new0 (BarDoFooData);
        _data_->_async_result = g_task_new (NULL, NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, bar_real_do_foo);
        g_task_set_task_data (_data_->_async_result, _data_, bar_real_do_foo_data_free);
        _tmp0_ = _foo_ref0 (self);
        _data_->self = _tmp0_;
@@ -464,6 +468,8 @@ bar_do_foo_finish (Foo* base,
                    GAsyncResult* _res_)
 {
        BarDoFooData* _data_;
+       g_return_if_fail (G_IS_TASK (_res_));
+       g_return_if_fail (g_async_result_is_tagged (_res_, bar_real_do_foo));
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
 }
 

diff --git a/tests/asynchronous/bug602594.c-expected b/tests/asynchronous/bug602594.c-expected
index 9250053b6ed587dd113211e630f30b0cc75eb8f5..163a94106be7badf1f7d8676197ff91c5368a00a 100644 (file)
--- a/tests/asynchronous/bug602594.c-expected
+++ b/tests/asynchronous/bug602594.c-expected
@@ -375,6 +375,7 @@ callback (const gchar* s,
        g_return_if_fail (s != NULL);
        _data_ = g_slice_new0 (CallbackData);
        _data_->_async_result = g_task_new (NULL, NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, callback);
        g_task_set_task_data (_data_->_async_result, _data_, callback_data_free);
        _tmp0_ = g_strdup (s);
        _g_free0 (_data_->s);
@@ -387,6 +388,8 @@ void
 callback_finish (GAsyncResult* _res_)
 {
        CallbackData* _data_;
+       g_return_if_fail (G_IS_TASK (_res_));
+       g_return_if_fail (g_async_result_is_tagged (_res_, callback));
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
 }
 

diff --git a/tests/asynchronous/bug612641.c-expected b/tests/asynchronous/bug612641.c-expected
index 0c9fec2ffd43950b7c4405eb63f6269c4342c8dc..30fa89ccf00ead6c7248840b2d926f19b25a9c67 100644 (file)
--- a/tests/asynchronous/bug612641.c-expected
+++ b/tests/asynchronous/bug612641.c-expected
@@ -131,6 +131,7 @@ foo_foo (Foo* self,
        g_return_if_fail (IS_FOO (self));
        _data_ = g_slice_new0 (FooFooData);
        _data_->_async_result = g_task_new (NULL, NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, foo_foo);
        g_task_set_task_data (_data_->_async_result, _data_, foo_foo_data_free);
        _tmp0_ = _foo_ref0 (self);
        _data_->self = _tmp0_;
@@ -145,6 +146,8 @@ foo_foo_finish (Foo* self,
 {
        FooFunc result;
        FooFooData* _data_;
+       g_return_val_if_fail (G_IS_TASK (_res_), NULL);
+       g_return_val_if_fail (g_async_result_is_tagged (_res_, foo_foo), NULL);
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
        result = _data_->result;
        *result_target = _data_->result_target;

diff --git a/tests/asynchronous/bug613484.c-expected b/tests/asynchronous/bug613484.c-expected
index b81ecd4112d7be3d126ad879178ff9958386f7b4..becf120b521abdd2ed4ba245eb6f5c09d2a2b1bc 100644 (file)
--- a/tests/asynchronous/bug613484.c-expected
+++ b/tests/asynchronous/bug613484.c-expected
@@ -122,6 +122,7 @@ do_foo_async (Foo* foo,
        g_return_if_fail (value != NULL);
        _data_ = g_slice_new0 (DoFooAsyncData);
        _data_->_async_result = g_task_new (NULL, NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, do_foo_async);
        g_task_set_task_data (_data_->_async_result, _data_, do_foo_async_data_free);
        _tmp0_ = *foo;
        _data_->foo = _tmp0_;
@@ -142,6 +143,8 @@ void
 do_foo_finish (GAsyncResult* _res_)
 {
        DoFooAsyncData* _data_;
+       g_return_if_fail (G_IS_TASK (_res_));
+       g_return_if_fail (g_async_result_is_tagged (_res_, do_foo_async));
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
 }
 

diff --git a/tests/asynchronous/bug614294.c-expected b/tests/asynchronous/bug614294.c-expected
index d93ad67231a865657e2c945391fbafdaab47f4dc..347da84cac2a305f1ad606f3abeb161dee5919a3 100644 (file)
--- a/tests/asynchronous/bug614294.c-expected
+++ b/tests/asynchronous/bug614294.c-expected
@@ -417,6 +417,7 @@ bar_real_foo_async (Bar* self,
        Bar* _tmp0_;
        _data_ = g_slice_new0 (BarFooAsyncData);
        _data_->_async_result = g_task_new (G_OBJECT (self), NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, bar_real_foo_async);
        g_task_set_task_data (_data_->_async_result, _data_, bar_real_foo_async_data_free);
        _tmp0_ = _g_object_ref0 (self);
        _data_->self = _tmp0_;
@@ -429,6 +430,8 @@ bar_real_foo_finish (Bar* self,
                      GError** error)
 {
        BarFooAsyncData* _data_;
+       g_return_if_fail (g_task_is_valid (_res_, G_OBJECT (self)));
+       g_return_if_fail (g_async_result_is_tagged (_res_, bar_real_foo_async));
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
 }
 
@@ -577,6 +580,7 @@ sub_bar_real_foo_async (Bar* base,
        self = G_TYPE_CHECK_INSTANCE_CAST (base, TYPE_SUB_BAR, SubBar);
        _data_ = g_slice_new0 (SubBarFooAsyncData);
        _data_->_async_result = g_task_new (G_OBJECT (self), NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, sub_bar_real_foo_async);
        g_task_set_task_data (_data_->_async_result, _data_, sub_bar_real_foo_async_data_free);
        _tmp0_ = _g_object_ref0 (self);
        _data_->self = _tmp0_;
@@ -589,6 +593,8 @@ sub_bar_foo_finish (Bar* base,
                     GError** error)
 {
        SubBarFooAsyncData* _data_;
+       g_return_if_fail (g_task_is_valid (_res_, G_OBJECT (base)));
+       g_return_if_fail (g_async_result_is_tagged (_res_, sub_bar_real_foo_async));
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
 }
 
@@ -778,6 +784,7 @@ baz_real_foo_async (AFoo* base,
        self = G_TYPE_CHECK_INSTANCE_CAST (base, TYPE_BAZ, Baz);
        _data_ = g_slice_new0 (BazFooAsyncData);
        _data_->_async_result = g_task_new (G_OBJECT (self), NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, baz_real_foo_async);
        g_task_set_task_data (_data_->_async_result, _data_, baz_real_foo_async_data_free);
        _tmp0_ = _g_object_ref0 (self);
        _data_->self = _tmp0_;
@@ -790,6 +797,8 @@ baz_foo_finish (AFoo* base,
                 GError** error)
 {
        BazFooAsyncData* _data_;
+       g_return_if_fail (g_task_is_valid (_res_, G_OBJECT (base)));
+       g_return_if_fail (g_async_result_is_tagged (_res_, baz_real_foo_async));
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
 }
 
@@ -892,6 +901,7 @@ sub_baz_real_foo_async (AFoo* base,
        self = G_TYPE_CHECK_INSTANCE_CAST (base, TYPE_SUB_BAZ, SubBaz);
        _data_ = g_slice_new0 (SubBazFooAsyncData);
        _data_->_async_result = g_task_new (G_OBJECT (self), NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, sub_baz_real_foo_async);
        g_task_set_task_data (_data_->_async_result, _data_, sub_baz_real_foo_async_data_free);
        _tmp0_ = _g_object_ref0 (self);
        _data_->self = _tmp0_;
@@ -904,6 +914,8 @@ sub_baz_foo_finish (AFoo* base,
                     GError** error)
 {
        SubBazFooAsyncData* _data_;
+       g_return_if_fail (g_task_is_valid (_res_, G_OBJECT (base)));
+       g_return_if_fail (g_async_result_is_tagged (_res_, sub_baz_real_foo_async));
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
 }
 
@@ -1001,6 +1013,7 @@ run (GAsyncReadyCallback _callback_,
        RunData* _data_;
        _data_ = g_slice_new0 (RunData);
        _data_->_async_result = g_task_new (NULL, NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, run);
        g_task_set_task_data (_data_->_async_result, _data_, run_data_free);
        run_co (_data_);
 }
@@ -1009,6 +1022,8 @@ void
 run_finish (GAsyncResult* _res_)
 {
        RunData* _data_;
+       g_return_if_fail (G_IS_TASK (_res_));
+       g_return_if_fail (g_async_result_is_tagged (_res_, run));
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
 }
 

diff --git a/tests/asynchronous/bug620740.c-expected b/tests/asynchronous/bug620740.c-expected
index 1f64bdfb2c061e9d1cd268c6e37368f1e8673f87..ab24861d19dbb00b23f652a512401f6424f94eb4 100644 (file)
--- a/tests/asynchronous/bug620740.c-expected
+++ b/tests/asynchronous/bug620740.c-expected
@@ -102,6 +102,7 @@ do_foo_async (GAsyncReadyCallback _callback_,
        DoFooAsyncData* _data_;
        _data_ = g_slice_new0 (DoFooAsyncData);
        _data_->_async_result = g_task_new (NULL, NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, do_foo_async);
        g_task_set_task_data (_data_->_async_result, _data_, do_foo_async_data_free);
        do_foo_async_co (_data_);
 }
@@ -111,6 +112,8 @@ do_foo_finish (GAsyncResult* _res_,
                Foo* result)
 {
        DoFooAsyncData* _data_;
+       g_return_if_fail (G_IS_TASK (_res_));
+       g_return_if_fail (g_async_result_is_tagged (_res_, do_foo_async));
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
        *result = _data_->result;
 }

diff --git a/tests/asynchronous/bug626053.c-expected b/tests/asynchronous/bug626053.c-expected
index c0d3478b0c59a677621e784e04ec9af7f4230588..eb3f921e8c471068481e5c6fbaab53e4ba3b750d 100644 (file)
--- a/tests/asynchronous/bug626053.c-expected
+++ b/tests/asynchronous/bug626053.c-expected
@@ -132,6 +132,7 @@ foo_foo (Foo* self,
        g_return_if_fail (IS_FOO (self));
        _data_ = g_slice_new0 (FooFooData);
        _data_->_async_result = g_task_new (NULL, NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, foo_foo);
        g_task_set_task_data (_data_->_async_result, _data_, foo_foo_data_free);
        _tmp0_ = _foo_ref0 (self);
        _data_->self = _tmp0_;
@@ -145,6 +146,8 @@ foo_foo_finish (Foo* self,
 {
        gchar** result;
        FooFooData* _data_;
+       g_return_val_if_fail (G_IS_TASK (_res_), NULL);
+       g_return_val_if_fail (g_async_result_is_tagged (_res_, foo_foo), NULL);
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
        result = _data_->result;
        *result_length1 = _data_->result_length1;

diff --git a/tests/asynchronous/bug639591.c-expected b/tests/asynchronous/bug639591.c-expected
index 4e5333ab2e726322249a614d420d8916b7c116fb..06c65047063eaeb04da4e1d657aee9a7390016ea 100644 (file)
--- a/tests/asynchronous/bug639591.c-expected
+++ b/tests/asynchronous/bug639591.c-expected
@@ -80,6 +80,7 @@ foo (Deleg deleg,
        FooData* _data_;
        _data_ = g_slice_new0 (FooData);
        _data_->_async_result = g_task_new (NULL, NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, foo);
        g_task_set_task_data (_data_->_async_result, _data_, foo_data_free);
        (_data_->deleg_target_destroy_notify == NULL) ? NULL : (_data_->deleg_target_destroy_notify (_data_->deleg_target), NULL);
        _data_->deleg = NULL;
@@ -95,6 +96,8 @@ void
 foo_finish (GAsyncResult* _res_)
 {
        FooData* _data_;
+       g_return_if_fail (G_IS_TASK (_res_));
+       g_return_if_fail (g_async_result_is_tagged (_res_, foo));
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
 }
 

diff --git a/tests/asynchronous/bug640721.c-expected b/tests/asynchronous/bug640721.c-expected
index 2a4d06dd491c7b8fb0519420976f7743ce835f5d..3c07fcc9246d032cf51e2d5575855c53c6ffb002 100644 (file)
--- a/tests/asynchronous/bug640721.c-expected
+++ b/tests/asynchronous/bug640721.c-expected
@@ -71,6 +71,7 @@ foo (GAsyncReadyCallback _callback_,
        FooData* _data_;
        _data_ = g_slice_new0 (FooData);
        _data_->_async_result = g_task_new (NULL, NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, foo);
        g_task_set_task_data (_data_->_async_result, _data_, foo_data_free);
        foo_co (_data_);
 }
@@ -80,6 +81,8 @@ foo_finish (GAsyncResult* _res_,
             gint* i)
 {
        FooData* _data_;
+       g_return_if_fail (G_IS_TASK (_res_));
+       g_return_if_fail (g_async_result_is_tagged (_res_, foo));
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
        if (i) {
                *i = _data_->i;

diff --git a/tests/asynchronous/bug641182.c-expected b/tests/asynchronous/bug641182.c-expected
index 0bcaec2807a3a0072ae4cd494adc116c2e0ba40e..f47d8121b964fbd489d90c3b470c9915cc8f4123 100644 (file)
--- a/tests/asynchronous/bug641182.c-expected
+++ b/tests/asynchronous/bug641182.c-expected
@@ -384,6 +384,7 @@ test (GAsyncReadyCallback _callback_,
        TestData* _data_;
        _data_ = g_slice_new0 (TestData);
        _data_->_async_result = g_task_new (NULL, NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, test);
        g_task_set_task_data (_data_->_async_result, _data_, test_data_free);
        test_co (_data_);
 }
@@ -392,6 +393,8 @@ void
 test_finish (GAsyncResult* _res_)
 {
        TestData* _data_;
+       g_return_if_fail (G_IS_TASK (_res_));
+       g_return_if_fail (g_async_result_is_tagged (_res_, test));
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
 }
 

diff --git a/tests/asynchronous/bug646945.c-expected b/tests/asynchronous/bug646945.c-expected
index bd25eb2ead1d31ff11a8dcd353e0d176443e81e2..324a6c58821100d8a35904f436dc1fb2d651011c 100644 (file)
--- a/tests/asynchronous/bug646945.c-expected
+++ b/tests/asynchronous/bug646945.c-expected
@@ -198,6 +198,7 @@ foo_real_method1 (Foo* self,
        Foo* _tmp0_;
        _data_ = g_slice_new0 (FooMethod1Data);
        _data_->_async_result = g_task_new (G_OBJECT (self), NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, foo_real_method1);
        g_task_set_task_data (_data_->_async_result, _data_, foo_real_method1_data_free);
        _tmp0_ = _g_object_ref0 (self);
        _data_->self = _tmp0_;
@@ -209,6 +210,8 @@ foo_real_method1_finish (Foo* self,
                          GAsyncResult* _res_)
 {
        FooMethod1Data* _data_;
+       g_return_if_fail (g_task_is_valid (_res_, G_OBJECT (self)));
+       g_return_if_fail (g_async_result_is_tagged (_res_, foo_real_method1));
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
 }
 
@@ -323,6 +326,7 @@ bar_real_method2 (Bar* self,
        Bar* _tmp0_;
        _data_ = g_slice_new0 (BarMethod2Data);
        _data_->_async_result = g_task_new (G_OBJECT (self), NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, bar_real_method2);
        g_task_set_task_data (_data_->_async_result, _data_, bar_real_method2_data_free);
        _tmp0_ = _g_object_ref0 (self);
        _data_->self = _tmp0_;
@@ -334,6 +338,8 @@ bar_real_method2_finish (Bar* self,
                          GAsyncResult* _res_)
 {
        BarMethod2Data* _data_;
+       g_return_if_fail (g_task_is_valid (_res_, G_OBJECT (self)));
+       g_return_if_fail (g_async_result_is_tagged (_res_, bar_real_method2));
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
 }
 
@@ -430,6 +436,7 @@ baz_real_method1 (Foo* base,
        self = G_TYPE_CHECK_INSTANCE_CAST (base, TYPE_BAZ, Baz);
        _data_ = g_slice_new0 (BazMethod1Data);
        _data_->_async_result = g_task_new (G_OBJECT (self), NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, baz_real_method1);
        g_task_set_task_data (_data_->_async_result, _data_, baz_real_method1_data_free);
        _tmp0_ = _g_object_ref0 (self);
        _data_->self = _tmp0_;
@@ -441,6 +448,8 @@ baz_method1_finish (Foo* base,
                     GAsyncResult* _res_)
 {
        BazMethod1Data* _data_;
+       g_return_if_fail (g_task_is_valid (_res_, G_OBJECT (base)));
+       g_return_if_fail (g_async_result_is_tagged (_res_, baz_real_method1));
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
 }
 
@@ -485,6 +494,7 @@ baz_real_method2 (Bar* base,
        self = G_TYPE_CHECK_INSTANCE_CAST (base, TYPE_BAZ, Baz);
        _data_ = g_slice_new0 (BazMethod2Data);
        _data_->_async_result = g_task_new (G_OBJECT (self), NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, baz_real_method2);
        g_task_set_task_data (_data_->_async_result, _data_, baz_real_method2_data_free);
        _tmp0_ = _g_object_ref0 (self);
        _data_->self = _tmp0_;
@@ -496,6 +506,8 @@ baz_method2_finish (Bar* base,
                     GAsyncResult* _res_)
 {
        BazMethod2Data* _data_;
+       g_return_if_fail (g_task_is_valid (_res_, G_OBJECT (base)));
+       g_return_if_fail (g_async_result_is_tagged (_res_, baz_real_method2));
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
 }
 

diff --git a/tests/asynchronous/bug652252.c-expected b/tests/asynchronous/bug652252.c-expected
index a8258eb3417d6b3c2a20858e358a0eb284f8d91c..52a4fff3e36a6719c579f225789937eef3b3b945 100644 (file)
--- a/tests/asynchronous/bug652252.c-expected
+++ b/tests/asynchronous/bug652252.c-expected
@@ -135,6 +135,7 @@ foo_real_foo (Foo* self,
        Foo* _tmp0_;
        _data_ = g_slice_new0 (FooFooData);
        _data_->_async_result = g_task_new (G_OBJECT (self), NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, foo_real_foo);
        g_task_set_task_data (_data_->_async_result, _data_, foo_real_foo_data_free);
        _tmp0_ = _g_object_ref0 (self);
        _data_->self = _tmp0_;
@@ -146,6 +147,8 @@ foo_real_foo_finish (Foo* self,
                      GAsyncResult* _res_)
 {
        FooFooData* _data_;
+       g_return_if_fail (g_task_is_valid (_res_, G_OBJECT (self)));
+       g_return_if_fail (g_async_result_is_tagged (_res_, foo_real_foo));
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
 }
 

diff --git a/tests/asynchronous/bug653861.c-expected b/tests/asynchronous/bug653861.c-expected
index 56c14138d247d5fcc8def6e7ecf1e8778c6adbf6..62d2150551983ed6957e01642fd8cc44dd1491fa 100644 (file)
--- a/tests/asynchronous/bug653861.c-expected
+++ b/tests/asynchronous/bug653861.c-expected
@@ -138,6 +138,7 @@ foo_bar (Foo* self,
        g_return_if_fail (IS_FOO (self));
        _data_ = g_slice_new0 (FooBarData);
        _data_->_async_result = g_task_new (NULL, NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, foo_bar);
        g_task_set_task_data (_data_->_async_result, _data_, foo_bar_data_free);
        _tmp0_ = _foo_ref0 (self);
        _data_->self = _tmp0_;
@@ -156,6 +157,8 @@ foo_bar_finish (Foo* self,
                 GAsyncResult* _res_)
 {
        FooBarData* _data_;
+       g_return_if_fail (G_IS_TASK (_res_));
+       g_return_if_fail (g_async_result_is_tagged (_res_, foo_bar));
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
 }
 

diff --git a/tests/asynchronous/bug654336.c-expected b/tests/asynchronous/bug654336.c-expected
index 1863c431095deffe0760d1d63e77a66b78f94e99..a9b6a340525915158cca7121ed74eb23e4c48b92 100644 (file)
--- a/tests/asynchronous/bug654336.c-expected
+++ b/tests/asynchronous/bug654336.c-expected
@@ -79,6 +79,7 @@ foo (GType t_type,
        FooData* _data_;
        _data_ = g_slice_new0 (FooData);
        _data_->_async_result = g_task_new (NULL, NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, foo);
        g_task_set_task_data (_data_->_async_result, _data_, foo_data_free);
        _data_->t_type = t_type;
        _data_->t_dup_func = t_dup_func;
@@ -90,6 +91,8 @@ void
 foo_finish (GAsyncResult* _res_)
 {
        FooData* _data_;
+       g_return_if_fail (G_IS_TASK (_res_));
+       g_return_if_fail (g_async_result_is_tagged (_res_, foo));
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
 }
 
@@ -128,6 +131,7 @@ bar (GAsyncReadyCallback _callback_,
        BarData* _data_;
        _data_ = g_slice_new0 (BarData);
        _data_->_async_result = g_task_new (NULL, NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, bar);
        g_task_set_task_data (_data_->_async_result, _data_, bar_data_free);
        bar_co (_data_);
 }
@@ -136,6 +140,8 @@ void
 bar_finish (GAsyncResult* _res_)
 {
        BarData* _data_;
+       g_return_if_fail (G_IS_TASK (_res_));
+       g_return_if_fail (g_async_result_is_tagged (_res_, bar));
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
 }
 

diff --git a/tests/asynchronous/bug654337.c-expected b/tests/asynchronous/bug654337.c-expected
index 6166142d2582c27471d2814b6b6427861a04f631..6bb741015e414f30b6006a2a13bce4e78ef4475c 100644 (file)
--- a/tests/asynchronous/bug654337.c-expected
+++ b/tests/asynchronous/bug654337.c-expected
@@ -80,6 +80,7 @@ foo (GType t_type,
        FooData* _data_;
        _data_ = g_slice_new0 (FooData);
        _data_->_async_result = g_task_new (NULL, NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, foo);
        g_task_set_task_data (_data_->_async_result, _data_, foo_data_free);
        _data_->t_type = t_type;
        _data_->t_dup_func = t_dup_func;
@@ -91,6 +92,8 @@ void
 foo_finish (GAsyncResult* _res_)
 {
        FooData* _data_;
+       g_return_if_fail (G_IS_TASK (_res_));
+       g_return_if_fail (g_async_result_is_tagged (_res_, foo));
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
 }
 

diff --git a/tests/asynchronous/bug659886.c-expected b/tests/asynchronous/bug659886.c-expected
index e3cb69b7bad317e027af8618c3c67ddd7bab974a..cc80862b65c8950fa2bfbd0766dcd4e53f3684d7 100644 (file)
--- a/tests/asynchronous/bug659886.c-expected
+++ b/tests/asynchronous/bug659886.c-expected
@@ -110,6 +110,7 @@ foo_construct (GType object_type,
        FooNewData* _data_;
        _data_ = g_slice_new0 (FooNewData);
        _data_->_async_result = g_task_new (NULL, NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, foo_construct);
        g_task_set_task_data (_data_->_async_result, _data_, foo_construct_data_free);
        _data_->object_type = object_type;
        foo_construct_co (_data_);
@@ -120,6 +121,8 @@ foo_construct_finish (GAsyncResult* _res_)
 {
        Foo* result;
        FooNewData* _data_;
+       g_return_val_if_fail (G_IS_TASK (_res_), NULL);
+       g_return_val_if_fail (g_async_result_is_tagged (_res_, foo_construct), NULL);
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
        result = _data_->self;
        _data_->self = NULL;
@@ -209,6 +212,7 @@ bar (GAsyncReadyCallback _callback_,
        BarData* _data_;
        _data_ = g_slice_new0 (BarData);
        _data_->_async_result = g_task_new (NULL, NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, bar);
        g_task_set_task_data (_data_->_async_result, _data_, bar_data_free);
        bar_co (_data_);
 }
@@ -217,6 +221,8 @@ void
 bar_finish (GAsyncResult* _res_)
 {
        BarData* _data_;
+       g_return_if_fail (G_IS_TASK (_res_));
+       g_return_if_fail (g_async_result_is_tagged (_res_, bar));
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
 }
 

diff --git a/tests/asynchronous/bug661961.c-expected b/tests/asynchronous/bug661961.c-expected
index 6baecf2ab377713b00cce9972dcfe6afe22eac42..7bc37b9bc018e575c3438fc35a637a6f5b0eeba7 100644 (file)
--- a/tests/asynchronous/bug661961.c-expected
+++ b/tests/asynchronous/bug661961.c-expected
@@ -93,6 +93,7 @@ foo (GType t_type,
        gpointer _tmp0_;
        _data_ = g_slice_new0 (FooData);
        _data_->_async_result = g_task_new (NULL, NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, foo);
        g_task_set_task_data (_data_->_async_result, _data_, foo_data_free);
        _tmp0_ = ((bar != NULL) && (t_dup_func != NULL)) ? t_dup_func ((gpointer) bar) : ((gpointer) bar);
        ((_data_->bar == NULL) || (_data_->t_destroy_func == NULL)) ? NULL : (_data_->bar = (_data_->t_destroy_func (_data_->bar), NULL));
@@ -108,6 +109,8 @@ foo_finish (GAsyncResult* _res_)
 {
        gpointer result;
        FooData* _data_;
+       g_return_val_if_fail (G_IS_TASK (_res_), NULL);
+       g_return_val_if_fail (g_async_result_is_tagged (_res_, foo), NULL);
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
        result = _data_->result;
        _data_->result = NULL;

diff --git a/tests/asynchronous/bug710103.c-expected b/tests/asynchronous/bug710103.c-expected
index e0eecf9b3a58491f81f56d9e8cf398a20552902f..37173ca42995447e7566d1e675bea04bedc763f8 100644 (file)
--- a/tests/asynchronous/bug710103.c-expected
+++ b/tests/asynchronous/bug710103.c-expected
@@ -257,6 +257,7 @@ foo_bar (Foo* self,
        g_return_if_fail (IS_FOO (self));
        _data_ = g_slice_new0 (FooBarData);
        _data_->_async_result = g_task_new (G_OBJECT (self), NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, foo_bar);
        g_task_set_task_data (_data_->_async_result, _data_, foo_bar_data_free);
        _tmp0_ = _g_object_ref0 (self);
        _data_->self = _tmp0_;
@@ -267,6 +268,8 @@ void
 foo_bar_finish (GAsyncResult* _res_)
 {
        FooBarData* _data_;
+       g_return_if_fail (G_IS_TASK (_res_));
+       g_return_if_fail (g_async_result_is_tagged (_res_, foo_bar));
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
 }
 
@@ -308,6 +311,7 @@ foo_construct_async (GType object_type,
        FooNewAsyncData* _data_;
        _data_ = g_slice_new0 (FooNewAsyncData);
        _data_->_async_result = g_task_new (NULL, NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, foo_construct_async);
        g_task_set_task_data (_data_->_async_result, _data_, foo_construct_async_data_free);
        _data_->object_type = object_type;
        foo_construct_async_co (_data_);
@@ -318,6 +322,8 @@ foo_construct_finish (GAsyncResult* _res_)
 {
        Foo* result;
        FooNewAsyncData* _data_;
+       g_return_val_if_fail (G_IS_TASK (_res_), NULL);
+       g_return_val_if_fail (g_async_result_is_tagged (_res_, foo_construct_async), NULL);
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
        result = _data_->self;
        _data_->self = NULL;
@@ -375,6 +381,7 @@ foo_create_foo_async (GAsyncReadyCallback _callback_,
        FooCreateFooAsyncData* _data_;
        _data_ = g_slice_new0 (FooCreateFooAsyncData);
        _data_->_async_result = g_task_new (NULL, NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, foo_create_foo_async);
        g_task_set_task_data (_data_->_async_result, _data_, foo_create_foo_async_data_free);
        foo_create_foo_async_co (_data_);
 }
@@ -384,6 +391,8 @@ foo_create_foo_finish (GAsyncResult* _res_)
 {
        Foo* result;
        FooCreateFooAsyncData* _data_;
+       g_return_val_if_fail (G_IS_TASK (_res_), NULL);
+       g_return_val_if_fail (g_async_result_is_tagged (_res_, foo_create_foo_async), NULL);
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
        result = _data_->result;
        _data_->result = NULL;

diff --git a/tests/asynchronous/bug741929.c-expected b/tests/asynchronous/bug741929.c-expected
index e76e3563bdd5969fbe4645f2bba896f0ce31cec3..870230e75c15def2380a18608e47a90850a41741 100644 (file)
--- a/tests/asynchronous/bug741929.c-expected
+++ b/tests/asynchronous/bug741929.c-expected
@@ -190,6 +190,7 @@ foo_query_async (Foo* self,
        g_return_if_fail (IS_FOO (self));
        _data_ = g_slice_new0 (FooQueryAsyncData);
        _data_->_async_result = g_task_new (G_OBJECT (self), NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, foo_query_async);
        g_task_set_task_data (_data_->_async_result, _data_, foo_query_async_data_free);
        _tmp0_ = _g_object_ref0 (self);
        _data_->self = _tmp0_;
@@ -202,6 +203,8 @@ foo_query_finish (Foo* self,
                   GError** error)
 {
        FooQueryAsyncData* _data_;
+       g_return_if_fail (g_task_is_valid (_res_, G_OBJECT (self)));
+       g_return_if_fail (g_async_result_is_tagged (_res_, foo_query_async));
        _data_ = g_task_propagate_pointer (G_TASK (_res_), error);
        if (NULL == _data_) {
                return;
@@ -337,6 +340,7 @@ foo_internal_query_async (Foo* self,
        g_return_if_fail (IS_FOO (self));
        _data_ = g_slice_new0 (FooInternalQueryAsyncData);
        _data_->_async_result = g_task_new (G_OBJECT (self), NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, foo_internal_query_async);
        g_task_set_task_data (_data_->_async_result, _data_, foo_internal_query_async_data_free);
        _tmp0_ = _g_object_ref0 (self);
        _data_->self = _tmp0_;
@@ -350,6 +354,8 @@ foo_internal_query_finish (Foo* self,
 {
        gboolean result;
        FooInternalQueryAsyncData* _data_;
+       g_return_val_if_fail (g_task_is_valid (_res_, G_OBJECT (self)), FALSE);
+       g_return_val_if_fail (g_async_result_is_tagged (_res_, foo_internal_query_async), FALSE);
        _data_ = g_task_propagate_pointer (G_TASK (_res_), error);
        if (NULL == _data_) {
                gboolean _tmp0_ = FALSE;
@@ -399,6 +405,7 @@ foo_close_query_async (Foo* self,
        g_return_if_fail (IS_FOO (self));
        _data_ = g_slice_new0 (FooCloseQueryAsyncData);
        _data_->_async_result = g_task_new (G_OBJECT (self), NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, foo_close_query_async);
        g_task_set_task_data (_data_->_async_result, _data_, foo_close_query_async_data_free);
        _tmp0_ = _g_object_ref0 (self);
        _data_->self = _tmp0_;
@@ -411,6 +418,8 @@ foo_close_query_finish (Foo* self,
                         GError** error)
 {
        FooCloseQueryAsyncData* _data_;
+       g_return_if_fail (g_task_is_valid (_res_, G_OBJECT (self)));
+       g_return_if_fail (g_async_result_is_tagged (_res_, foo_close_query_async));
        _data_ = g_task_propagate_pointer (G_TASK (_res_), error);
        if (NULL == _data_) {
                return;
@@ -499,6 +508,7 @@ go_async (GAsyncReadyCallback _callback_,
        GoAsyncData* _data_;
        _data_ = g_slice_new0 (GoAsyncData);
        _data_->_async_result = g_task_new (NULL, NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, go_async);
        g_task_set_task_data (_data_->_async_result, _data_, go_async_data_free);
        go_async_co (_data_);
 }
@@ -507,6 +517,8 @@ void
 go_finish (GAsyncResult* _res_)
 {
        GoAsyncData* _data_;
+       g_return_if_fail (G_IS_TASK (_res_));
+       g_return_if_fail (g_async_result_is_tagged (_res_, go_async));
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
 }
 

diff --git a/tests/asynchronous/bug742621.c-expected b/tests/asynchronous/bug742621.c-expected
index d39f27052a2a532c923e2ac8c4ff148d801bfac4..bc890cd13f9d2ec8bd966ad9c8944934860e1e33 100644 (file)
--- a/tests/asynchronous/bug742621.c-expected
+++ b/tests/asynchronous/bug742621.c-expected
@@ -245,6 +245,7 @@ go_async (GAsyncReadyCallback _callback_,
        GoAsyncData* _data_;
        _data_ = g_slice_new0 (GoAsyncData);
        _data_->_async_result = g_task_new (NULL, NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, go_async);
        g_task_set_task_data (_data_->_async_result, _data_, go_async_data_free);
        go_async_co (_data_);
 }
@@ -254,6 +255,8 @@ go_finish (GAsyncResult* _res_,
            GError** error)
 {
        GoAsyncData* _data_;
+       g_return_if_fail (G_IS_TASK (_res_));
+       g_return_if_fail (g_async_result_is_tagged (_res_, go_async));
        _data_ = g_task_propagate_pointer (G_TASK (_res_), error);
        if (NULL == _data_) {
                return;

diff --git a/tests/asynchronous/bug762819.c-expected b/tests/asynchronous/bug762819.c-expected
index d2a218cd1db23846559d7f40ca1fabcff909e8e9..5e97d5931edfe2f3e68ea1594dfec2f2cda7add0 100644 (file)
--- a/tests/asynchronous/bug762819.c-expected
+++ b/tests/asynchronous/bug762819.c-expected
@@ -235,6 +235,7 @@ foo_real_get_string_async (Bar* base,
        self = G_TYPE_CHECK_INSTANCE_CAST (base, TYPE_FOO, Foo);
        _data_ = g_slice_new0 (FooGetStringAsyncData);
        _data_->_async_result = g_task_new (G_OBJECT (self), NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, foo_real_get_string_async);
        g_task_set_task_data (_data_->_async_result, _data_, foo_real_get_string_async_data_free);
        _tmp0_ = _g_object_ref0 (self);
        _data_->self = _tmp0_;
@@ -247,6 +248,8 @@ foo_get_string_finish (Bar* base,
 {
        gchar** result;
        FooGetStringAsyncData* _data_;
+       g_return_val_if_fail (g_task_is_valid (_res_, G_OBJECT (base)), NULL);
+       g_return_val_if_fail (g_async_result_is_tagged (_res_, foo_real_get_string_async), NULL);
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
        result = _data_->result;
        _data_->result = NULL;

diff --git a/tests/asynchronous/bug777242.c-expected b/tests/asynchronous/bug777242.c-expected
index 53d01a201e9a04af12d4ff2cd6ba98121bfbea35..2dc2179458be2910efd9e7d1e4f5b6008b9def58 100644 (file)
--- a/tests/asynchronous/bug777242.c-expected
+++ b/tests/asynchronous/bug777242.c-expected
@@ -73,6 +73,7 @@ run (GAsyncReadyCallback _callback_,
        RunData* _data_;
        _data_ = g_slice_new0 (RunData);
        _data_->_async_result = g_task_new (NULL, NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, run);
        g_task_set_task_data (_data_->_async_result, _data_, run_data_free);
        run_co (_data_);
 }
@@ -81,6 +82,8 @@ void
 run_finish (GAsyncResult* _res_)
 {
        RunData* _data_;
+       g_return_if_fail (G_IS_TASK (_res_));
+       g_return_if_fail (g_async_result_is_tagged (_res_, run));
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
 }
 

diff --git a/tests/asynchronous/bug783543.c-expected b/tests/asynchronous/bug783543.c-expected
index 5269a3e1a9b9b98edb77374c4900f78ad33175ca..e105eac493655341af61ee795d226794d7039236 100644 (file)
--- a/tests/asynchronous/bug783543.c-expected
+++ b/tests/asynchronous/bug783543.c-expected
@@ -113,6 +113,7 @@ foo_bar (Foo* self,
        g_return_if_fail (IS_FOO (self));
        _data_ = g_slice_new0 (FooBarData);
        _data_->_async_result = g_task_new (G_OBJECT (self), NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, foo_bar);
        g_task_set_task_data (_data_->_async_result, _data_, foo_bar_data_free);
        _tmp0_ = _g_object_ref0 (self);
        _data_->self = _tmp0_;
@@ -124,6 +125,8 @@ foo_bar_finish (Foo* self,
                 GAsyncResult* _res_)
 {
        FooBarData* _data_;
+       g_return_if_fail (g_task_is_valid (_res_, G_OBJECT (self)));
+       g_return_if_fail (g_async_result_is_tagged (_res_, foo_bar));
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
 }
 

diff --git a/tests/asynchronous/bug792660.c-expected b/tests/asynchronous/bug792660.c-expected
index 2bb990b2f2d553870c5df35590d89cbe9d697238..ec34c9cc3b0b64b91d34edb0f7503920475f1879 100644 (file)
--- a/tests/asynchronous/bug792660.c-expected
+++ b/tests/asynchronous/bug792660.c-expected
@@ -398,6 +398,7 @@ bar_real_foo (Foo* base,
        self = G_TYPE_CHECK_INSTANCE_CAST (base, TYPE_BAR, Bar);
        _data_ = g_slice_new0 (BarFooData);
        _data_->_async_result = g_task_new (NULL, NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, bar_real_foo);
        g_task_set_task_data (_data_->_async_result, _data_, bar_real_foo_data_free);
        _tmp0_ = _foo_ref0 (self);
        _data_->self = _tmp0_;
@@ -411,6 +412,8 @@ bar_foo_finish (Foo* base,
                 GAsyncResult* _res_)
 {
        BarFooData* _data_;
+       g_return_if_fail (G_IS_TASK (_res_));
+       g_return_if_fail (g_async_result_is_tagged (_res_, bar_real_foo));
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
 }
 

diff --git a/tests/asynchronous/bug792942.c-expected b/tests/asynchronous/bug792942.c-expected
index e75ac39e10096768477ad9edd43d43770b4bacab..a6f42d270e39155940347641137ed1db6cf16ac7 100644 (file)
--- a/tests/asynchronous/bug792942.c-expected
+++ b/tests/asynchronous/bug792942.c-expected
@@ -129,6 +129,7 @@ foo_construct (GType object_type,
        FooNewData* _data_;
        _data_ = g_slice_new0 (FooNewData);
        _data_->_async_result = g_task_new (NULL, NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, foo_construct);
        g_task_set_task_data (_data_->_async_result, _data_, foo_construct_data_free);
        _data_->object_type = object_type;
        foo_construct_co (_data_);
@@ -140,6 +141,8 @@ foo_construct_finish (GAsyncResult* _res_,
 {
        Foo* result;
        FooNewData* _data_;
+       g_return_val_if_fail (G_IS_TASK (_res_), NULL);
+       g_return_val_if_fail (g_async_result_is_tagged (_res_, foo_construct), NULL);
        _data_ = g_task_propagate_pointer (G_TASK (_res_), error);
        if (NULL == _data_) {
                return NULL;
@@ -399,6 +402,7 @@ run (GAsyncReadyCallback _callback_,
        RunData* _data_;
        _data_ = g_slice_new0 (RunData);
        _data_->_async_result = g_task_new (NULL, NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, run);
        g_task_set_task_data (_data_->_async_result, _data_, run_data_free);
        run_co (_data_);
 }
@@ -407,6 +411,8 @@ void
 run_finish (GAsyncResult* _res_)
 {
        RunData* _data_;
+       g_return_if_fail (G_IS_TASK (_res_));
+       g_return_if_fail (g_async_result_is_tagged (_res_, run));
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
 }
 

diff --git a/tests/asynchronous/bug793158.c-expected b/tests/asynchronous/bug793158.c-expected
index 5c96743a652753c20b3f0df17b4d8ccb8caa95db..6d846f7f5d42327786606871212e6190beb9fc40 100644 (file)
--- a/tests/asynchronous/bug793158.c-expected
+++ b/tests/asynchronous/bug793158.c-expected
@@ -145,6 +145,7 @@ foo_bar (Foo* self,
        g_return_if_fail (IS_FOO (self));
        _data_ = g_slice_new0 (FooBarData);
        _data_->_async_result = g_task_new (G_OBJECT (self), NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, foo_bar);
        g_task_set_task_data (_data_->_async_result, _data_, foo_bar_data_free);
        _tmp0_ = _g_object_ref0 (self);
        _data_->self = _tmp0_;
@@ -158,6 +159,8 @@ foo_bar_finish (Foo* self,
 {
        gboolean result;
        FooBarData* _data_;
+       g_return_val_if_fail (g_task_is_valid (_res_, G_OBJECT (self)), FALSE);
+       g_return_val_if_fail (g_async_result_is_tagged (_res_, foo_bar), FALSE);
        _data_ = g_task_propagate_pointer (G_TASK (_res_), error);
        if (NULL == _data_) {
                gboolean _tmp0_ = FALSE;

diff --git a/tests/asynchronous/captured-fixed-array.c-expected b/tests/asynchronous/captured-fixed-array.c-expected
index 823e7f4ae7fbe3f67bb56d8c1ecadf427f2bcc99..af84775403ed07e5c1bb79316bbe1f78e1ea0a9f 100644 (file)
--- a/tests/asynchronous/captured-fixed-array.c-expected
+++ b/tests/asynchronous/captured-fixed-array.c-expected
@@ -65,6 +65,7 @@ foo (gint array_param[3],
        FooData* _data_;
        _data_ = g_slice_new0 (FooData);
        _data_->_async_result = g_task_new (NULL, NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, foo);
        g_task_set_task_data (_data_->_async_result, _data_, foo_data_free);
        memcpy (_data_->array_param, array_param, 3 * sizeof (gint));
        foo_co (_data_);
@@ -74,6 +75,8 @@ void
 foo_finish (GAsyncResult* _res_)
 {
        FooData* _data_;
+       g_return_if_fail (G_IS_TASK (_res_));
+       g_return_if_fail (g_async_result_is_tagged (_res_, foo));
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
 }
 

diff --git a/tests/asynchronous/catch-error-scope.c-expected b/tests/asynchronous/catch-error-scope.c-expected
index bac16eb695f82452f00a5832192fd29c0a458063..6b36759c8a5cc0e09c29d3d3ad2ee805ed698212 100644 (file)
--- a/tests/asynchronous/catch-error-scope.c-expected
+++ b/tests/asynchronous/catch-error-scope.c-expected
@@ -118,6 +118,7 @@ foo (GAsyncReadyCallback _callback_,
        FooData* _data_;
        _data_ = g_slice_new0 (FooData);
        _data_->_async_result = g_task_new (NULL, NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, foo);
        g_task_set_task_data (_data_->_async_result, _data_, foo_data_free);
        foo_co (_data_);
 }
@@ -126,6 +127,8 @@ void
 foo_finish (GAsyncResult* _res_)
 {
        FooData* _data_;
+       g_return_if_fail (G_IS_TASK (_res_));
+       g_return_if_fail (g_async_result_is_tagged (_res_, foo));
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
 }
 

diff --git a/tests/asynchronous/catch-in-finally.c-expected b/tests/asynchronous/catch-in-finally.c-expected
index e90dbd98226a28787f0b983eef9fe7a469fb1b75..f9782e8d6430c824c506169fc807a1d9647e3296 100644 (file)
--- a/tests/asynchronous/catch-in-finally.c-expected
+++ b/tests/asynchronous/catch-in-finally.c-expected
@@ -178,6 +178,7 @@ fail (GAsyncReadyCallback _callback_,
        FailData* _data_;
        _data_ = g_slice_new0 (FailData);
        _data_->_async_result = g_task_new (NULL, NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, fail);
        g_task_set_task_data (_data_->_async_result, _data_, fail_data_free);
        fail_co (_data_);
 }
@@ -187,6 +188,8 @@ fail_finish (GAsyncResult* _res_,
              GError** error)
 {
        FailData* _data_;
+       g_return_if_fail (G_IS_TASK (_res_));
+       g_return_if_fail (g_async_result_is_tagged (_res_, fail));
        _data_ = g_task_propagate_pointer (G_TASK (_res_), error);
        if (NULL == _data_) {
                return;
@@ -240,6 +243,7 @@ may_fail (GAsyncReadyCallback _callback_,
        MayFailData* _data_;
        _data_ = g_slice_new0 (MayFailData);
        _data_->_async_result = g_task_new (NULL, NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, may_fail);
        g_task_set_task_data (_data_->_async_result, _data_, may_fail_data_free);
        may_fail_co (_data_);
 }
@@ -249,6 +253,8 @@ may_fail_finish (GAsyncResult* _res_,
                  GError** error)
 {
        MayFailData* _data_;
+       g_return_if_fail (G_IS_TASK (_res_));
+       g_return_if_fail (g_async_result_is_tagged (_res_, may_fail));
        _data_ = g_task_propagate_pointer (G_TASK (_res_), error);
        if (NULL == _data_) {
                return;
@@ -290,6 +296,7 @@ foo (GAsyncReadyCallback _callback_,
        FooData* _data_;
        _data_ = g_slice_new0 (FooData);
        _data_->_async_result = g_task_new (NULL, NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, foo);
        g_task_set_task_data (_data_->_async_result, _data_, foo_data_free);
        foo_co (_data_);
 }
@@ -299,6 +306,8 @@ foo_finish (GAsyncResult* _res_,
             GError** error)
 {
        FooData* _data_;
+       g_return_if_fail (G_IS_TASK (_res_));
+       g_return_if_fail (g_async_result_is_tagged (_res_, foo));
        _data_ = g_task_propagate_pointer (G_TASK (_res_), error);
        if (NULL == _data_) {
                return;
@@ -413,6 +422,7 @@ bar (GAsyncReadyCallback _callback_,
        BarData* _data_;
        _data_ = g_slice_new0 (BarData);
        _data_->_async_result = g_task_new (NULL, NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, bar);
        g_task_set_task_data (_data_->_async_result, _data_, bar_data_free);
        bar_co (_data_);
 }
@@ -422,6 +432,8 @@ bar_finish (GAsyncResult* _res_,
             GError** error)
 {
        BarData* _data_;
+       g_return_if_fail (G_IS_TASK (_res_));
+       g_return_if_fail (g_async_result_is_tagged (_res_, bar));
        _data_ = g_task_propagate_pointer (G_TASK (_res_), error);
        if (NULL == _data_) {
                return;
@@ -595,6 +607,7 @@ run (GAsyncReadyCallback _callback_,
        RunData* _data_;
        _data_ = g_slice_new0 (RunData);
        _data_->_async_result = g_task_new (NULL, NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, run);
        g_task_set_task_data (_data_->_async_result, _data_, run_data_free);
        run_co (_data_);
 }
@@ -603,6 +616,8 @@ void
 run_finish (GAsyncResult* _res_)
 {
        RunData* _data_;
+       g_return_if_fail (G_IS_TASK (_res_));
+       g_return_if_fail (g_async_result_is_tagged (_res_, run));
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
 }
 

diff --git a/tests/asynchronous/closures.c-expected b/tests/asynchronous/closures.c-expected
index b265de24faf61f65bc54e8f9f1f82df421c9d074..7969dd6ec151da4d4ac3af0aced996de93403ec7 100644 (file)
--- a/tests/asynchronous/closures.c-expected
+++ b/tests/asynchronous/closures.c-expected
@@ -91,6 +91,7 @@ foo (const gchar* baz,
        g_return_if_fail (baz != NULL);
        _data_ = g_slice_new0 (FooData);
        _data_->_async_result = g_task_new (NULL, NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, foo);
        g_task_set_task_data (_data_->_async_result, _data_, foo_data_free);
        _tmp0_ = g_strdup (baz);
        _g_free0 (_data_->baz);
@@ -102,6 +103,8 @@ void
 foo_finish (GAsyncResult* _res_)
 {
        FooData* _data_;
+       g_return_if_fail (G_IS_TASK (_res_));
+       g_return_if_fail (g_async_result_is_tagged (_res_, foo));
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
 }
 

diff --git a/tests/asynchronous/constructor-argument-check.c-expected b/tests/asynchronous/constructor-argument-check.c-expected
index af1f0a0443e66721a09c88e180aa858f65925bde..b9c808e65413008d16d73b559f82a617e895d86f 100644 (file)
--- a/tests/asynchronous/constructor-argument-check.c-expected
+++ b/tests/asynchronous/constructor-argument-check.c-expected
@@ -140,6 +140,7 @@ foo_construct (GType object_type,
        g_return_if_fail (bar != NULL);
        _data_ = g_slice_new0 (FooNewData);
        _data_->_async_result = g_task_new (NULL, NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, foo_construct);
        g_task_set_task_data (_data_->_async_result, _data_, foo_construct_data_free);
        _data_->object_type = object_type;
        _tmp0_ = g_strdup (bar);
@@ -153,6 +154,8 @@ foo_construct_finish (GAsyncResult* _res_)
 {
        Foo* result;
        FooNewData* _data_;
+       g_return_val_if_fail (G_IS_TASK (_res_), NULL);
+       g_return_val_if_fail (g_async_result_is_tagged (_res_, foo_construct), NULL);
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
        result = _data_->self;
        _data_->self = NULL;
@@ -410,6 +413,7 @@ run (GAsyncReadyCallback _callback_,
        RunData* _data_;
        _data_ = g_slice_new0 (RunData);
        _data_->_async_result = g_task_new (NULL, NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, run);
        g_task_set_task_data (_data_->_async_result, _data_, run_data_free);
        run_co (_data_);
 }
@@ -418,6 +422,8 @@ void
 run_finish (GAsyncResult* _res_)
 {
        RunData* _data_;
+       g_return_if_fail (G_IS_TASK (_res_));
+       g_return_if_fail (g_async_result_is_tagged (_res_, run));
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
 }
 

diff --git a/tests/asynchronous/creation-method-uncaught.c-expected b/tests/asynchronous/creation-method-uncaught.c-expected
index f484c027a0d0847e3dbdbb3bee0dcbb99c5013f5..7d6512a67fcc4043c05eedb60aca6ada0f39262a 100644 (file)
--- a/tests/asynchronous/creation-method-uncaught.c-expected
+++ b/tests/asynchronous/creation-method-uncaught.c-expected
@@ -153,6 +153,7 @@ foo_construct (GType object_type,
        FooNewData* _data_;
        _data_ = g_slice_new0 (FooNewData);
        _data_->_async_result = g_task_new (NULL, NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, foo_construct);
        g_task_set_task_data (_data_->_async_result, _data_, foo_construct_data_free);
        _data_->object_type = object_type;
        foo_construct_co (_data_);
@@ -164,6 +165,8 @@ foo_construct_finish (GAsyncResult* _res_,
 {
        Foo* result;
        FooNewData* _data_;
+       g_return_val_if_fail (G_IS_TASK (_res_), NULL);
+       g_return_val_if_fail (g_async_result_is_tagged (_res_, foo_construct), NULL);
        _data_ = g_task_propagate_pointer (G_TASK (_res_), error);
        if (NULL == _data_) {
                return NULL;

diff --git a/tests/asynchronous/finish-name.c-expected b/tests/asynchronous/finish-name.c-expected
index aa24f04fe5242067016fa64566ed8d061a2dfe6e..cbb80a31fbf870225664cd81bcc9eaf917af58bc 100644 (file)
--- a/tests/asynchronous/finish-name.c-expected
+++ b/tests/asynchronous/finish-name.c-expected
@@ -250,6 +250,7 @@ foo_construct_async (GType object_type,
        FooNewAsyncData* _data_;
        _data_ = g_slice_new0 (FooNewAsyncData);
        _data_->_async_result = g_task_new (NULL, NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, foo_construct_async);
        g_task_set_task_data (_data_->_async_result, _data_, foo_construct_async_data_free);
        _data_->object_type = object_type;
        foo_construct_async_co (_data_);
@@ -260,6 +261,8 @@ foo_construct_finish (GAsyncResult* _res_)
 {
        Foo* result;
        FooNewAsyncData* _data_;
+       g_return_val_if_fail (G_IS_TASK (_res_), NULL);
+       g_return_val_if_fail (g_async_result_is_tagged (_res_, foo_construct_async), NULL);
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
        result = _data_->self;
        _data_->self = NULL;
@@ -327,6 +330,7 @@ foo_bar (Foo* self,
        g_return_if_fail (IS_FOO (self));
        _data_ = g_slice_new0 (FooBarData);
        _data_->_async_result = g_task_new (NULL, NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, foo_bar);
        g_task_set_task_data (_data_->_async_result, _data_, foo_bar_data_free);
        _tmp0_ = _foo_ref0 (self);
        _data_->self = _tmp0_;
@@ -339,6 +343,8 @@ foo_bar_end (Foo* self,
 {
        gchar* result;
        FooBarData* _data_;
+       g_return_val_if_fail (G_IS_TASK (_res_), NULL);
+       g_return_val_if_fail (g_async_result_is_tagged (_res_, foo_bar), NULL);
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
        result = _data_->result;
        _data_->result = NULL;
@@ -386,6 +392,7 @@ foo_real_baz (Foo* self,
        Foo* _tmp0_;
        _data_ = g_slice_new0 (FooBazData);
        _data_->_async_result = g_task_new (NULL, NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, foo_real_baz);
        g_task_set_task_data (_data_->_async_result, _data_, foo_real_baz_data_free);
        _tmp0_ = _foo_ref0 (self);
        _data_->self = _tmp0_;
@@ -398,6 +405,8 @@ foo_real_baz_finish (Foo* self,
 {
        gchar* result;
        FooBazData* _data_;
+       g_return_val_if_fail (G_IS_TASK (_res_), NULL);
+       g_return_val_if_fail (g_async_result_is_tagged (_res_, foo_real_baz), NULL);
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
        result = _data_->result;
        _data_->result = NULL;
@@ -686,6 +695,7 @@ bar_real_baz (Foo* base,
        self = G_TYPE_CHECK_INSTANCE_CAST (base, TYPE_BAR, Bar);
        _data_ = g_slice_new0 (BarBazData);
        _data_->_async_result = g_task_new (NULL, NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, bar_real_baz);
        g_task_set_task_data (_data_->_async_result, _data_, bar_real_baz_data_free);
        _tmp0_ = _foo_ref0 (self);
        _data_->self = _tmp0_;
@@ -698,6 +708,8 @@ bar_baz_end (Foo* base,
 {
        gchar* result;
        BarBazData* _data_;
+       g_return_val_if_fail (G_IS_TASK (_res_), NULL);
+       g_return_val_if_fail (g_async_result_is_tagged (_res_, bar_real_baz), NULL);
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
        result = _data_->result;
        _data_->result = NULL;
@@ -792,6 +804,7 @@ manam (GAsyncReadyCallback _callback_,
        ManamData* _data_;
        _data_ = g_slice_new0 (ManamData);
        _data_->_async_result = g_task_new (NULL, NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, manam);
        g_task_set_task_data (_data_->_async_result, _data_, manam_data_free);
        manam_co (_data_);
 }
@@ -801,6 +814,8 @@ manam_end (GAsyncResult* _res_)
 {
        gchar* result;
        ManamData* _data_;
+       g_return_val_if_fail (G_IS_TASK (_res_), NULL);
+       g_return_val_if_fail (g_async_result_is_tagged (_res_, manam), NULL);
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
        result = _data_->result;
        _data_->result = NULL;

diff --git a/tests/asynchronous/generator.c-expected b/tests/asynchronous/generator.c-expected
index 4329360f9cf02f6c3e937730fea4884d54e8adb1..d73cd57487477ce232eb0b761b4b12dc23041968 100644 (file)
--- a/tests/asynchronous/generator.c-expected
+++ b/tests/asynchronous/generator.c-expected
@@ -239,6 +239,7 @@ generator_helper (Generator* self,
        g_return_if_fail (IS_GENERATOR (self));
        _data_ = g_slice_new0 (GeneratorHelperData);
        _data_->_async_result = g_task_new (NULL, NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, generator_helper);
        g_task_set_task_data (_data_->_async_result, _data_, generator_helper_data_free);
        _tmp0_ = _generator_ref0 (self);
        _data_->self = _tmp0_;
@@ -250,6 +251,8 @@ generator_helper_finish (Generator* self,
                          GAsyncResult* _res_)
 {
        GeneratorHelperData* _data_;
+       g_return_if_fail (G_IS_TASK (_res_));
+       g_return_if_fail (g_async_result_is_tagged (_res_, generator_helper));
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
 }
 
@@ -338,6 +341,7 @@ generator_feed (Generator* self,
        g_return_if_fail (IS_GENERATOR (self));
        _data_ = g_slice_new0 (GeneratorFeedData);
        _data_->_async_result = g_task_new (NULL, NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, generator_feed);
        g_task_set_task_data (_data_->_async_result, _data_, generator_feed_data_free);
        _tmp0_ = _generator_ref0 (self);
        _data_->self = _tmp0_;
@@ -352,6 +356,8 @@ generator_feed_finish (Generator* self,
                        GAsyncResult* _res_)
 {
        GeneratorFeedData* _data_;
+       g_return_if_fail (G_IS_TASK (_res_));
+       g_return_if_fail (g_async_result_is_tagged (_res_, generator_feed));
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
 }
 
@@ -663,6 +669,7 @@ int_generator_real_generate (Generator* base,
        self = G_TYPE_CHECK_INSTANCE_CAST (base, TYPE_INT_GENERATOR, IntGenerator);
        _data_ = g_slice_new0 (IntGeneratorGenerateData);
        _data_->_async_result = g_task_new (NULL, NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, int_generator_real_generate);
        g_task_set_task_data (_data_->_async_result, _data_, int_generator_real_generate_data_free);
        _tmp0_ = _generator_ref0 (self);
        _data_->self = _tmp0_;
@@ -674,6 +681,8 @@ int_generator_generate_finish (Generator* base,
                                GAsyncResult* _res_)
 {
        IntGeneratorGenerateData* _data_;
+       g_return_if_fail (G_IS_TASK (_res_));
+       g_return_if_fail (g_async_result_is_tagged (_res_, int_generator_real_generate));
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
 }
 

diff --git a/tests/asynchronous/main-block-async-call.c-expected b/tests/asynchronous/main-block-async-call.c-expected
index af2a5cd03d125433cb5a2d73cda30004a87d51ac..e106e01d9226c4efdf29ade2bd0d8c33043eeac7 100644 (file)
--- a/tests/asynchronous/main-block-async-call.c-expected
+++ b/tests/asynchronous/main-block-async-call.c-expected
@@ -81,6 +81,7 @@ foo (GAsyncReadyCallback _callback_,
        FooData* _data_;
        _data_ = g_slice_new0 (FooData);
        _data_->_async_result = g_task_new (NULL, NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, foo);
        g_task_set_task_data (_data_->_async_result, _data_, foo_data_free);
        foo_co (_data_);
 }
@@ -90,6 +91,8 @@ foo_finish (GAsyncResult* _res_)
 {
        gchar* result;
        FooData* _data_;
+       g_return_val_if_fail (G_IS_TASK (_res_), NULL);
+       g_return_val_if_fail (g_async_result_is_tagged (_res_, foo), NULL);
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
        result = _data_->result;
        _data_->result = NULL;
@@ -148,6 +151,7 @@ _vala_main_async (GAsyncReadyCallback _callback_,
        ValaMainAsyncData* _data_;
        _data_ = g_slice_new0 (ValaMainAsyncData);
        _data_->_async_result = g_task_new (NULL, NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, _vala_main_async);
        g_task_set_task_data (_data_->_async_result, _data_, _vala_main_async_data_free);
        _vala_main_async_co (_data_);
 }
@@ -156,6 +160,8 @@ void
 _vala_main_finish (GAsyncResult* _res_)
 {
        ValaMainAsyncData* _data_;
+       g_return_if_fail (G_IS_TASK (_res_));
+       g_return_if_fail (g_async_result_is_tagged (_res_, _vala_main_async));
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
 }
 

diff --git a/tests/asynchronous/main-block-async-creation.c-expected b/tests/asynchronous/main-block-async-creation.c-expected
index 83fa5433500b24654c3a7991a5e5700f4b86f546..f5349150e1fe98eb1de05f431f545bdb32a11bf9 100644 (file)
--- a/tests/asynchronous/main-block-async-creation.c-expected
+++ b/tests/asynchronous/main-block-async-creation.c-expected
@@ -124,6 +124,7 @@ foo_construct (GType object_type,
        FooNewData* _data_;
        _data_ = g_slice_new0 (FooNewData);
        _data_->_async_result = g_task_new (NULL, NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, foo_construct);
        g_task_set_task_data (_data_->_async_result, _data_, foo_construct_data_free);
        _data_->object_type = object_type;
        foo_construct_co (_data_);
@@ -134,6 +135,8 @@ foo_construct_finish (GAsyncResult* _res_)
 {
        Foo* result;
        FooNewData* _data_;
+       g_return_val_if_fail (G_IS_TASK (_res_), NULL);
+       g_return_val_if_fail (g_async_result_is_tagged (_res_, foo_construct), NULL);
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
        result = _data_->self;
        _data_->self = NULL;
@@ -389,6 +392,7 @@ _vala_main_async (GAsyncReadyCallback _callback_,
        ValaMainAsyncData* _data_;
        _data_ = g_slice_new0 (ValaMainAsyncData);
        _data_->_async_result = g_task_new (NULL, NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, _vala_main_async);
        g_task_set_task_data (_data_->_async_result, _data_, _vala_main_async_data_free);
        _vala_main_async_co (_data_);
 }
@@ -397,6 +401,8 @@ void
 _vala_main_finish (GAsyncResult* _res_)
 {
        ValaMainAsyncData* _data_;
+       g_return_if_fail (G_IS_TASK (_res_));
+       g_return_if_fail (g_async_result_is_tagged (_res_, _vala_main_async));
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
 }
 

diff --git a/tests/asynchronous/main-block-async-yield.c-expected b/tests/asynchronous/main-block-async-yield.c-expected
index c9d3b7e37a261eb01bd4ec11607bf37677f230de..a65e972945b39b6d00cd8a92a9e8f5564841fed6 100644 (file)
--- a/tests/asynchronous/main-block-async-yield.c-expected
+++ b/tests/asynchronous/main-block-async-yield.c-expected
@@ -44,6 +44,7 @@ _vala_main_async (GAsyncReadyCallback _callback_,
        ValaMainAsyncData* _data_;
        _data_ = g_slice_new0 (ValaMainAsyncData);
        _data_->_async_result = g_task_new (NULL, NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, _vala_main_async);
        g_task_set_task_data (_data_->_async_result, _data_, _vala_main_async_data_free);
        _vala_main_async_co (_data_);
 }
@@ -52,6 +53,8 @@ void
 _vala_main_finish (GAsyncResult* _res_)
 {
        ValaMainAsyncData* _data_;
+       g_return_if_fail (G_IS_TASK (_res_));
+       g_return_if_fail (g_async_result_is_tagged (_res_, _vala_main_async));
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
 }
 

diff --git a/tests/asynchronous/method-main-async-void.c-expected b/tests/asynchronous/method-main-async-void.c-expected
index 322e2bdabc09b5b8956757c9a45bd4b5ace0b501..159b58bce90e24757cb1b54bc9da3ad559d749ce 100644 (file)
--- a/tests/asynchronous/method-main-async-void.c-expected
+++ b/tests/asynchronous/method-main-async-void.c-expected
@@ -52,6 +52,7 @@ _vala_main_async (gchar** args,
        ValaMainAsyncData* _data_;
        _data_ = g_slice_new0 (ValaMainAsyncData);
        _data_->_async_result = g_task_new (NULL, NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, _vala_main_async);
        g_task_set_task_data (_data_->_async_result, _data_, _vala_main_async_data_free);
        _data_->args = args;
        _data_->args_length1 = args_length1;
@@ -62,6 +63,8 @@ void
 _vala_main_finish (GAsyncResult* _res_)
 {
        ValaMainAsyncData* _data_;
+       g_return_if_fail (G_IS_TASK (_res_));
+       g_return_if_fail (g_async_result_is_tagged (_res_, _vala_main_async));
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
 }
 

diff --git a/tests/asynchronous/method-main-async.c-expected b/tests/asynchronous/method-main-async.c-expected
index e4a7409bc31f5bec38405927a136024a7b738836..fb428665e0eb8db84d62abaea15c7d4723b2829a 100644 (file)
--- a/tests/asynchronous/method-main-async.c-expected
+++ b/tests/asynchronous/method-main-async.c-expected
@@ -64,6 +64,7 @@ _vala_main_async (gchar** args,
        ValaMainAsyncData* _data_;
        _data_ = g_slice_new0 (ValaMainAsyncData);
        _data_->_async_result = g_task_new (NULL, NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, _vala_main_async);
        g_task_set_task_data (_data_->_async_result, _data_, _vala_main_async_data_free);
        _data_->args = args;
        _data_->args_length1 = args_length1;
@@ -75,6 +76,8 @@ _vala_main_finish (GAsyncResult* _res_)
 {
        gint result;
        ValaMainAsyncData* _data_;
+       g_return_val_if_fail (G_IS_TASK (_res_), 0);
+       g_return_val_if_fail (g_async_result_is_tagged (_res_, _vala_main_async), 0);
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
        result = _data_->result;
        return result;

diff --git a/tests/asynchronous/nowrapper.c-expected b/tests/asynchronous/nowrapper.c-expected
index 22a848c00bea95ff3e0a7d801b06524ef7fc8f92..33a7031eaba9d0eb8e4517d8abbb6a2721c3db79 100644 (file)
--- a/tests/asynchronous/nowrapper.c-expected
+++ b/tests/asynchronous/nowrapper.c-expected
@@ -187,6 +187,7 @@ foo_real_bar (Foo* self,
        Foo* _tmp0_;
        _data_ = g_slice_new0 (FooBarData);
        _data_->_async_result = g_task_new (G_OBJECT (self), NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, foo_real_bar);
        g_task_set_task_data (_data_->_async_result, _data_, foo_real_bar_data_free);
        _tmp0_ = _g_object_ref0 (self);
        _data_->self = _tmp0_;
@@ -199,6 +200,8 @@ foo_real_bar_finish (Foo* self,
 {
        gint result;
        FooBarData* _data_;
+       g_return_val_if_fail (g_task_is_valid (_res_, G_OBJECT (self)), 0);
+       g_return_val_if_fail (g_async_result_is_tagged (_res_, foo_real_bar), 0);
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
        result = _data_->result;
        return result;
@@ -245,6 +248,7 @@ foo_real_manam (IFoo* base,
        self = G_TYPE_CHECK_INSTANCE_CAST (base, TYPE_FOO, Foo);
        _data_ = g_slice_new0 (FooManamData);
        _data_->_async_result = g_task_new (G_OBJECT (self), NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, foo_real_manam);
        g_task_set_task_data (_data_->_async_result, _data_, foo_real_manam_data_free);
        _tmp0_ = _g_object_ref0 (self);
        _data_->self = _tmp0_;
@@ -257,6 +261,8 @@ foo_manam_finish (IFoo* base,
 {
        gint result;
        FooManamData* _data_;
+       g_return_val_if_fail (g_task_is_valid (_res_, G_OBJECT (base)), 0);
+       g_return_val_if_fail (g_async_result_is_tagged (_res_, foo_real_manam), 0);
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
        result = _data_->result;
        return result;

diff --git a/tests/asynchronous/out-parameter-free-on-error.c-expected b/tests/asynchronous/out-parameter-free-on-error.c-expected
index 0ba4c763d974527e82d250b9a222eb958887ff11..4a1ff56906d6d70c91cf812c41e19f959661db73 100644 (file)
--- a/tests/asynchronous/out-parameter-free-on-error.c-expected
+++ b/tests/asynchronous/out-parameter-free-on-error.c-expected
@@ -217,6 +217,7 @@ foo_async (Manam* i,
        g_return_if_fail (IS_MANAM (i));
        _data_ = g_slice_new0 (FooAsyncData);
        _data_->_async_result = g_task_new (NULL, NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, foo_async);
        g_task_set_task_data (_data_->_async_result, _data_, foo_async_data_free);
        _tmp0_ = _g_object_ref0 (i);
        _g_object_unref0 (_data_->i);
@@ -230,6 +231,8 @@ foo_finish (GAsyncResult* _res_,
             GError** error)
 {
        FooAsyncData* _data_;
+       g_return_if_fail (G_IS_TASK (_res_));
+       g_return_if_fail (g_async_result_is_tagged (_res_, foo_async));
        _data_ = g_task_propagate_pointer (G_TASK (_res_), error);
        if (NULL == _data_) {
                return;
@@ -294,6 +297,7 @@ run (GAsyncReadyCallback _callback_,
        RunData* _data_;
        _data_ = g_slice_new0 (RunData);
        _data_->_async_result = g_task_new (NULL, NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, run);
        g_task_set_task_data (_data_->_async_result, _data_, run_data_free);
        run_co (_data_);
 }
@@ -302,6 +306,8 @@ void
 run_finish (GAsyncResult* _res_)
 {
        RunData* _data_;
+       g_return_if_fail (G_IS_TASK (_res_));
+       g_return_if_fail (g_async_result_is_tagged (_res_, run));
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
 }
 

diff --git a/tests/asynchronous/result-pos.c-expected b/tests/asynchronous/result-pos.c-expected
index ad74c166f3c9326e47912d43a30642489d1c4cad..8402f9a1c4647f53e17b5920f0090b8bc0210b41 100644 (file)
--- a/tests/asynchronous/result-pos.c-expected
+++ b/tests/asynchronous/result-pos.c-expected
@@ -116,6 +116,7 @@ foo (gint in_i,
        FooData* _data_;
        _data_ = g_slice_new0 (FooData);
        _data_->_async_result = g_task_new (NULL, NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, foo);
        g_task_set_task_data (_data_->_async_result, _data_, foo_data_free);
        _data_->in_i = in_i;
        foo_co (_data_);
@@ -126,6 +127,8 @@ foo_finish (gint* out_i,
             GAsyncResult* _res_)
 {
        FooData* _data_;
+       g_return_if_fail (G_IS_TASK (_res_));
+       g_return_if_fail (g_async_result_is_tagged (_res_, foo));
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
        if (out_i) {
                *out_i = _data_->out_i;
@@ -169,6 +172,7 @@ bar (gint in_i,
        BarData* _data_;
        _data_ = g_slice_new0 (BarData);
        _data_->_async_result = g_task_new (NULL, NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, bar);
        g_task_set_task_data (_data_->_async_result, _data_, bar_data_free);
        _data_->in_i = in_i;
        bar_co (_data_);
@@ -180,6 +184,8 @@ bar_finish (gint* out_i,
             GError** error)
 {
        BarData* _data_;
+       g_return_if_fail (G_IS_TASK (_res_));
+       g_return_if_fail (g_async_result_is_tagged (_res_, bar));
        _data_ = g_task_propagate_pointer (G_TASK (_res_), error);
        if (NULL == _data_) {
                return;
@@ -225,6 +231,7 @@ run (GAsyncReadyCallback _callback_,
        RunData* _data_;
        _data_ = g_slice_new0 (RunData);
        _data_->_async_result = g_task_new (NULL, NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, run);
        g_task_set_task_data (_data_->_async_result, _data_, run_data_free);
        run_co (_data_);
 }
@@ -233,6 +240,8 @@ void
 run_finish (GAsyncResult* _res_)
 {
        RunData* _data_;
+       g_return_if_fail (G_IS_TASK (_res_));
+       g_return_if_fail (g_async_result_is_tagged (_res_, run));
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
 }
 

diff --git a/tests/asynchronous/yield.c-expected b/tests/asynchronous/yield.c-expected
index d25d1e0a1a5110a9b3c704c82413c08cb1d883fa..cab50bcc4fa1885fd39b03d9277c7d4e57871911 100644 (file)
--- a/tests/asynchronous/yield.c-expected
+++ b/tests/asynchronous/yield.c-expected
@@ -52,6 +52,7 @@ foo (GAsyncReadyCallback _callback_,
        FooData* _data_;
        _data_ = g_slice_new0 (FooData);
        _data_->_async_result = g_task_new (NULL, NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, foo);
        g_task_set_task_data (_data_->_async_result, _data_, foo_data_free);
        foo_co (_data_);
 }
@@ -60,6 +61,8 @@ void
 foo_finish (GAsyncResult* _res_)
 {
        FooData* _data_;
+       g_return_if_fail (G_IS_TASK (_res_));
+       g_return_if_fail (g_async_result_is_tagged (_res_, foo));
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
 }
 

diff --git a/tests/dbus/async-errors_client.c-expected b/tests/dbus/async-errors_client.c-expected
index 931b767280c8aa24d845c34af4e565455cadfa2f..7300d7cae4269867f0480cbc4d30e6b192f91b58 100644 (file)
--- a/tests/dbus/async-errors_client.c-expected
+++ b/tests/dbus/async-errors_client.c-expected
@@ -937,6 +937,7 @@ run (GAsyncReadyCallback _callback_,
        RunData* _data_;
        _data_ = g_slice_new0 (RunData);
        _data_->_async_result = g_task_new (NULL, NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, run);
        g_task_set_task_data (_data_->_async_result, _data_, run_data_free);
        run_co (_data_);
 }
@@ -945,6 +946,8 @@ void
 run_finish (GAsyncResult* _res_)
 {
        RunData* _data_;
+       g_return_if_fail (G_IS_TASK (_res_));
+       g_return_if_fail (g_async_result_is_tagged (_res_, run));
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
 }
 

diff --git a/tests/dbus/async-errors_server.c-expected b/tests/dbus/async-errors_server.c-expected
index 0b70543af9ce3829b4dfc8da106ea2bf482c927c..0e7b921d9c58f620c381bffca573a335d5f07535 100644 (file)
--- a/tests/dbus/async-errors_server.c-expected
+++ b/tests/dbus/async-errors_server.c-expected
@@ -294,6 +294,7 @@ test_test_void (Test* self,
        g_return_if_fail (IS_TEST (self));
        _data_ = g_slice_new0 (TestTestVoidData);
        _data_->_async_result = g_task_new (G_OBJECT (self), NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, test_test_void);
        g_task_set_task_data (_data_->_async_result, _data_, test_test_void_data_free);
        _tmp0_ = _g_object_ref0 (self);
        _data_->self = _tmp0_;
@@ -306,6 +307,8 @@ test_test_void_finish (Test* self,
                        GError** error)
 {
        TestTestVoidData* _data_;
+       g_return_if_fail (g_task_is_valid (_res_, G_OBJECT (self)));
+       g_return_if_fail (g_async_result_is_tagged (_res_, test_test_void));
        _data_ = g_task_propagate_pointer (G_TASK (_res_), error);
        if (NULL == _data_) {
                return;
@@ -372,6 +375,7 @@ test_test_int (Test* self,
        g_return_if_fail (IS_TEST (self));
        _data_ = g_slice_new0 (TestTestIntData);
        _data_->_async_result = g_task_new (G_OBJECT (self), NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, test_test_int);
        g_task_set_task_data (_data_->_async_result, _data_, test_test_int_data_free);
        _tmp0_ = _g_object_ref0 (self);
        _data_->self = _tmp0_;
@@ -387,6 +391,8 @@ test_test_int_finish (Test* self,
 {
        gint result;
        TestTestIntData* _data_;
+       g_return_val_if_fail (g_task_is_valid (_res_, G_OBJECT (self)), 0);
+       g_return_val_if_fail (g_async_result_is_tagged (_res_, test_test_int), 0);
        _data_ = g_task_propagate_pointer (G_TASK (_res_), error);
        if (NULL == _data_) {
                gint _tmp0_ = 0;
@@ -455,6 +461,7 @@ test_test_string (Test* self,
        g_return_if_fail (s != NULL);
        _data_ = g_slice_new0 (TestTestStringData);
        _data_->_async_result = g_task_new (G_OBJECT (self), NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, test_test_string);
        g_task_set_task_data (_data_->_async_result, _data_, test_test_string_data_free);
        _tmp0_ = _g_object_ref0 (self);
        _data_->self = _tmp0_;
@@ -472,6 +479,8 @@ test_test_string_finish (Test* self,
 {
        gchar* result;
        TestTestStringData* _data_;
+       g_return_val_if_fail (g_task_is_valid (_res_, G_OBJECT (self)), NULL);
+       g_return_val_if_fail (g_async_result_is_tagged (_res_, test_test_string), NULL);
        _data_ = g_task_propagate_pointer (G_TASK (_res_), error);
        if (NULL == _data_) {
                return NULL;
@@ -543,6 +552,7 @@ test_test_cancellable (Test* self,
        g_return_if_fail ((cancellable == NULL) || G_TYPE_CHECK_INSTANCE_TYPE (cancellable, g_cancellable_get_type ()));
        _data_ = g_slice_new0 (TestTestCancellableData);
        _data_->_async_result = g_task_new (G_OBJECT (self), cancellable, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, test_test_cancellable);
        g_task_set_task_data (_data_->_async_result, _data_, test_test_cancellable_data_free);
        _tmp0_ = _g_object_ref0 (self);
        _data_->self = _tmp0_;
@@ -558,6 +568,8 @@ test_test_cancellable_finish (Test* self,
                               GError** error)
 {
        TestTestCancellableData* _data_;
+       g_return_if_fail (g_task_is_valid (_res_, G_OBJECT (self)));
+       g_return_if_fail (g_async_result_is_tagged (_res_, test_test_cancellable));
        _data_ = g_task_propagate_pointer (G_TASK (_res_), error);
        if (NULL == _data_) {
                return;

diff --git a/tests/dbus/async-no-reply_client.c-expected b/tests/dbus/async-no-reply_client.c-expected
index afc9b536658c39c3c26000412e9f59ba40b5d322..36ff156789f65682510e5f2cf284ca0bb840666c 100644 (file)
--- a/tests/dbus/async-no-reply_client.c-expected
+++ b/tests/dbus/async-no-reply_client.c-expected
@@ -700,6 +700,7 @@ run (GAsyncReadyCallback _callback_,
        RunData* _data_;
        _data_ = g_slice_new0 (RunData);
        _data_->_async_result = g_task_new (NULL, NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, run);
        g_task_set_task_data (_data_->_async_result, _data_, run_data_free);
        run_co (_data_);
 }
@@ -708,6 +709,8 @@ void
 run_finish (GAsyncResult* _res_)
 {
        RunData* _data_;
+       g_return_if_fail (G_IS_TASK (_res_));
+       g_return_if_fail (g_async_result_is_tagged (_res_, run));
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
 }
 

diff --git a/tests/dbus/async-no-reply_server.c-expected b/tests/dbus/async-no-reply_server.c-expected
index dc76019d124de9349762f8911c6f3a934e5761e2..33ef02671e11fef5a2459effe841ac26b7dce61a 100644 (file)
--- a/tests/dbus/async-no-reply_server.c-expected
+++ b/tests/dbus/async-no-reply_server.c-expected
@@ -236,6 +236,7 @@ test_list_messages (Test* self,
        g_return_if_fail (IS_TEST (self));
        _data_ = g_slice_new0 (TestListMessagesData);
        _data_->_async_result = g_task_new (G_OBJECT (self), NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, test_list_messages);
        g_task_set_task_data (_data_->_async_result, _data_, test_list_messages_data_free);
        _tmp0_ = _g_object_ref0 (self);
        _data_->self = _tmp0_;
@@ -249,6 +250,8 @@ test_list_messages_finish (Test* self,
 {
        gchar** result;
        TestListMessagesData* _data_;
+       g_return_val_if_fail (g_task_is_valid (_res_, G_OBJECT (self)), NULL);
+       g_return_val_if_fail (g_async_result_is_tagged (_res_, test_list_messages), NULL);
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
        result = _data_->result;
        *result_length1 = _data_->result_length1;
@@ -325,6 +328,7 @@ test_post_message (Test* self,
        g_return_if_fail (message != NULL);
        _data_ = g_slice_new0 (TestPostMessageData);
        _data_->_async_result = g_task_new (G_OBJECT (self), NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, test_post_message);
        g_task_set_task_data (_data_->_async_result, _data_, test_post_message_data_free);
        _tmp0_ = _g_object_ref0 (self);
        _data_->self = _tmp0_;
@@ -339,6 +343,8 @@ test_post_message_finish (Test* self,
                           GAsyncResult* _res_)
 {
        TestPostMessageData* _data_;
+       g_return_if_fail (g_task_is_valid (_res_, G_OBJECT (self)));
+       g_return_if_fail (g_async_result_is_tagged (_res_, test_post_message));
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
 }
 

diff --git a/tests/dbus/async_client.c-expected b/tests/dbus/async_client.c-expected
index 8b4e7f145713ae59edd6412c806ff09770713c71..049b02190b5c2dca945aff3b4bf5b1a2e848c883 100644 (file)
--- a/tests/dbus/async_client.c-expected
+++ b/tests/dbus/async_client.c-expected
@@ -802,6 +802,7 @@ run (GAsyncReadyCallback _callback_,
        RunData* _data_;
        _data_ = g_slice_new0 (RunData);
        _data_->_async_result = g_task_new (NULL, NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, run);
        g_task_set_task_data (_data_->_async_result, _data_, run_data_free);
        run_co (_data_);
 }
@@ -810,6 +811,8 @@ void
 run_finish (GAsyncResult* _res_)
 {
        RunData* _data_;
+       g_return_if_fail (G_IS_TASK (_res_));
+       g_return_if_fail (g_async_result_is_tagged (_res_, run));
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
 }
 

diff --git a/tests/dbus/async_server.c-expected b/tests/dbus/async_server.c-expected
index 0316e107d6a12be562f0e335fc1250acbbfc61f9..45d31816f56c7aa7f09a64d6f04f479531a257f6 100644 (file)
--- a/tests/dbus/async_server.c-expected
+++ b/tests/dbus/async_server.c-expected
@@ -253,6 +253,7 @@ test_test_void (Test* self,
        g_return_if_fail (IS_TEST (self));
        _data_ = g_slice_new0 (TestTestVoidData);
        _data_->_async_result = g_task_new (G_OBJECT (self), NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, test_test_void);
        g_task_set_task_data (_data_->_async_result, _data_, test_test_void_data_free);
        _tmp0_ = _g_object_ref0 (self);
        _data_->self = _tmp0_;
@@ -264,6 +265,8 @@ test_test_void_finish (Test* self,
                        GAsyncResult* _res_)
 {
        TestTestVoidData* _data_;
+       g_return_if_fail (g_task_is_valid (_res_, G_OBJECT (self)));
+       g_return_if_fail (g_async_result_is_tagged (_res_, test_test_void));
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
 }
 
@@ -322,6 +325,7 @@ test_test_int (Test* self,
        g_return_if_fail (IS_TEST (self));
        _data_ = g_slice_new0 (TestTestIntData);
        _data_->_async_result = g_task_new (G_OBJECT (self), NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, test_test_int);
        g_task_set_task_data (_data_->_async_result, _data_, test_test_int_data_free);
        _tmp0_ = _g_object_ref0 (self);
        _data_->self = _tmp0_;
@@ -336,6 +340,8 @@ test_test_int_finish (Test* self,
 {
        gint result;
        TestTestIntData* _data_;
+       g_return_val_if_fail (g_task_is_valid (_res_, G_OBJECT (self)), 0);
+       g_return_val_if_fail (g_async_result_is_tagged (_res_, test_test_int), 0);
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
        if (j) {
                *j = _data_->j;
@@ -406,6 +412,7 @@ test_test_string (Test* self,
        g_return_if_fail (s != NULL);
        _data_ = g_slice_new0 (TestTestStringData);
        _data_->_async_result = g_task_new (G_OBJECT (self), NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, test_test_string);
        g_task_set_task_data (_data_->_async_result, _data_, test_test_string_data_free);
        _tmp0_ = _g_object_ref0 (self);
        _data_->self = _tmp0_;
@@ -422,6 +429,8 @@ test_test_string_finish (Test* self,
 {
        gchar* result;
        TestTestStringData* _data_;
+       g_return_val_if_fail (g_task_is_valid (_res_, G_OBJECT (self)), NULL);
+       g_return_val_if_fail (g_async_result_is_tagged (_res_, test_test_string), NULL);
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
        if (t) {
                *t = _data_->t;

diff --git a/tests/dbus/bug783002_client.c-expected b/tests/dbus/bug783002_client.c-expected
index 1c1b07aa58583f9bc641c2093e8d88f1e59bbdfd..fc0c97f8579fa4409ff0aec4d249f2341c69d749 100644 (file)
--- a/tests/dbus/bug783002_client.c-expected
+++ b/tests/dbus/bug783002_client.c-expected
@@ -525,6 +525,7 @@ run (GAsyncReadyCallback _callback_,
        RunData* _data_;
        _data_ = g_slice_new0 (RunData);
        _data_->_async_result = g_task_new (NULL, NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, run);
        g_task_set_task_data (_data_->_async_result, _data_, run_data_free);
        run_co (_data_);
 }
@@ -533,6 +534,8 @@ void
 run_finish (GAsyncResult* _res_)
 {
        RunData* _data_;
+       g_return_if_fail (G_IS_TASK (_res_));
+       g_return_if_fail (g_async_result_is_tagged (_res_, run));
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
 }
 

diff --git a/tests/dbus/bug783002_server.c-expected b/tests/dbus/bug783002_server.c-expected
index cad107c3ea99302223b560ec26d60cc8384d918c..235871a4e4f0292eaccfed44997a6e928bb5f4c0 100644 (file)
--- a/tests/dbus/bug783002_server.c-expected
+++ b/tests/dbus/bug783002_server.c-expected
@@ -211,6 +211,7 @@ test_test_array_lifetime (Test* self,
        g_return_if_fail (IS_TEST (self));
        _data_ = g_slice_new0 (TestTestArrayLifetimeData);
        _data_->_async_result = g_task_new (G_OBJECT (self), NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, test_test_array_lifetime);
        g_task_set_task_data (_data_->_async_result, _data_, test_test_array_lifetime_data_free);
        _tmp0_ = _g_object_ref0 (self);
        _data_->self = _tmp0_;
@@ -226,6 +227,8 @@ test_test_array_lifetime_finish (Test* self,
 {
        gchar* result;
        TestTestArrayLifetimeData* _data_;
+       g_return_val_if_fail (g_task_is_valid (_res_, G_OBJECT (self)), NULL);
+       g_return_val_if_fail (g_async_result_is_tagged (_res_, test_test_array_lifetime), NULL);
        _data_ = g_task_propagate_pointer (G_TASK (_res_), error);
        if (NULL == _data_) {
                return NULL;

diff --git a/tests/dbus/dynamic-method_client.c-expected b/tests/dbus/dynamic-method_client.c-expected
index f685056cbe4d49d24efdbb4b8e5eff19925fd0e9..5d45b28a9e7884e0b38b80069a02a6b11e5f4a09 100644 (file)
--- a/tests/dbus/dynamic-method_client.c-expected
+++ b/tests/dbus/dynamic-method_client.c-expected
@@ -87,6 +87,7 @@ run (GAsyncReadyCallback _callback_,
        RunData* _data_;
        _data_ = g_slice_new0 (RunData);
        _data_->_async_result = g_task_new (NULL, NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, run);
        g_task_set_task_data (_data_->_async_result, _data_, run_data_free);
        run_co (_data_);
 }
@@ -95,6 +96,8 @@ void
 run_finish (GAsyncResult* _res_)
 {
        RunData* _data_;
+       g_return_if_fail (G_IS_TASK (_res_));
+       g_return_if_fail (g_async_result_is_tagged (_res_, run));
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
 }
 

diff --git a/tests/dbus/filedescriptor-async_client.c-expected b/tests/dbus/filedescriptor-async_client.c-expected
index 715f08d8154e313d22c9c5be0b54efd3de312fb4..4ff425818a5be281f095402b1f3aaccf0f46b198 100644 (file)
--- a/tests/dbus/filedescriptor-async_client.c-expected
+++ b/tests/dbus/filedescriptor-async_client.c-expected
@@ -559,6 +559,7 @@ run (GAsyncReadyCallback _callback_,
        RunData* _data_;
        _data_ = g_slice_new0 (RunData);
        _data_->_async_result = g_task_new (NULL, NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, run);
        g_task_set_task_data (_data_->_async_result, _data_, run_data_free);
        run_co (_data_);
 }
@@ -567,6 +568,8 @@ void
 run_finish (GAsyncResult* _res_)
 {
        RunData* _data_;
+       g_return_if_fail (G_IS_TASK (_res_));
+       g_return_if_fail (g_async_result_is_tagged (_res_, run));
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
 }
 

diff --git a/tests/dbus/filedescriptor-async_server.c-expected b/tests/dbus/filedescriptor-async_server.c-expected
index 98ff7391555d75516444b716bb7bcfd430767d92..e351a8c9d41b302580847bfc8c8c0853cc1ba33d 100644 (file)
--- a/tests/dbus/filedescriptor-async_server.c-expected
+++ b/tests/dbus/filedescriptor-async_server.c-expected
@@ -227,6 +227,7 @@ test_test_in (Test* self,
        g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (i, G_TYPE_UNIX_INPUT_STREAM));
        _data_ = g_slice_new0 (TestTestInData);
        _data_->_async_result = g_task_new (G_OBJECT (self), NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, test_test_in);
        g_task_set_task_data (_data_->_async_result, _data_, test_test_in_data_free);
        _tmp0_ = _g_object_ref0 (self);
        _data_->self = _tmp0_;
@@ -244,6 +245,8 @@ test_test_in_finish (Test* self,
 {
        GUnixInputStream* result;
        TestTestInData* _data_;
+       g_return_val_if_fail (g_task_is_valid (_res_, G_OBJECT (self)), NULL);
+       g_return_val_if_fail (g_async_result_is_tagged (_res_, test_test_in), NULL);
        _data_ = g_task_propagate_pointer (G_TASK (_res_), error);
        if (NULL == _data_) {
                return NULL;

diff --git a/tests/dbus/no-reply_client.c-expected b/tests/dbus/no-reply_client.c-expected
index 54dc251f325bf17e7ecaedbf99a650b3b5bf7928..817e564e314482613b4b36ad808614805ea6c97c 100644 (file)
--- a/tests/dbus/no-reply_client.c-expected
+++ b/tests/dbus/no-reply_client.c-expected
@@ -628,6 +628,7 @@ run (GAsyncReadyCallback _callback_,
        RunData* _data_;
        _data_ = g_slice_new0 (RunData);
        _data_->_async_result = g_task_new (NULL, NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, run);
        g_task_set_task_data (_data_->_async_result, _data_, run_data_free);
        run_co (_data_);
 }
@@ -636,6 +637,8 @@ void
 run_finish (GAsyncResult* _res_)
 {
        RunData* _data_;
+       g_return_if_fail (G_IS_TASK (_res_));
+       g_return_if_fail (g_async_result_is_tagged (_res_, run));
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
 }
 

diff --git a/tests/generics/member-dup-destroy.c-expected b/tests/generics/member-dup-destroy.c-expected
index 8314dece6b2e4e48b2d578a7385f991f4adc48ae..da5660295e859d289361432d0cc1147a8405565f 100644 (file)
--- a/tests/generics/member-dup-destroy.c-expected
+++ b/tests/generics/member-dup-destroy.c-expected
@@ -227,6 +227,7 @@ foo_foo_async (Foo* self,
        g_return_if_fail (IS_FOO (self));
        _data_ = g_slice_new0 (FooFooAsyncData);
        _data_->_async_result = g_task_new (G_OBJECT (self), NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, foo_foo_async);
        g_task_set_task_data (_data_->_async_result, _data_, foo_foo_async_data_free);
        _tmp0_ = _g_object_ref0 (self);
        _data_->self = _tmp0_;
@@ -238,6 +239,8 @@ foo_foo_finish (Foo* self,
                 GAsyncResult* _res_)
 {
        FooFooAsyncData* _data_;
+       g_return_if_fail (g_task_is_valid (_res_, G_OBJECT (self)));
+       g_return_if_fail (g_async_result_is_tagged (_res_, foo_foo_async));
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
 }
 
@@ -428,6 +431,7 @@ bar_async (GType t_type,
        gpointer _tmp0_;
        _data_ = g_slice_new0 (BarAsyncData);
        _data_->_async_result = g_task_new (NULL, NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, bar_async);
        g_task_set_task_data (_data_->_async_result, _data_, bar_async_data_free);
        _tmp0_ = ((t != NULL) && (t_dup_func != NULL)) ? t_dup_func ((gpointer) t) : ((gpointer) t);
        ((_data_->t == NULL) || (_data_->t_destroy_func == NULL)) ? NULL : (_data_->t = (_data_->t_destroy_func (_data_->t), NULL));
@@ -442,6 +446,8 @@ void
 bar_finish (GAsyncResult* _res_)
 {
        BarAsyncData* _data_;
+       g_return_if_fail (G_IS_TASK (_res_));
+       g_return_if_fail (g_async_result_is_tagged (_res_, bar_async));
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
 }
 

diff --git a/tests/genie/class-abstract.c-expected b/tests/genie/class-abstract.c-expected
index 3dcdf3c4ee34355aeb49fb8e5501f941183aadd3..b18adcad3cdb7ffe7f1fcf850db5e299930f9af9 100644 (file)
--- a/tests/genie/class-abstract.c-expected
+++ b/tests/genie/class-abstract.c-expected
@@ -384,6 +384,7 @@ test2_construct (GType object_type,
        Test2NewData* _data_;
        _data_ = g_slice_new0 (Test2NewData);
        _data_->_async_result = g_task_new (NULL, NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, test2_construct);
        g_task_set_task_data (_data_->_async_result, _data_, test2_construct_data_free);
        _data_->object_type = object_type;
        test2_construct_co (_data_);
@@ -394,6 +395,8 @@ test2_construct_finish (GAsyncResult* _res_)
 {
        Test2* result;
        Test2NewData* _data_;
+       g_return_val_if_fail (G_IS_TASK (_res_), NULL);
+       g_return_val_if_fail (g_async_result_is_tagged (_res_, test2_construct), NULL);
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
        result = _data_->self;
        _data_->self = NULL;

diff --git a/tests/methods/bug639054.c-expected b/tests/methods/bug639054.c-expected
index 0951c87511fb58687983350d4d7e32973d50c4e2..3fb36a4a3a769b6eb4b2536371210f747f43fb2a 100644 (file)
--- a/tests/methods/bug639054.c-expected
+++ b/tests/methods/bug639054.c-expected
@@ -137,6 +137,7 @@ foo (guint8* bar,
        g_return_if_fail (baz != NULL);
        _data_ = g_slice_new0 (FooData);
        _data_->_async_result = g_task_new (NULL, NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, foo);
        g_task_set_task_data (_data_->_async_result, _data_, foo_data_free);
        _data_->bar = bar;
        _data_->bar_length1 = bar_length1;
@@ -148,6 +149,8 @@ void
 foo_finish (GAsyncResult* _res_)
 {
        FooData* _data_;
+       g_return_if_fail (G_IS_TASK (_res_));
+       g_return_if_fail (g_async_result_is_tagged (_res_, foo));
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
 }
 

diff --git a/tests/methods/prepostconditions-captured.c-expected b/tests/methods/prepostconditions-captured.c-expected
index 5d49fe82fe414e4ab195ab8ae0a1f38c663d71db..988feb7b4136aa172a9a9c84e6d595b4ba807300 100644 (file)
--- a/tests/methods/prepostconditions-captured.c-expected
+++ b/tests/methods/prepostconditions-captured.c-expected
@@ -210,6 +210,7 @@ foo (gint i,
        FooData* _data_;
        _data_ = g_slice_new0 (FooData);
        _data_->_async_result = g_task_new (NULL, NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, foo);
        g_task_set_task_data (_data_->_async_result, _data_, foo_data_free);
        _data_->i = i;
        foo_co (_data_);
@@ -220,6 +221,8 @@ foo_finish (GAsyncResult* _res_)
 {
        gint result;
        FooData* _data_;
+       g_return_val_if_fail (G_IS_TASK (_res_), 0);
+       g_return_val_if_fail (g_async_result_is_tagged (_res_, foo), 0);
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
        result = _data_->result;
        return result;

diff --git a/tests/objects/interface-abstract-async-override.c-expected b/tests/objects/interface-abstract-async-override.c-expected
index 86c8841a1c2b555a03c1d8dc3d8ac1d60245c5a1..3e989fe7d21cf75c457b2a24ed0477ab845e2486 100644 (file)
--- a/tests/objects/interface-abstract-async-override.c-expected
+++ b/tests/objects/interface-abstract-async-override.c-expected
@@ -186,6 +186,7 @@ bar_real_foo (IFoo* base,
        self = G_TYPE_CHECK_INSTANCE_CAST (base, TYPE_BAR, Bar);
        _data_ = g_slice_new0 (BarFooData);
        _data_->_async_result = g_task_new (G_OBJECT (self), NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, bar_real_foo);
        g_task_set_task_data (_data_->_async_result, _data_, bar_real_foo_data_free);
        _tmp0_ = _g_object_ref0 (self);
        _data_->self = _tmp0_;
@@ -198,6 +199,8 @@ bar_foo_finish (IFoo* base,
 {
        gint result;
        BarFooData* _data_;
+       g_return_val_if_fail (g_task_is_valid (_res_, G_OBJECT (base)), 0);
+       g_return_val_if_fail (g_async_result_is_tagged (_res_, bar_real_foo), 0);
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
        result = _data_->result;
        return result;

diff --git a/tests/objects/interface-async-base-access.c-expected b/tests/objects/interface-async-base-access.c-expected
index a704fb3596faee402a440bc1c0374fc5615aac6d..f326f85af1ada92bd522c585547ff9538870cb36 100644 (file)
--- a/tests/objects/interface-async-base-access.c-expected
+++ b/tests/objects/interface-async-base-access.c-expected
@@ -237,6 +237,7 @@ bar_real_foo (IFoo* base,
        self = G_TYPE_CHECK_INSTANCE_CAST (base, TYPE_BAR, Bar);
        _data_ = g_slice_new0 (BarFooData);
        _data_->_async_result = g_task_new (NULL, NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, bar_real_foo);
        g_task_set_task_data (_data_->_async_result, _data_, bar_real_foo_data_free);
        _tmp0_ = _bar_ref0 (self);
        _data_->self = _tmp0_;
@@ -248,6 +249,8 @@ bar_foo_finish (IFoo* base,
                 GAsyncResult* _res_)
 {
        BarFooData* _data_;
+       g_return_if_fail (G_IS_TASK (_res_));
+       g_return_if_fail (g_async_result_is_tagged (_res_, bar_real_foo));
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
 }
 
@@ -515,6 +518,7 @@ foo_bar (Foo* self,
        g_return_if_fail (IS_FOO (self));
        _data_ = g_slice_new0 (FooBarData);
        _data_->_async_result = g_task_new (NULL, NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, foo_bar);
        g_task_set_task_data (_data_->_async_result, _data_, foo_bar_data_free);
        _tmp0_ = _bar_ref0 (self);
        _data_->self = _tmp0_;
@@ -526,6 +530,8 @@ foo_bar_finish (Foo* self,
                 GAsyncResult* _res_)
 {
        FooBarData* _data_;
+       g_return_if_fail (G_IS_TASK (_res_));
+       g_return_if_fail (g_async_result_is_tagged (_res_, foo_bar));
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
 }
 

diff --git a/tests/objects/interface-async-captured-generic.c-expected b/tests/objects/interface-async-captured-generic.c-expected
index be2dbef43d893013b3aa89d8517af1cad1e1b52f..69cdb476a77bf78b63d79d5d84a08221848c053c 100644 (file)
--- a/tests/objects/interface-async-captured-generic.c-expected
+++ b/tests/objects/interface-async-captured-generic.c-expected
@@ -130,6 +130,7 @@ ifoo_bar (IFoo* self,
        IFoo* _tmp0_;
        _data_ = g_slice_new0 (IfooBarData);
        _data_->_async_result = g_task_new (G_OBJECT (self), NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, ifoo_bar);
        g_task_set_task_data (_data_->_async_result, _data_, ifoo_bar_data_free);
        _tmp0_ = _g_object_ref0 (self);
        _data_->self = _tmp0_;
@@ -143,6 +144,8 @@ ifoo_bar_finish (IFoo* self,
                  GAsyncResult* _res_)
 {
        IfooBarData* _data_;
+       g_return_if_fail (g_task_is_valid (_res_, G_OBJECT (self)));
+       g_return_if_fail (g_async_result_is_tagged (_res_, ifoo_bar));
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
 }
 

diff --git a/tests/objects/interface-virtual-override.c-expected b/tests/objects/interface-virtual-override.c-expected
index 4960a998f07c94d7371334bf1bfba71e3113c84c..790d4fbcb599866192e5fbb5a1ded3f6ca8d7086 100644 (file)
--- a/tests/objects/interface-virtual-override.c-expected
+++ b/tests/objects/interface-virtual-override.c-expected
@@ -169,6 +169,7 @@ ifoo_real_bar (IFoo* self,
        IFoo* _tmp0_;
        _data_ = g_slice_new0 (IfooBarData);
        _data_->_async_result = g_task_new (G_OBJECT (self), NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, ifoo_real_bar);
        g_task_set_task_data (_data_->_async_result, _data_, ifoo_real_bar_data_free);
        _tmp0_ = _g_object_ref0 (self);
        _data_->self = _tmp0_;
@@ -181,6 +182,8 @@ ifoo_real_bar_finish (IFoo* self,
 {
        gint result;
        IfooBarData* _data_;
+       g_return_val_if_fail (g_task_is_valid (_res_, G_OBJECT (self)), 0);
+       g_return_val_if_fail (g_async_result_is_tagged (_res_, ifoo_real_bar), 0);
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
        result = _data_->result;
        return result;
@@ -284,6 +287,7 @@ bar_real_bar (IFoo* base,
        self = G_TYPE_CHECK_INSTANCE_CAST (base, TYPE_BAR, Bar);
        _data_ = g_slice_new0 (BarBarData);
        _data_->_async_result = g_task_new (G_OBJECT (self), NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, bar_real_bar);
        g_task_set_task_data (_data_->_async_result, _data_, bar_real_bar_data_free);
        _tmp0_ = _g_object_ref0 (self);
        _data_->self = _tmp0_;
@@ -296,6 +300,8 @@ bar_bar_finish (IFoo* base,
 {
        gint result;
        BarBarData* _data_;
+       g_return_val_if_fail (g_task_is_valid (_res_, G_OBJECT (base)), 0);
+       g_return_val_if_fail (g_async_result_is_tagged (_res_, bar_real_bar), 0);
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
        result = _data_->result;
        return result;

diff --git a/tests/objects/property-array-length.c-expected b/tests/objects/property-array-length.c-expected
index 4e47b9bf86f49b4a0921edc79f378c3d3a5495f7..c518b7d85571717b33e04322770a4eb740fc57b3 100644 (file)
--- a/tests/objects/property-array-length.c-expected
+++ b/tests/objects/property-array-length.c-expected
@@ -136,6 +136,7 @@ foo (guint8* data,
        FooData* _data_;
        _data_ = g_slice_new0 (FooData);
        _data_->_async_result = g_task_new (NULL, NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, foo);
        g_task_set_task_data (_data_->_async_result, _data_, foo_data_free);
        _data_->data = data;
        _data_->data_length1 = data_length1;
@@ -146,6 +147,8 @@ void
 foo_finish (GAsyncResult* _res_)
 {
        FooData* _data_;
+       g_return_if_fail (G_IS_TASK (_res_));
+       g_return_if_fail (g_async_result_is_tagged (_res_, foo));
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
 }
 
@@ -185,6 +188,7 @@ bar (GAsyncReadyCallback _callback_,
        BarData* _data_;
        _data_ = g_slice_new0 (BarData);
        _data_->_async_result = g_task_new (NULL, NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, bar);
        g_task_set_task_data (_data_->_async_result, _data_, bar_data_free);
        bar_co (_data_);
 }
@@ -193,6 +197,8 @@ void
 bar_finish (GAsyncResult* _res_)
 {
        BarData* _data_;
+       g_return_if_fail (G_IS_TASK (_res_));
+       g_return_if_fail (g_async_result_is_tagged (_res_, bar));
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
 }
 

diff --git a/tests/parser/yield-return.c-expected b/tests/parser/yield-return.c-expected
index e3c4b3efe4c2fd28f2076dac528dc56b8a18d135..76e955d64145779ae6200a59f332f2a87638f61e 100644 (file)
--- a/tests/parser/yield-return.c-expected
+++ b/tests/parser/yield-return.c-expected
@@ -162,6 +162,7 @@ foo_construct (GType object_type,
        FooNewData* _data_;
        _data_ = g_slice_new0 (FooNewData);
        _data_->_async_result = g_task_new (NULL, NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, foo_construct);
        g_task_set_task_data (_data_->_async_result, _data_, foo_construct_data_free);
        _data_->object_type = object_type;
        foo_construct_co (_data_);
@@ -172,6 +173,8 @@ foo_construct_finish (GAsyncResult* _res_)
 {
        Foo* result;
        FooNewData* _data_;
+       g_return_val_if_fail (G_IS_TASK (_res_), NULL);
+       g_return_val_if_fail (g_async_result_is_tagged (_res_, foo_construct), NULL);
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
        result = _data_->self;
        _data_->self = NULL;
@@ -428,6 +431,7 @@ foo (GAsyncReadyCallback _callback_,
        FooData* _data_;
        _data_ = g_slice_new0 (FooData);
        _data_->_async_result = g_task_new (NULL, NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, foo);
        g_task_set_task_data (_data_->_async_result, _data_, foo_data_free);
        foo_co (_data_);
 }
@@ -437,6 +441,8 @@ foo_finish (GAsyncResult* _res_)
 {
        gchar* result;
        FooData* _data_;
+       g_return_val_if_fail (G_IS_TASK (_res_), NULL);
+       g_return_val_if_fail (g_async_result_is_tagged (_res_, foo), NULL);
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
        result = _data_->result;
        _data_->result = NULL;
@@ -481,6 +487,7 @@ bar (GAsyncReadyCallback _callback_,
        BarData* _data_;
        _data_ = g_slice_new0 (BarData);
        _data_->_async_result = g_task_new (NULL, NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, bar);
        g_task_set_task_data (_data_->_async_result, _data_, bar_data_free);
        bar_co (_data_);
 }
@@ -490,6 +497,8 @@ bar_finish (GAsyncResult* _res_)
 {
        Foo* result;
        BarData* _data_;
+       g_return_val_if_fail (G_IS_TASK (_res_), NULL);
+       g_return_val_if_fail (g_async_result_is_tagged (_res_, bar), NULL);
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
        result = _data_->result;
        _data_->result = NULL;
@@ -552,6 +561,7 @@ baz (GAsyncReadyCallback _callback_,
        BazData* _data_;
        _data_ = g_slice_new0 (BazData);
        _data_->_async_result = g_task_new (NULL, NULL, _callback_, _user_data_);
+       g_task_set_source_tag (_data_->_async_result, baz);
        g_task_set_task_data (_data_->_async_result, _data_, baz_data_free);
        baz_co (_data_);
 }
@@ -561,6 +571,8 @@ baz_finish (GAsyncResult* _res_)
 {
        gchar* result;
        BazData* _data_;
+       g_return_val_if_fail (G_IS_TASK (_res_), NULL);
+       g_return_val_if_fail (g_async_result_is_tagged (_res_, baz), NULL);
        _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL);
        result = _data_->result;
        _data_->result = NULL;