← Back to branch summary

~ubuntu-branches/debian/sid/folks/sid

« back to all changes in this revision

Viewing changes to tests/telepathy/persona-store-capabilities.c

  • Committer: Bazaar Package Importer
  • Author(s): Laurent Bigonville, Laurent Bigonville, Sjoerd Simons
  • Date: 2010-11-04 15:37:37 UTC
  • mfrom: (1.1.6 upstream)
  • Revision ID: james.westby@ubuntu.com-20101104153737-d6ystqvviify529o
Tags: 0.3.1-1
[ Laurent Bigonville ]
* New upstream release
  - debian/control:
    + Bump build-dependencies
    + Add minimal version for gobject-introspection build-dependency
    + Bump libtelepathy-glib-dev dependency against libfolks-telepathy-dev
* Adjust both .symbols files

[ Sjoerd Simons ]
* Don't run the tests for now

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/telepathy/persona-store-capabilities.c
 
1
/* persona-store-capabilities.c generated by valac 0.10.0, the Vala compiler
 
2
 * generated from persona-store-capabilities.vala, do not modify */
 
3
 
 
4
 
 
5
#include <glib.h>
 
6
#include <glib-object.h>
 
7
#include <folks-test.h>
 
8
#include <telepathy-glib/telepathy-glib.h>
 
9
#include <tp-test-contactlist.h>
 
10
#include <stdlib.h>
 
11
#include <string.h>
 
12
#include <gee.h>
 
13
#include <folks.h>
 
14
#include <gio/gio.h>
 
15
#include <folks-telepathy.h>
 
16
 
 
17
 
 
18
#define TYPE_PERSONA_STORE_CAPABILITIES_TESTS (persona_store_capabilities_tests_get_type ())
 
19
#define PERSONA_STORE_CAPABILITIES_TESTS(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_PERSONA_STORE_CAPABILITIES_TESTS, PersonaStoreCapabilitiesTests))
 
20
#define PERSONA_STORE_CAPABILITIES_TESTS_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_PERSONA_STORE_CAPABILITIES_TESTS, PersonaStoreCapabilitiesTestsClass))
 
21
#define IS_PERSONA_STORE_CAPABILITIES_TESTS(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_PERSONA_STORE_CAPABILITIES_TESTS))
 
22
#define IS_PERSONA_STORE_CAPABILITIES_TESTS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_PERSONA_STORE_CAPABILITIES_TESTS))
 
23
#define PERSONA_STORE_CAPABILITIES_TESTS_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_PERSONA_STORE_CAPABILITIES_TESTS, PersonaStoreCapabilitiesTestsClass))
 
24
 
 
25
typedef struct _PersonaStoreCapabilitiesTests PersonaStoreCapabilitiesTests;
 
26
typedef struct _PersonaStoreCapabilitiesTestsClass PersonaStoreCapabilitiesTestsClass;
 
27
typedef struct _PersonaStoreCapabilitiesTestsPrivate PersonaStoreCapabilitiesTestsPrivate;
 
28
#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
 
29
#define _g_main_loop_unref0(var) ((var == NULL) ? NULL : (var = (g_main_loop_unref (var), NULL)))
 
30
#define _g_free0(var) (var = (g_free (var), NULL))
 
31
#define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL)))
 
32
#define _g_list_free0(var) ((var == NULL) ? NULL : (var = (g_list_free (var), NULL)))
 
33
typedef struct _Block1Data Block1Data;
 
34
typedef struct _Block2Data Block2Data;
 
35
 
 
36
struct _PersonaStoreCapabilitiesTests {
 
37
        FolksTestCase parent_instance;
 
38
        PersonaStoreCapabilitiesTestsPrivate * priv;
 
39
};
 
40
 
 
41
struct _PersonaStoreCapabilitiesTestsClass {
 
42
        FolksTestCaseClass parent_class;
 
43
};
 
44
 
 
45
struct _PersonaStoreCapabilitiesTestsPrivate {
 
46
        TpDBusDaemon* daemon;
 
47
        TpTestAccount* account;
 
48
        TpTestAccountManager* account_manager;
 
49
        TpTestContactListConnection* conn;
 
50
        GMainLoop* main_loop;
 
51
        char* bus_name;
 
52
        char* object_path;
 
53
        GeeHashSet* group_flags_received;
 
54
};
 
55
 
 
56
struct _Block1Data {
 
57
        int _ref_count_;
 
58
        PersonaStoreCapabilitiesTests * self;
 
59
        GMainLoop* main_loop;
 
60
};
 
61
 
 
62
struct _Block2Data {
 
63
        int _ref_count_;
 
64
        PersonaStoreCapabilitiesTests * self;
 
65
        FolksPersonaStore* store;
 
66
};
 
67
 
 
68
 
 
69
static gpointer persona_store_capabilities_tests_parent_class = NULL;
 
70
 
 
71
GType persona_store_capabilities_tests_get_type (void) G_GNUC_CONST;
 
72
#define PERSONA_STORE_CAPABILITIES_TESTS_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), TYPE_PERSONA_STORE_CAPABILITIES_TESTS, PersonaStoreCapabilitiesTestsPrivate))
 
73
enum  {
 
74
        PERSONA_STORE_CAPABILITIES_TESTS_DUMMY_PROPERTY
 
75
};
 
76
PersonaStoreCapabilitiesTests* persona_store_capabilities_tests_new (void);
 
77
PersonaStoreCapabilitiesTests* persona_store_capabilities_tests_construct (GType object_type);
 
78
void persona_store_capabilities_tests_test_persona_store_capabilities (PersonaStoreCapabilitiesTests* self);
 
79
static void _persona_store_capabilities_tests_test_persona_store_capabilities_folks_test_case_test_method (gpointer self);
 
80
static void persona_store_capabilities_tests_real_set_up (FolksTestCase* base);
 
81
static void persona_store_capabilities_tests_real_tear_down (FolksTestCase* base);
 
82
static gboolean _lambda5_ (PersonaStoreCapabilitiesTests* self);
 
83
static gboolean __lambda5__gsource_func (gpointer self);
 
84
static gboolean _lambda0_ (const char* d, GLogLevelFlags l, const char* m, PersonaStoreCapabilitiesTests* self);
 
85
static gboolean __lambda0__glog_fatal_func (const char* log_domain, GLogLevelFlags log_levels, const char* message, gpointer self);
 
86
static void _lambda1_ (FolksBackend* b, PersonaStoreCapabilitiesTests* self);
 
87
static void _lambda2_ (FolksPersonaStore* ps, PersonaStoreCapabilitiesTests* self);
 
88
static void persona_store_capabilities_tests_set_up_persona_store (PersonaStoreCapabilitiesTests* self, FolksPersonaStore* store);
 
89
static void __lambda2__folks_backend_persona_store_added (FolksBackend* _sender, FolksPersonaStore* store, gpointer self);
 
90
static void __lambda1__folks_backend_store_backend_available (FolksBackendStore* _sender, FolksBackend* backend, gpointer self);
 
91
static gboolean _lambda4_ (Block1Data* _data1_);
 
92
static gboolean __lambda4__gsource_func (gpointer self);
 
93
static Block1Data* block1_data_ref (Block1Data* _data1_);
 
94
static void block1_data_unref (Block1Data* _data1_);
 
95
static void _lambda3_ (GObject* obj, GAsyncResult* _result_, Block2Data* _data2_);
 
96
static void persona_store_capabilities_tests_can_add_personas_cb (PersonaStoreCapabilitiesTests* self, GObject* s, GParamSpec* p);
 
97
static void _persona_store_capabilities_tests_can_add_personas_cb_g_object_notify (GObject* _sender, GParamSpec* pspec, gpointer self);
 
98
static void persona_store_capabilities_tests_can_remove_personas_cb (PersonaStoreCapabilitiesTests* self, GObject* s, GParamSpec* p);
 
99
static void _persona_store_capabilities_tests_can_remove_personas_cb_g_object_notify (GObject* _sender, GParamSpec* pspec, gpointer self);
 
100
static void persona_store_capabilities_tests_can_alias_personas_cb (PersonaStoreCapabilitiesTests* self, GObject* s, GParamSpec* p);
 
101
static void _persona_store_capabilities_tests_can_alias_personas_cb_g_object_notify (GObject* _sender, GParamSpec* pspec, gpointer self);
 
102
static void persona_store_capabilities_tests_can_group_personas_cb (PersonaStoreCapabilitiesTests* self, GObject* s, GParamSpec* p);
 
103
static void _persona_store_capabilities_tests_can_group_personas_cb_g_object_notify (GObject* _sender, GParamSpec* pspec, gpointer self);
 
104
static void __lambda3__gasync_ready_callback (GObject* source_object, GAsyncResult* res, gpointer self);
 
105
static Block2Data* block2_data_ref (Block2Data* _data2_);
 
106
static void block2_data_unref (Block2Data* _data2_);
 
107
static void persona_store_capabilities_tests_finalize (GObject* obj);
 
108
gint _vala_main (char** args, int args_length1);
 
109
static int _vala_strcmp0 (const char * str1, const char * str2);
 
110
 
 
111
 
 
112
 
 
113
static void _persona_store_capabilities_tests_test_persona_store_capabilities_folks_test_case_test_method (gpointer self) {
 
114
        persona_store_capabilities_tests_test_persona_store_capabilities (self);
 
115
}
 
116
 
 
117
 
 
118
PersonaStoreCapabilitiesTests* persona_store_capabilities_tests_construct (GType object_type) {
 
119
        PersonaStoreCapabilitiesTests * self;
 
120
        self = (PersonaStoreCapabilitiesTests*) folks_test_case_construct (object_type, "PersonaStoreCapabilities");
 
121
        folks_test_case_add_test ((FolksTestCase*) self, "persona store capabilities", _persona_store_capabilities_tests_test_persona_store_capabilities_folks_test_case_test_method, self);
 
122
        return self;
 
123
}
 
124
 
 
125
 
 
126
PersonaStoreCapabilitiesTests* persona_store_capabilities_tests_new (void) {
 
127
        return persona_store_capabilities_tests_construct (TYPE_PERSONA_STORE_CAPABILITIES_TESTS);
 
128
}
 
129
 
 
130
 
 
131
static gpointer _g_object_ref0 (gpointer self) {
 
132
        return self ? g_object_ref (self) : NULL;
 
133
}
 
134
 
 
135
 
 
136
static void persona_store_capabilities_tests_real_set_up (FolksTestCase* base) {
 
137
        PersonaStoreCapabilitiesTests * self;
 
138
        GeeHashSet* _tmp0_;
 
139
        GMainLoop* _tmp1_;
 
140
        TpTestContactListConnection* _tmp4_;
 
141
        TpHandleRepoIface* handle_repo;
 
142
        TpHandle self_handle;
 
143
        TpTestAccount* _tmp10_;
 
144
        TpTestAccountManager* _tmp11_;
 
145
        GError * _inner_error_ = NULL;
 
146
        self = (PersonaStoreCapabilitiesTests*) base;
 
147
        self->priv->group_flags_received = (_tmp0_ = gee_hash_set_new (G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, g_free, g_str_hash, g_str_equal), _g_object_unref0 (self->priv->group_flags_received), _tmp0_);
 
148
        self->priv->main_loop = (_tmp1_ = g_main_loop_new (NULL, FALSE), _g_main_loop_unref0 (self->priv->main_loop), _tmp1_);
 
149
        {
 
150
                TpDBusDaemon* _tmp2_;
 
151
                TpDBusDaemon* _tmp3_;
 
152
                _tmp2_ = tp_dbus_daemon_dup (&_inner_error_);
 
153
                if (_inner_error_ != NULL) {
 
154
                        goto __catch0_g_error;
 
155
                }
 
156
                self->priv->daemon = (_tmp3_ = _tmp2_, _g_object_unref0 (self->priv->daemon), _tmp3_);
 
157
        }
 
158
        goto __finally0;
 
159
        __catch0_g_error:
 
160
        {
 
161
                GError * e;
 
162
                e = _inner_error_;
 
163
                _inner_error_ = NULL;
 
164
                {
 
165
                        g_error ("persona-store-capabilities.vala:39: Couldn't get D-Bus daemon: %s", e->message);
 
166
                        _g_error_free0 (e);
 
167
                }
 
168
        }
 
169
        __finally0:
 
170
        if (_inner_error_ != NULL) {
 
171
                g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
 
172
                g_clear_error (&_inner_error_);
 
173
                return;
 
174
        }
 
175
        self->priv->conn = (_tmp4_ = tp_test_contact_list_connection_new ("me@example.com", "protocol", 0, 0), _g_object_unref0 (self->priv->conn), _tmp4_);
 
176
        {
 
177
                char* _tmp5_ = NULL;
 
178
                char* _tmp6_;
 
179
                char* _tmp7_ = NULL;
 
180
                char* _tmp8_;
 
181
                (tp_base_connection_register ((TpBaseConnection*) self->priv->conn, "cm", &_tmp5_, &_tmp7_, &_inner_error_), self->priv->bus_name = (_tmp6_ = _tmp5_, _g_free0 (self->priv->bus_name), _tmp6_));
 
182
                self->priv->object_path = (_tmp8_ = _tmp7_, _g_free0 (self->priv->object_path), _tmp8_);
 
183
                if (_inner_error_ != NULL) {
 
184
                        goto __catch1_g_error;
 
185
                }
 
186
        }
 
187
        goto __finally1;
 
188
        __catch1_g_error:
 
189
        {
 
190
                GError * e;
 
191
                e = _inner_error_;
 
192
                _inner_error_ = NULL;
 
193
                {
 
194
                        g_error ("persona-store-capabilities.vala:52: Failed to register connection %p.", self->priv->conn);
 
195
                        _g_error_free0 (e);
 
196
                }
 
197
        }
 
198
        __finally1:
 
199
        if (_inner_error_ != NULL) {
 
200
                g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
 
201
                g_clear_error (&_inner_error_);
 
202
                return;
 
203
        }
 
204
        handle_repo = _g_object_ref0 (tp_base_connection_get_handles ((TpBaseConnection*) self->priv->conn, TP_HANDLE_TYPE_CONTACT));
 
205
        self_handle = (TpHandle) 0;
 
206
        {
 
207
                TpHandle _tmp9_;
 
208
                _tmp9_ = tp_handle_ensure (handle_repo, "me@example.com", NULL, &_inner_error_);
 
209
                if (_inner_error_ != NULL) {
 
210
                        goto __catch2_g_error;
 
211
                }
 
212
                self_handle = _tmp9_;
 
213
        }
 
214
        goto __finally2;
 
215
        __catch2_g_error:
 
216
        {
 
217
                GError * e;
 
218
                e = _inner_error_;
 
219
                _inner_error_ = NULL;
 
220
                {
 
221
                        g_error ("persona-store-capabilities.vala:64: Couldn't ensure self handle '%s': " \
 
222
"%s", "me@example.com", e->message);
 
223
                        _g_error_free0 (e);
 
224
                }
 
225
        }
 
226
        __finally2:
 
227
        if (_inner_error_ != NULL) {
 
228
                _g_object_unref0 (handle_repo);
 
229
                g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
 
230
                g_clear_error (&_inner_error_);
 
231
                return;
 
232
        }
 
233
        tp_base_connection_set_self_handle ((TpBaseConnection*) self->priv->conn, self_handle);
 
234
        tp_base_connection_change_status ((TpBaseConnection*) self->priv->conn, TP_CONNECTION_STATUS_CONNECTED, TP_CONNECTION_STATUS_REASON_REQUESTED);
 
235
        self->priv->account = (_tmp10_ = tp_test_account_new (self->priv->object_path), _g_object_unref0 (self->priv->account), _tmp10_);
 
236
        tp_dbus_daemon_register_object (self->priv->daemon, TP_ACCOUNT_OBJECT_PATH_BASE "cm/protocol/account", (GObject*) self->priv->account);
 
237
        {
 
238
                tp_dbus_daemon_request_name (self->priv->daemon, TP_ACCOUNT_MANAGER_BUS_NAME, FALSE, &_inner_error_);
 
239
                if (_inner_error_ != NULL) {
 
240
                        goto __catch3_g_error;
 
241
                }
 
242
        }
 
243
        goto __finally3;
 
244
        __catch3_g_error:
 
245
        {
 
246
                GError * e;
 
247
                e = _inner_error_;
 
248
                _inner_error_ = NULL;
 
249
                {
 
250
                        g_error ("persona-store-capabilities.vala:86: Couldn't request account manager b" \
 
251
"us name '%s': %s", TP_ACCOUNT_MANAGER_BUS_NAME, e->message);
 
252
                        _g_error_free0 (e);
 
253
                }
 
254
        }
 
255
        __finally3:
 
256
        if (_inner_error_ != NULL) {
 
257
                _g_object_unref0 (handle_repo);
 
258
                g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
 
259
                g_clear_error (&_inner_error_);
 
260
                return;
 
261
        }
 
262
        self->priv->account_manager = (_tmp11_ = tp_test_account_manager_new (), _g_object_unref0 (self->priv->account_manager), _tmp11_);
 
263
        tp_dbus_daemon_register_object (self->priv->daemon, TP_ACCOUNT_MANAGER_OBJECT_PATH, (GObject*) self->priv->account_manager);
 
264
        _g_object_unref0 (handle_repo);
 
265
}
 
266
 
 
267
 
 
268
static gboolean _lambda5_ (PersonaStoreCapabilitiesTests* self) {
 
269
        gboolean result = FALSE;
 
270
        GMainLoop* _tmp0_;
 
271
        g_main_loop_quit (self->priv->main_loop);
 
272
        self->priv->main_loop = (_tmp0_ = NULL, _g_main_loop_unref0 (self->priv->main_loop), _tmp0_);
 
273
        result = FALSE;
 
274
        return result;
 
275
}
 
276
 
 
277
 
 
278
static gboolean __lambda5__gsource_func (gpointer self) {
 
279
        gboolean result;
 
280
        result = _lambda5_ (self);
 
281
        return result;
 
282
}
 
283
 
 
284
 
 
285
static void persona_store_capabilities_tests_real_tear_down (FolksTestCase* base) {
 
286
        PersonaStoreCapabilitiesTests * self;
 
287
        TpTestAccountManager* _tmp0_;
 
288
        TpTestAccount* _tmp1_;
 
289
        TpTestContactListConnection* _tmp2_;
 
290
        TpDBusDaemon* _tmp3_;
 
291
        char* _tmp4_;
 
292
        char* _tmp5_;
 
293
        GError * _inner_error_ = NULL;
 
294
        self = (PersonaStoreCapabilitiesTests*) base;
 
295
        tp_base_connection_change_status ((TpBaseConnection*) self->priv->conn, TP_CONNECTION_STATUS_DISCONNECTED, TP_CONNECTION_STATUS_REASON_REQUESTED);
 
296
        tp_dbus_daemon_unregister_object (self->priv->daemon, (GObject*) self->priv->account_manager);
 
297
        self->priv->account_manager = (_tmp0_ = NULL, _g_object_unref0 (self->priv->account_manager), _tmp0_);
 
298
        {
 
299
                tp_dbus_daemon_release_name (self->priv->daemon, TP_ACCOUNT_MANAGER_BUS_NAME, &_inner_error_);
 
300
                if (_inner_error_ != NULL) {
 
301
                        goto __catch4_g_error;
 
302
                }
 
303
        }
 
304
        goto __finally4;
 
305
        __catch4_g_error:
 
306
        {
 
307
                GError * e;
 
308
                e = _inner_error_;
 
309
                _inner_error_ = NULL;
 
310
                {
 
311
                        g_error ("persona-store-capabilities.vala:109: Couldn't release account manager " \
 
312
"bus name '%s': %s", TP_ACCOUNT_MANAGER_BUS_NAME, e->message);
 
313
                        _g_error_free0 (e);
 
314
                }
 
315
        }
 
316
        __finally4:
 
317
        if (_inner_error_ != NULL) {
 
318
                g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
 
319
                g_clear_error (&_inner_error_);
 
320
                return;
 
321
        }
 
322
        tp_dbus_daemon_unregister_object (self->priv->daemon, (GObject*) self->priv->account);
 
323
        self->priv->account = (_tmp1_ = NULL, _g_object_unref0 (self->priv->account), _tmp1_);
 
324
        self->priv->conn = (_tmp2_ = NULL, _g_object_unref0 (self->priv->conn), _tmp2_);
 
325
        self->priv->daemon = (_tmp3_ = NULL, _g_object_unref0 (self->priv->daemon), _tmp3_);
 
326
        self->priv->bus_name = (_tmp4_ = NULL, _g_free0 (self->priv->bus_name), _tmp4_);
 
327
        self->priv->object_path = (_tmp5_ = NULL, _g_free0 (self->priv->object_path), _tmp5_);
 
328
        g_timeout_add_seconds_full (G_PRIORITY_DEFAULT, (guint) 5, __lambda5__gsource_func, g_object_ref (self), g_object_unref);
 
329
        g_main_loop_run (self->priv->main_loop);
 
330
}
 
331
 
 
332
 
 
333
static gboolean _lambda0_ (const char* d, GLogLevelFlags l, const char* m, PersonaStoreCapabilitiesTests* self) {
 
334
        gboolean result = FALSE;
 
335
        g_return_val_if_fail (m != NULL, FALSE);
 
336
        result = !g_str_has_suffix (m, "couldn't get list of favourite contacts: " "The name org.freedesktop.Telepathy.Logger was not provided by " "any .service files");
 
337
        return result;
 
338
}
 
339
 
 
340
 
 
341
static gboolean __lambda0__glog_fatal_func (const char* log_domain, GLogLevelFlags log_levels, const char* message, gpointer self) {
 
342
        gboolean result;
 
343
        result = _lambda0_ (log_domain, log_levels, message, self);
 
344
        return result;
 
345
}
 
346
 
 
347
 
 
348
static void _lambda2_ (FolksPersonaStore* ps, PersonaStoreCapabilitiesTests* self) {
 
349
        g_return_if_fail (ps != NULL);
 
350
        persona_store_capabilities_tests_set_up_persona_store (self, ps);
 
351
}
 
352
 
 
353
 
 
354
static void __lambda2__folks_backend_persona_store_added (FolksBackend* _sender, FolksPersonaStore* store, gpointer self) {
 
355
        _lambda2_ (store, self);
 
356
}
 
357
 
 
358
 
 
359
static void _lambda1_ (FolksBackend* b, PersonaStoreCapabilitiesTests* self) {
 
360
        g_return_if_fail (b != NULL);
 
361
        if (_vala_strcmp0 (folks_backend_get_name (b), "telepathy") == 0) {
 
362
                g_signal_connect_object (b, "persona-store-added", (GCallback) __lambda2__folks_backend_persona_store_added, self, 0);
 
363
                {
 
364
                        GList* store_collection;
 
365
                        GList* store_it;
 
366
                        store_collection = g_hash_table_get_values (folks_backend_get_persona_stores (b));
 
367
                        for (store_it = store_collection; store_it != NULL; store_it = store_it->next) {
 
368
                                FolksPersonaStore* store;
 
369
                                store = (FolksPersonaStore*) store_it->data;
 
370
                                {
 
371
                                        persona_store_capabilities_tests_set_up_persona_store (self, store);
 
372
                                }
 
373
                        }
 
374
                        _g_list_free0 (store_collection);
 
375
                }
 
376
        }
 
377
}
 
378
 
 
379
 
 
380
static void __lambda1__folks_backend_store_backend_available (FolksBackendStore* _sender, FolksBackend* backend, gpointer self) {
 
381
        _lambda1_ (backend, self);
 
382
}
 
383
 
 
384
 
 
385
static gboolean _lambda4_ (Block1Data* _data1_) {
 
386
        PersonaStoreCapabilitiesTests * self;
 
387
        gboolean result = FALSE;
 
388
        self = _data1_->self;
 
389
        g_main_loop_quit (_data1_->main_loop);
 
390
        result = FALSE;
 
391
        return result;
 
392
}
 
393
 
 
394
 
 
395
static gboolean __lambda4__gsource_func (gpointer self) {
 
396
        gboolean result;
 
397
        result = _lambda4_ (self);
 
398
        return result;
 
399
}
 
400
 
 
401
 
 
402
static Block1Data* block1_data_ref (Block1Data* _data1_) {
 
403
        g_atomic_int_inc (&_data1_->_ref_count_);
 
404
        return _data1_;
 
405
}
 
406
 
 
407
 
 
408
static void block1_data_unref (Block1Data* _data1_) {
 
409
        if (g_atomic_int_dec_and_test (&_data1_->_ref_count_)) {
 
410
                _g_object_unref0 (_data1_->self);
 
411
                _g_main_loop_unref0 (_data1_->main_loop);
 
412
                g_slice_free (Block1Data, _data1_);
 
413
        }
 
414
}
 
415
 
 
416
 
 
417
void persona_store_capabilities_tests_test_persona_store_capabilities (PersonaStoreCapabilitiesTests* self) {
 
418
        Block1Data* _data1_;
 
419
        FolksBackendStore* backend_store;
 
420
        g_return_if_fail (self != NULL);
 
421
        _data1_ = g_slice_new0 (Block1Data);
 
422
        _data1_->_ref_count_ = 1;
 
423
        _data1_->self = g_object_ref (self);
 
424
        _data1_->main_loop = g_main_loop_new (NULL, FALSE);
 
425
        g_test_log_set_fatal_handler (__lambda0__glog_fatal_func, self);
 
426
        backend_store = folks_backend_store_dup ();
 
427
        g_signal_connect_object (backend_store, "backend-available", (GCallback) __lambda1__folks_backend_store_backend_available, self, 0);
 
428
        folks_backend_store_load_backends (backend_store, NULL, NULL);
 
429
        g_timeout_add_seconds_full (G_PRIORITY_DEFAULT, (guint) 3, __lambda4__gsource_func, block1_data_ref (_data1_), block1_data_unref);
 
430
        g_main_loop_run (_data1_->main_loop);
 
431
        g_assert (gee_abstract_collection_contains ((GeeAbstractCollection*) self->priv->group_flags_received, "can-add-personas"));
 
432
        g_assert (gee_abstract_collection_contains ((GeeAbstractCollection*) self->priv->group_flags_received, "can-remove-personas"));
 
433
        _g_object_unref0 (backend_store);
 
434
        block1_data_unref (_data1_);
 
435
}
 
436
 
 
437
 
 
438
static void _persona_store_capabilities_tests_can_add_personas_cb_g_object_notify (GObject* _sender, GParamSpec* pspec, gpointer self) {
 
439
        persona_store_capabilities_tests_can_add_personas_cb (self, _sender, pspec);
 
440
}
 
441
 
 
442
 
 
443
static void _persona_store_capabilities_tests_can_remove_personas_cb_g_object_notify (GObject* _sender, GParamSpec* pspec, gpointer self) {
 
444
        persona_store_capabilities_tests_can_remove_personas_cb (self, _sender, pspec);
 
445
}
 
446
 
 
447
 
 
448
static void _persona_store_capabilities_tests_can_alias_personas_cb_g_object_notify (GObject* _sender, GParamSpec* pspec, gpointer self) {
 
449
        persona_store_capabilities_tests_can_alias_personas_cb (self, _sender, pspec);
 
450
}
 
451
 
 
452
 
 
453
static void _persona_store_capabilities_tests_can_group_personas_cb_g_object_notify (GObject* _sender, GParamSpec* pspec, gpointer self) {
 
454
        persona_store_capabilities_tests_can_group_personas_cb (self, _sender, pspec);
 
455
}
 
456
 
 
457
 
 
458
static void _lambda3_ (GObject* obj, GAsyncResult* _result_, Block2Data* _data2_) {
 
459
        PersonaStoreCapabilitiesTests * self;
 
460
        GError * _inner_error_ = NULL;
 
461
        self = _data2_->self;
 
462
        g_return_if_fail (_result_ != NULL);
 
463
        {
 
464
                folks_persona_store_prepare_finish (_data2_->store, _result_, &_inner_error_);
 
465
                if (_inner_error_ != NULL) {
 
466
                        goto __catch5_g_error;
 
467
                }
 
468
                if (folks_persona_store_get_can_add_personas (_data2_->store) != FOLKS_MAYBE_BOOL_UNSET) {
 
469
                        persona_store_capabilities_tests_can_add_personas_cb (self, (GObject*) _data2_->store, NULL);
 
470
                } else {
 
471
                        g_signal_connect_object ((GObject*) _data2_->store, "notify::can-add-personas", (GCallback) _persona_store_capabilities_tests_can_add_personas_cb_g_object_notify, self, 0);
 
472
                }
 
473
                if (folks_persona_store_get_can_remove_personas (_data2_->store) != FOLKS_MAYBE_BOOL_UNSET) {
 
474
                        persona_store_capabilities_tests_can_remove_personas_cb (self, (GObject*) _data2_->store, NULL);
 
475
                } else {
 
476
                        g_signal_connect_object ((GObject*) _data2_->store, "notify::can-remove-personas", (GCallback) _persona_store_capabilities_tests_can_remove_personas_cb_g_object_notify, self, 0);
 
477
                }
 
478
                if (folks_persona_store_get_can_alias_personas (_data2_->store) != FOLKS_MAYBE_BOOL_UNSET) {
 
479
                        persona_store_capabilities_tests_can_alias_personas_cb (self, (GObject*) _data2_->store, NULL);
 
480
                } else {
 
481
                        g_signal_connect_object ((GObject*) _data2_->store, "notify::can-alias-personas", (GCallback) _persona_store_capabilities_tests_can_alias_personas_cb_g_object_notify, self, 0);
 
482
                }
 
483
                if (folks_persona_store_get_can_group_personas (_data2_->store) != FOLKS_MAYBE_BOOL_UNSET) {
 
484
                        persona_store_capabilities_tests_can_group_personas_cb (self, (GObject*) _data2_->store, NULL);
 
485
                } else {
 
486
                        g_signal_connect_object ((GObject*) _data2_->store, "notify::can-group-personas", (GCallback) _persona_store_capabilities_tests_can_group_personas_cb_g_object_notify, self, 0);
 
487
                }
 
488
        }
 
489
        goto __finally5;
 
490
        __catch5_g_error:
 
491
        {
 
492
                GError * e;
 
493
                e = _inner_error_;
 
494
                _inner_error_ = NULL;
 
495
                {
 
496
                        g_warning ("Error preparing PersonaStore type: %s, id: %s: " "'%s'", folks_persona_store_get_type_id (_data2_->store), folks_persona_store_get_id (_data2_->store), e->message);
 
497
                        _g_error_free0 (e);
 
498
                }
 
499
        }
 
500
        __finally5:
 
501
        if (_inner_error_ != NULL) {
 
502
                g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
 
503
                g_clear_error (&_inner_error_);
 
504
                return;
 
505
        }
 
506
}
 
507
 
 
508
 
 
509
static void __lambda3__gasync_ready_callback (GObject* source_object, GAsyncResult* res, gpointer self) {
 
510
        _lambda3_ (source_object, res, self);
 
511
        block2_data_unref (self);
 
512
}
 
513
 
 
514
 
 
515
static Block2Data* block2_data_ref (Block2Data* _data2_) {
 
516
        g_atomic_int_inc (&_data2_->_ref_count_);
 
517
        return _data2_;
 
518
}
 
519
 
 
520
 
 
521
static void block2_data_unref (Block2Data* _data2_) {
 
522
        if (g_atomic_int_dec_and_test (&_data2_->_ref_count_)) {
 
523
                _g_object_unref0 (_data2_->self);
 
524
                _g_object_unref0 (_data2_->store);
 
525
                g_slice_free (Block2Data, _data2_);
 
526
        }
 
527
}
 
528
 
 
529
 
 
530
static void persona_store_capabilities_tests_set_up_persona_store (PersonaStoreCapabilitiesTests* self, FolksPersonaStore* store) {
 
531
        Block2Data* _data2_;
 
532
        g_return_if_fail (self != NULL);
 
533
        g_return_if_fail (store != NULL);
 
534
        _data2_ = g_slice_new0 (Block2Data);
 
535
        _data2_->_ref_count_ = 1;
 
536
        _data2_->self = g_object_ref (self);
 
537
        _data2_->store = _g_object_ref0 (store);
 
538
        folks_persona_store_prepare (_data2_->store, __lambda3__gasync_ready_callback, block2_data_ref (_data2_));
 
539
        block2_data_unref (_data2_);
 
540
}
 
541
 
 
542
 
 
543
static void persona_store_capabilities_tests_can_add_personas_cb (PersonaStoreCapabilitiesTests* self, GObject* s, GParamSpec* p) {
 
544
        TpfPersonaStore* store;
 
545
        g_return_if_fail (self != NULL);
 
546
        g_return_if_fail (s != NULL);
 
547
        g_assert (TPF_IS_PERSONA_STORE (s));
 
548
        store = _g_object_ref0 (TPF_PERSONA_STORE (s));
 
549
        if (folks_persona_store_get_can_add_personas ((FolksPersonaStore*) store) != FOLKS_MAYBE_BOOL_UNSET) {
 
550
                guint _tmp0_;
 
551
                GQuark _tmp1_;
 
552
                g_assert (folks_persona_store_get_can_add_personas ((FolksPersonaStore*) store) == FOLKS_MAYBE_BOOL_TRUE);
 
553
                gee_abstract_collection_add ((GeeAbstractCollection*) self->priv->group_flags_received, "can-add-personas");
 
554
                g_signal_parse_name ("notify::can-add-personas", G_TYPE_OBJECT, &_tmp0_, &_tmp1_, TRUE);
 
555
                g_signal_handlers_disconnect_matched ((GObject*) store, G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_DETAIL | G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, _tmp0_, _tmp1_, NULL, (GCallback) _persona_store_capabilities_tests_can_add_personas_cb_g_object_notify, self);
 
556
        }
 
557
        _g_object_unref0 (store);
 
558
}
 
559
 
 
560
 
 
561
static void persona_store_capabilities_tests_can_remove_personas_cb (PersonaStoreCapabilitiesTests* self, GObject* s, GParamSpec* p) {
 
562
        TpfPersonaStore* store;
 
563
        g_return_if_fail (self != NULL);
 
564
        g_return_if_fail (s != NULL);
 
565
        g_assert (TPF_IS_PERSONA_STORE (s));
 
566
        store = _g_object_ref0 (TPF_PERSONA_STORE (s));
 
567
        if (folks_persona_store_get_can_remove_personas ((FolksPersonaStore*) store) != FOLKS_MAYBE_BOOL_UNSET) {
 
568
                guint _tmp0_;
 
569
                GQuark _tmp1_;
 
570
                g_assert (folks_persona_store_get_can_remove_personas ((FolksPersonaStore*) store) == FOLKS_MAYBE_BOOL_TRUE);
 
571
                gee_abstract_collection_add ((GeeAbstractCollection*) self->priv->group_flags_received, "can-remove-personas");
 
572
                g_signal_parse_name ("notify::can-remove-personas", G_TYPE_OBJECT, &_tmp0_, &_tmp1_, TRUE);
 
573
                g_signal_handlers_disconnect_matched ((GObject*) store, G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_DETAIL | G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, _tmp0_, _tmp1_, NULL, (GCallback) _persona_store_capabilities_tests_can_remove_personas_cb_g_object_notify, self);
 
574
        }
 
575
        _g_object_unref0 (store);
 
576
}
 
577
 
 
578
 
 
579
static void persona_store_capabilities_tests_can_alias_personas_cb (PersonaStoreCapabilitiesTests* self, GObject* s, GParamSpec* p) {
 
580
        TpfPersonaStore* store;
 
581
        g_return_if_fail (self != NULL);
 
582
        g_return_if_fail (s != NULL);
 
583
        g_assert (TPF_IS_PERSONA_STORE (s));
 
584
        store = _g_object_ref0 (TPF_PERSONA_STORE (s));
 
585
        if (folks_persona_store_get_can_alias_personas ((FolksPersonaStore*) store) != FOLKS_MAYBE_BOOL_UNSET) {
 
586
                guint _tmp0_;
 
587
                GQuark _tmp1_;
 
588
                g_assert (folks_persona_store_get_can_alias_personas ((FolksPersonaStore*) store) == FOLKS_MAYBE_BOOL_TRUE);
 
589
                gee_abstract_collection_add ((GeeAbstractCollection*) self->priv->group_flags_received, "can-alias-personas");
 
590
                g_signal_parse_name ("notify::can-alias-personas", G_TYPE_OBJECT, &_tmp0_, &_tmp1_, TRUE);
 
591
                g_signal_handlers_disconnect_matched ((GObject*) store, G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_DETAIL | G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, _tmp0_, _tmp1_, NULL, (GCallback) _persona_store_capabilities_tests_can_alias_personas_cb_g_object_notify, self);
 
592
        }
 
593
        _g_object_unref0 (store);
 
594
}
 
595
 
 
596
 
 
597
static void persona_store_capabilities_tests_can_group_personas_cb (PersonaStoreCapabilitiesTests* self, GObject* s, GParamSpec* p) {
 
598
        TpfPersonaStore* store;
 
599
        g_return_if_fail (self != NULL);
 
600
        g_return_if_fail (s != NULL);
 
601
        g_assert (TPF_IS_PERSONA_STORE (s));
 
602
        store = _g_object_ref0 (TPF_PERSONA_STORE (s));
 
603
        if (folks_persona_store_get_can_group_personas ((FolksPersonaStore*) store) != FOLKS_MAYBE_BOOL_UNSET) {
 
604
                guint _tmp0_;
 
605
                GQuark _tmp1_;
 
606
                g_assert (folks_persona_store_get_can_group_personas ((FolksPersonaStore*) store) == FOLKS_MAYBE_BOOL_TRUE);
 
607
                gee_abstract_collection_add ((GeeAbstractCollection*) self->priv->group_flags_received, "can-group-personas");
 
608
                g_signal_parse_name ("notify::can-group-personas", G_TYPE_OBJECT, &_tmp0_, &_tmp1_, TRUE);
 
609
                g_signal_handlers_disconnect_matched ((GObject*) store, G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_DETAIL | G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, _tmp0_, _tmp1_, NULL, (GCallback) _persona_store_capabilities_tests_can_group_personas_cb_g_object_notify, self);
 
610
        }
 
611
        _g_object_unref0 (store);
 
612
}
 
613
 
 
614
 
 
615
static void persona_store_capabilities_tests_class_init (PersonaStoreCapabilitiesTestsClass * klass) {
 
616
        persona_store_capabilities_tests_parent_class = g_type_class_peek_parent (klass);
 
617
        g_type_class_add_private (klass, sizeof (PersonaStoreCapabilitiesTestsPrivate));
 
618
        FOLKS_TEST_CASE_CLASS (klass)->set_up = persona_store_capabilities_tests_real_set_up;
 
619
        FOLKS_TEST_CASE_CLASS (klass)->tear_down = persona_store_capabilities_tests_real_tear_down;
 
620
        G_OBJECT_CLASS (klass)->finalize = persona_store_capabilities_tests_finalize;
 
621
}
 
622
 
 
623
 
 
624
static void persona_store_capabilities_tests_instance_init (PersonaStoreCapabilitiesTests * self) {
 
625
        self->priv = PERSONA_STORE_CAPABILITIES_TESTS_GET_PRIVATE (self);
 
626
}
 
627
 
 
628
 
 
629
static void persona_store_capabilities_tests_finalize (GObject* obj) {
 
630
        PersonaStoreCapabilitiesTests * self;
 
631
        self = PERSONA_STORE_CAPABILITIES_TESTS (obj);
 
632
        _g_object_unref0 (self->priv->daemon);
 
633
        _g_object_unref0 (self->priv->account);
 
634
        _g_object_unref0 (self->priv->account_manager);
 
635
        _g_object_unref0 (self->priv->conn);
 
636
        _g_main_loop_unref0 (self->priv->main_loop);
 
637
        _g_free0 (self->priv->bus_name);
 
638
        _g_free0 (self->priv->object_path);
 
639
        _g_object_unref0 (self->priv->group_flags_received);
 
640
        G_OBJECT_CLASS (persona_store_capabilities_tests_parent_class)->finalize (obj);
 
641
}
 
642
 
 
643
 
 
644
GType persona_store_capabilities_tests_get_type (void) {
 
645
        static volatile gsize persona_store_capabilities_tests_type_id__volatile = 0;
 
646
        if (g_once_init_enter (&persona_store_capabilities_tests_type_id__volatile)) {
 
647
                static const GTypeInfo g_define_type_info = { sizeof (PersonaStoreCapabilitiesTestsClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) persona_store_capabilities_tests_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (PersonaStoreCapabilitiesTests), 0, (GInstanceInitFunc) persona_store_capabilities_tests_instance_init, NULL };
 
648
                GType persona_store_capabilities_tests_type_id;
 
649
                persona_store_capabilities_tests_type_id = g_type_register_static (FOLKS_TYPE_TEST_CASE, "PersonaStoreCapabilitiesTests", &g_define_type_info, 0);
 
650
                g_once_init_leave (&persona_store_capabilities_tests_type_id__volatile, persona_store_capabilities_tests_type_id);
 
651
        }
 
652
        return persona_store_capabilities_tests_type_id__volatile;
 
653
}
 
654
 
 
655
 
 
656
gint _vala_main (char** args, int args_length1) {
 
657
        gint result = 0;
 
658
        GTestSuite* root;
 
659
        PersonaStoreCapabilitiesTests* _tmp0_;
 
660
        g_test_init (&args_length1, &args, NULL);
 
661
        root = g_test_get_root ();
 
662
        g_test_suite_add_suite (root, folks_test_case_get_suite ((FolksTestCase*) (_tmp0_ = persona_store_capabilities_tests_new ())));
 
663
        _g_object_unref0 (_tmp0_);
 
664
        g_test_run ();
 
665
        result = 0;
 
666
        return result;
 
667
}
 
668
 
 
669
 
 
670
int main (int argc, char ** argv) {
 
671
        g_type_init ();
 
672
        return _vala_main (argv, argc);
 
673
}
 
674
 
 
675
 
 
676
static int _vala_strcmp0 (const char * str1, const char * str2) {
 
677
        if (str1 == NULL) {
 
678
                return -(str1 != str2);
 
679
        }
 
680
        if (str2 == NULL) {
 
681
                return str1 != str2;
 
682
        }
 
683
        return strcmp (str1, str2);
 
684
}
 
685
 
 
686
 
 
687
 
 
688