json-glib/tests/generator.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 }