json-glib/tests/invalid.c

   1 #include "config.h"
   2
   3 #include <stdlib.h>
   4 #include <stdio.h>
   5
   6 #include <glib.h>
   7
   8 #include <json-glib/json-glib.h>
   9
  10 static void
  11 test_invalid_bareword (gconstpointer user_data)
  12 {
  13   const char *json = user_data;
  14   GError *error = NULL;
  15   JsonParser *parser;
  16   gboolean res;
  17
  18   parser = json_parser_new ();
  19   g_assert (JSON_IS_PARSER (parser));
  20
  21   if (g_test_verbose ())
  22     g_print ("invalid data: '%s'...", json);
  23
  24   res = json_parser_load_from_data (parser, json, -1, &error);
  25
  26   g_assert (!res);
  27   g_assert_error (error, JSON_PARSER_ERROR, JSON_PARSER_ERROR_INVALID_BAREWORD);
  28
  29   if (g_test_verbose ())
  30     g_print ("expected error: %s\n", error->message);
  31
  32   g_clear_error (&error);
  33
  34   g_object_unref (parser);
  35 }
  36
  37 static void
  38 test_invalid_assignment (gconstpointer user_data)
  39 {
  40   const char *json = user_data;
  41   GError *error = NULL;
  42   JsonParser *parser;
  43   gboolean res;
  44
  45   parser = json_parser_new ();
  46   g_assert (JSON_IS_PARSER (parser));
  47
  48   if (g_test_verbose ())
  49     g_print ("invalid data: '%s'...", json);
  50
  51   res = json_parser_load_from_data (parser, json, -1, &error);
  52
  53   g_assert (!res);
  54   g_assert (error != NULL);
  55
  56   if (g_test_verbose ())
  57     g_print ("expected error: %s\n", error->message);
  58
  59   g_clear_error (&error);
  60
  61   g_object_unref (parser);
  62 }
  63
  64 static void
  65 test_invalid_value (gconstpointer user_data)
  66 {
  67   const char *json = user_data;
  68   GError *error = NULL;
  69   JsonParser *parser;
  70   gboolean res;
  71
  72   parser = json_parser_new ();
  73   g_assert (JSON_IS_PARSER (parser));
  74
  75   if (g_test_verbose ())
  76     g_print ("invalid data: '%s'...", json);
  77
  78   res = json_parser_load_from_data (parser, json, -1, &error);
  79
  80   g_assert (!res);
  81   g_assert (error != NULL);
  82
  83   if (g_test_verbose ())
  84     g_print ("expected error: %s\n", error->message);
  85
  86   g_clear_error (&error);
  87
  88   g_object_unref (parser);
  89 }
  90
  91 static void
  92 test_invalid_array (gconstpointer user_data)
  93 {
  94   const char *json = user_data;
  95   GError *error = NULL;
  96   JsonParser *parser;
  97   gboolean res;
  98
  99   parser = json_parser_new ();
 100   g_assert (JSON_IS_PARSER (parser));
 101
 102   if (g_test_verbose ())
 103     g_print ("invalid data: '%s'...", json);
 104
 105   res = json_parser_load_from_data (parser, json, -1, &error);
 106
 107   g_assert (!res);
 108   g_assert (error != NULL);
 109
 110   if (g_test_verbose ())
 111     g_print ("expected error: %s\n", error->message);
 112
 113   g_clear_error (&error);
 114
 115   g_object_unref (parser);
 116 }
 117
 118 static void
 119 test_invalid_object (gconstpointer user_data)
 120 {
 121   const char *json = user_data;
 122   GError *error = NULL;
 123   JsonParser *parser;
 124   gboolean res;
 125
 126   parser = json_parser_new ();
 127   g_assert (JSON_IS_PARSER (parser));
 128
 129   if (g_test_verbose ())
 130     g_print ("invalid data: '%s'...", json);
 131
 132   res = json_parser_load_from_data (parser, json, -1, &error);
 133
 134   g_assert (!res);
 135   g_assert (error != NULL);
 136
 137   if (g_test_verbose ())
 138     g_print ("expected error: %s\n", error->message);
 139
 140   g_clear_error (&error);
 141
 142   g_object_unref (parser);
 143 }
 144
 145 static void
 146 test_missing_comma (gconstpointer user_data)
 147 {
 148   const char *json = user_data;
 149   GError *error = NULL;
 150   JsonParser *parser;
 151   gboolean res;
 152
 153   parser = json_parser_new ();
 154   g_assert (JSON_IS_PARSER (parser));
 155
 156   if (g_test_verbose ())
 157     g_print ("invalid data: '%s'...", json);
 158
 159   res = json_parser_load_from_data (parser, json, -1, &error);
 160
 161   g_assert (!res);
 162   g_assert_error (error, JSON_PARSER_ERROR, JSON_PARSER_ERROR_MISSING_COMMA);
 163
 164   if (g_test_verbose ())
 165     g_print ("expected error: %s\n", error->message);
 166
 167   g_clear_error (&error);
 168
 169   g_object_unref (parser);
 170 }
 171
 172 static void
 173 test_trailing_comma (gconstpointer user_data)
 174 {
 175   const char *json = user_data;
 176   GError *error = NULL;
 177   JsonParser *parser;
 178   gboolean res;
 179
 180   parser = json_parser_new ();
 181   g_assert (JSON_IS_PARSER (parser));
 182
 183   if (g_test_verbose ())
 184     g_print ("invalid data: '%s'...", json);
 185
 186   res = json_parser_load_from_data (parser, json, -1, &error);
 187
 188   g_assert (!res);
 189   g_assert_error (error, JSON_PARSER_ERROR, JSON_PARSER_ERROR_TRAILING_COMMA);
 190
 191   if (g_test_verbose ())
 192     g_print ("expected error: %s\n", error->message);
 193
 194   g_clear_error (&error);
 195
 196   g_object_unref (parser);
 197 }
 198
 199 static const struct
 200 {
 201   const char *path;
 202   const char *json;
 203   gpointer func;
 204 } test_invalid[] = {
 205   /* bareword */
 206   { "bareword-1", "rainbows", test_invalid_bareword },
 207   { "bareword-2", "[ unicorns ]", test_invalid_bareword },
 208   { "bareword-3", "{ \"foo\" : ponies }", test_invalid_bareword },
 209   { "bareword-4", "[ 3, 2, 1, lift_off ]", test_invalid_bareword },
 210   { "bareword-5", "{ foo : 42 }", test_invalid_bareword },
 211
 212   /* values */
 213   { "values-1", "[ -false ]", test_invalid_value },
 214
 215   /* assignment */
 216   { "assignment-1", "var foo", test_invalid_assignment },
 217   { "assignment-2", "var foo = no", test_invalid_assignment },
 218   { "assignment-3", "var = true", test_invalid_assignment },
 219   { "assignment-4", "var blah = 42:", test_invalid_assignment },
 220   { "assignment-5", "let foo = true;", test_invalid_assignment },
 221
 222   /* arrays */
 223   { "array-1", "[ true, false", test_invalid_array },
 224   { "array-2", "[ true }", test_invalid_array },
 225   { "array-3", "[ \"foo\" : 42 ]", test_invalid_array },
 226
 227   /* objects */
 228   { "object-1", "{ foo : 42 }", test_invalid_object },
 229   { "object-2", "{ 42 : \"foo\" }", test_invalid_object },
 230   { "object-3", "{ \"foo\", 42 }", test_invalid_object },
 231   { "object-4", "{ \"foo\" : 42 ]", test_invalid_object },
 232   { "object-5", "{ \"blah\" }", test_invalid_object },
 233   { "object-6", "{ \"a\" : 0 \"b\" : 1 }", test_invalid_object },
 234   { "object-7", "{ null: false }", test_invalid_object },
 235
 236   /* missing commas */
 237   { "missing-comma-1", "[ true false ]", test_missing_comma },
 238   { "missing-comma-2", "{ \"foo\" : 42 \"bar\": null }", test_missing_comma },
 239
 240   /* trailing commas */
 241   { "trailing-comma-1", "[ true, ]", test_trailing_comma },
 242   { "trailing-comma-2", "{ \"foo\" : 42, }", test_trailing_comma },
 243 };
 244
 245 static guint n_test_invalid = G_N_ELEMENTS (test_invalid);
 246
 247 int
 248 main (int   argc,
 249       char *argv[])
 250 {
 251   int i;
 252
 253   g_test_init (&argc, &argv, NULL);
 254
 255   for (i = 0; i < n_test_invalid; i++)
 256     {
 257       char *test_path = g_strconcat ("/invalid/json/", test_invalid[i].path, NULL);
 258
 259       g_test_add_data_func_full (test_path,
 260                                  (gpointer) test_invalid[i].json,
 261                                  test_invalid[i].func,
 262                                  NULL);
 263
 264       g_free (test_path);
 265     }
 266
 267   return g_test_run ();
 268 }