← Back to branch summary

~didrocks/ubuntuone-client/dont-suffer-zg-crash

« back to all changes in this revision

Viewing changes to libsyncdaemon/test-libsyncdaemon-vapi.c

  • Committer: Bazaar Package Importer
  • Author(s): Rodney Dawes
  • Date: 2011-02-11 16:18:11 UTC
  • mfrom: (1.1.44 upstream)
  • Revision ID: james.westby@ubuntu.com-20110211161811-lbelxu332e8r2dov
Tags: 1.5.4-0ubuntu1
https://launchpad.net/bugs/682878
https://launchpad.net/bugs/708335
https://launchpad.net/bugs/712674
https://launchpad.net/bugs/715776
https://launchpad.net/bugs/702055
https://launchpad.net/bugs/702075
https://launchpad.net/bugs/702128
https://launchpad.net/bugs/702138
https://launchpad.net/bugs/702144
* New upstream release.
  - Files still get downloaded from unsubscribed folder (LP: #682878)
  - Add subscription capabilities to shares (LP: #708335)
  - Nautilus offers Publish option within other's shares (LP: #712674)
  - Shares dir name may not be unique (LP: #715776)
  - Send a notification when new Volume is available (LP: #702055)
  - Add messaging menu entry for new Volumes (LP: #702075)
  - Aggregate notifications for completed operations (LP: #702128)
  - Send a notification for new Share offers (LP: #702138)
  - Add messaging menu entry for new Share offers (LP: #702144)
* Remove ubuntuone-client-tools as u1sync has been moved out.
* Simplify python package as we don't have multiple python packages now.

Show diffs side-by-side

added added

removed removed

Lines of Context:
libsyncdaemon/test-libsyncdaemon-vapi.c
 
1
/* test-libsyncdaemon-vapi.c generated by valac 0.11.5, the Vala compiler
 
2
 * generated from test-libsyncdaemon-vapi.vala, do not modify */
 
3
 
 
4
/*
 
5
 * Syncdaemon Vala API test binary
 
6
 *
 
7
 * Copyright 2011 Canonical Ltd.
 
8
 *
 
9
 * This program is free software: you can redistribute it and/or modify it
 
10
 * under the terms of the GNU General Public License version 3, as published
 
11
 * by the Free Software Foundation.
 
12
 *
 
13
 * This program is distributed in the hope that it will be useful, but
 
14
 * WITHOUT ANY WARRANTY; without even the implied warranties of
 
15
 * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
 
16
 * PURPOSE.  See the GNU General Public License for more details.
 
17
 *
 
18
 * You should have received a copy of the GNU General Public License along
 
19
 * with this program.  If not, see <http://www.gnu.org/licenses/>.
 
20
 *
 
21
 */
 
22
 
 
23
#include <glib.h>
 
24
#include <glib-object.h>
 
25
#include <libsyncdaemon/libsyncdaemon.h>
 
26
#include <stdlib.h>
 
27
#include <string.h>
 
28
#include <gobject/gvaluecollector.h>
 
29
 
 
30
 
 
31
#define TYPE_TEST_VAPI (test_vapi_get_type ())
 
32
#define TEST_VAPI(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_TEST_VAPI, TestVapi))
 
33
#define TEST_VAPI_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_TEST_VAPI, TestVapiClass))
 
34
#define IS_TEST_VAPI(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_TEST_VAPI))
 
35
#define IS_TEST_VAPI_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_TEST_VAPI))
 
36
#define TEST_VAPI_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_TEST_VAPI, TestVapiClass))
 
37
 
 
38
typedef struct _TestVapi TestVapi;
 
39
typedef struct _TestVapiClass TestVapiClass;
 
40
typedef struct _TestVapiPrivate TestVapiPrivate;
 
41
#define _g_main_loop_unref0(var) ((var == NULL) ? NULL : (var = (g_main_loop_unref (var), NULL)))
 
42
#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
 
43
typedef struct _ParamSpecTestVapi ParamSpecTestVapi;
 
44
#define _test_vapi_unref0(var) ((var == NULL) ? NULL : (var = (test_vapi_unref (var), NULL)))
 
45
 
 
46
struct _TestVapi {
 
47
        GTypeInstance parent_instance;
 
48
        volatile int ref_count;
 
49
        TestVapiPrivate * priv;
 
50
};
 
51
 
 
52
struct _TestVapiClass {
 
53
        GTypeClass parent_class;
 
54
        void (*finalize) (TestVapi *self);
 
55
};
 
56
 
 
57
struct _TestVapiPrivate {
 
58
        GMainLoop* loop;
 
59
        gint status;
 
60
};
 
61
 
 
62
struct _ParamSpecTestVapi {
 
63
        GParamSpec parent_instance;
 
64
};
 
65
 
 
66
 
 
67
static gpointer test_vapi_parent_class = NULL;
 
68
 
 
69
gpointer test_vapi_ref (gpointer instance);
 
70
void test_vapi_unref (gpointer instance);
 
71
GParamSpec* param_spec_test_vapi (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
 
72
void value_set_test_vapi (GValue* value, gpointer v_object);
 
73
void value_take_test_vapi (GValue* value, gpointer v_object);
 
74
gpointer value_get_test_vapi (const GValue* value);
 
75
GType test_vapi_get_type (void) G_GNUC_CONST;
 
76
#define TEST_VAPI_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), TYPE_TEST_VAPI, TestVapiPrivate))
 
77
enum  {
 
78
        TEST_VAPI_DUMMY_PROPERTY
 
79
};
 
80
TestVapi* test_vapi_new (void);
 
81
TestVapi* test_vapi_construct (GType object_type);
 
82
static gboolean test_vapi_test_instantiation (TestVapi* self);
 
83
gint test_vapi_main (TestVapi* self);
 
84
static void test_vapi_finalize (TestVapi* obj);
 
85
gint _vala_main (gchar** args, int args_length1);
 
86
 
 
87
 
 
88
TestVapi* test_vapi_construct (GType object_type) {
 
89
        TestVapi* self = NULL;
 
90
        self = (TestVapi*) g_type_create_instance (object_type);
 
91
        self->priv->status = 0;
 
92
        return self;
 
93
}
 
94
 
 
95
 
 
96
TestVapi* test_vapi_new (void) {
 
97
        return test_vapi_construct (TYPE_TEST_VAPI);
 
98
}
 
99
 
 
100
 
 
101
static gboolean test_vapi_test_instantiation (TestVapi* self) {
 
102
        gboolean result = FALSE;
 
103
        SyncdaemonDaemon* _tmp0_ = NULL;
 
104
        SyncdaemonDaemon* _tmp1_;
 
105
        g_return_val_if_fail (self != NULL, FALSE);
 
106
        _tmp0_ = syncdaemon_daemon_new ();
 
107
        _tmp1_ = _tmp0_;
 
108
        _g_object_unref0 (_tmp1_);
 
109
        g_main_loop_quit (self->priv->loop);
 
110
        result = FALSE;
 
111
        return result;
 
112
}
 
113
 
 
114
 
 
115
gint test_vapi_main (TestVapi* self) {
 
116
        gint result = 0;
 
117
        GMainLoop* _tmp0_ = NULL;
 
118
        GMainLoop* _tmp1_;
 
119
        GSourceFunc _tmp2_;
 
120
        g_return_val_if_fail (self != NULL, 0);
 
121
        _tmp0_ = g_main_loop_new (NULL, FALSE);
 
122
        _tmp1_ = _tmp0_;
 
123
        _g_main_loop_unref0 (self->priv->loop);
 
124
        self->priv->loop = _tmp1_;
 
125
        _tmp2_ = (GSourceFunc) test_vapi_test_instantiation;
 
126
        g_idle_add_full (G_PRIORITY_DEFAULT_IDLE, _tmp2_, self, NULL);
 
127
        g_main_loop_run (self->priv->loop);
 
128
        result = self->priv->status;
 
129
        return result;
 
130
}
 
131
 
 
132
 
 
133
static void value_test_vapi_init (GValue* value) {
 
134
        value->data[0].v_pointer = NULL;
 
135
}
 
136
 
 
137
 
 
138
static void value_test_vapi_free_value (GValue* value) {
 
139
        if (value->data[0].v_pointer) {
 
140
                test_vapi_unref (value->data[0].v_pointer);
 
141
        }
 
142
}
 
143
 
 
144
 
 
145
static void value_test_vapi_copy_value (const GValue* src_value, GValue* dest_value) {
 
146
        if (src_value->data[0].v_pointer) {
 
147
                dest_value->data[0].v_pointer = test_vapi_ref (src_value->data[0].v_pointer);
 
148
        } else {
 
149
                dest_value->data[0].v_pointer = NULL;
 
150
        }
 
151
}
 
152
 
 
153
 
 
154
static gpointer value_test_vapi_peek_pointer (const GValue* value) {
 
155
        return value->data[0].v_pointer;
 
156
}
 
157
 
 
158
 
 
159
static gchar* value_test_vapi_collect_value (GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
 
160
        if (collect_values[0].v_pointer) {
 
161
                TestVapi* object;
 
162
                object = collect_values[0].v_pointer;
 
163
                if (object->parent_instance.g_class == NULL) {
 
164
                        return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
 
165
                } else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) {
 
166
                        return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
 
167
                }
 
168
                value->data[0].v_pointer = test_vapi_ref (object);
 
169
        } else {
 
170
                value->data[0].v_pointer = NULL;
 
171
        }
 
172
        return NULL;
 
173
}
 
174
 
 
175
 
 
176
static gchar* value_test_vapi_lcopy_value (const GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
 
177
        TestVapi** object_p;
 
178
        object_p = collect_values[0].v_pointer;
 
179
        if (!object_p) {
 
180
                return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
 
181
        }
 
182
        if (!value->data[0].v_pointer) {
 
183
                *object_p = NULL;
 
184
        } else if (collect_flags & G_VALUE_NOCOPY_CONTENTS) {
 
185
                *object_p = value->data[0].v_pointer;
 
186
        } else {
 
187
                *object_p = test_vapi_ref (value->data[0].v_pointer);
 
188
        }
 
189
        return NULL;
 
190
}
 
191
 
 
192
 
 
193
GParamSpec* param_spec_test_vapi (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags) {
 
194
        ParamSpecTestVapi* spec;
 
195
        g_return_val_if_fail (g_type_is_a (object_type, TYPE_TEST_VAPI), NULL);
 
196
        spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags);
 
197
        G_PARAM_SPEC (spec)->value_type = object_type;
 
198
        return G_PARAM_SPEC (spec);
 
199
}
 
200
 
 
201
 
 
202
gpointer value_get_test_vapi (const GValue* value) {
 
203
        g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_TEST_VAPI), NULL);
 
204
        return value->data[0].v_pointer;
 
205
}
 
206
 
 
207
 
 
208
void value_set_test_vapi (GValue* value, gpointer v_object) {
 
209
        TestVapi* old;
 
210
        g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_TEST_VAPI));
 
211
        old = value->data[0].v_pointer;
 
212
        if (v_object) {
 
213
                g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_TEST_VAPI));
 
214
                g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
 
215
                value->data[0].v_pointer = v_object;
 
216
                test_vapi_ref (value->data[0].v_pointer);
 
217
        } else {
 
218
                value->data[0].v_pointer = NULL;
 
219
        }
 
220
        if (old) {
 
221
                test_vapi_unref (old);
 
222
        }
 
223
}
 
224
 
 
225
 
 
226
void value_take_test_vapi (GValue* value, gpointer v_object) {
 
227
        TestVapi* old;
 
228
        g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_TEST_VAPI));
 
229
        old = value->data[0].v_pointer;
 
230
        if (v_object) {
 
231
                g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_TEST_VAPI));
 
232
                g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
 
233
                value->data[0].v_pointer = v_object;
 
234
        } else {
 
235
                value->data[0].v_pointer = NULL;
 
236
        }
 
237
        if (old) {
 
238
                test_vapi_unref (old);
 
239
        }
 
240
}
 
241
 
 
242
 
 
243
static void test_vapi_class_init (TestVapiClass * klass) {
 
244
        test_vapi_parent_class = g_type_class_peek_parent (klass);
 
245
        TEST_VAPI_CLASS (klass)->finalize = test_vapi_finalize;
 
246
        g_type_class_add_private (klass, sizeof (TestVapiPrivate));
 
247
}
 
248
 
 
249
 
 
250
static void test_vapi_instance_init (TestVapi * self) {
 
251
        self->priv = TEST_VAPI_GET_PRIVATE (self);
 
252
        self->ref_count = 1;
 
253
}
 
254
 
 
255
 
 
256
static void test_vapi_finalize (TestVapi* obj) {
 
257
        TestVapi * self;
 
258
        self = TEST_VAPI (obj);
 
259
        _g_main_loop_unref0 (self->priv->loop);
 
260
}
 
261
 
 
262
 
 
263
GType test_vapi_get_type (void) {
 
264
        static volatile gsize test_vapi_type_id__volatile = 0;
 
265
        if (g_once_init_enter (&test_vapi_type_id__volatile)) {
 
266
                static const GTypeValueTable g_define_type_value_table = { value_test_vapi_init, value_test_vapi_free_value, value_test_vapi_copy_value, value_test_vapi_peek_pointer, "p", value_test_vapi_collect_value, "p", value_test_vapi_lcopy_value };
 
267
                static const GTypeInfo g_define_type_info = { sizeof (TestVapiClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) test_vapi_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (TestVapi), 0, (GInstanceInitFunc) test_vapi_instance_init, &g_define_type_value_table };
 
268
                static const GTypeFundamentalInfo g_define_type_fundamental_info = { (G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE) };
 
269
                GType test_vapi_type_id;
 
270
                test_vapi_type_id = g_type_register_fundamental (g_type_fundamental_next (), "TestVapi", &g_define_type_info, &g_define_type_fundamental_info, 0);
 
271
                g_once_init_leave (&test_vapi_type_id__volatile, test_vapi_type_id);
 
272
        }
 
273
        return test_vapi_type_id__volatile;
 
274
}
 
275
 
 
276
 
 
277
gpointer test_vapi_ref (gpointer instance) {
 
278
        TestVapi* self;
 
279
        self = instance;
 
280
        g_atomic_int_inc (&self->ref_count);
 
281
        return instance;
 
282
}
 
283
 
 
284
 
 
285
void test_vapi_unref (gpointer instance) {
 
286
        TestVapi* self;
 
287
        self = instance;
 
288
        if (g_atomic_int_dec_and_test (&self->ref_count)) {
 
289
                TEST_VAPI_GET_CLASS (self)->finalize (self);
 
290
                g_type_free_instance ((GTypeInstance *) self);
 
291
        }
 
292
}
 
293
 
 
294
 
 
295
gint _vala_main (gchar** args, int args_length1) {
 
296
        gint result = 0;
 
297
        TestVapi* _tmp0_ = NULL;
 
298
        TestVapi* test;
 
299
        gint _tmp1_;
 
300
        _tmp0_ = test_vapi_new ();
 
301
        test = _tmp0_;
 
302
        _tmp1_ = test_vapi_main (test);
 
303
        result = _tmp1_;
 
304
        _test_vapi_unref0 (test);
 
305
        return result;
 
306
}
 
307
 
 
308
 
 
309
int main (int argc, char ** argv) {
 
310
        g_type_init ();
 
311
        return _vala_main (argv, argc);
 
312
}
 
313
 
 
314
 
 
315