~ubuntu-branches/ubuntu/precise/folks/precise

« back to all changes in this revision

Viewing changes to tests/tracker/add-persona.c

  • Committer: Bazaar Package Importer
  • Author(s): Ken VanDine
  • Date: 2011-06-10 11:28:11 UTC
  • mfrom: (1.2.11 upstream) (4.2.1 experimental)
  • Revision ID: james.westby@ubuntu.com-20110610112811-whyeodbo9mjezxfp
Tags: 0.5.2-1ubuntu1
* Merge with Debian experimental, remaining Ubuntu changes:
  - debian/control:
    + Add Vcs-Bzr link

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
/* add-persona.c generated by valac 0.12.0, the Vala compiler
 
2
 * generated from add-persona.vala, do not modify */
 
3
 
 
4
/*
 
5
 * Copyright (C) 2011 Collabora Ltd.
 
6
 *
 
7
 * This library is free software: you can redistribute it and/or modify
 
8
 * it under the terms of the GNU Lesser General Public License as published by
 
9
 * the Free Software Foundation, either version 2.1 of the License, or
 
10
 * (at your option) any later version.
 
11
 *
 
12
 * This library is distributed in the hope that it will be useful,
 
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
15
 * GNU Lesser General Public License for more details.
 
16
 *
 
17
 * You should have received a copy of the GNU Lesser General Public License
 
18
 * along with this library.  If not, see <http://www.gnu.org/licenses/>.
 
19
 *
 
20
 * Authors: Raul Gutierrez Segales <raul.gutierrez.segales@collabora.co.uk>
 
21
 *
 
22
 */
 
23
 
 
24
#include <glib.h>
 
25
#include <glib-object.h>
 
26
#include <folks-test.h>
 
27
#include <tracker-test.h>
 
28
#include <folks/folks.h>
 
29
#include <stdlib.h>
 
30
#include <string.h>
 
31
#include <folks/folks-tracker.h>
 
32
#include <gee.h>
 
33
#include <gio/gio.h>
 
34
 
 
35
 
 
36
#define TYPE_ADD_PERSONA_TESTS (add_persona_tests_get_type ())
 
37
#define ADD_PERSONA_TESTS(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_ADD_PERSONA_TESTS, AddPersonaTests))
 
38
#define ADD_PERSONA_TESTS_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_ADD_PERSONA_TESTS, AddPersonaTestsClass))
 
39
#define IS_ADD_PERSONA_TESTS(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_ADD_PERSONA_TESTS))
 
40
#define IS_ADD_PERSONA_TESTS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_ADD_PERSONA_TESTS))
 
41
#define ADD_PERSONA_TESTS_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_ADD_PERSONA_TESTS, AddPersonaTestsClass))
 
42
 
 
43
typedef struct _AddPersonaTests AddPersonaTests;
 
44
typedef struct _AddPersonaTestsClass AddPersonaTestsClass;
 
45
typedef struct _AddPersonaTestsPrivate AddPersonaTestsPrivate;
 
46
#define _g_main_loop_unref0(var) ((var == NULL) ? NULL : (var = (g_main_loop_unref (var), NULL)))
 
47
#define _tracker_test_backend_unref0(var) ((var == NULL) ? NULL : (var = (tracker_test_backend_unref (var), NULL)))
 
48
#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
 
49
#define _g_free0(var) (var = (g_free (var), NULL))
 
50
#define _g_hash_table_unref0(var) ((var == NULL) ? NULL : (var = (g_hash_table_unref (var), NULL)))
 
51
#define _g_date_time_unref0(var) ((var == NULL) ? NULL : (var = (g_date_time_unref (var), NULL)))
 
52
#define _g_list_free0(var) ((var == NULL) ? NULL : (var = (g_list_free (var), NULL)))
 
53
#define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL)))
 
54
typedef struct _AddPersonaTestsTestAddPersonaAsyncData AddPersonaTestsTestAddPersonaAsyncData;
 
55
#define __vala_GValue_free0(var) ((var == NULL) ? NULL : (var = (_vala_GValue_free (var), NULL)))
 
56
typedef struct _AddPersonaTestsAddPersonaData AddPersonaTestsAddPersonaData;
 
57
 
 
58
struct _AddPersonaTests {
 
59
        FolksTestCase parent_instance;
 
60
        AddPersonaTestsPrivate * priv;
 
61
};
 
62
 
 
63
struct _AddPersonaTestsClass {
 
64
        FolksTestCaseClass parent_class;
 
65
};
 
66
 
 
67
struct _AddPersonaTestsPrivate {
 
68
        GMainLoop* _main_loop;
 
69
        TrackerTestBackend* _tracker_backend;
 
70
        FolksIndividualAggregator* _aggregator;
 
71
        gchar* _persona_fullname;
 
72
        gchar* _persona_alias;
 
73
        gchar* _family_name;
 
74
        gchar* _given_name;
 
75
        GHashTable* _properties_found;
 
76
        gchar* _persona_iid;
 
77
        gchar* _file_uri;
 
78
        gchar* _birthday;
 
79
        GDateTime* _bday;
 
80
        gchar* _email_1;
 
81
        gchar* _email_2;
 
82
        gchar* _im_addr_1;
 
83
        gchar* _im_addr_2;
 
84
        gchar* _note_1;
 
85
        gchar* _phone_1;
 
86
        gchar* _phone_2;
 
87
        gchar* _title_1;
 
88
        gchar* _organisation_1;
 
89
        FolksPostalAddress* _address;
 
90
        gchar* _po_box;
 
91
        gchar* _locality;
 
92
        gchar* _postal_code;
 
93
        gchar* _street;
 
94
        gchar* _extension;
 
95
        gchar* _country;
 
96
        gchar* _region;
 
97
        gchar* _url_1;
 
98
        gchar* _url_2;
 
99
        TrfPersonaStore* _pstore;
 
100
        gboolean _added_persona;
 
101
        GStaticRecMutex __lock__added_persona;
 
102
};
 
103
 
 
104
struct _AddPersonaTestsTestAddPersonaAsyncData {
 
105
        int _state_;
 
106
        GObject* _source_object_;
 
107
        GAsyncResult* _res_;
 
108
        GSimpleAsyncResult* _async_result;
 
109
        AddPersonaTests* self;
 
110
        FolksBackendStore* _tmp0_;
 
111
        FolksBackendStore* store;
 
112
        FolksIndividualAggregator* _tmp1_;
 
113
        GeeMap* _tmp2_;
 
114
        GeeCollection* _tmp3_;
 
115
        GeeCollection* _tmp4_;
 
116
        GeeIterator* _tmp5_;
 
117
        GeeIterator* _tmp6_;
 
118
        GeeIterator* _backend_it;
 
119
        gboolean _tmp7_;
 
120
        gpointer _tmp8_;
 
121
        FolksBackend* backend;
 
122
        GeeMap* _tmp9_;
 
123
        gpointer _tmp10_;
 
124
        GError * e;
 
125
        GError * _inner_error_;
 
126
};
 
127
 
 
128
struct _AddPersonaTestsAddPersonaData {
 
129
        int _state_;
 
130
        GObject* _source_object_;
 
131
        GAsyncResult* _res_;
 
132
        GSimpleAsyncResult* _async_result;
 
133
        AddPersonaTests* self;
 
134
        GHashTable* _tmp0_;
 
135
        GHashTable* details;
 
136
        GValue _tmp1_;
 
137
        GValue _tmp2_;
 
138
        GValue _tmp3_;
 
139
        GValue* _tmp4_;
 
140
        GValue* _tmp5_;
 
141
        GValue* v1;
 
142
        const gchar* _tmp6_;
 
143
        gchar* _tmp7_;
 
144
        GValue* _tmp8_;
 
145
        GValue _tmp9_;
 
146
        GValue _tmp10_;
 
147
        GValue _tmp11_;
 
148
        GValue* _tmp12_;
 
149
        GValue* _tmp13_;
 
150
        GValue* v2;
 
151
        const gchar* _tmp14_;
 
152
        gchar* _tmp15_;
 
153
        GValue* _tmp16_;
 
154
        GValue _tmp17_;
 
155
        GValue _tmp18_;
 
156
        GValue _tmp19_;
 
157
        GValue* _tmp20_;
 
158
        GValue* _tmp21_;
 
159
        GValue* v3;
 
160
        const gchar* _tmp22_;
 
161
        gchar* _tmp23_;
 
162
        GValue* _tmp24_;
 
163
        GValue _tmp25_;
 
164
        GValue _tmp26_;
 
165
        GValue _tmp27_;
 
166
        GValue* _tmp28_;
 
167
        GValue* _tmp29_;
 
168
        GValue* v4;
 
169
        FolksStructuredName* _tmp30_;
 
170
        FolksStructuredName* sname;
 
171
        const gchar* _tmp31_;
 
172
        gchar* _tmp32_;
 
173
        GValue* _tmp33_;
 
174
        GValue _tmp34_;
 
175
        GValue _tmp35_;
 
176
        GValue _tmp36_;
 
177
        GValue* _tmp37_;
 
178
        GValue* _tmp38_;
 
179
        GValue* v5;
 
180
        GFile* _tmp39_;
 
181
        GFile* avatar;
 
182
        const gchar* _tmp40_;
 
183
        gchar* _tmp41_;
 
184
        GValue* _tmp42_;
 
185
        GValue _tmp43_;
 
186
        GValue _tmp44_;
 
187
        GValue _tmp45_;
 
188
        GValue* _tmp46_;
 
189
        GValue* _tmp47_;
 
190
        GValue* v6;
 
191
        GTimeVal t;
 
192
        GDateTime* _tmp48_;
 
193
        GDateTime* dobj;
 
194
        const gchar* _tmp49_;
 
195
        gchar* _tmp50_;
 
196
        GValue* _tmp51_;
 
197
        GValue _tmp52_;
 
198
        GValue _tmp53_;
 
199
        GValue _tmp54_;
 
200
        GValue* _tmp55_;
 
201
        GValue* _tmp56_;
 
202
        GValue* v7;
 
203
        const gchar* _tmp57_;
 
204
        gchar* _tmp58_;
 
205
        GValue* _tmp59_;
 
206
        GValue _tmp60_;
 
207
        GValue _tmp61_;
 
208
        GValue _tmp62_;
 
209
        GValue* _tmp63_;
 
210
        GValue* _tmp64_;
 
211
        GValue* v8;
 
212
        GeeHashSet* _tmp65_;
 
213
        GeeHashSet* emails;
 
214
        FolksFieldDetails* _tmp66_;
 
215
        FolksFieldDetails* email_1;
 
216
        FolksFieldDetails* _tmp67_;
 
217
        FolksFieldDetails* email_2;
 
218
        const gchar* _tmp68_;
 
219
        gchar* _tmp69_;
 
220
        GValue* _tmp70_;
 
221
        GValue _tmp71_;
 
222
        GValue _tmp72_;
 
223
        GValue _tmp73_;
 
224
        GValue* _tmp74_;
 
225
        GValue* _tmp75_;
 
226
        GValue* v9;
 
227
        GeeHashMultiMap* _tmp76_;
 
228
        GeeHashMultiMap* im_addrs;
 
229
        const gchar* _tmp77_;
 
230
        gchar* _tmp78_;
 
231
        GValue* _tmp79_;
 
232
        GValue _tmp80_;
 
233
        GValue _tmp81_;
 
234
        GValue _tmp82_;
 
235
        GValue* _tmp83_;
 
236
        GValue* _tmp84_;
 
237
        GValue* v10;
 
238
        GeeHashSet* _tmp85_;
 
239
        GeeHashSet* notes;
 
240
        FolksNote* _tmp86_;
 
241
        FolksNote* n1;
 
242
        const gchar* _tmp87_;
 
243
        gchar* _tmp88_;
 
244
        GValue* _tmp89_;
 
245
        GValue _tmp90_;
 
246
        GValue _tmp91_;
 
247
        GValue _tmp92_;
 
248
        GValue* _tmp93_;
 
249
        GValue* _tmp94_;
 
250
        GValue* v11;
 
251
        GeeHashSet* _tmp95_;
 
252
        GeeHashSet* phones;
 
253
        FolksFieldDetails* _tmp96_;
 
254
        FolksFieldDetails* phone_1;
 
255
        FolksFieldDetails* _tmp97_;
 
256
        FolksFieldDetails* phone_2;
 
257
        const gchar* _tmp98_;
 
258
        gchar* _tmp99_;
 
259
        GValue* _tmp100_;
 
260
        GValue _tmp101_;
 
261
        GValue _tmp102_;
 
262
        GValue _tmp103_;
 
263
        GValue* _tmp104_;
 
264
        GValue* _tmp105_;
 
265
        GValue* v12;
 
266
        GeeHashSet* _tmp106_;
 
267
        GeeHashSet* roles;
 
268
        FolksRole* _tmp107_;
 
269
        FolksRole* r1;
 
270
        const gchar* _tmp108_;
 
271
        gchar* _tmp109_;
 
272
        GValue* _tmp110_;
 
273
        GValue _tmp111_;
 
274
        GValue _tmp112_;
 
275
        GValue _tmp113_;
 
276
        GValue* _tmp114_;
 
277
        GValue* _tmp115_;
 
278
        GValue* v13;
 
279
        GeeHashSet* _tmp116_;
 
280
        GeeHashSet* postal_addresses;
 
281
        GeeHashSet* _tmp117_;
 
282
        GeeHashSet* types;
 
283
        FolksPostalAddress* _tmp118_;
 
284
        FolksPostalAddress* postal_a;
 
285
        const gchar* _tmp119_;
 
286
        gchar* _tmp120_;
 
287
        GValue* _tmp121_;
 
288
        GValue _tmp122_;
 
289
        GValue _tmp123_;
 
290
        GValue _tmp124_;
 
291
        GValue* _tmp125_;
 
292
        GValue* _tmp126_;
 
293
        GValue* v14;
 
294
        GeeHashSet* _tmp127_;
 
295
        GeeHashSet* urls;
 
296
        FolksFieldDetails* _tmp128_;
 
297
        FolksFieldDetails* url_1;
 
298
        FolksFieldDetails* _tmp129_;
 
299
        FolksFieldDetails* url_2;
 
300
        const gchar* _tmp130_;
 
301
        gchar* _tmp131_;
 
302
        GValue* _tmp132_;
 
303
        FolksPersona* _tmp133_;
 
304
        FolksPersona* _tmp134_;
 
305
        TrfPersona* persona;
 
306
        const gchar* _tmp135_;
 
307
        gchar* _tmp136_;
 
308
        GError * e;
 
309
        GError * _inner_error_;
 
310
};
 
311
 
 
312
 
 
313
static gpointer add_persona_tests_parent_class = NULL;
 
314
 
 
315
GType add_persona_tests_get_type (void) G_GNUC_CONST;
 
316
#define ADD_PERSONA_TESTS_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), TYPE_ADD_PERSONA_TESTS, AddPersonaTestsPrivate))
 
317
enum  {
 
318
        ADD_PERSONA_TESTS_DUMMY_PROPERTY
 
319
};
 
320
AddPersonaTests* add_persona_tests_new (void);
 
321
AddPersonaTests* add_persona_tests_construct (GType object_type);
 
322
void add_persona_tests_test_add_persona (AddPersonaTests* self);
 
323
static void _add_persona_tests_test_add_persona_folks_test_case_test_method (gpointer self);
 
324
static void add_persona_tests_real_set_up (FolksTestCase* base);
 
325
static void add_persona_tests_real_tear_down (FolksTestCase* base);
 
326
static void _g_free0_ (gpointer var);
 
327
static void _add_persona_tests_test_add_persona_async (AddPersonaTests* self, GAsyncReadyCallback _callback_, gpointer _user_data_);
 
328
static void _add_persona_tests_test_add_persona_finish (AddPersonaTests* self, GAsyncResult* _res_);
 
329
static gboolean _lambda0_ (AddPersonaTests* self);
 
330
static gboolean __lambda0__gsource_func (gpointer self);
 
331
static void _add_persona_tests_test_add_persona_async_data_free (gpointer _data);
 
332
static gboolean _add_persona_tests_test_add_persona_async_co (AddPersonaTestsTestAddPersonaAsyncData* data);
 
333
static void _add_persona_tests_test_add_persona_async_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
 
334
static void _add_persona_tests_individuals_changed_cb (AddPersonaTests* self, GeeSet* added, GeeSet* removed, const gchar* message, FolksPersona* actor, FolksGroupDetailsChangeReason reason);
 
335
static void __add_persona_tests_individuals_changed_cb_folks_individual_aggregator_individuals_changed (FolksIndividualAggregator* _sender, GeeSet* added, GeeSet* removed, const gchar* message, FolksPersona* actor, FolksGroupDetailsChangeReason reason, gpointer self);
 
336
static void _add_persona_tests_notify_pstore_cb (AddPersonaTests* self, GObject* _pstore, GParamSpec* ps);
 
337
static void __add_persona_tests_notify_pstore_cb_g_object_notify (GObject* _sender, GParamSpec* pspec, gpointer self);
 
338
static void _add_persona_tests_try_to_add (AddPersonaTests* self);
 
339
static void _add_persona_tests_add_persona_data_free (gpointer _data);
 
340
static void _add_persona_tests_add_persona (AddPersonaTests* self, GAsyncReadyCallback _callback_, gpointer _user_data_);
 
341
static void _add_persona_tests_add_persona_finish (AddPersonaTests* self, GAsyncResult* _res_);
 
342
static gboolean _add_persona_tests_add_persona_co (AddPersonaTestsAddPersonaData* data);
 
343
static void _vala_GValue_free (GValue* self);
 
344
static void __vala_GValue_free0_ (gpointer var);
 
345
static GValue* _g_value_dup (GValue* self);
 
346
static void _add_persona_tests_add_persona_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_);
 
347
static void _add_persona_tests_notify_persona_sname (AddPersonaTests* self, GObject* persona_p, GParamSpec* ps);
 
348
static void __add_persona_tests_notify_persona_sname_g_object_notify (GObject* _sender, GParamSpec* pspec, gpointer self);
 
349
static void _add_persona_tests_notify_cb (AddPersonaTests* self, GObject* individual_obj, GParamSpec* ps);
 
350
static void __add_persona_tests_notify_cb_g_object_notify (GObject* _sender, GParamSpec* pspec, gpointer self);
 
351
static void _add_persona_tests_check_properties (AddPersonaTests* self, FolksIndividual* i);
 
352
static void _add_persona_tests_check_sname (AddPersonaTests* self, FolksStructuredName* sname);
 
353
static void _add_persona_tests_exit_if_all_properties_found (AddPersonaTests* self);
 
354
static void add_persona_tests_finalize (GObject* obj);
 
355
gint _vala_main (gchar** args, int args_length1);
 
356
 
 
357
 
 
358
static void _add_persona_tests_test_add_persona_folks_test_case_test_method (gpointer self) {
 
359
        add_persona_tests_test_add_persona (self);
 
360
}
 
361
 
 
362
 
 
363
AddPersonaTests* add_persona_tests_construct (GType object_type) {
 
364
        AddPersonaTests * self = NULL;
 
365
        TrackerTestBackend* _tmp0_ = NULL;
 
366
        self = (AddPersonaTests*) folks_test_case_construct (object_type, "AddPersonaTests");
 
367
        _tmp0_ = tracker_test_backend_new ();
 
368
        _tracker_test_backend_unref0 (self->priv->_tracker_backend);
 
369
        self->priv->_tracker_backend = _tmp0_;
 
370
        folks_test_case_add_test ((FolksTestCase*) self, "test adding personas to Tracker ", _add_persona_tests_test_add_persona_folks_test_case_test_method, self);
 
371
        return self;
 
372
}
 
373
 
 
374
 
 
375
AddPersonaTests* add_persona_tests_new (void) {
 
376
        return add_persona_tests_construct (TYPE_ADD_PERSONA_TESTS);
 
377
}
 
378
 
 
379
 
 
380
static void add_persona_tests_real_set_up (FolksTestCase* base) {
 
381
        AddPersonaTests * self;
 
382
        self = (AddPersonaTests*) base;
 
383
}
 
384
 
 
385
 
 
386
static void add_persona_tests_real_tear_down (FolksTestCase* base) {
 
387
        AddPersonaTests * self;
 
388
        self = (AddPersonaTests*) base;
 
389
}
 
390
 
 
391
 
 
392
static void _g_free0_ (gpointer var) {
 
393
        var = (g_free (var), NULL);
 
394
}
 
395
 
 
396
 
 
397
static gboolean _lambda0_ (AddPersonaTests* self) {
 
398
        gboolean result = FALSE;
 
399
        g_main_loop_quit (self->priv->_main_loop);
 
400
        g_assert_not_reached ();
 
401
        return result;
 
402
}
 
403
 
 
404
 
 
405
static gboolean __lambda0__gsource_func (gpointer self) {
 
406
        gboolean result;
 
407
        result = _lambda0_ (self);
 
408
        return result;
 
409
}
 
410
 
 
411
 
 
412
void add_persona_tests_test_add_persona (AddPersonaTests* self) {
 
413
        GMainLoop* _tmp0_ = NULL;
 
414
        gchar* _tmp1_;
 
415
        gchar* _tmp2_;
 
416
        gchar* _tmp3_;
 
417
        gchar* _tmp4_;
 
418
        gchar* _tmp5_;
 
419
        gchar* _tmp6_;
 
420
        gchar* _tmp7_;
 
421
        gchar* _tmp8_;
 
422
        gchar* _tmp9_;
 
423
        gchar* _tmp10_;
 
424
        gchar* _tmp11_;
 
425
        gchar* _tmp12_;
 
426
        gchar* _tmp13_;
 
427
        gchar* _tmp14_;
 
428
        gchar* _tmp15_;
 
429
        gchar* _tmp16_;
 
430
        GeeHashSet* _tmp17_ = NULL;
 
431
        GeeHashSet* types;
 
432
        FolksPostalAddress* _tmp18_ = NULL;
 
433
        GTimeVal t = {0};
 
434
        GDateTime* _tmp19_ = NULL;
 
435
        GHashTable* _tmp20_ = NULL;
 
436
        gchar* _tmp21_;
 
437
        gchar* _tmp22_;
 
438
        gchar* _tmp23_;
 
439
        gchar* _tmp24_;
 
440
        gchar* _tmp25_;
 
441
        gchar* _tmp26_;
 
442
        gchar* _tmp27_;
 
443
        gchar* _tmp28_;
 
444
        gchar* _tmp29_;
 
445
        gchar* _tmp30_;
 
446
        gchar* _tmp31_;
 
447
        gchar* _tmp32_;
 
448
        gchar* _tmp33_;
 
449
        gchar* _tmp34_;
 
450
        gchar* _tmp35_;
 
451
        gchar* _tmp36_;
 
452
        gchar* _tmp37_;
 
453
        gchar* _tmp38_;
 
454
        GList* _tmp39_ = NULL;
 
455
        g_return_if_fail (self != NULL);
 
456
        _tmp0_ = g_main_loop_new (NULL, FALSE);
 
457
        _g_main_loop_unref0 (self->priv->_main_loop);
 
458
        self->priv->_main_loop = _tmp0_;
 
459
        _tmp1_ = g_strdup ("persona #1");
 
460
        _g_free0 (self->priv->_persona_fullname);
 
461
        self->priv->_persona_fullname = _tmp1_;
 
462
        _tmp2_ = g_strdup ("alias");
 
463
        _g_free0 (self->priv->_persona_alias);
 
464
        self->priv->_persona_alias = _tmp2_;
 
465
        _tmp3_ = g_strdup ("family");
 
466
        _g_free0 (self->priv->_family_name);
 
467
        self->priv->_family_name = _tmp3_;
 
468
        _tmp4_ = g_strdup ("given");
 
469
        _g_free0 (self->priv->_given_name);
 
470
        self->priv->_given_name = _tmp4_;
 
471
        _tmp5_ = g_strdup ("");
 
472
        _g_free0 (self->priv->_persona_iid);
 
473
        self->priv->_persona_iid = _tmp5_;
 
474
        _tmp6_ = g_strdup ("file:///tmp/some-avatar.jpg");
 
475
        _g_free0 (self->priv->_file_uri);
 
476
        self->priv->_file_uri = _tmp6_;
 
477
        _tmp7_ = g_strdup ("2001-10-26T20:32:52Z");
 
478
        _g_free0 (self->priv->_birthday);
 
479
        self->priv->_birthday = _tmp7_;
 
480
        _tmp8_ = g_strdup ("someone-1@example.org");
 
481
        _g_free0 (self->priv->_email_1);
 
482
        self->priv->_email_1 = _tmp8_;
 
483
        _tmp9_ = g_strdup ("someone-2@example.org");
 
484
        _g_free0 (self->priv->_email_2);
 
485
        self->priv->_email_2 = _tmp9_;
 
486
        _tmp10_ = g_strdup ("someone-1@jabber.example.org");
 
487
        _g_free0 (self->priv->_im_addr_1);
 
488
        self->priv->_im_addr_1 = _tmp10_;
 
489
        _tmp11_ = g_strdup ("someone-2@jabber.example.org");
 
490
        _g_free0 (self->priv->_im_addr_2);
 
491
        self->priv->_im_addr_2 = _tmp11_;
 
492
        _tmp12_ = g_strdup ("this is a note");
 
493
        _g_free0 (self->priv->_note_1);
 
494
        self->priv->_note_1 = _tmp12_;
 
495
        _tmp13_ = g_strdup ("12345");
 
496
        _g_free0 (self->priv->_phone_1);
 
497
        self->priv->_phone_1 = _tmp13_;
 
498
        _tmp14_ = g_strdup ("54321");
 
499
        _g_free0 (self->priv->_phone_2);
 
500
        self->priv->_phone_2 = _tmp14_;
 
501
        _tmp15_ = g_strdup ("CFO");
 
502
        _g_free0 (self->priv->_title_1);
 
503
        self->priv->_title_1 = _tmp15_;
 
504
        _tmp16_ = g_strdup ("Example Inc.");
 
505
        _g_free0 (self->priv->_organisation_1);
 
506
        self->priv->_organisation_1 = _tmp16_;
 
507
        _tmp17_ = gee_hash_set_new (G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, g_free, NULL, NULL);
 
508
        types = _tmp17_;
 
509
        _tmp18_ = folks_postal_address_new (self->priv->_po_box, self->priv->_extension, self->priv->_street, self->priv->_locality, self->priv->_region, self->priv->_postal_code, self->priv->_country, NULL, (GeeSet*) types, NULL);
 
510
        _g_object_unref0 (self->priv->_address);
 
511
        self->priv->_address = _tmp18_;
 
512
        g_get_current_time (&t);
 
513
        g_time_val_from_iso8601 (self->priv->_birthday, &t);
 
514
        _tmp19_ = g_date_time_new_from_timeval_utc (&t);
 
515
        _g_date_time_unref0 (self->priv->_bday);
 
516
        self->priv->_bday = _tmp19_;
 
517
        _tmp20_ = g_hash_table_new_full (g_str_hash, g_str_equal, _g_free0_, NULL);
 
518
        _g_hash_table_unref0 (self->priv->_properties_found);
 
519
        self->priv->_properties_found = _tmp20_;
 
520
        _tmp21_ = g_strdup ("full_name");
 
521
        g_hash_table_insert (self->priv->_properties_found, _tmp21_, GINT_TO_POINTER (FALSE));
 
522
        _tmp22_ = g_strdup ("alias");
 
523
        g_hash_table_insert (self->priv->_properties_found, _tmp22_, GINT_TO_POINTER (FALSE));
 
524
        _tmp23_ = g_strdup ("is_favourite");
 
525
        g_hash_table_insert (self->priv->_properties_found, _tmp23_, GINT_TO_POINTER (FALSE));
 
526
        _tmp24_ = g_strdup ("structured_name");
 
527
        g_hash_table_insert (self->priv->_properties_found, _tmp24_, GINT_TO_POINTER (FALSE));
 
528
        _tmp25_ = g_strdup ("avatar");
 
529
        g_hash_table_insert (self->priv->_properties_found, _tmp25_, GINT_TO_POINTER (FALSE));
 
530
        _tmp26_ = g_strdup ("birthday");
 
531
        g_hash_table_insert (self->priv->_properties_found, _tmp26_, GINT_TO_POINTER (FALSE));
 
532
        _tmp27_ = g_strdup ("gender");
 
533
        g_hash_table_insert (self->priv->_properties_found, _tmp27_, GINT_TO_POINTER (FALSE));
 
534
        _tmp28_ = g_strdup ("email-1");
 
535
        g_hash_table_insert (self->priv->_properties_found, _tmp28_, GINT_TO_POINTER (FALSE));
 
536
        _tmp29_ = g_strdup ("email-2");
 
537
        g_hash_table_insert (self->priv->_properties_found, _tmp29_, GINT_TO_POINTER (FALSE));
 
538
        _tmp30_ = g_strdup ("im-addr-1");
 
539
        g_hash_table_insert (self->priv->_properties_found, _tmp30_, GINT_TO_POINTER (FALSE));
 
540
        _tmp31_ = g_strdup ("im-addr-2");
 
541
        g_hash_table_insert (self->priv->_properties_found, _tmp31_, GINT_TO_POINTER (FALSE));
 
542
        _tmp32_ = g_strdup ("note-1");
 
543
        g_hash_table_insert (self->priv->_properties_found, _tmp32_, GINT_TO_POINTER (FALSE));
 
544
        _tmp33_ = g_strdup ("phone-1");
 
545
        g_hash_table_insert (self->priv->_properties_found, _tmp33_, GINT_TO_POINTER (FALSE));
 
546
        _tmp34_ = g_strdup ("phone-2");
 
547
        g_hash_table_insert (self->priv->_properties_found, _tmp34_, GINT_TO_POINTER (FALSE));
 
548
        _tmp35_ = g_strdup ("role-1");
 
549
        g_hash_table_insert (self->priv->_properties_found, _tmp35_, GINT_TO_POINTER (FALSE));
 
550
        _tmp36_ = g_strdup ("postal-address-1");
 
551
        g_hash_table_insert (self->priv->_properties_found, _tmp36_, GINT_TO_POINTER (FALSE));
 
552
        _tmp37_ = g_strdup ("url-1");
 
553
        g_hash_table_insert (self->priv->_properties_found, _tmp37_, GINT_TO_POINTER (FALSE));
 
554
        _tmp38_ = g_strdup ("url-2");
 
555
        g_hash_table_insert (self->priv->_properties_found, _tmp38_, GINT_TO_POINTER (FALSE));
 
556
        _add_persona_tests_test_add_persona_async (self, NULL, NULL);
 
557
        g_timeout_add_seconds_full (G_PRIORITY_DEFAULT, (guint) 5, __lambda0__gsource_func, g_object_ref (self), g_object_unref);
 
558
        g_main_loop_run (self->priv->_main_loop);
 
559
        _tmp39_ = g_hash_table_get_values (self->priv->_properties_found);
 
560
        {
 
561
                GList* k_collection;
 
562
                GList* k_it;
 
563
                k_collection = _tmp39_;
 
564
                for (k_it = k_collection; k_it != NULL; k_it = k_it->next) {
 
565
                        gboolean k;
 
566
                        k = GPOINTER_TO_INT (k_it->data);
 
567
                        {
 
568
                                g_assert (k);
 
569
                        }
 
570
                }
 
571
                _g_list_free0 (k_collection);
 
572
        }
 
573
        tracker_test_backend_tear_down (self->priv->_tracker_backend);
 
574
        _g_object_unref0 (types);
 
575
}
 
576
 
 
577
 
 
578
static void _add_persona_tests_test_add_persona_async_data_free (gpointer _data) {
 
579
        AddPersonaTestsTestAddPersonaAsyncData* data;
 
580
        data = _data;
 
581
        _g_object_unref0 (data->self);
 
582
        g_slice_free (AddPersonaTestsTestAddPersonaAsyncData, data);
 
583
}
 
584
 
 
585
 
 
586
static gpointer _g_object_ref0 (gpointer self) {
 
587
        return self ? g_object_ref (self) : NULL;
 
588
}
 
589
 
 
590
 
 
591
static void _add_persona_tests_test_add_persona_async (AddPersonaTests* self, GAsyncReadyCallback _callback_, gpointer _user_data_) {
 
592
        AddPersonaTestsTestAddPersonaAsyncData* _data_;
 
593
        _data_ = g_slice_new0 (AddPersonaTestsTestAddPersonaAsyncData);
 
594
        _data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, _add_persona_tests_test_add_persona_async);
 
595
        g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, _add_persona_tests_test_add_persona_async_data_free);
 
596
        _data_->self = _g_object_ref0 (self);
 
597
        _add_persona_tests_test_add_persona_async_co (_data_);
 
598
}
 
599
 
 
600
 
 
601
static void _add_persona_tests_test_add_persona_finish (AddPersonaTests* self, GAsyncResult* _res_) {
 
602
        AddPersonaTestsTestAddPersonaAsyncData* _data_;
 
603
        _data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
 
604
}
 
605
 
 
606
 
 
607
static void _add_persona_tests_test_add_persona_async_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
 
608
        AddPersonaTestsTestAddPersonaAsyncData* data;
 
609
        data = _user_data_;
 
610
        data->_source_object_ = source_object;
 
611
        data->_res_ = _res_;
 
612
        _add_persona_tests_test_add_persona_async_co (data);
 
613
}
 
614
 
 
615
 
 
616
static void __add_persona_tests_individuals_changed_cb_folks_individual_aggregator_individuals_changed (FolksIndividualAggregator* _sender, GeeSet* added, GeeSet* removed, const gchar* message, FolksPersona* actor, FolksGroupDetailsChangeReason reason, gpointer self) {
 
617
        _add_persona_tests_individuals_changed_cb (self, added, removed, message, actor, reason);
 
618
}
 
619
 
 
620
 
 
621
static void __add_persona_tests_notify_pstore_cb_g_object_notify (GObject* _sender, GParamSpec* pspec, gpointer self) {
 
622
        _add_persona_tests_notify_pstore_cb (self, _sender, pspec);
 
623
}
 
624
 
 
625
 
 
626
static gboolean _add_persona_tests_test_add_persona_async_co (AddPersonaTestsTestAddPersonaAsyncData* data) {
 
627
        switch (data->_state_) {
 
628
                case 0:
 
629
                goto _state_0;
 
630
                case 1:
 
631
                goto _state_1;
 
632
                case 2:
 
633
                goto _state_2;
 
634
                default:
 
635
                g_assert_not_reached ();
 
636
        }
 
637
        _state_0:
 
638
        data->_tmp0_ = NULL;
 
639
        data->_tmp0_ = folks_backend_store_dup ();
 
640
        data->store = data->_tmp0_;
 
641
        data->_state_ = 1;
 
642
        folks_backend_store_prepare (data->store, _add_persona_tests_test_add_persona_async_ready, data);
 
643
        return FALSE;
 
644
        _state_1:
 
645
        folks_backend_store_prepare_finish (data->store, data->_res_);
 
646
        data->_tmp1_ = NULL;
 
647
        data->_tmp1_ = folks_individual_aggregator_new ();
 
648
        _g_object_unref0 (data->self->priv->_aggregator);
 
649
        data->self->priv->_aggregator = data->_tmp1_;
 
650
        g_signal_connect_object (data->self->priv->_aggregator, "individuals-changed", (GCallback) __add_persona_tests_individuals_changed_cb_folks_individual_aggregator_individuals_changed, data->self, 0);
 
651
        data->_state_ = 2;
 
652
        folks_individual_aggregator_prepare (data->self->priv->_aggregator, _add_persona_tests_test_add_persona_async_ready, data);
 
653
        return FALSE;
 
654
        _state_2:
 
655
        folks_individual_aggregator_prepare_finish (data->self->priv->_aggregator, data->_res_, &data->_inner_error_);
 
656
        if (data->_inner_error_ != NULL) {
 
657
                goto __catch0_g_error;
 
658
        }
 
659
        _g_object_unref0 (data->self->priv->_pstore);
 
660
        data->self->priv->_pstore = NULL;
 
661
        {
 
662
                data->_tmp2_ = NULL;
 
663
                data->_tmp2_ = folks_backend_store_get_enabled_backends (data->store);
 
664
                data->_tmp3_ = NULL;
 
665
                data->_tmp3_ = gee_map_get_values (data->_tmp2_);
 
666
                data->_tmp4_ = data->_tmp3_;
 
667
                data->_tmp5_ = NULL;
 
668
                data->_tmp5_ = gee_iterable_iterator ((GeeIterable*) data->_tmp4_);
 
669
                data->_tmp6_ = data->_tmp5_;
 
670
                _g_object_unref0 (data->_tmp4_);
 
671
                data->_backend_it = data->_tmp6_;
 
672
                while (TRUE) {
 
673
                        data->_tmp7_ = gee_iterator_next (data->_backend_it);
 
674
                        if (!data->_tmp7_) {
 
675
                                break;
 
676
                        }
 
677
                        data->_tmp8_ = NULL;
 
678
                        data->_tmp8_ = gee_iterator_get (data->_backend_it);
 
679
                        data->backend = (FolksBackend*) data->_tmp8_;
 
680
                        data->_tmp9_ = NULL;
 
681
                        data->_tmp9_ = folks_backend_get_persona_stores (data->backend);
 
682
                        data->_tmp10_ = NULL;
 
683
                        data->_tmp10_ = gee_map_get (data->_tmp9_, "tracker");
 
684
                        _g_object_unref0 (data->self->priv->_pstore);
 
685
                        data->self->priv->_pstore = TRF_PERSONA_STORE ((FolksPersonaStore*) data->_tmp10_);
 
686
                        if (data->self->priv->_pstore != NULL) {
 
687
                                _g_object_unref0 (data->backend);
 
688
                                break;
 
689
                        }
 
690
                        _g_object_unref0 (data->backend);
 
691
                }
 
692
                _g_object_unref0 (data->_backend_it);
 
693
        }
 
694
        g_assert (data->self->priv->_pstore != NULL);
 
695
        g_signal_connect_object ((GObject*) data->self->priv->_pstore, "notify::is-prepared", (GCallback) __add_persona_tests_notify_pstore_cb_g_object_notify, data->self, 0);
 
696
        _add_persona_tests_try_to_add (data->self);
 
697
        goto __finally0;
 
698
        __catch0_g_error:
 
699
        {
 
700
                data->e = data->_inner_error_;
 
701
                data->_inner_error_ = NULL;
 
702
                g_warning ("add-persona.vala:172: Error when calling prepare: %s\n", data->e->message);
 
703
                _g_error_free0 (data->e);
 
704
        }
 
705
        __finally0:
 
706
        if (data->_inner_error_ != NULL) {
 
707
                _g_object_unref0 (data->store);
 
708
                g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, data->_inner_error_->message, g_quark_to_string (data->_inner_error_->domain), data->_inner_error_->code);
 
709
                g_clear_error (&data->_inner_error_);
 
710
                return FALSE;
 
711
        }
 
712
        _g_object_unref0 (data->store);
 
713
        if (data->_state_ == 0) {
 
714
                g_simple_async_result_complete_in_idle (data->_async_result);
 
715
        } else {
 
716
                g_simple_async_result_complete (data->_async_result);
 
717
        }
 
718
        g_object_unref (data->_async_result);
 
719
        return FALSE;
 
720
}
 
721
 
 
722
 
 
723
static void _add_persona_tests_add_persona_data_free (gpointer _data) {
 
724
        AddPersonaTestsAddPersonaData* data;
 
725
        data = _data;
 
726
        _g_object_unref0 (data->self);
 
727
        g_slice_free (AddPersonaTestsAddPersonaData, data);
 
728
}
 
729
 
 
730
 
 
731
static void _add_persona_tests_add_persona (AddPersonaTests* self, GAsyncReadyCallback _callback_, gpointer _user_data_) {
 
732
        AddPersonaTestsAddPersonaData* _data_;
 
733
        _data_ = g_slice_new0 (AddPersonaTestsAddPersonaData);
 
734
        _data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, _add_persona_tests_add_persona);
 
735
        g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, _add_persona_tests_add_persona_data_free);
 
736
        _data_->self = _g_object_ref0 (self);
 
737
        _add_persona_tests_add_persona_co (_data_);
 
738
}
 
739
 
 
740
 
 
741
static void _add_persona_tests_add_persona_finish (AddPersonaTests* self, GAsyncResult* _res_) {
 
742
        AddPersonaTestsAddPersonaData* _data_;
 
743
        _data_ = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (_res_));
 
744
}
 
745
 
 
746
 
 
747
static void _vala_GValue_free (GValue* self) {
 
748
        g_value_unset (self);
 
749
        g_free (self);
 
750
}
 
751
 
 
752
 
 
753
static void __vala_GValue_free0_ (gpointer var) {
 
754
        (var == NULL) ? NULL : (var = (_vala_GValue_free (var), NULL));
 
755
}
 
756
 
 
757
 
 
758
static GValue* _g_value_dup (GValue* self) {
 
759
        return g_boxed_copy (G_TYPE_VALUE, self);
 
760
}
 
761
 
 
762
 
 
763
static gpointer __g_value_dup0 (gpointer self) {
 
764
        return self ? _g_value_dup (self) : NULL;
 
765
}
 
766
 
 
767
 
 
768
static void _add_persona_tests_add_persona_ready (GObject* source_object, GAsyncResult* _res_, gpointer _user_data_) {
 
769
        AddPersonaTestsAddPersonaData* data;
 
770
        data = _user_data_;
 
771
        data->_source_object_ = source_object;
 
772
        data->_res_ = _res_;
 
773
        _add_persona_tests_add_persona_co (data);
 
774
}
 
775
 
 
776
 
 
777
static gboolean _add_persona_tests_add_persona_co (AddPersonaTestsAddPersonaData* data) {
 
778
        switch (data->_state_) {
 
779
                case 0:
 
780
                goto _state_0;
 
781
                case 1:
 
782
                goto _state_1;
 
783
                default:
 
784
                g_assert_not_reached ();
 
785
        }
 
786
        _state_0:
 
787
        data->_tmp0_ = NULL;
 
788
        data->_tmp0_ = g_hash_table_new_full (g_str_hash, g_str_equal, _g_free0_, __vala_GValue_free0_);
 
789
        data->details = data->_tmp0_;
 
790
        memset (&data->_tmp1_, 0, sizeof (GValue));
 
791
        g_value_init (&data->_tmp1_, G_TYPE_STRING);
 
792
        memset (&data->_tmp2_, 0, sizeof (GValue));
 
793
        data->_tmp2_ = data->_tmp1_;
 
794
        data->_tmp3_ = data->_tmp2_;
 
795
        data->_tmp4_ = __g_value_dup0 (&data->_tmp3_);
 
796
        data->_tmp5_ = data->_tmp4_;
 
797
        G_IS_VALUE (&data->_tmp3_) ? (g_value_unset (&data->_tmp3_), NULL) : NULL;
 
798
        data->v1 = data->_tmp5_;
 
799
        g_value_set_string (data->v1, data->self->priv->_persona_fullname);
 
800
        data->_tmp6_ = NULL;
 
801
        data->_tmp6_ = folks_persona_store_detail_key (FOLKS_PERSONA_DETAIL_FULL_NAME);
 
802
        data->_tmp7_ = g_strdup (data->_tmp6_);
 
803
        data->_tmp8_ = data->v1;
 
804
        data->v1 = NULL;
 
805
        g_hash_table_insert (data->details, data->_tmp7_, data->_tmp8_);
 
806
        memset (&data->_tmp9_, 0, sizeof (GValue));
 
807
        g_value_init (&data->_tmp9_, G_TYPE_STRING);
 
808
        memset (&data->_tmp10_, 0, sizeof (GValue));
 
809
        data->_tmp10_ = data->_tmp9_;
 
810
        data->_tmp11_ = data->_tmp10_;
 
811
        data->_tmp12_ = __g_value_dup0 (&data->_tmp11_);
 
812
        data->_tmp13_ = data->_tmp12_;
 
813
        G_IS_VALUE (&data->_tmp11_) ? (g_value_unset (&data->_tmp11_), NULL) : NULL;
 
814
        data->v2 = data->_tmp13_;
 
815
        g_value_set_string (data->v2, data->self->priv->_persona_alias);
 
816
        data->_tmp14_ = NULL;
 
817
        data->_tmp14_ = folks_persona_store_detail_key (FOLKS_PERSONA_DETAIL_ALIAS);
 
818
        data->_tmp15_ = g_strdup (data->_tmp14_);
 
819
        data->_tmp16_ = data->v2;
 
820
        data->v2 = NULL;
 
821
        g_hash_table_insert (data->details, data->_tmp15_, data->_tmp16_);
 
822
        memset (&data->_tmp17_, 0, sizeof (GValue));
 
823
        g_value_init (&data->_tmp17_, G_TYPE_BOOLEAN);
 
824
        memset (&data->_tmp18_, 0, sizeof (GValue));
 
825
        data->_tmp18_ = data->_tmp17_;
 
826
        data->_tmp19_ = data->_tmp18_;
 
827
        data->_tmp20_ = __g_value_dup0 (&data->_tmp19_);
 
828
        data->_tmp21_ = data->_tmp20_;
 
829
        G_IS_VALUE (&data->_tmp19_) ? (g_value_unset (&data->_tmp19_), NULL) : NULL;
 
830
        data->v3 = data->_tmp21_;
 
831
        g_value_set_boolean (data->v3, TRUE);
 
832
        data->_tmp22_ = NULL;
 
833
        data->_tmp22_ = folks_persona_store_detail_key (FOLKS_PERSONA_DETAIL_IS_FAVOURITE);
 
834
        data->_tmp23_ = g_strdup (data->_tmp22_);
 
835
        data->_tmp24_ = data->v3;
 
836
        data->v3 = NULL;
 
837
        g_hash_table_insert (data->details, data->_tmp23_, data->_tmp24_);
 
838
        memset (&data->_tmp25_, 0, sizeof (GValue));
 
839
        g_value_init (&data->_tmp25_, FOLKS_TYPE_STRUCTURED_NAME);
 
840
        memset (&data->_tmp26_, 0, sizeof (GValue));
 
841
        data->_tmp26_ = data->_tmp25_;
 
842
        data->_tmp27_ = data->_tmp26_;
 
843
        data->_tmp28_ = __g_value_dup0 (&data->_tmp27_);
 
844
        data->_tmp29_ = data->_tmp28_;
 
845
        G_IS_VALUE (&data->_tmp27_) ? (g_value_unset (&data->_tmp27_), NULL) : NULL;
 
846
        data->v4 = data->_tmp29_;
 
847
        data->_tmp30_ = NULL;
 
848
        data->_tmp30_ = folks_structured_name_new (data->self->priv->_family_name, data->self->priv->_given_name, NULL, NULL, NULL);
 
849
        data->sname = data->_tmp30_;
 
850
        g_value_set_object (data->v4, (GObject*) data->sname);
 
851
        data->_tmp31_ = NULL;
 
852
        data->_tmp31_ = folks_persona_store_detail_key (FOLKS_PERSONA_DETAIL_STRUCTURED_NAME);
 
853
        data->_tmp32_ = g_strdup (data->_tmp31_);
 
854
        data->_tmp33_ = data->v4;
 
855
        data->v4 = NULL;
 
856
        g_hash_table_insert (data->details, data->_tmp32_, data->_tmp33_);
 
857
        memset (&data->_tmp34_, 0, sizeof (GValue));
 
858
        g_value_init (&data->_tmp34_, G_TYPE_FILE);
 
859
        memset (&data->_tmp35_, 0, sizeof (GValue));
 
860
        data->_tmp35_ = data->_tmp34_;
 
861
        data->_tmp36_ = data->_tmp35_;
 
862
        data->_tmp37_ = __g_value_dup0 (&data->_tmp36_);
 
863
        data->_tmp38_ = data->_tmp37_;
 
864
        G_IS_VALUE (&data->_tmp36_) ? (g_value_unset (&data->_tmp36_), NULL) : NULL;
 
865
        data->v5 = data->_tmp38_;
 
866
        data->_tmp39_ = NULL;
 
867
        data->_tmp39_ = g_file_new_for_uri (data->self->priv->_file_uri);
 
868
        data->avatar = data->_tmp39_;
 
869
        g_value_set_object (data->v5, (GObject*) data->avatar);
 
870
        data->_tmp40_ = NULL;
 
871
        data->_tmp40_ = folks_persona_store_detail_key (FOLKS_PERSONA_DETAIL_AVATAR);
 
872
        data->_tmp41_ = g_strdup (data->_tmp40_);
 
873
        data->_tmp42_ = data->v5;
 
874
        data->v5 = NULL;
 
875
        g_hash_table_insert (data->details, data->_tmp41_, data->_tmp42_);
 
876
        memset (&data->_tmp43_, 0, sizeof (GValue));
 
877
        g_value_init (&data->_tmp43_, G_TYPE_DATE_TIME);
 
878
        memset (&data->_tmp44_, 0, sizeof (GValue));
 
879
        data->_tmp44_ = data->_tmp43_;
 
880
        data->_tmp45_ = data->_tmp44_;
 
881
        data->_tmp46_ = __g_value_dup0 (&data->_tmp45_);
 
882
        data->_tmp47_ = data->_tmp46_;
 
883
        G_IS_VALUE (&data->_tmp45_) ? (g_value_unset (&data->_tmp45_), NULL) : NULL;
 
884
        data->v6 = data->_tmp47_;
 
885
        g_get_current_time (&data->t);
 
886
        g_time_val_from_iso8601 (data->self->priv->_birthday, &data->t);
 
887
        data->_tmp48_ = NULL;
 
888
        data->_tmp48_ = g_date_time_new_from_timeval_utc (&data->t);
 
889
        data->dobj = data->_tmp48_;
 
890
        g_value_set_boxed (data->v6, data->dobj);
 
891
        data->_tmp49_ = NULL;
 
892
        data->_tmp49_ = folks_persona_store_detail_key (FOLKS_PERSONA_DETAIL_BIRTHDAY);
 
893
        data->_tmp50_ = g_strdup (data->_tmp49_);
 
894
        data->_tmp51_ = data->v6;
 
895
        data->v6 = NULL;
 
896
        g_hash_table_insert (data->details, data->_tmp50_, data->_tmp51_);
 
897
        memset (&data->_tmp52_, 0, sizeof (GValue));
 
898
        g_value_init (&data->_tmp52_, FOLKS_TYPE_GENDER);
 
899
        memset (&data->_tmp53_, 0, sizeof (GValue));
 
900
        data->_tmp53_ = data->_tmp52_;
 
901
        data->_tmp54_ = data->_tmp53_;
 
902
        data->_tmp55_ = __g_value_dup0 (&data->_tmp54_);
 
903
        data->_tmp56_ = data->_tmp55_;
 
904
        G_IS_VALUE (&data->_tmp54_) ? (g_value_unset (&data->_tmp54_), NULL) : NULL;
 
905
        data->v7 = data->_tmp56_;
 
906
        g_value_set_enum (data->v7, (gint) FOLKS_GENDER_MALE);
 
907
        data->_tmp57_ = NULL;
 
908
        data->_tmp57_ = folks_persona_store_detail_key (FOLKS_PERSONA_DETAIL_GENDER);
 
909
        data->_tmp58_ = g_strdup (data->_tmp57_);
 
910
        data->_tmp59_ = data->v7;
 
911
        data->v7 = NULL;
 
912
        g_hash_table_insert (data->details, data->_tmp58_, data->_tmp59_);
 
913
        memset (&data->_tmp60_, 0, sizeof (GValue));
 
914
        g_value_init (&data->_tmp60_, GEE_TYPE_SET);
 
915
        memset (&data->_tmp61_, 0, sizeof (GValue));
 
916
        data->_tmp61_ = data->_tmp60_;
 
917
        data->_tmp62_ = data->_tmp61_;
 
918
        data->_tmp63_ = __g_value_dup0 (&data->_tmp62_);
 
919
        data->_tmp64_ = data->_tmp63_;
 
920
        G_IS_VALUE (&data->_tmp62_) ? (g_value_unset (&data->_tmp62_), NULL) : NULL;
 
921
        data->v8 = data->_tmp64_;
 
922
        data->_tmp65_ = NULL;
 
923
        data->_tmp65_ = gee_hash_set_new (FOLKS_TYPE_FIELD_DETAILS, (GBoxedCopyFunc) g_object_ref, g_object_unref, NULL, NULL);
 
924
        data->emails = data->_tmp65_;
 
925
        data->_tmp66_ = NULL;
 
926
        data->_tmp66_ = folks_field_details_new (data->self->priv->_email_1);
 
927
        data->email_1 = data->_tmp66_;
 
928
        gee_abstract_collection_add ((GeeAbstractCollection*) data->emails, data->email_1);
 
929
        data->_tmp67_ = NULL;
 
930
        data->_tmp67_ = folks_field_details_new (data->self->priv->_email_2);
 
931
        data->email_2 = data->_tmp67_;
 
932
        gee_abstract_collection_add ((GeeAbstractCollection*) data->emails, data->email_2);
 
933
        g_value_set_object (data->v8, (GObject*) data->emails);
 
934
        data->_tmp68_ = NULL;
 
935
        data->_tmp68_ = folks_persona_store_detail_key (FOLKS_PERSONA_DETAIL_EMAIL_ADDRESSES);
 
936
        data->_tmp69_ = g_strdup (data->_tmp68_);
 
937
        data->_tmp70_ = data->v8;
 
938
        data->v8 = NULL;
 
939
        g_hash_table_insert (data->details, data->_tmp69_, data->_tmp70_);
 
940
        memset (&data->_tmp71_, 0, sizeof (GValue));
 
941
        g_value_init (&data->_tmp71_, GEE_TYPE_MULTI_MAP);
 
942
        memset (&data->_tmp72_, 0, sizeof (GValue));
 
943
        data->_tmp72_ = data->_tmp71_;
 
944
        data->_tmp73_ = data->_tmp72_;
 
945
        data->_tmp74_ = __g_value_dup0 (&data->_tmp73_);
 
946
        data->_tmp75_ = data->_tmp74_;
 
947
        G_IS_VALUE (&data->_tmp73_) ? (g_value_unset (&data->_tmp73_), NULL) : NULL;
 
948
        data->v9 = data->_tmp75_;
 
949
        data->_tmp76_ = NULL;
 
950
        data->_tmp76_ = gee_hash_multi_map_new (G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, g_free, G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, g_free, NULL, NULL, NULL, NULL);
 
951
        data->im_addrs = data->_tmp76_;
 
952
        gee_multi_map_set ((GeeMultiMap*) data->im_addrs, "jabber", data->self->priv->_im_addr_1);
 
953
        gee_multi_map_set ((GeeMultiMap*) data->im_addrs, "yahoo", data->self->priv->_im_addr_2);
 
954
        g_value_set_object (data->v9, (GObject*) data->im_addrs);
 
955
        data->_tmp77_ = NULL;
 
956
        data->_tmp77_ = folks_persona_store_detail_key (FOLKS_PERSONA_DETAIL_IM_ADDRESSES);
 
957
        data->_tmp78_ = g_strdup (data->_tmp77_);
 
958
        data->_tmp79_ = __g_value_dup0 (data->v9);
 
959
        g_hash_table_insert (data->details, data->_tmp78_, data->_tmp79_);
 
960
        memset (&data->_tmp80_, 0, sizeof (GValue));
 
961
        g_value_init (&data->_tmp80_, GEE_TYPE_SET);
 
962
        memset (&data->_tmp81_, 0, sizeof (GValue));
 
963
        data->_tmp81_ = data->_tmp80_;
 
964
        data->_tmp82_ = data->_tmp81_;
 
965
        data->_tmp83_ = __g_value_dup0 (&data->_tmp82_);
 
966
        data->_tmp84_ = data->_tmp83_;
 
967
        G_IS_VALUE (&data->_tmp82_) ? (g_value_unset (&data->_tmp82_), NULL) : NULL;
 
968
        data->v10 = data->_tmp84_;
 
969
        data->_tmp85_ = NULL;
 
970
        data->_tmp85_ = gee_hash_set_new (FOLKS_TYPE_NOTE, (GBoxedCopyFunc) g_object_ref, g_object_unref, NULL, NULL);
 
971
        data->notes = data->_tmp85_;
 
972
        data->_tmp86_ = NULL;
 
973
        data->_tmp86_ = folks_note_new (data->self->priv->_note_1, NULL);
 
974
        data->n1 = data->_tmp86_;
 
975
        gee_abstract_collection_add ((GeeAbstractCollection*) data->notes, data->n1);
 
976
        g_value_set_object (data->v10, (GObject*) data->notes);
 
977
        data->_tmp87_ = NULL;
 
978
        data->_tmp87_ = folks_persona_store_detail_key (FOLKS_PERSONA_DETAIL_NOTES);
 
979
        data->_tmp88_ = g_strdup (data->_tmp87_);
 
980
        data->_tmp89_ = data->v10;
 
981
        data->v10 = NULL;
 
982
        g_hash_table_insert (data->details, data->_tmp88_, data->_tmp89_);
 
983
        memset (&data->_tmp90_, 0, sizeof (GValue));
 
984
        g_value_init (&data->_tmp90_, GEE_TYPE_SET);
 
985
        memset (&data->_tmp91_, 0, sizeof (GValue));
 
986
        data->_tmp91_ = data->_tmp90_;
 
987
        data->_tmp92_ = data->_tmp91_;
 
988
        data->_tmp93_ = __g_value_dup0 (&data->_tmp92_);
 
989
        data->_tmp94_ = data->_tmp93_;
 
990
        G_IS_VALUE (&data->_tmp92_) ? (g_value_unset (&data->_tmp92_), NULL) : NULL;
 
991
        data->v11 = data->_tmp94_;
 
992
        data->_tmp95_ = NULL;
 
993
        data->_tmp95_ = gee_hash_set_new (FOLKS_TYPE_FIELD_DETAILS, (GBoxedCopyFunc) g_object_ref, g_object_unref, NULL, NULL);
 
994
        data->phones = data->_tmp95_;
 
995
        data->_tmp96_ = NULL;
 
996
        data->_tmp96_ = folks_field_details_new (data->self->priv->_phone_1);
 
997
        data->phone_1 = data->_tmp96_;
 
998
        gee_abstract_collection_add ((GeeAbstractCollection*) data->phones, data->phone_1);
 
999
        data->_tmp97_ = NULL;
 
1000
        data->_tmp97_ = folks_field_details_new (data->self->priv->_phone_2);
 
1001
        data->phone_2 = data->_tmp97_;
 
1002
        gee_abstract_collection_add ((GeeAbstractCollection*) data->phones, data->phone_2);
 
1003
        g_value_set_object (data->v11, (GObject*) data->phones);
 
1004
        data->_tmp98_ = NULL;
 
1005
        data->_tmp98_ = folks_persona_store_detail_key (FOLKS_PERSONA_DETAIL_PHONE_NUMBERS);
 
1006
        data->_tmp99_ = g_strdup (data->_tmp98_);
 
1007
        data->_tmp100_ = data->v11;
 
1008
        data->v11 = NULL;
 
1009
        g_hash_table_insert (data->details, data->_tmp99_, data->_tmp100_);
 
1010
        memset (&data->_tmp101_, 0, sizeof (GValue));
 
1011
        g_value_init (&data->_tmp101_, GEE_TYPE_SET);
 
1012
        memset (&data->_tmp102_, 0, sizeof (GValue));
 
1013
        data->_tmp102_ = data->_tmp101_;
 
1014
        data->_tmp103_ = data->_tmp102_;
 
1015
        data->_tmp104_ = __g_value_dup0 (&data->_tmp103_);
 
1016
        data->_tmp105_ = data->_tmp104_;
 
1017
        G_IS_VALUE (&data->_tmp103_) ? (g_value_unset (&data->_tmp103_), NULL) : NULL;
 
1018
        data->v12 = data->_tmp105_;
 
1019
        data->_tmp106_ = NULL;
 
1020
        data->_tmp106_ = gee_hash_set_new (FOLKS_TYPE_ROLE, (GBoxedCopyFunc) g_object_ref, g_object_unref, NULL, NULL);
 
1021
        data->roles = data->_tmp106_;
 
1022
        data->_tmp107_ = NULL;
 
1023
        data->_tmp107_ = folks_role_new (data->self->priv->_title_1, data->self->priv->_organisation_1, NULL);
 
1024
        data->r1 = data->_tmp107_;
 
1025
        gee_abstract_collection_add ((GeeAbstractCollection*) data->roles, data->r1);
 
1026
        g_value_set_object (data->v12, (GObject*) data->roles);
 
1027
        data->_tmp108_ = NULL;
 
1028
        data->_tmp108_ = folks_persona_store_detail_key (FOLKS_PERSONA_DETAIL_ROLES);
 
1029
        data->_tmp109_ = g_strdup (data->_tmp108_);
 
1030
        data->_tmp110_ = data->v12;
 
1031
        data->v12 = NULL;
 
1032
        g_hash_table_insert (data->details, data->_tmp109_, data->_tmp110_);
 
1033
        memset (&data->_tmp111_, 0, sizeof (GValue));
 
1034
        g_value_init (&data->_tmp111_, GEE_TYPE_SET);
 
1035
        memset (&data->_tmp112_, 0, sizeof (GValue));
 
1036
        data->_tmp112_ = data->_tmp111_;
 
1037
        data->_tmp113_ = data->_tmp112_;
 
1038
        data->_tmp114_ = __g_value_dup0 (&data->_tmp113_);
 
1039
        data->_tmp115_ = data->_tmp114_;
 
1040
        G_IS_VALUE (&data->_tmp113_) ? (g_value_unset (&data->_tmp113_), NULL) : NULL;
 
1041
        data->v13 = data->_tmp115_;
 
1042
        data->_tmp116_ = NULL;
 
1043
        data->_tmp116_ = gee_hash_set_new (FOLKS_TYPE_POSTAL_ADDRESS, (GBoxedCopyFunc) g_object_ref, g_object_unref, NULL, NULL);
 
1044
        data->postal_addresses = data->_tmp116_;
 
1045
        data->_tmp117_ = NULL;
 
1046
        data->_tmp117_ = gee_hash_set_new (G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, g_free, NULL, NULL);
 
1047
        data->types = data->_tmp117_;
 
1048
        data->_tmp118_ = NULL;
 
1049
        data->_tmp118_ = folks_postal_address_new (data->self->priv->_po_box, data->self->priv->_extension, data->self->priv->_street, data->self->priv->_locality, data->self->priv->_region, data->self->priv->_postal_code, data->self->priv->_country, NULL, (GeeSet*) data->types, NULL);
 
1050
        data->postal_a = data->_tmp118_;
 
1051
        gee_abstract_collection_add ((GeeAbstractCollection*) data->postal_addresses, data->postal_a);
 
1052
        g_value_set_object (data->v13, (GObject*) data->postal_addresses);
 
1053
        data->_tmp119_ = NULL;
 
1054
        data->_tmp119_ = folks_persona_store_detail_key (FOLKS_PERSONA_DETAIL_POSTAL_ADDRESSES);
 
1055
        data->_tmp120_ = g_strdup (data->_tmp119_);
 
1056
        data->_tmp121_ = data->v13;
 
1057
        data->v13 = NULL;
 
1058
        g_hash_table_insert (data->details, data->_tmp120_, data->_tmp121_);
 
1059
        memset (&data->_tmp122_, 0, sizeof (GValue));
 
1060
        g_value_init (&data->_tmp122_, GEE_TYPE_SET);
 
1061
        memset (&data->_tmp123_, 0, sizeof (GValue));
 
1062
        data->_tmp123_ = data->_tmp122_;
 
1063
        data->_tmp124_ = data->_tmp123_;
 
1064
        data->_tmp125_ = __g_value_dup0 (&data->_tmp124_);
 
1065
        data->_tmp126_ = data->_tmp125_;
 
1066
        G_IS_VALUE (&data->_tmp124_) ? (g_value_unset (&data->_tmp124_), NULL) : NULL;
 
1067
        data->v14 = data->_tmp126_;
 
1068
        data->_tmp127_ = NULL;
 
1069
        data->_tmp127_ = gee_hash_set_new (FOLKS_TYPE_FIELD_DETAILS, (GBoxedCopyFunc) g_object_ref, g_object_unref, NULL, NULL);
 
1070
        data->urls = data->_tmp127_;
 
1071
        data->_tmp128_ = NULL;
 
1072
        data->_tmp128_ = folks_field_details_new (data->self->priv->_url_1);
 
1073
        data->url_1 = data->_tmp128_;
 
1074
        gee_abstract_collection_add ((GeeAbstractCollection*) data->urls, data->url_1);
 
1075
        data->_tmp129_ = NULL;
 
1076
        data->_tmp129_ = folks_field_details_new (data->self->priv->_url_2);
 
1077
        data->url_2 = data->_tmp129_;
 
1078
        gee_abstract_collection_add ((GeeAbstractCollection*) data->urls, data->url_2);
 
1079
        g_value_set_object (data->v14, (GObject*) data->urls);
 
1080
        data->_tmp130_ = NULL;
 
1081
        data->_tmp130_ = folks_persona_store_detail_key (FOLKS_PERSONA_DETAIL_URLS);
 
1082
        data->_tmp131_ = g_strdup (data->_tmp130_);
 
1083
        data->_tmp132_ = data->v14;
 
1084
        data->v14 = NULL;
 
1085
        g_hash_table_insert (data->details, data->_tmp131_, data->_tmp132_);
 
1086
        data->_state_ = 1;
 
1087
        folks_individual_aggregator_add_persona_from_details (data->self->priv->_aggregator, NULL, (FolksPersonaStore*) data->self->priv->_pstore, data->details, _add_persona_tests_add_persona_ready, data);
 
1088
        return FALSE;
 
1089
        _state_1:
 
1090
        data->_tmp133_ = NULL;
 
1091
        data->_tmp133_ = folks_individual_aggregator_add_persona_from_details_finish (data->self->priv->_aggregator, data->_res_, &data->_inner_error_);
 
1092
        data->_tmp134_ = data->_tmp133_;
 
1093
        if (data->_inner_error_ != NULL) {
 
1094
                if (data->_inner_error_->domain == FOLKS_INDIVIDUAL_AGGREGATOR_ERROR) {
 
1095
                        goto __catch1_folks_individual_aggregator_error;
 
1096
                }
 
1097
                _g_object_unref0 (data->url_2);
 
1098
                _g_object_unref0 (data->url_1);
 
1099
                _g_object_unref0 (data->urls);
 
1100
                __vala_GValue_free0 (data->v14);
 
1101
                _g_object_unref0 (data->postal_a);
 
1102
                _g_object_unref0 (data->types);
 
1103
                _g_object_unref0 (data->postal_addresses);
 
1104
                __vala_GValue_free0 (data->v13);
 
1105
                _g_object_unref0 (data->r1);
 
1106
                _g_object_unref0 (data->roles);
 
1107
                __vala_GValue_free0 (data->v12);
 
1108
                _g_object_unref0 (data->phone_2);
 
1109
                _g_object_unref0 (data->phone_1);
 
1110
                _g_object_unref0 (data->phones);
 
1111
                __vala_GValue_free0 (data->v11);
 
1112
                _g_object_unref0 (data->n1);
 
1113
                _g_object_unref0 (data->notes);
 
1114
                __vala_GValue_free0 (data->v10);
 
1115
                _g_object_unref0 (data->im_addrs);
 
1116
                __vala_GValue_free0 (data->v9);
 
1117
                _g_object_unref0 (data->email_2);
 
1118
                _g_object_unref0 (data->email_1);
 
1119
                _g_object_unref0 (data->emails);
 
1120
                __vala_GValue_free0 (data->v8);
 
1121
                __vala_GValue_free0 (data->v7);
 
1122
                _g_date_time_unref0 (data->dobj);
 
1123
                __vala_GValue_free0 (data->v6);
 
1124
                _g_object_unref0 (data->avatar);
 
1125
                __vala_GValue_free0 (data->v5);
 
1126
                _g_object_unref0 (data->sname);
 
1127
                __vala_GValue_free0 (data->v4);
 
1128
                __vala_GValue_free0 (data->v3);
 
1129
                __vala_GValue_free0 (data->v2);
 
1130
                __vala_GValue_free0 (data->v1);
 
1131
                _g_hash_table_unref0 (data->details);
 
1132
                g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, data->_inner_error_->message, g_quark_to_string (data->_inner_error_->domain), data->_inner_error_->code);
 
1133
                g_clear_error (&data->_inner_error_);
 
1134
                return FALSE;
 
1135
        }
 
1136
        data->persona = TRF_PERSONA (data->_tmp134_);
 
1137
        data->_tmp135_ = NULL;
 
1138
        data->_tmp135_ = folks_persona_get_iid ((FolksPersona*) data->persona);
 
1139
        data->_tmp136_ = g_strdup (data->_tmp135_);
 
1140
        _g_free0 (data->self->priv->_persona_iid);
 
1141
        data->self->priv->_persona_iid = data->_tmp136_;
 
1142
        _g_object_unref0 (data->persona);
 
1143
        goto __finally1;
 
1144
        __catch1_folks_individual_aggregator_error:
 
1145
        {
 
1146
                data->e = data->_inner_error_;
 
1147
                data->_inner_error_ = NULL;
 
1148
                g_warning ("add-persona.vala:302: [AddPersonaError] add_persona_from_details: %s\n", data->e->message);
 
1149
                _g_error_free0 (data->e);
 
1150
        }
 
1151
        __finally1:
 
1152
        if (data->_inner_error_ != NULL) {
 
1153
                _g_object_unref0 (data->url_2);
 
1154
                _g_object_unref0 (data->url_1);
 
1155
                _g_object_unref0 (data->urls);
 
1156
                __vala_GValue_free0 (data->v14);
 
1157
                _g_object_unref0 (data->postal_a);
 
1158
                _g_object_unref0 (data->types);
 
1159
                _g_object_unref0 (data->postal_addresses);
 
1160
                __vala_GValue_free0 (data->v13);
 
1161
                _g_object_unref0 (data->r1);
 
1162
                _g_object_unref0 (data->roles);
 
1163
                __vala_GValue_free0 (data->v12);
 
1164
                _g_object_unref0 (data->phone_2);
 
1165
                _g_object_unref0 (data->phone_1);
 
1166
                _g_object_unref0 (data->phones);
 
1167
                __vala_GValue_free0 (data->v11);
 
1168
                _g_object_unref0 (data->n1);
 
1169
                _g_object_unref0 (data->notes);
 
1170
                __vala_GValue_free0 (data->v10);
 
1171
                _g_object_unref0 (data->im_addrs);
 
1172
                __vala_GValue_free0 (data->v9);
 
1173
                _g_object_unref0 (data->email_2);
 
1174
                _g_object_unref0 (data->email_1);
 
1175
                _g_object_unref0 (data->emails);
 
1176
                __vala_GValue_free0 (data->v8);
 
1177
                __vala_GValue_free0 (data->v7);
 
1178
                _g_date_time_unref0 (data->dobj);
 
1179
                __vala_GValue_free0 (data->v6);
 
1180
                _g_object_unref0 (data->avatar);
 
1181
                __vala_GValue_free0 (data->v5);
 
1182
                _g_object_unref0 (data->sname);
 
1183
                __vala_GValue_free0 (data->v4);
 
1184
                __vala_GValue_free0 (data->v3);
 
1185
                __vala_GValue_free0 (data->v2);
 
1186
                __vala_GValue_free0 (data->v1);
 
1187
                _g_hash_table_unref0 (data->details);
 
1188
                g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, data->_inner_error_->message, g_quark_to_string (data->_inner_error_->domain), data->_inner_error_->code);
 
1189
                g_clear_error (&data->_inner_error_);
 
1190
                return FALSE;
 
1191
        }
 
1192
        _g_object_unref0 (data->url_2);
 
1193
        _g_object_unref0 (data->url_1);
 
1194
        _g_object_unref0 (data->urls);
 
1195
        __vala_GValue_free0 (data->v14);
 
1196
        _g_object_unref0 (data->postal_a);
 
1197
        _g_object_unref0 (data->types);
 
1198
        _g_object_unref0 (data->postal_addresses);
 
1199
        __vala_GValue_free0 (data->v13);
 
1200
        _g_object_unref0 (data->r1);
 
1201
        _g_object_unref0 (data->roles);
 
1202
        __vala_GValue_free0 (data->v12);
 
1203
        _g_object_unref0 (data->phone_2);
 
1204
        _g_object_unref0 (data->phone_1);
 
1205
        _g_object_unref0 (data->phones);
 
1206
        __vala_GValue_free0 (data->v11);
 
1207
        _g_object_unref0 (data->n1);
 
1208
        _g_object_unref0 (data->notes);
 
1209
        __vala_GValue_free0 (data->v10);
 
1210
        _g_object_unref0 (data->im_addrs);
 
1211
        __vala_GValue_free0 (data->v9);
 
1212
        _g_object_unref0 (data->email_2);
 
1213
        _g_object_unref0 (data->email_1);
 
1214
        _g_object_unref0 (data->emails);
 
1215
        __vala_GValue_free0 (data->v8);
 
1216
        __vala_GValue_free0 (data->v7);
 
1217
        _g_date_time_unref0 (data->dobj);
 
1218
        __vala_GValue_free0 (data->v6);
 
1219
        _g_object_unref0 (data->avatar);
 
1220
        __vala_GValue_free0 (data->v5);
 
1221
        _g_object_unref0 (data->sname);
 
1222
        __vala_GValue_free0 (data->v4);
 
1223
        __vala_GValue_free0 (data->v3);
 
1224
        __vala_GValue_free0 (data->v2);
 
1225
        __vala_GValue_free0 (data->v1);
 
1226
        _g_hash_table_unref0 (data->details);
 
1227
        if (data->_state_ == 0) {
 
1228
                g_simple_async_result_complete_in_idle (data->_async_result);
 
1229
        } else {
 
1230
                g_simple_async_result_complete (data->_async_result);
 
1231
        }
 
1232
        g_object_unref (data->_async_result);
 
1233
        return FALSE;
 
1234
}
 
1235
 
 
1236
 
 
1237
static void __add_persona_tests_notify_persona_sname_g_object_notify (GObject* _sender, GParamSpec* pspec, gpointer self) {
 
1238
        _add_persona_tests_notify_persona_sname (self, _sender, pspec);
 
1239
}
 
1240
 
 
1241
 
 
1242
static void __add_persona_tests_notify_cb_g_object_notify (GObject* _sender, GParamSpec* pspec, gpointer self) {
 
1243
        _add_persona_tests_notify_cb (self, _sender, pspec);
 
1244
}
 
1245
 
 
1246
 
 
1247
static void _add_persona_tests_individuals_changed_cb (AddPersonaTests* self, GeeSet* added, GeeSet* removed, const gchar* message, FolksPersona* actor, FolksGroupDetailsChangeReason reason) {
 
1248
        gint _tmp10_;
 
1249
        g_return_if_fail (self != NULL);
 
1250
        g_return_if_fail (added != NULL);
 
1251
        g_return_if_fail (removed != NULL);
 
1252
        {
 
1253
                GeeIterator* _tmp0_ = NULL;
 
1254
                GeeIterator* _i_it;
 
1255
                _tmp0_ = gee_iterable_iterator ((GeeIterable*) added);
 
1256
                _i_it = _tmp0_;
 
1257
                while (TRUE) {
 
1258
                        gboolean _tmp1_;
 
1259
                        gpointer _tmp2_ = NULL;
 
1260
                        FolksIndividual* i;
 
1261
                        gboolean _tmp3_;
 
1262
                        _tmp1_ = gee_iterator_next (_i_it);
 
1263
                        if (!_tmp1_) {
 
1264
                                break;
 
1265
                        }
 
1266
                        _tmp2_ = gee_iterator_get (_i_it);
 
1267
                        i = (FolksIndividual*) _tmp2_;
 
1268
                        _tmp3_ = folks_individual_get_is_user (i);
 
1269
                        if (_tmp3_ == FALSE) {
 
1270
                                {
 
1271
                                        GeeSet* _tmp4_ = NULL;
 
1272
                                        GeeIterator* _tmp5_ = NULL;
 
1273
                                        GeeIterator* _p_it;
 
1274
                                        _tmp4_ = folks_individual_get_personas (i);
 
1275
                                        _tmp5_ = gee_iterable_iterator ((GeeIterable*) _tmp4_);
 
1276
                                        _p_it = _tmp5_;
 
1277
                                        while (TRUE) {
 
1278
                                                gboolean _tmp6_;
 
1279
                                                gpointer _tmp7_ = NULL;
 
1280
                                                FolksPersona* p;
 
1281
                                                gboolean _tmp8_ = FALSE;
 
1282
                                                _tmp6_ = gee_iterator_next (_p_it);
 
1283
                                                if (!_tmp6_) {
 
1284
                                                        break;
 
1285
                                                }
 
1286
                                                _tmp7_ = gee_iterator_get (_p_it);
 
1287
                                                p = (FolksPersona*) _tmp7_;
 
1288
                                                if (FOLKS_IS_NAME_DETAILS (p)) {
 
1289
                                                        FolksStructuredName* _tmp9_ = NULL;
 
1290
                                                        _tmp9_ = folks_name_details_get_structured_name (FOLKS_NAME_DETAILS (p));
 
1291
                                                        _tmp8_ = _tmp9_ != NULL;
 
1292
                                                } else {
 
1293
                                                        _tmp8_ = FALSE;
 
1294
                                                }
 
1295
                                                if (_tmp8_) {
 
1296
                                                        g_signal_connect_object ((GObject*) p, "notify::structured-name", (GCallback) __add_persona_tests_notify_persona_sname_g_object_notify, self, 0);
 
1297
                                                }
 
1298
                                                _g_object_unref0 (p);
 
1299
                                        }
 
1300
                                        _g_object_unref0 (_p_it);
 
1301
                                }
 
1302
                                g_signal_connect_object ((GObject*) i, "notify::full-name", (GCallback) __add_persona_tests_notify_cb_g_object_notify, self, 0);
 
1303
                                g_signal_connect_object ((GObject*) i, "notify::alias", (GCallback) __add_persona_tests_notify_cb_g_object_notify, self, 0);
 
1304
                                g_signal_connect_object ((GObject*) i, "notify::avatar", (GCallback) __add_persona_tests_notify_cb_g_object_notify, self, 0);
 
1305
                                g_signal_connect_object ((GObject*) i, "notify::is-favourite", (GCallback) __add_persona_tests_notify_cb_g_object_notify, self, 0);
 
1306
                                g_signal_connect_object ((GObject*) i, "notify::structured-name", (GCallback) __add_persona_tests_notify_cb_g_object_notify, self, 0);
 
1307
                                g_signal_connect_object ((GObject*) i, "notify::family-name", (GCallback) __add_persona_tests_notify_cb_g_object_notify, self, 0);
 
1308
                                g_signal_connect_object ((GObject*) i, "notify::given-name", (GCallback) __add_persona_tests_notify_cb_g_object_notify, self, 0);
 
1309
                                g_signal_connect_object ((GObject*) i, "notify::avatar", (GCallback) __add_persona_tests_notify_cb_g_object_notify, self, 0);
 
1310
                                g_signal_connect_object ((GObject*) i, "notify::birthday", (GCallback) __add_persona_tests_notify_cb_g_object_notify, self, 0);
 
1311
                                g_signal_connect_object ((GObject*) i, "notify::gender", (GCallback) __add_persona_tests_notify_cb_g_object_notify, self, 0);
 
1312
                                g_signal_connect_object ((GObject*) i, "notify::email-addresses", (GCallback) __add_persona_tests_notify_cb_g_object_notify, self, 0);
 
1313
                                g_signal_connect_object ((GObject*) i, "notify::im-addresses", (GCallback) __add_persona_tests_notify_cb_g_object_notify, self, 0);
 
1314
                                g_signal_connect_object ((GObject*) i, "notify::notes", (GCallback) __add_persona_tests_notify_cb_g_object_notify, self, 0);
 
1315
                                g_signal_connect_object ((GObject*) i, "notify::phone-numbers", (GCallback) __add_persona_tests_notify_cb_g_object_notify, self, 0);
 
1316
                                g_signal_connect_object ((GObject*) i, "notify::roles", (GCallback) __add_persona_tests_notify_cb_g_object_notify, self, 0);
 
1317
                                g_signal_connect_object ((GObject*) i, "notify::postal-addresses", (GCallback) __add_persona_tests_notify_cb_g_object_notify, self, 0);
 
1318
                                g_signal_connect_object ((GObject*) i, "notify::urls", (GCallback) __add_persona_tests_notify_cb_g_object_notify, self, 0);
 
1319
                                _add_persona_tests_check_properties (self, i);
 
1320
                        }
 
1321
                        _g_object_unref0 (i);
 
1322
                }
 
1323
                _g_object_unref0 (_i_it);
 
1324
        }
 
1325
        _tmp10_ = gee_collection_get_size ((GeeCollection*) removed);
 
1326
        g_assert (_tmp10_ == 0);
 
1327
}
 
1328
 
 
1329
 
 
1330
static void _add_persona_tests_notify_cb (AddPersonaTests* self, GObject* individual_obj, GParamSpec* ps) {
 
1331
        FolksIndividual* _tmp0_;
 
1332
        FolksIndividual* i;
 
1333
        g_return_if_fail (self != NULL);
 
1334
        g_return_if_fail (individual_obj != NULL);
 
1335
        g_return_if_fail (ps != NULL);
 
1336
        _tmp0_ = _g_object_ref0 (FOLKS_INDIVIDUAL (individual_obj));
 
1337
        i = _tmp0_;
 
1338
        _add_persona_tests_check_properties (self, i);
 
1339
        _g_object_unref0 (i);
 
1340
}
 
1341
 
 
1342
 
 
1343
static void _add_persona_tests_notify_persona_sname (AddPersonaTests* self, GObject* persona_p, GParamSpec* ps) {
 
1344
        TrfPersona* _tmp0_;
 
1345
        TrfPersona* persona;
 
1346
        FolksStructuredName* _tmp1_ = NULL;
 
1347
        g_return_if_fail (self != NULL);
 
1348
        g_return_if_fail (persona_p != NULL);
 
1349
        g_return_if_fail (ps != NULL);
 
1350
        _tmp0_ = _g_object_ref0 (TRF_PERSONA (persona_p));
 
1351
        persona = _tmp0_;
 
1352
        _tmp1_ = folks_name_details_get_structured_name ((FolksNameDetails*) persona);
 
1353
        _add_persona_tests_check_sname (self, _tmp1_);
 
1354
        _add_persona_tests_exit_if_all_properties_found (self);
 
1355
        _g_object_unref0 (persona);
 
1356
}
 
1357
 
 
1358
 
 
1359
static void _add_persona_tests_notify_pstore_cb (AddPersonaTests* self, GObject* _pstore, GParamSpec* ps) {
 
1360
        g_return_if_fail (self != NULL);
 
1361
        g_return_if_fail (_pstore != NULL);
 
1362
        g_return_if_fail (ps != NULL);
 
1363
        _add_persona_tests_try_to_add (self);
 
1364
}
 
1365
 
 
1366
 
 
1367
static void _add_persona_tests_try_to_add (AddPersonaTests* self) {
 
1368
        GError * _inner_error_ = NULL;
 
1369
        g_return_if_fail (self != NULL);
 
1370
        {
 
1371
                gboolean _tmp0_ = FALSE;
 
1372
                gboolean _tmp1_;
 
1373
                g_static_rec_mutex_lock (&self->priv->__lock__added_persona);
 
1374
                _tmp1_ = folks_persona_store_get_is_prepared ((FolksPersonaStore*) self->priv->_pstore);
 
1375
                if (_tmp1_) {
 
1376
                        _tmp0_ = self->priv->_added_persona == FALSE;
 
1377
                } else {
 
1378
                        _tmp0_ = FALSE;
 
1379
                }
 
1380
                if (_tmp0_) {
 
1381
                        self->priv->_added_persona = TRUE;
 
1382
                        _add_persona_tests_add_persona (self, NULL, NULL);
 
1383
                }
 
1384
                __finally2:
 
1385
                g_static_rec_mutex_unlock (&self->priv->__lock__added_persona);
 
1386
                if (_inner_error_ != NULL) {
 
1387
                        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);
 
1388
                        g_clear_error (&_inner_error_);
 
1389
                        return;
 
1390
                }
 
1391
        }
 
1392
}
 
1393
 
 
1394
 
 
1395
static void _add_persona_tests_check_properties (AddPersonaTests* self, FolksIndividual* i) {
 
1396
        const gchar* _tmp0_ = NULL;
 
1397
        const gchar* _tmp2_ = NULL;
 
1398
        gboolean _tmp4_;
 
1399
        FolksStructuredName* _tmp6_ = NULL;
 
1400
        gboolean _tmp8_ = FALSE;
 
1401
        GFile* _tmp9_ = NULL;
 
1402
        gboolean _tmp14_ = FALSE;
 
1403
        GDateTime* _tmp15_ = NULL;
 
1404
        FolksGender _tmp19_;
 
1405
        g_return_if_fail (self != NULL);
 
1406
        g_return_if_fail (i != NULL);
 
1407
        _tmp0_ = folks_name_details_get_full_name ((FolksNameDetails*) i);
 
1408
        if (g_strcmp0 (_tmp0_, self->priv->_persona_fullname) == 0) {
 
1409
                gchar* _tmp1_;
 
1410
                _tmp1_ = g_strdup ("full_name");
 
1411
                g_hash_table_replace (self->priv->_properties_found, _tmp1_, GINT_TO_POINTER (TRUE));
 
1412
        }
 
1413
        _tmp2_ = folks_alias_details_get_alias ((FolksAliasDetails*) i);
 
1414
        if (g_strcmp0 (_tmp2_, self->priv->_persona_alias) == 0) {
 
1415
                gchar* _tmp3_;
 
1416
                _tmp3_ = g_strdup ("alias");
 
1417
                g_hash_table_replace (self->priv->_properties_found, _tmp3_, GINT_TO_POINTER (TRUE));
 
1418
        }
 
1419
        _tmp4_ = folks_favourite_details_get_is_favourite ((FolksFavouriteDetails*) i);
 
1420
        if (_tmp4_) {
 
1421
                gchar* _tmp5_;
 
1422
                _tmp5_ = g_strdup ("is_favourite");
 
1423
                g_hash_table_replace (self->priv->_properties_found, _tmp5_, GINT_TO_POINTER (TRUE));
 
1424
        }
 
1425
        _tmp6_ = folks_name_details_get_structured_name ((FolksNameDetails*) i);
 
1426
        if (_tmp6_ != NULL) {
 
1427
                FolksStructuredName* _tmp7_ = NULL;
 
1428
                _tmp7_ = folks_name_details_get_structured_name ((FolksNameDetails*) i);
 
1429
                _add_persona_tests_check_sname (self, _tmp7_);
 
1430
        }
 
1431
        _tmp9_ = folks_avatar_details_get_avatar ((FolksAvatarDetails*) i);
 
1432
        if (_tmp9_ != NULL) {
 
1433
                GFile* _tmp10_ = NULL;
 
1434
                gchar* _tmp11_ = NULL;
 
1435
                gchar* _tmp12_;
 
1436
                _tmp10_ = folks_avatar_details_get_avatar ((FolksAvatarDetails*) i);
 
1437
                _tmp11_ = g_file_get_uri (_tmp10_);
 
1438
                _tmp12_ = _tmp11_;
 
1439
                _tmp8_ = g_strcmp0 (_tmp12_, self->priv->_file_uri) == 0;
 
1440
                _g_free0 (_tmp12_);
 
1441
        } else {
 
1442
                _tmp8_ = FALSE;
 
1443
        }
 
1444
        if (_tmp8_) {
 
1445
                gchar* _tmp13_;
 
1446
                _tmp13_ = g_strdup ("avatar");
 
1447
                g_hash_table_replace (self->priv->_properties_found, _tmp13_, GINT_TO_POINTER (TRUE));
 
1448
        }
 
1449
        _tmp15_ = folks_birthday_details_get_birthday ((FolksBirthdayDetails*) i);
 
1450
        if (_tmp15_ != NULL) {
 
1451
                GDateTime* _tmp16_ = NULL;
 
1452
                gint _tmp17_;
 
1453
                _tmp16_ = folks_birthday_details_get_birthday ((FolksBirthdayDetails*) i);
 
1454
                _tmp17_ = g_date_time_compare (_tmp16_, self->priv->_bday);
 
1455
                _tmp14_ = _tmp17_ == 0;
 
1456
        } else {
 
1457
                _tmp14_ = FALSE;
 
1458
        }
 
1459
        if (_tmp14_) {
 
1460
                gchar* _tmp18_;
 
1461
                _tmp18_ = g_strdup ("birthday");
 
1462
                g_hash_table_replace (self->priv->_properties_found, _tmp18_, GINT_TO_POINTER (TRUE));
 
1463
        }
 
1464
        _tmp19_ = folks_gender_details_get_gender ((FolksGenderDetails*) i);
 
1465
        if (_tmp19_ == FOLKS_GENDER_MALE) {
 
1466
                gchar* _tmp20_;
 
1467
                _tmp20_ = g_strdup ("gender");
 
1468
                g_hash_table_replace (self->priv->_properties_found, _tmp20_, GINT_TO_POINTER (TRUE));
 
1469
        }
 
1470
        {
 
1471
                GeeSet* _tmp21_ = NULL;
 
1472
                GeeIterator* _tmp22_ = NULL;
 
1473
                GeeIterator* _e_it;
 
1474
                _tmp21_ = folks_email_details_get_email_addresses ((FolksEmailDetails*) i);
 
1475
                _tmp22_ = gee_iterable_iterator ((GeeIterable*) _tmp21_);
 
1476
                _e_it = _tmp22_;
 
1477
                while (TRUE) {
 
1478
                        gboolean _tmp23_;
 
1479
                        gpointer _tmp24_ = NULL;
 
1480
                        FolksFieldDetails* e;
 
1481
                        const gchar* _tmp25_ = NULL;
 
1482
                        _tmp23_ = gee_iterator_next (_e_it);
 
1483
                        if (!_tmp23_) {
 
1484
                                break;
 
1485
                        }
 
1486
                        _tmp24_ = gee_iterator_get (_e_it);
 
1487
                        e = (FolksFieldDetails*) _tmp24_;
 
1488
                        _tmp25_ = folks_field_details_get_value (e);
 
1489
                        if (g_strcmp0 (_tmp25_, self->priv->_email_1) == 0) {
 
1490
                                gchar* _tmp26_;
 
1491
                                _tmp26_ = g_strdup ("email-1");
 
1492
                                g_hash_table_replace (self->priv->_properties_found, _tmp26_, GINT_TO_POINTER (TRUE));
 
1493
                        } else {
 
1494
                                const gchar* _tmp27_ = NULL;
 
1495
                                _tmp27_ = folks_field_details_get_value (e);
 
1496
                                if (g_strcmp0 (_tmp27_, self->priv->_email_2) == 0) {
 
1497
                                        gchar* _tmp28_;
 
1498
                                        _tmp28_ = g_strdup ("email-2");
 
1499
                                        g_hash_table_replace (self->priv->_properties_found, _tmp28_, GINT_TO_POINTER (TRUE));
 
1500
                                }
 
1501
                        }
 
1502
                        _g_object_unref0 (e);
 
1503
                }
 
1504
                _g_object_unref0 (_e_it);
 
1505
        }
 
1506
        {
 
1507
                GeeMultiMap* _tmp29_ = NULL;
 
1508
                GeeSet* _tmp30_ = NULL;
 
1509
                GeeSet* _tmp31_;
 
1510
                GeeIterator* _tmp32_ = NULL;
 
1511
                GeeIterator* _tmp33_;
 
1512
                GeeIterator* _proto_it;
 
1513
                _tmp29_ = folks_im_details_get_im_addresses ((FolksImDetails*) i);
 
1514
                _tmp30_ = gee_multi_map_get_keys (_tmp29_);
 
1515
                _tmp31_ = _tmp30_;
 
1516
                _tmp32_ = gee_iterable_iterator ((GeeIterable*) _tmp31_);
 
1517
                _tmp33_ = _tmp32_;
 
1518
                _g_object_unref0 (_tmp31_);
 
1519
                _proto_it = _tmp33_;
 
1520
                while (TRUE) {
 
1521
                        gboolean _tmp34_;
 
1522
                        gpointer _tmp35_ = NULL;
 
1523
                        gchar* proto;
 
1524
                        GeeMultiMap* _tmp36_ = NULL;
 
1525
                        GeeCollection* _tmp37_ = NULL;
 
1526
                        GeeCollection* addrs;
 
1527
                        _tmp34_ = gee_iterator_next (_proto_it);
 
1528
                        if (!_tmp34_) {
 
1529
                                break;
 
1530
                        }
 
1531
                        _tmp35_ = gee_iterator_get (_proto_it);
 
1532
                        proto = (gchar*) _tmp35_;
 
1533
                        _tmp36_ = folks_im_details_get_im_addresses ((FolksImDetails*) i);
 
1534
                        _tmp37_ = gee_multi_map_get (_tmp36_, proto);
 
1535
                        addrs = _tmp37_;
 
1536
                        {
 
1537
                                GeeIterator* _tmp38_ = NULL;
 
1538
                                GeeIterator* _a_it;
 
1539
                                _tmp38_ = gee_iterable_iterator ((GeeIterable*) addrs);
 
1540
                                _a_it = _tmp38_;
 
1541
                                while (TRUE) {
 
1542
                                        gboolean _tmp39_;
 
1543
                                        gpointer _tmp40_ = NULL;
 
1544
                                        gchar* a;
 
1545
                                        _tmp39_ = gee_iterator_next (_a_it);
 
1546
                                        if (!_tmp39_) {
 
1547
                                                break;
 
1548
                                        }
 
1549
                                        _tmp40_ = gee_iterator_get (_a_it);
 
1550
                                        a = (gchar*) _tmp40_;
 
1551
                                        if (g_strcmp0 (a, self->priv->_im_addr_1) == 0) {
 
1552
                                                gchar* _tmp41_;
 
1553
                                                _tmp41_ = g_strdup ("im-addr-1");
 
1554
                                                g_hash_table_replace (self->priv->_properties_found, _tmp41_, GINT_TO_POINTER (TRUE));
 
1555
                                        } else {
 
1556
                                                if (g_strcmp0 (a, self->priv->_im_addr_2) == 0) {
 
1557
                                                        gchar* _tmp42_;
 
1558
                                                        _tmp42_ = g_strdup ("im-addr-2");
 
1559
                                                        g_hash_table_replace (self->priv->_properties_found, _tmp42_, GINT_TO_POINTER (TRUE));
 
1560
                                                }
 
1561
                                        }
 
1562
                                        _g_free0 (a);
 
1563
                                }
 
1564
                                _g_object_unref0 (_a_it);
 
1565
                        }
 
1566
                        _g_object_unref0 (addrs);
 
1567
                        _g_free0 (proto);
 
1568
                }
 
1569
                _g_object_unref0 (_proto_it);
 
1570
        }
 
1571
        {
 
1572
                GeeSet* _tmp43_ = NULL;
 
1573
                GeeIterator* _tmp44_ = NULL;
 
1574
                GeeIterator* _n_it;
 
1575
                _tmp43_ = folks_note_details_get_notes ((FolksNoteDetails*) i);
 
1576
                _tmp44_ = gee_iterable_iterator ((GeeIterable*) _tmp43_);
 
1577
                _n_it = _tmp44_;
 
1578
                while (TRUE) {
 
1579
                        gboolean _tmp45_;
 
1580
                        gpointer _tmp46_ = NULL;
 
1581
                        FolksNote* n;
 
1582
                        const gchar* _tmp47_ = NULL;
 
1583
                        _tmp45_ = gee_iterator_next (_n_it);
 
1584
                        if (!_tmp45_) {
 
1585
                                break;
 
1586
                        }
 
1587
                        _tmp46_ = gee_iterator_get (_n_it);
 
1588
                        n = (FolksNote*) _tmp46_;
 
1589
                        _tmp47_ = folks_note_get_content (n);
 
1590
                        if (g_strcmp0 (_tmp47_, self->priv->_note_1) == 0) {
 
1591
                                gchar* _tmp48_;
 
1592
                                _tmp48_ = g_strdup ("note-1");
 
1593
                                g_hash_table_replace (self->priv->_properties_found, _tmp48_, GINT_TO_POINTER (TRUE));
 
1594
                        }
 
1595
                        _g_object_unref0 (n);
 
1596
                }
 
1597
                _g_object_unref0 (_n_it);
 
1598
        }
 
1599
        {
 
1600
                GeeSet* _tmp49_ = NULL;
 
1601
                GeeIterator* _tmp50_ = NULL;
 
1602
                GeeIterator* _e_it;
 
1603
                _tmp49_ = folks_phone_details_get_phone_numbers ((FolksPhoneDetails*) i);
 
1604
                _tmp50_ = gee_iterable_iterator ((GeeIterable*) _tmp49_);
 
1605
                _e_it = _tmp50_;
 
1606
                while (TRUE) {
 
1607
                        gboolean _tmp51_;
 
1608
                        gpointer _tmp52_ = NULL;
 
1609
                        FolksFieldDetails* e;
 
1610
                        const gchar* _tmp53_ = NULL;
 
1611
                        _tmp51_ = gee_iterator_next (_e_it);
 
1612
                        if (!_tmp51_) {
 
1613
                                break;
 
1614
                        }
 
1615
                        _tmp52_ = gee_iterator_get (_e_it);
 
1616
                        e = (FolksFieldDetails*) _tmp52_;
 
1617
                        _tmp53_ = folks_field_details_get_value (e);
 
1618
                        if (g_strcmp0 (_tmp53_, self->priv->_phone_1) == 0) {
 
1619
                                gchar* _tmp54_;
 
1620
                                _tmp54_ = g_strdup ("phone-1");
 
1621
                                g_hash_table_replace (self->priv->_properties_found, _tmp54_, GINT_TO_POINTER (TRUE));
 
1622
                        } else {
 
1623
                                const gchar* _tmp55_ = NULL;
 
1624
                                _tmp55_ = folks_field_details_get_value (e);
 
1625
                                if (g_strcmp0 (_tmp55_, self->priv->_phone_2) == 0) {
 
1626
                                        gchar* _tmp56_;
 
1627
                                        _tmp56_ = g_strdup ("phone-2");
 
1628
                                        g_hash_table_replace (self->priv->_properties_found, _tmp56_, GINT_TO_POINTER (TRUE));
 
1629
                                }
 
1630
                        }
 
1631
                        _g_object_unref0 (e);
 
1632
                }
 
1633
                _g_object_unref0 (_e_it);
 
1634
        }
 
1635
        {
 
1636
                GeeSet* _tmp57_ = NULL;
 
1637
                GeeIterator* _tmp58_ = NULL;
 
1638
                GeeIterator* _r_it;
 
1639
                _tmp57_ = folks_role_details_get_roles ((FolksRoleDetails*) i);
 
1640
                _tmp58_ = gee_iterable_iterator ((GeeIterable*) _tmp57_);
 
1641
                _r_it = _tmp58_;
 
1642
                while (TRUE) {
 
1643
                        gboolean _tmp59_;
 
1644
                        gpointer _tmp60_ = NULL;
 
1645
                        FolksRole* r;
 
1646
                        gboolean _tmp61_ = FALSE;
 
1647
                        const gchar* _tmp62_ = NULL;
 
1648
                        _tmp59_ = gee_iterator_next (_r_it);
 
1649
                        if (!_tmp59_) {
 
1650
                                break;
 
1651
                        }
 
1652
                        _tmp60_ = gee_iterator_get (_r_it);
 
1653
                        r = (FolksRole*) _tmp60_;
 
1654
                        _tmp62_ = folks_role_get_title (r);
 
1655
                        if (g_strcmp0 (_tmp62_, self->priv->_title_1) == 0) {
 
1656
                                const gchar* _tmp63_ = NULL;
 
1657
                                _tmp63_ = folks_role_get_organisation_name (r);
 
1658
                                _tmp61_ = g_strcmp0 (_tmp63_, self->priv->_organisation_1) == 0;
 
1659
                        } else {
 
1660
                                _tmp61_ = FALSE;
 
1661
                        }
 
1662
                        if (_tmp61_) {
 
1663
                                gchar* _tmp64_;
 
1664
                                _tmp64_ = g_strdup ("role-1");
 
1665
                                g_hash_table_replace (self->priv->_properties_found, _tmp64_, GINT_TO_POINTER (TRUE));
 
1666
                        }
 
1667
                        _g_object_unref0 (r);
 
1668
                }
 
1669
                _g_object_unref0 (_r_it);
 
1670
        }
 
1671
        {
 
1672
                GeeSet* _tmp65_ = NULL;
 
1673
                GeeIterator* _tmp66_ = NULL;
 
1674
                GeeIterator* _pa_it;
 
1675
                _tmp65_ = folks_postal_address_details_get_postal_addresses ((FolksPostalAddressDetails*) i);
 
1676
                _tmp66_ = gee_iterable_iterator ((GeeIterable*) _tmp65_);
 
1677
                _pa_it = _tmp66_;
 
1678
                while (TRUE) {
 
1679
                        gboolean _tmp67_;
 
1680
                        gpointer _tmp68_ = NULL;
 
1681
                        FolksPostalAddress* pa;
 
1682
                        const gchar* _tmp69_ = NULL;
 
1683
                        gboolean _tmp70_;
 
1684
                        _tmp67_ = gee_iterator_next (_pa_it);
 
1685
                        if (!_tmp67_) {
 
1686
                                break;
 
1687
                        }
 
1688
                        _tmp68_ = gee_iterator_get (_pa_it);
 
1689
                        pa = (FolksPostalAddress*) _tmp68_;
 
1690
                        _tmp69_ = folks_postal_address_get_uid (pa);
 
1691
                        folks_postal_address_set_uid (self->priv->_address, _tmp69_);
 
1692
                        _tmp70_ = folks_postal_address_equal (pa, self->priv->_address);
 
1693
                        if (_tmp70_) {
 
1694
                                gchar* _tmp71_;
 
1695
                                _tmp71_ = g_strdup ("postal-address-1");
 
1696
                                g_hash_table_replace (self->priv->_properties_found, _tmp71_, GINT_TO_POINTER (TRUE));
 
1697
                        }
 
1698
                        _g_object_unref0 (pa);
 
1699
                }
 
1700
                _g_object_unref0 (_pa_it);
 
1701
        }
 
1702
        {
 
1703
                GeeSet* _tmp72_ = NULL;
 
1704
                GeeIterator* _tmp73_ = NULL;
 
1705
                GeeIterator* _u_it;
 
1706
                _tmp72_ = folks_url_details_get_urls ((FolksUrlDetails*) i);
 
1707
                _tmp73_ = gee_iterable_iterator ((GeeIterable*) _tmp72_);
 
1708
                _u_it = _tmp73_;
 
1709
                while (TRUE) {
 
1710
                        gboolean _tmp74_;
 
1711
                        gpointer _tmp75_ = NULL;
 
1712
                        FolksFieldDetails* u;
 
1713
                        const gchar* _tmp76_ = NULL;
 
1714
                        const gchar* _tmp78_ = NULL;
 
1715
                        _tmp74_ = gee_iterator_next (_u_it);
 
1716
                        if (!_tmp74_) {
 
1717
                                break;
 
1718
                        }
 
1719
                        _tmp75_ = gee_iterator_get (_u_it);
 
1720
                        u = (FolksFieldDetails*) _tmp75_;
 
1721
                        _tmp76_ = folks_field_details_get_value (u);
 
1722
                        if (g_strcmp0 (_tmp76_, self->priv->_url_1) == 0) {
 
1723
                                gchar* _tmp77_;
 
1724
                                _tmp77_ = g_strdup ("url-1");
 
1725
                                g_hash_table_replace (self->priv->_properties_found, _tmp77_, GINT_TO_POINTER (TRUE));
 
1726
                        }
 
1727
                        _tmp78_ = folks_field_details_get_value (u);
 
1728
                        if (g_strcmp0 (_tmp78_, self->priv->_url_2) == 0) {
 
1729
                                gchar* _tmp79_;
 
1730
                                _tmp79_ = g_strdup ("url-2");
 
1731
                                g_hash_table_replace (self->priv->_properties_found, _tmp79_, GINT_TO_POINTER (TRUE));
 
1732
                        }
 
1733
                        _g_object_unref0 (u);
 
1734
                }
 
1735
                _g_object_unref0 (_u_it);
 
1736
        }
 
1737
        _add_persona_tests_exit_if_all_properties_found (self);
 
1738
}
 
1739
 
 
1740
 
 
1741
static void _add_persona_tests_exit_if_all_properties_found (AddPersonaTests* self) {
 
1742
        GList* _tmp0_ = NULL;
 
1743
        g_return_if_fail (self != NULL);
 
1744
        _tmp0_ = g_hash_table_get_keys (self->priv->_properties_found);
 
1745
        {
 
1746
                GList* k_collection;
 
1747
                GList* k_it;
 
1748
                k_collection = _tmp0_;
 
1749
                for (k_it = k_collection; k_it != NULL; k_it = k_it->next) {
 
1750
                        const gchar* k;
 
1751
                        k = (const gchar*) k_it->data;
 
1752
                        {
 
1753
                                gconstpointer _tmp1_ = NULL;
 
1754
                                gboolean v;
 
1755
                                _tmp1_ = g_hash_table_lookup (self->priv->_properties_found, k);
 
1756
                                v = GPOINTER_TO_INT (_tmp1_);
 
1757
                                if (v == FALSE) {
 
1758
                                        _g_list_free0 (k_collection);
 
1759
                                        return;
 
1760
                                }
 
1761
                        }
 
1762
                }
 
1763
                _g_list_free0 (k_collection);
 
1764
        }
 
1765
        g_main_loop_quit (self->priv->_main_loop);
 
1766
}
 
1767
 
 
1768
 
 
1769
static void _add_persona_tests_check_sname (AddPersonaTests* self, FolksStructuredName* sname) {
 
1770
        gboolean _tmp0_ = FALSE;
 
1771
        const gchar* _tmp1_ = NULL;
 
1772
        g_return_if_fail (self != NULL);
 
1773
        g_return_if_fail (sname != NULL);
 
1774
        _tmp1_ = folks_structured_name_get_family_name (sname);
 
1775
        if (g_strcmp0 (_tmp1_, self->priv->_family_name) == 0) {
 
1776
                const gchar* _tmp2_ = NULL;
 
1777
                _tmp2_ = folks_structured_name_get_given_name (sname);
 
1778
                _tmp0_ = g_strcmp0 (_tmp2_, self->priv->_given_name) == 0;
 
1779
        } else {
 
1780
                _tmp0_ = FALSE;
 
1781
        }
 
1782
        if (_tmp0_) {
 
1783
                gchar* _tmp3_;
 
1784
                _tmp3_ = g_strdup ("structured_name");
 
1785
                g_hash_table_replace (self->priv->_properties_found, _tmp3_, GINT_TO_POINTER (TRUE));
 
1786
        }
 
1787
}
 
1788
 
 
1789
 
 
1790
static void add_persona_tests_class_init (AddPersonaTestsClass * klass) {
 
1791
        add_persona_tests_parent_class = g_type_class_peek_parent (klass);
 
1792
        g_type_class_add_private (klass, sizeof (AddPersonaTestsPrivate));
 
1793
        FOLKS_TEST_CASE_CLASS (klass)->set_up = add_persona_tests_real_set_up;
 
1794
        FOLKS_TEST_CASE_CLASS (klass)->tear_down = add_persona_tests_real_tear_down;
 
1795
        G_OBJECT_CLASS (klass)->finalize = add_persona_tests_finalize;
 
1796
}
 
1797
 
 
1798
 
 
1799
static void add_persona_tests_instance_init (AddPersonaTests * self) {
 
1800
        gchar* _tmp0_;
 
1801
        gchar* _tmp1_;
 
1802
        gchar* _tmp2_;
 
1803
        gchar* _tmp3_;
 
1804
        gchar* _tmp4_;
 
1805
        gchar* _tmp5_;
 
1806
        gchar* _tmp6_;
 
1807
        gchar* _tmp7_;
 
1808
        gchar* _tmp8_;
 
1809
        self->priv = ADD_PERSONA_TESTS_GET_PRIVATE (self);
 
1810
        _tmp0_ = g_strdup ("12345");
 
1811
        self->priv->_po_box = _tmp0_;
 
1812
        _tmp1_ = g_strdup ("locality");
 
1813
        self->priv->_locality = _tmp1_;
 
1814
        _tmp2_ = g_strdup ("code");
 
1815
        self->priv->_postal_code = _tmp2_;
 
1816
        _tmp3_ = g_strdup ("some street");
 
1817
        self->priv->_street = _tmp3_;
 
1818
        _tmp4_ = g_strdup ("some extension");
 
1819
        self->priv->_extension = _tmp4_;
 
1820
        _tmp5_ = g_strdup ("some country");
 
1821
        self->priv->_country = _tmp5_;
 
1822
        _tmp6_ = g_strdup ("some region");
 
1823
        self->priv->_region = _tmp6_;
 
1824
        _tmp7_ = g_strdup ("http://www-1.example.org");
 
1825
        self->priv->_url_1 = _tmp7_;
 
1826
        _tmp8_ = g_strdup ("http://www-1.example.org");
 
1827
        self->priv->_url_2 = _tmp8_;
 
1828
        g_static_rec_mutex_init (&self->priv->__lock__added_persona);
 
1829
        self->priv->_added_persona = FALSE;
 
1830
}
 
1831
 
 
1832
 
 
1833
static void add_persona_tests_finalize (GObject* obj) {
 
1834
        AddPersonaTests * self;
 
1835
        self = ADD_PERSONA_TESTS (obj);
 
1836
        _g_main_loop_unref0 (self->priv->_main_loop);
 
1837
        _tracker_test_backend_unref0 (self->priv->_tracker_backend);
 
1838
        _g_object_unref0 (self->priv->_aggregator);
 
1839
        _g_free0 (self->priv->_persona_fullname);
 
1840
        _g_free0 (self->priv->_persona_alias);
 
1841
        _g_free0 (self->priv->_family_name);
 
1842
        _g_free0 (self->priv->_given_name);
 
1843
        _g_hash_table_unref0 (self->priv->_properties_found);
 
1844
        _g_free0 (self->priv->_persona_iid);
 
1845
        _g_free0 (self->priv->_file_uri);
 
1846
        _g_free0 (self->priv->_birthday);
 
1847
        _g_date_time_unref0 (self->priv->_bday);
 
1848
        _g_free0 (self->priv->_email_1);
 
1849
        _g_free0 (self->priv->_email_2);
 
1850
        _g_free0 (self->priv->_im_addr_1);
 
1851
        _g_free0 (self->priv->_im_addr_2);
 
1852
        _g_free0 (self->priv->_note_1);
 
1853
        _g_free0 (self->priv->_phone_1);
 
1854
        _g_free0 (self->priv->_phone_2);
 
1855
        _g_free0 (self->priv->_title_1);
 
1856
        _g_free0 (self->priv->_organisation_1);
 
1857
        _g_object_unref0 (self->priv->_address);
 
1858
        _g_free0 (self->priv->_po_box);
 
1859
        _g_free0 (self->priv->_locality);
 
1860
        _g_free0 (self->priv->_postal_code);
 
1861
        _g_free0 (self->priv->_street);
 
1862
        _g_free0 (self->priv->_extension);
 
1863
        _g_free0 (self->priv->_country);
 
1864
        _g_free0 (self->priv->_region);
 
1865
        _g_free0 (self->priv->_url_1);
 
1866
        _g_free0 (self->priv->_url_2);
 
1867
        _g_object_unref0 (self->priv->_pstore);
 
1868
        g_static_rec_mutex_free (&self->priv->__lock__added_persona);
 
1869
        G_OBJECT_CLASS (add_persona_tests_parent_class)->finalize (obj);
 
1870
}
 
1871
 
 
1872
 
 
1873
GType add_persona_tests_get_type (void) {
 
1874
        static volatile gsize add_persona_tests_type_id__volatile = 0;
 
1875
        if (g_once_init_enter (&add_persona_tests_type_id__volatile)) {
 
1876
                static const GTypeInfo g_define_type_info = { sizeof (AddPersonaTestsClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) add_persona_tests_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (AddPersonaTests), 0, (GInstanceInitFunc) add_persona_tests_instance_init, NULL };
 
1877
                GType add_persona_tests_type_id;
 
1878
                add_persona_tests_type_id = g_type_register_static (FOLKS_TYPE_TEST_CASE, "AddPersonaTests", &g_define_type_info, 0);
 
1879
                g_once_init_leave (&add_persona_tests_type_id__volatile, add_persona_tests_type_id);
 
1880
        }
 
1881
        return add_persona_tests_type_id__volatile;
 
1882
}
 
1883
 
 
1884
 
 
1885
gint _vala_main (gchar** args, int args_length1) {
 
1886
        gint result = 0;
 
1887
        GTestSuite* _tmp0_ = NULL;
 
1888
        GTestSuite* root;
 
1889
        AddPersonaTests* _tmp1_ = NULL;
 
1890
        AddPersonaTests* _tmp2_;
 
1891
        GTestSuite* _tmp3_ = NULL;
 
1892
        g_test_init (&args_length1, &args, NULL);
 
1893
        _tmp0_ = g_test_get_root ();
 
1894
        root = _tmp0_;
 
1895
        _tmp1_ = add_persona_tests_new ();
 
1896
        _tmp2_ = _tmp1_;
 
1897
        _tmp3_ = folks_test_case_get_suite ((FolksTestCase*) _tmp2_);
 
1898
        g_test_suite_add_suite (root, _tmp3_);
 
1899
        _g_object_unref0 (_tmp2_);
 
1900
        g_test_run ();
 
1901
        result = 0;
 
1902
        return result;
 
1903
}
 
1904
 
 
1905
 
 
1906
int main (int argc, char ** argv) {
 
1907
        g_type_init ();
 
1908
        return _vala_main (argv, argc);
 
1909
}
 
1910
 
 
1911
 
 
1912