← Back to branch summary

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

« back to all changes in this revision

Viewing changes to tests/folks/field-details.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:
tests/folks/field-details.c
1
 
/* field-details.c generated by valac 0.11.7, the Vala compiler
 
1
/* field-details.c generated by valac 0.12.0, the Vala compiler
2
2
 * generated from field-details.vala, do not modify */
3
3
 
4
4
 
7
7
#include <folks-test.h>
8
8
#include <stdlib.h>
9
9
#include <string.h>
10
 
#include <folks.h>
 
10
#include <folks/folks.h>
 
11
#include <gee.h>
11
12
 
12
13
 
13
14
#define TYPE_FIELD_DETAILS_TESTS (field_details_tests_get_type ())
22
23
typedef struct _FieldDetailsTestsPrivate FieldDetailsTestsPrivate;
23
24
#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
24
25
#define _g_free0(var) (var = (g_free (var), NULL))
25
 
#define _g_hash_table_unref0(var) ((var == NULL) ? NULL : (var = (g_hash_table_unref (var), NULL)))
26
26
#define __g_list_free__g_free0_0(var) ((var == NULL) ? NULL : (var = (_g_list_free__g_free0_ (var), NULL)))
27
27
 
28
28
struct _FieldDetailsTests {
112
112
        gint values_2_length1;
113
113
        gint _values_2_size_;
114
114
        FolksFieldDetails* details = NULL;
115
 
        guint i = 0U;
116
 
        GList* values = NULL;
 
115
        GeeCollection* values = NULL;
117
116
        FolksFieldDetails* _tmp8_ = NULL;
118
 
        GList* _tmp10_ = NULL;
119
 
        guint _tmp11_;
120
 
        GList* _tmp13_ = NULL;
121
 
        guint _tmp14_;
122
 
        GList* _tmp16_ = NULL;
 
117
        GeeCollection* _tmp10_ = NULL;
 
118
        gint _tmp11_;
 
119
        GeeCollection* _tmp14_ = NULL;
 
120
        gint _tmp15_;
 
121
        gboolean _tmp16_;
 
122
        GeeCollection* _tmp17_ = NULL;
123
123
        GList* values_2_list;
124
 
        GHashTable* _tmp20_ = NULL;
125
 
        GHashTable* param_table;
126
 
        gchar* _tmp21_;
127
 
        GList* _tmp22_ = NULL;
128
 
        guint _tmp23_;
 
124
        GeeHashMultiMap* _tmp21_ = NULL;
 
125
        GeeHashMultiMap* param_table;
 
126
        GeeCollection* _tmp23_ = NULL;
 
127
        gint _tmp24_;
129
128
        g_return_if_fail (self != NULL);
130
129
        _tmp0_ = g_strdup ("metasyntactic-variables");
131
130
        param_name = _tmp0_;
167
166
                        }
168
167
                }
169
168
        }
170
 
        i = (guint) 0;
171
169
        _tmp10_ = folks_field_details_get_parameter_values (details, param_name);
 
170
        _g_object_unref0 (values);
172
171
        values = _tmp10_;
173
 
        _tmp11_ = g_list_length (values);
 
172
        _tmp11_ = gee_collection_get_size (values);
174
173
        g_assert (_tmp11_ == values_1_length1);
175
174
        {
176
 
                GList* l;
177
 
                l = values;
178
 
                {
179
 
                        gboolean _tmp12_;
180
 
                        _tmp12_ = TRUE;
181
 
                        while (TRUE) {
182
 
                                if (!_tmp12_) {
183
 
                                        l = l->next;
184
 
                                        i++;
185
 
                                }
186
 
                                _tmp12_ = FALSE;
187
 
                                if (!(l != NULL)) {
188
 
                                        break;
189
 
                                }
190
 
                                g_assert (g_strcmp0 ((const gchar*) l->data, values_1[i]) == 0);
 
175
                gchar** val_collection;
 
176
                int val_collection_length1;
 
177
                int val_it;
 
178
                val_collection = values_1;
 
179
                val_collection_length1 = values_1_length1;
 
180
                for (val_it = 0; val_it < values_1_length1; val_it = val_it + 1) {
 
181
                        gchar* _tmp12_;
 
182
                        gchar* val;
 
183
                        _tmp12_ = g_strdup (val_collection[val_it]);
 
184
                        val = _tmp12_;
 
185
                        {
 
186
                                gboolean _tmp13_;
 
187
                                _tmp13_ = gee_collection_contains (values, val);
 
188
                                g_assert (_tmp13_);
 
189
                                _g_free0 (val);
191
190
                        }
192
191
                }
193
192
        }
194
 
        i = (guint) 0;
195
193
        folks_field_details_set_parameter (details, param_name, values_2[0]);
196
 
        _tmp13_ = folks_field_details_get_parameter_values (details, param_name);
197
 
        values = _tmp13_;
198
 
        _tmp14_ = g_list_length (values);
199
 
        g_assert (_tmp14_ == 1);
200
 
        {
201
 
                GList* l;
202
 
                l = values;
203
 
                {
204
 
                        gboolean _tmp15_;
205
 
                        _tmp15_ = TRUE;
206
 
                        while (TRUE) {
207
 
                                if (!_tmp15_) {
208
 
                                        l = l->next;
209
 
                                        i++;
210
 
                                }
211
 
                                _tmp15_ = FALSE;
212
 
                                if (!(l != NULL)) {
213
 
                                        break;
214
 
                                }
215
 
                                g_assert (g_strcmp0 ((const gchar*) l->data, values_2[i]) == 0);
216
 
                        }
217
 
                }
218
 
        }
 
194
        _tmp14_ = folks_field_details_get_parameter_values (details, param_name);
 
195
        _g_object_unref0 (values);
 
196
        values = _tmp14_;
 
197
        _tmp15_ = gee_collection_get_size (values);
 
198
        g_assert (_tmp15_ == 1);
 
199
        _tmp16_ = gee_collection_contains (values, values_2[0]);
 
200
        g_assert (_tmp16_);
219
201
        folks_field_details_remove_parameter_all (details, param_name);
220
 
        _tmp16_ = folks_field_details_get_parameter_values (details, param_name);
221
 
        values = _tmp16_;
 
202
        _tmp17_ = folks_field_details_get_parameter_values (details, param_name);
 
203
        _g_object_unref0 (values);
 
204
        values = _tmp17_;
222
205
        g_assert (values == NULL);
223
206
        {
224
207
                gchar** val_collection;
227
210
                val_collection = values_1;
228
211
                val_collection_length1 = values_1_length1;
229
212
                for (val_it = 0; val_it < values_1_length1; val_it = val_it + 1) {
230
 
                        gchar* _tmp17_;
231
 
                        gchar* val;
232
 
                        _tmp17_ = g_strdup (val_collection[val_it]);
233
 
                        val = _tmp17_;
234
 
                        {
235
 
                                folks_field_details_add_parameter (details, param_name, val);
236
 
                                _g_free0 (val);
237
 
                        }
238
 
                }
239
 
        }
240
 
        values_2_list = NULL;
241
 
        {
242
 
                gchar** val_collection;
243
 
                int val_collection_length1;
244
 
                int val_it;
245
 
                val_collection = values_2;
246
 
                val_collection_length1 = values_2_length1;
247
 
                for (val_it = 0; val_it < values_2_length1; val_it = val_it + 1) {
248
213
                        gchar* _tmp18_;
249
214
                        gchar* val;
250
215
                        _tmp18_ = g_strdup (val_collection[val_it]);
251
216
                        val = _tmp18_;
252
217
                        {
253
 
                                gchar* _tmp19_;
254
 
                                _tmp19_ = g_strdup (val);
255
 
                                values_2_list = g_list_append (values_2_list, _tmp19_);
256
 
                                _g_free0 (val);
257
 
                        }
258
 
                }
259
 
        }
260
 
        _tmp20_ = g_hash_table_new_full (g_str_hash, g_str_equal, _g_free0_, NULL);
261
 
        param_table = _tmp20_;
262
 
        _tmp21_ = g_strdup (param_name);
263
 
        g_hash_table_insert (param_table, _tmp21_, values_2_list);
264
 
        folks_field_details_extend_parameters (details, param_table);
265
 
        _tmp22_ = folks_field_details_get_parameter_values (details, param_name);
266
 
        values = _tmp22_;
267
 
        _tmp23_ = g_list_length (values);
268
 
        g_assert (_tmp23_ == (values_1_length1 + values_2_length1));
269
 
        i = (guint) 0;
270
 
        {
271
 
                gboolean _tmp24_;
272
 
                _tmp24_ = TRUE;
273
 
                while (TRUE) {
274
 
                        gconstpointer _tmp25_ = NULL;
275
 
                        if (!_tmp24_) {
276
 
                                i++;
277
 
                        }
278
 
                        _tmp24_ = FALSE;
279
 
                        if (!(i < values_1_length1)) {
280
 
                                break;
281
 
                        }
282
 
                        _tmp25_ = g_list_nth_data (values, i);
283
 
                        g_assert (g_strcmp0 ((const gchar*) _tmp25_, values_1[i]) == 0);
284
 
                }
285
 
        }
286
 
        {
287
 
                gboolean _tmp26_;
288
 
                _tmp26_ = TRUE;
289
 
                while (TRUE) {
290
 
                        gconstpointer _tmp27_ = NULL;
291
 
                        if (!_tmp26_) {
292
 
                                i++;
293
 
                        }
294
 
                        _tmp26_ = FALSE;
295
 
                        if (!(i < values_2_length1)) {
296
 
                                break;
297
 
                        }
298
 
                        _tmp27_ = g_list_nth_data (values, i);
299
 
                        g_assert (g_strcmp0 ((const gchar*) _tmp27_, values_2[i]) == 0);
300
 
                }
301
 
        }
302
 
        _g_hash_table_unref0 (param_table);
 
218
                                folks_field_details_add_parameter (details, param_name, val);
 
219
                                _g_free0 (val);
 
220
                        }
 
221
                }
 
222
        }
 
223
        values_2_list = NULL;
 
224
        {
 
225
                gchar** val_collection;
 
226
                int val_collection_length1;
 
227
                int val_it;
 
228
                val_collection = values_2;
 
229
                val_collection_length1 = values_2_length1;
 
230
                for (val_it = 0; val_it < values_2_length1; val_it = val_it + 1) {
 
231
                        gchar* _tmp19_;
 
232
                        gchar* val;
 
233
                        _tmp19_ = g_strdup (val_collection[val_it]);
 
234
                        val = _tmp19_;
 
235
                        {
 
236
                                gchar* _tmp20_;
 
237
                                _tmp20_ = g_strdup (val);
 
238
                                values_2_list = g_list_append (values_2_list, _tmp20_);
 
239
                                _g_free0 (val);
 
240
                        }
 
241
                }
 
242
        }
 
243
        _tmp21_ = 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);
 
244
        param_table = _tmp21_;
 
245
        {
 
246
                GList* val_collection;
 
247
                GList* val_it;
 
248
                val_collection = values_2_list;
 
249
                for (val_it = val_collection; val_it != NULL; val_it = val_it->next) {
 
250
                        gchar* _tmp22_;
 
251
                        gchar* val;
 
252
                        _tmp22_ = g_strdup ((const gchar*) val_it->data);
 
253
                        val = _tmp22_;
 
254
                        {
 
255
                                gee_multi_map_set ((GeeMultiMap*) param_table, param_name, val);
 
256
                                _g_free0 (val);
 
257
                        }
 
258
                }
 
259
        }
 
260
        folks_field_details_extend_parameters (details, (GeeMultiMap*) param_table);
 
261
        _tmp23_ = folks_field_details_get_parameter_values (details, param_name);
 
262
        _g_object_unref0 (values);
 
263
        values = _tmp23_;
 
264
        _tmp24_ = gee_collection_get_size (values);
 
265
        g_assert (_tmp24_ == (values_1_length1 + values_2_length1));
 
266
        {
 
267
                gchar** val_collection;
 
268
                int val_collection_length1;
 
269
                int val_it;
 
270
                val_collection = values_1;
 
271
                val_collection_length1 = values_1_length1;
 
272
                for (val_it = 0; val_it < values_1_length1; val_it = val_it + 1) {
 
273
                        gchar* _tmp25_;
 
274
                        gchar* val;
 
275
                        _tmp25_ = g_strdup (val_collection[val_it]);
 
276
                        val = _tmp25_;
 
277
                        {
 
278
                                gboolean _tmp26_;
 
279
                                _tmp26_ = gee_collection_contains (values, val);
 
280
                                g_assert (_tmp26_);
 
281
                                _g_free0 (val);
 
282
                        }
 
283
                }
 
284
        }
 
285
        {
 
286
                gchar** val_collection;
 
287
                int val_collection_length1;
 
288
                int val_it;
 
289
                val_collection = values_2;
 
290
                val_collection_length1 = values_2_length1;
 
291
                for (val_it = 0; val_it < values_2_length1; val_it = val_it + 1) {
 
292
                        gchar* _tmp27_;
 
293
                        gchar* val;
 
294
                        _tmp27_ = g_strdup (val_collection[val_it]);
 
295
                        val = _tmp27_;
 
296
                        {
 
297
                                gboolean _tmp28_;
 
298
                                _tmp28_ = gee_collection_contains (values, val);
 
299
                                g_assert (_tmp28_);
 
300
                                _g_free0 (val);
 
301
                        }
 
302
                }
 
303
        }
 
304
        _g_object_unref0 (param_table);
303
305
        __g_list_free__g_free0_0 (values_2_list);
 
306
        _g_object_unref0 (values);
304
307
        _g_object_unref0 (details);
305
308
        values_2 = (_vala_array_free (values_2, values_2_length1, (GDestroyNotify) g_free), NULL);
306
309
        values_1 = (_vala_array_free (values_1, values_1_length1, (GDestroyNotify) g_free), NULL);