← Back to branch summary

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

« back to all changes in this revision

Viewing changes to json-glib/tests/generator-test.c

  • Committer: Package Import Robot
  • Author(s): Martin Pitt
  • Date: 2011-09-12 09:08:07 UTC
  • mfrom: (1.1.8 upstream)
  • Revision ID: package-import@ubuntu.com-20110912090807-3br793wiakn3yr8r
Tags: 0.13.90-1
* New upstream release.
* Drop 0001-Fix-GVariant-creation-on-some-architectures-bug-6504.patch:
  Applied upstream.

Show diffs side-by-side

added added

removed removed

Lines of Context:
json-glib/tests/generator-test.c
1
 
#ifdef HAVE_CONFIG_H
2
 
#include "config.h"
3
 
#endif
4
 
 
5
 
#include <stdlib.h>
6
 
#include <stdio.h>
7
 
#include <string.h>
8
 
 
9
 
#include <glib.h>
10
 
 
11
 
#include <json-glib/json-glib.h>
12
 
 
13
 
#include <locale.h>
14
 
 
15
 
static const gchar *empty_array  = "[]";
16
 
static const gchar *empty_object = "{}";
17
 
 
18
 
static const gchar *simple_array = "[true,false,null,42,\"foo\"]";
19
 
static const gchar *nested_array = "[true,[false,null],42]";
20
 
 
21
 
static const gchar *simple_object = "{\"Bool1\":true,\"Bool2\":false,\"Null\":null,\"Int\":42,\"String\":\"foo\"}";
22
 
/* taken from the RFC 4627, Examples section */
23
 
static const gchar *nested_object =
24
 
"{"
25
 
  "\"Image\":{"
26
 
    "\"Width\":800,"
27
 
    "\"Height\":600,"
28
 
    "\"Title\":\"View from 15th Floor\","
29
 
    "\"Thumbnail\":{"
30
 
      "\"Url\":\"http://www.example.com/image/481989943\","
31
 
      "\"Height\":125,"
32
 
      "\"Width\":\"100\""
33
 
    "},"
34
 
    "\"IDs\":[116,943,234,38793]"
35
 
  "}"
36
 
"}";
37
 
 
38
 
static const struct {
39
 
  const gchar *lang;
40
 
  const gchar *sep;
41
 
  guint matches : 1;
42
 
} decimal_separator[] = {
43
 
  { "C", ".",  TRUE },
44
 
  { "de", ",", FALSE },
45
 
  { "en", ".", TRUE },
46
 
  { "fr", ",", FALSE }
47
 
};
48
 
 
49
 
static void
50
 
test_empty_array (void)
51
 
{
52
 
  JsonGenerator *gen = json_generator_new ();
53
 
  JsonNode *root;
54
 
  gchar *data;
55
 
  gsize len;
56
 
 
57
 
  root = json_node_new (JSON_NODE_ARRAY);
58
 
  json_node_take_array (root, json_array_new ());
59
 
 
60
 
  json_generator_set_root (gen, root);
61
 
  g_object_set (gen, "pretty", FALSE, NULL);
62
 
 
63
 
  data = json_generator_to_data (gen, &len);
64
 
 
65
 
  g_assert_cmpint (len, ==, strlen (empty_array));
66
 
  g_assert_cmpstr (data, ==, empty_array);
67
 
 
68
 
  g_free (data);
69
 
  json_node_free (root);
70
 
  g_object_unref (gen);
71
 
}
72
 
 
73
 
static void
74
 
test_empty_object (void)
75
 
{
76
 
  JsonGenerator *gen = json_generator_new ();
77
 
  JsonNode *root;
78
 
  gchar *data;
79
 
  gsize len;
80
 
 
81
 
  root = json_node_new (JSON_NODE_OBJECT);
82
 
  json_node_take_object (root, json_object_new ());
83
 
 
84
 
  json_generator_set_root (gen, root);
85
 
  g_object_set (gen, "pretty", FALSE, NULL);
86
 
 
87
 
  data = json_generator_to_data (gen, &len);
88
 
 
89
 
  g_assert_cmpint (len, ==, strlen (empty_object));
90
 
  g_assert_cmpstr (data, ==, empty_object);
91
 
 
92
 
  g_free (data);
93
 
  json_node_free (root);
94
 
  g_object_unref (gen);
95
 
}
96
 
 
97
 
static void
98
 
test_simple_array (void)
99
 
{
100
 
  JsonGenerator *generator = json_generator_new ();
101
 
  JsonNode *root;
102
 
  JsonArray *array;
103
 
  gchar *data;
104
 
  gsize len;
105
 
 
106
 
  root = json_node_new (JSON_NODE_ARRAY);
107
 
  array = json_array_sized_new (5);
108
 
 
109
 
  json_array_add_boolean_element (array, TRUE);
110
 
  json_array_add_boolean_element (array, FALSE);
111
 
  json_array_add_null_element (array);
112
 
  json_array_add_int_element (array, 42);
113
 
  json_array_add_string_element (array, "foo");
114
 
 
115
 
  json_node_take_array (root, array);
116
 
  json_generator_set_root (generator, root);
117
 
 
118
 
  g_object_set (generator, "pretty", FALSE, NULL);
119
 
  data = json_generator_to_data (generator, &len);
120
 
 
121
 
  if (g_test_verbose ())
122
 
    g_print ("checking simple array `%s' (expected: %s)\n",
123
 
             data,
124
 
             simple_array);
125
 
 
126
 
  g_assert_cmpint (len, ==, strlen (simple_array));
127
 
  g_assert_cmpstr (data, ==, simple_array);
128
 
 
129
 
  g_free (data);
130
 
  json_node_free (root);
131
 
  g_object_unref (generator);
132
 
}
133
 
 
134
 
static void
135
 
test_nested_array (void)
136
 
{
137
 
  JsonGenerator *generator = json_generator_new ();
138
 
  JsonNode *root;
139
 
  JsonArray *array, *nested;
140
 
  gchar *data;
141
 
  gsize len;
142
 
 
143
 
  root = json_node_new (JSON_NODE_ARRAY);
144
 
  array = json_array_sized_new (3);
145
 
 
146
 
  json_array_add_boolean_element (array, TRUE);
147
 
 
148
 
  {
149
 
    nested = json_array_sized_new (2);
150
 
 
151
 
    json_array_add_boolean_element (nested, FALSE);
152
 
    json_array_add_null_element (nested);
153
 
 
154
 
    json_array_add_array_element (array, nested);
155
 
  }
156
 
 
157
 
  json_array_add_int_element (array, 42);
158
 
 
159
 
  json_node_take_array (root, array);
160
 
  json_generator_set_root (generator, root);
161
 
 
162
 
  g_object_set (generator, "pretty", FALSE, NULL);
163
 
  data = json_generator_to_data (generator, &len);
164
 
 
165
 
  g_assert_cmpint (len, ==, strlen (nested_array));
166
 
  g_assert_cmpstr (data, ==, nested_array);
167
 
 
168
 
  g_free (data);
169
 
  json_node_free (root);
170
 
  g_object_unref (generator);
171
 
}
172
 
 
173
 
static void
174
 
test_simple_object (void)
175
 
{
176
 
  JsonGenerator *generator = json_generator_new ();
177
 
  JsonNode *root;
178
 
  JsonObject *object;
179
 
  gchar *data;
180
 
  gsize len;
181
 
 
182
 
  root = json_node_new (JSON_NODE_OBJECT);
183
 
  object = json_object_new ();
184
 
 
185
 
  json_object_set_boolean_member (object, "Bool1", TRUE);
186
 
  json_object_set_boolean_member (object, "Bool2", FALSE);
187
 
  json_object_set_null_member (object, "Null");
188
 
  json_object_set_int_member (object, "Int", 42);
189
 
  json_object_set_string_member (object, "String", "foo");
190
 
 
191
 
  json_node_take_object (root, object);
192
 
  json_generator_set_root (generator, root);
193
 
 
194
 
  g_object_set (generator, "pretty", FALSE, NULL);
195
 
  data = json_generator_to_data (generator, &len);
196
 
 
197
 
  if (g_test_verbose ())
198
 
    g_print ("checking simple object `%s' (expected: %s)\n",
199
 
             data,
200
 
             simple_object);
201
 
 
202
 
  g_assert_cmpint (len, ==, strlen (simple_object));
203
 
  g_assert_cmpstr (data, ==, simple_object);
204
 
 
205
 
  g_free (data);
206
 
  json_node_free (root);
207
 
  g_object_unref (generator);
208
 
}
209
 
 
210
 
static void
211
 
test_nested_object (void)
212
 
{
213
 
  JsonGenerator *generator = json_generator_new ();
214
 
  JsonNode *root;
215
 
  JsonObject *object, *nested;
216
 
  JsonArray *array;
217
 
  gchar *data;
218
 
  gsize len;
219
 
 
220
 
  root = json_node_new (JSON_NODE_OBJECT);
221
 
  object = json_object_new ();
222
 
 
223
 
  json_object_set_int_member (object, "Width", 800);
224
 
  json_object_set_int_member (object, "Height", 600);
225
 
  json_object_set_string_member (object, "Title", "View from 15th Floor");
226
 
 
227
 
  {
228
 
    nested = json_object_new ();
229
 
 
230
 
    json_object_set_string_member (nested, "Url", "http://www.example.com/image/481989943");
231
 
    json_object_set_int_member (nested, "Height", 125);
232
 
    json_object_set_string_member (nested, "Width", "100");
233
 
 
234
 
    json_object_set_object_member (object, "Thumbnail", nested);
235
 
  }
236
 
 
237
 
  {
238
 
    array = json_array_new ();
239
 
 
240
 
    json_array_add_int_element (array, 116);
241
 
    json_array_add_int_element (array, 943);
242
 
    json_array_add_int_element (array, 234);
243
 
    json_array_add_int_element (array, 38793);
244
 
 
245
 
    json_object_set_array_member (object, "IDs", array);
246
 
  }
247
 
 
248
 
  nested = json_object_new ();
249
 
  json_object_set_object_member (nested, "Image", object);
250
 
 
251
 
  json_node_take_object (root, nested);
252
 
  json_generator_set_root (generator, root);
253
 
 
254
 
  g_object_set (generator, "pretty", FALSE, NULL);
255
 
  data = json_generator_to_data (generator, &len);
256
 
 
257
 
  if (g_test_verbose ())
258
 
    g_print ("checking nested object `%s' (expected: %s)\n",
259
 
             data,
260
 
             nested_object);
261
 
 
262
 
  g_assert_cmpint (len, ==, strlen (nested_object));
263
 
  g_assert_cmpstr (data, ==, nested_object);
264
 
 
265
 
  g_free (data);
266
 
  json_node_free (root);
267
 
  g_object_unref (generator);
268
 
}
269
 
 
270
 
static void
271
 
test_decimal_separator (void)
272
 
{
273
 
  JsonNode *node = json_node_new (JSON_NODE_VALUE);
274
 
  JsonGenerator *generator = json_generator_new ();
275
 
  gchar *old_locale;
276
 
  gint i;
277
 
 
278
 
  json_node_set_double (node, 3.14);
279
 
 
280
 
  json_generator_set_root (generator, node);
281
 
 
282
 
  old_locale = setlocale (LC_NUMERIC, NULL);
283
 
 
284
 
  for (i = 0; i < G_N_ELEMENTS (decimal_separator); i++)
285
 
    {
286
 
      gchar *str, *expected;
287
 
 
288
 
      setlocale (LC_NUMERIC, decimal_separator[i].lang);
289
 
 
290
 
      str = json_generator_to_data (generator, NULL);
291
 
 
292
 
      if (g_test_verbose ())
293
 
        g_print ("%s: value: %.2f - string: '%s'\n",
294
 
                 G_STRFUNC,
295
 
                 json_node_get_double (node),
296
 
                 str);
297
 
 
298
 
      g_assert (str != NULL);
299
 
      expected = strstr (str, decimal_separator[i].sep);
300
 
      if (decimal_separator[i].matches)
301
 
        g_assert (expected != NULL);
302
 
      else
303
 
        g_assert (expected == NULL);
304
 
 
305
 
      g_free (str);
306
 
   }
307
 
 
308
 
  setlocale (LC_NUMERIC, old_locale);
309
 
 
310
 
  g_object_unref (generator);
311
 
  json_node_free (node);
312
 
}
313
 
 
314
 
int
315
 
main (int   argc,
316
 
      char *argv[])
317
 
{
318
 
  g_type_init ();
319
 
  g_test_init (&argc, &argv, NULL);
320
 
 
321
 
  g_test_add_func ("/generator/empty-array", test_empty_array);
322
 
  g_test_add_func ("/generator/empty-object", test_empty_object);
323
 
  g_test_add_func ("/generator/simple-array", test_simple_array);
324
 
  g_test_add_func ("/generator/nested-array", test_nested_array);
325
 
  g_test_add_func ("/generator/simple-object", test_simple_object);
326
 
  g_test_add_func ("/generator/nested-object", test_nested_object);
327
 
  g_test_add_func ("/generator/decimal-separator", test_decimal_separator);
328
 
 
329
 
  return g_test_run ();
330
 
}