← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/json-glib/oneiric

« back to all changes in this revision

Viewing changes to tests/test-serialize-full.c

  • Committer: Bazaar Package Importer
  • Author(s): Laurent Bigonville
  • Date: 2011-06-21 16:29:02 UTC
  • mfrom: (1.1.7 upstream)
  • Revision ID: james.westby@ubuntu.com-20110621162902-ddd1ue8pgcqbpj6s
Tags: 0.13.4-1
* New upstream release. (Thanks to Ted Gould <ted@ubuntu.com>)
  - Fixes for removal of G_CONST_RETURN
* debian/libjson-glib-1.0-0.symbols: Update for 0.13.4
* debian/watch: Switch to .bz2 tarballs

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/test-serialize-full.c
1
 
#include <stdlib.h>
2
 
#include <stdio.h>
3
 
#include <string.h>
4
 
 
5
 
#include <glib-object.h>
6
 
 
7
 
#include <json-glib/json-glib.h>
8
 
#include <json-glib/json-gobject.h>
9
 
 
10
 
#define TEST_TYPE_ENUM                  (test_enum_get_type ())
11
 
#define TEST_TYPE_BOXED                 (test_boxed_get_type ())
12
 
#define TEST_TYPE_OBJECT                (test_object_get_type ())
13
 
#define TEST_OBJECT(obj)                (G_TYPE_CHECK_INSTANCE_CAST ((obj), TEST_TYPE_OBJECT, TestObject))
14
 
#define TEST_IS_OBJECT(obj)             (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TEST_TYPE_OBJECT))
15
 
#define TEST_OBJECT_CLASS(klass)        (G_TYPE_CHECK_CLASS_CAST ((klass), TEST_TYPE_OBJECT, TestObjectClass))
16
 
#define TEST_IS_OBJECT_CLASS(klass)     (G_TYPE_CHECK_CLASS_TYPE ((klass), TEST_TYPE_OBJECT))
17
 
#define TEST_OBJECT_GET_CLASS(obj)      (G_TYPE_INSTANCE_GET_CLASS ((obj), TEST_TYPE_OBJECT, TestObjectClass))
18
 
 
19
 
typedef enum {
20
 
  TEST_ENUM_FOO,
21
 
  TEST_ENUM_BAR,
22
 
  TEST_ENUM_BAZ
23
 
} TestEnum;
24
 
 
25
 
typedef struct _TestBoxed               TestBoxed;
26
 
typedef struct _TestObject              TestObject;
27
 
typedef struct _TestObjectClass         TestObjectClass;
28
 
 
29
 
struct _TestBoxed
30
 
{
31
 
  gint foo;
32
 
  gboolean bar;
33
 
};
34
 
 
35
 
struct _TestObject
36
 
{
37
 
  GObject parent_instance;
38
 
 
39
 
  gint foo;
40
 
  gboolean bar;
41
 
  gchar *baz;
42
 
  TestBoxed blah;
43
 
  TestEnum meh;
44
 
  gchar **mah;
45
 
 
46
 
  TestObject *test;
47
 
};
48
 
 
49
 
struct _TestObjectClass
50
 
{
51
 
  GObjectClass parent_class;
52
 
};
53
 
 
54
 
GType test_object_get_type (void);
55
 
 
56
 
/*** implementation ***/
57
 
 
58
 
static TestBoxed *
59
 
test_boxed_copy (const TestBoxed *src)
60
 
{
61
 
  TestBoxed *copy = g_slice_new (TestBoxed);
62
 
 
63
 
  *copy = *src;
64
 
 
65
 
  return copy;
66
 
}
67
 
 
68
 
static void
69
 
test_boxed_free (TestBoxed *boxed)
70
 
{
71
 
  if (G_LIKELY (boxed))
72
 
    {
73
 
      g_slice_free (TestBoxed, boxed);
74
 
    }
75
 
}
76
 
 
77
 
GType
78
 
test_boxed_get_type (void)
79
 
{
80
 
  static GType b_type = 0;
81
 
 
82
 
  if (G_UNLIKELY (b_type == 0))
83
 
    b_type = g_boxed_type_register_static ("TestBoxed",
84
 
                                           (GBoxedCopyFunc) test_boxed_copy,
85
 
                                           (GBoxedFreeFunc) test_boxed_free);
86
 
 
87
 
  return b_type;
88
 
}
89
 
 
90
 
GType
91
 
test_enum_get_type (void)
92
 
{
93
 
  static GType e_type = 0;
94
 
 
95
 
  if (G_UNLIKELY (e_type == 0))
96
 
    {
97
 
      static const GEnumValue values[] = {
98
 
        { TEST_ENUM_FOO, "TEST_ENUM_FOO", "foo" },
99
 
        { TEST_ENUM_BAR, "TEST_ENUM_BAR", "bar" },
100
 
        { TEST_ENUM_BAZ, "TEST_ENUM_BAZ", "baz" },
101
 
        { 0, NULL, NULL }
102
 
      };
103
 
 
104
 
      e_type = g_enum_register_static ("TestEnum", values);
105
 
    }
106
 
 
107
 
  return e_type;
108
 
}
109
 
 
110
 
enum
111
 
{
112
 
  PROP_0,
113
 
 
114
 
  PROP_FOO,
115
 
  PROP_BAR,
116
 
  PROP_BAZ,
117
 
  PROP_BLAH,
118
 
  PROP_MEH,
119
 
  PROP_MAH,
120
 
  PROP_TEST
121
 
};
122
 
 
123
 
static void json_serializable_iface_init (gpointer g_iface);
124
 
 
125
 
G_DEFINE_TYPE_WITH_CODE (TestObject, test_object, G_TYPE_OBJECT,
126
 
                         G_IMPLEMENT_INTERFACE (JSON_TYPE_SERIALIZABLE,
127
 
                                                json_serializable_iface_init));
128
 
 
129
 
static JsonNode *
130
 
test_object_serialize_property (JsonSerializable *serializable,
131
 
                                const gchar      *name,
132
 
                                const GValue     *value,
133
 
                                GParamSpec       *pspec)
134
 
{
135
 
  JsonNode *retval;
136
 
 
137
 
  if (strcmp (name, "blah") == 0)
138
 
    {
139
 
      TestBoxed *boxed;
140
 
      JsonObject *obj;
141
 
 
142
 
      retval = json_node_new (JSON_NODE_OBJECT);
143
 
      obj = json_object_new ();
144
 
      
145
 
      boxed = g_value_get_boxed (value);
146
 
 
147
 
      json_object_set_int_member (obj, "foo", boxed->foo);
148
 
      json_object_set_boolean_member (obj, "bar", boxed->bar);
149
 
 
150
 
      json_node_take_object (retval, obj);
151
 
 
152
 
      test_boxed_free (boxed);
153
 
    }
154
 
  else
155
 
    {
156
 
      GValue copy = { 0, };
157
 
 
158
 
      retval = json_node_new (JSON_NODE_VALUE);
159
 
 
160
 
      g_value_init (&copy, G_PARAM_SPEC_VALUE_TYPE (pspec));
161
 
      g_value_copy (value, &copy);
162
 
      json_node_set_value (retval, &copy);
163
 
      g_value_unset (&copy);
164
 
    }
165
 
 
166
 
  return retval;
167
 
}
168
 
 
169
 
static void
170
 
json_serializable_iface_init (gpointer g_iface)
171
 
{
172
 
  JsonSerializableIface *iface = g_iface;
173
 
 
174
 
  iface->serialize_property = test_object_serialize_property;
175
 
}
176
 
 
177
 
static void
178
 
test_object_finalize (GObject *gobject)
179
 
{
180
 
  g_free (TEST_OBJECT (gobject)->baz);
181
 
  g_strfreev (TEST_OBJECT (gobject)->mah);
182
 
 
183
 
  if (TEST_OBJECT (gobject)->test != NULL)
184
 
    g_object_unref (TEST_OBJECT (gobject)->test);
185
 
 
186
 
  G_OBJECT_CLASS (test_object_parent_class)->finalize (gobject);
187
 
}
188
 
 
189
 
static void
190
 
test_object_set_property (GObject      *gobject,
191
 
                          guint         prop_id,
192
 
                          const GValue *value,
193
 
                          GParamSpec   *pspec)
194
 
{
195
 
  switch (prop_id)
196
 
    {
197
 
    case PROP_FOO:
198
 
      TEST_OBJECT (gobject)->foo = g_value_get_int (value);
199
 
      break;
200
 
 
201
 
    case PROP_BAR:
202
 
      TEST_OBJECT (gobject)->bar = g_value_get_boolean (value);
203
 
      break;
204
 
 
205
 
    case PROP_BAZ:
206
 
      g_free (TEST_OBJECT (gobject)->baz);
207
 
      TEST_OBJECT (gobject)->baz = g_value_dup_string (value);
208
 
      break;
209
 
 
210
 
    case PROP_MEH:
211
 
      TEST_OBJECT (gobject)->meh = g_value_get_enum (value);
212
 
      break;
213
 
 
214
 
    case PROP_MAH:
215
 
      TEST_OBJECT (gobject)->mah = g_strdupv (g_value_get_boxed (value));
216
 
      break;
217
 
 
218
 
    case PROP_TEST:
219
 
      TEST_OBJECT (gobject)->test = g_value_dup_object (value);
220
 
      break;
221
 
 
222
 
    default:
223
 
      G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
224
 
    }
225
 
}
226
 
 
227
 
static void
228
 
test_object_get_property (GObject    *gobject,
229
 
                          guint       prop_id,
230
 
                          GValue     *value,
231
 
                          GParamSpec *pspec)
232
 
{
233
 
  switch (prop_id)
234
 
    {
235
 
    case PROP_FOO:
236
 
      g_value_set_int (value, TEST_OBJECT (gobject)->foo);
237
 
      break;
238
 
 
239
 
    case PROP_BAR:
240
 
      g_value_set_boolean (value, TEST_OBJECT (gobject)->bar);
241
 
      break;
242
 
 
243
 
    case PROP_BAZ:
244
 
      g_value_set_string (value, TEST_OBJECT (gobject)->baz);
245
 
      break;
246
 
 
247
 
    case PROP_BLAH:
248
 
      g_value_set_boxed (value, &(TEST_OBJECT (gobject)->blah));
249
 
      break;
250
 
 
251
 
    case PROP_MEH:
252
 
      g_value_set_enum (value, TEST_OBJECT (gobject)->meh);
253
 
      break;
254
 
 
255
 
    case PROP_MAH:
256
 
      g_value_set_boxed (value, TEST_OBJECT (gobject)->mah);
257
 
      break;
258
 
 
259
 
    case PROP_TEST:
260
 
      g_value_set_object (value, TEST_OBJECT (gobject)->test);
261
 
      break;
262
 
 
263
 
    default:
264
 
      G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
265
 
    }
266
 
}
267
 
 
268
 
static void
269
 
test_object_class_init (TestObjectClass *klass)
270
 
{
271
 
  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
272
 
 
273
 
  gobject_class->set_property = test_object_set_property;
274
 
  gobject_class->get_property = test_object_get_property;
275
 
  gobject_class->finalize = test_object_finalize;
276
 
 
277
 
  g_object_class_install_property (gobject_class,
278
 
                                   PROP_FOO,
279
 
                                   g_param_spec_int ("foo", "Foo", "Foo",
280
 
                                                     0, G_MAXINT, 42,
281
 
                                                     G_PARAM_READWRITE));
282
 
  g_object_class_install_property (gobject_class,
283
 
                                   PROP_BAR,
284
 
                                   g_param_spec_boolean ("bar", "Bar", "Bar",
285
 
                                                         FALSE,
286
 
                                                         G_PARAM_READWRITE |
287
 
                                                         G_PARAM_CONSTRUCT_ONLY));
288
 
  g_object_class_install_property (gobject_class,
289
 
                                   PROP_BAZ,
290
 
                                   g_param_spec_string ("baz", "Baz", "Baz",
291
 
                                                        NULL,
292
 
                                                        G_PARAM_READWRITE));
293
 
  g_object_class_install_property (gobject_class,
294
 
                                   PROP_BLAH,
295
 
                                   g_param_spec_boxed ("blah", "Blah", "Blah",
296
 
                                                       TEST_TYPE_BOXED,
297
 
                                                       G_PARAM_READABLE));
298
 
  g_object_class_install_property (gobject_class,
299
 
                                   PROP_MEH,
300
 
                                   g_param_spec_enum ("meh", "Meh", "Meh",
301
 
                                                      TEST_TYPE_ENUM,
302
 
                                                      TEST_ENUM_BAR,
303
 
                                                      G_PARAM_READWRITE));
304
 
  g_object_class_install_property (gobject_class,
305
 
                                   PROP_MAH,
306
 
                                   g_param_spec_boxed ("mah", "Mah", "Mah",
307
 
                                                       G_TYPE_STRV,
308
 
                                                       G_PARAM_READWRITE));
309
 
  g_object_class_install_property (gobject_class,
310
 
                                   PROP_TEST,
311
 
                                   g_param_spec_object ("test", "Test", "Test",
312
 
                                                        TEST_TYPE_OBJECT,
313
 
                                                        G_PARAM_READWRITE));
314
 
}
315
 
 
316
 
static void
317
 
test_object_init (TestObject *object)
318
 
{
319
 
  object->foo = 0;
320
 
  object->bar = FALSE;
321
 
  object->baz = NULL; 
322
 
 
323
 
  object->blah.foo = object->foo;
324
 
  object->blah.bar = object->bar;
325
 
 
326
 
  object->meh = TEST_ENUM_BAR;
327
 
 
328
 
  object->mah = NULL;
329
 
 
330
 
  object->test = NULL;
331
 
}
332
 
 
333
 
static const gchar *var_test =
334
 
"{\n"
335
 
"  \"foo\"  : 42,\n"
336
 
"  \"bar\"  : true,\n"
337
 
"  \"baz\"  : \"hello\",\n"
338
 
"  \"meh\"  : \"baz\",\n"
339
 
"  \"mah\"  : [ \"hello\", \", \", \"world\", \"!\" ],\n"
340
 
"  \"test\" : {\n"
341
 
"    \"bar\" : true,\n"
342
 
"    \"baz\" : \"world\",\n"
343
 
"    \"meh\" : \"foo\"\n"
344
 
"  }\n"
345
 
"}";
346
 
 
347
 
static void
348
 
test_deserialize (void)
349
 
{
350
 
  TestObject *test;
351
 
  GObject *object;
352
 
  GError *error;
353
 
  gchar *str;
354
 
 
355
 
  error = NULL;
356
 
  object = json_gobject_from_data (TEST_TYPE_OBJECT, var_test, -1, &error);
357
 
  if (error)
358
 
    g_error ("*** Unable to parse buffer: %s\n", error->message);
359
 
 
360
 
  if (g_test_verbose ())
361
 
    g_print ("*** TestObject ***\n"
362
 
             " foo: %s\n"
363
 
             " bar: %s\n"
364
 
             " baz: %s\n"
365
 
             " meh: %s\n",
366
 
             TEST_OBJECT (object)->foo == 42            ? "<true>" : "<false>",
367
 
             TEST_OBJECT (object)->bar == TRUE          ? "<true>" : "<false>",
368
 
             TEST_OBJECT (object)->baz != NULL          ? "<true>" : "<false>",
369
 
             TEST_OBJECT (object)->meh == TEST_ENUM_BAZ ? "<true>" : "<false>");
370
 
 
371
 
  g_assert_cmpint (TEST_OBJECT (object)->foo, ==, 42);
372
 
  g_assert (TEST_OBJECT (object)->bar);
373
 
  g_assert_cmpstr (TEST_OBJECT (object)->baz, ==, "hello");
374
 
  g_assert_cmpint (TEST_OBJECT (object)->meh, ==, TEST_ENUM_BAZ);
375
 
 
376
 
  g_assert (TEST_OBJECT (object)->mah != NULL);
377
 
  g_assert_cmpint (g_strv_length (TEST_OBJECT (object)->mah), ==, 4);
378
 
 
379
 
  str = g_strjoinv (NULL, TEST_OBJECT (object)->mah);
380
 
  g_assert_cmpstr (str, ==, "hello, world!");
381
 
  g_free (str);
382
 
 
383
 
  g_assert (TEST_IS_OBJECT (TEST_OBJECT (object)->test));
384
 
  test = TEST_OBJECT (TEST_OBJECT (object)->test);
385
 
  g_assert (test->bar);
386
 
  g_assert_cmpstr (test->baz, ==, "world");
387
 
  g_assert_cmpint (test->meh, ==, TEST_ENUM_FOO);
388
 
 
389
 
  g_object_unref (object);
390
 
}
391
 
 
392
 
int
393
 
main (int   argc,
394
 
      char *argv[])
395
 
{
396
 
  g_type_init ();
397
 
  g_test_init (&argc, &argv, NULL);
398
 
 
399
 
  g_test_add_func ("/deserialize/json-to-gobject", test_deserialize);
400
 
 
401
 
  return g_test_run ();
402
 
}