tests/keyfile-test.c

   1 #include <glib.h>
   2 #include <string.h>
   3 #include <stdlib.h>
   4
   5 static GKeyFile *
   6 load_data (const gchar *data)
   7 {
   8   GKeyFile *keyfile;
   9   GError *error = NULL;
  10
  11   keyfile = g_key_file_new ();
  12   g_key_file_load_from_data (keyfile, data, -1, 0, &error);
  13   if (error)
  14     {
  15       g_print ("Could not load data: %s\n", error->message);
  16       exit (1);
  17     }
  18
  19   return keyfile;
  20 }
  21
  22 static void
  23 check_error (GError **error,
  24              GQuark   domain,
  25              gint     code)
  26 {
  27   if (*error == NULL)
  28     {
  29       g_print ("Missing an error\n");
  30       exit (1);
  31     }
  32
  33   if ((*error)->domain != domain)
  34     {
  35       g_print ("Wrong error domain: got %s, expected %s\n",
  36                g_quark_to_string ((*error)->domain),
  37                g_quark_to_string (domain));
  38       exit (1);
  39     }
  40
  41   if ((*error)->code != code)
  42     {
  43       g_print ("Wrong error code: got %d, expected %d\n",
  44                (*error)->code, code);
  45       exit (1);
  46     }
  47
  48   g_error_free (*error);
  49   *error = NULL;
  50 }
  51
  52 static void
  53 check_no_error (GError **error)
  54 {
  55   if (*error != NULL)
  56     {
  57       g_print ("Unexpected error: (%s, %d) %s\n",
  58                g_quark_to_string ((*error)->domain),
  59                (*error)->code, (*error)->message);
  60       exit (1);
  61     }
  62 }
  63
  64 static void
  65 check_string_value (GKeyFile    *keyfile,
  66                     const gchar *group,
  67                     const gchar *key,
  68                     const gchar *expected)
  69 {
  70   GError *error = NULL;
  71   gchar *value;
  72
  73   value = g_key_file_get_string (keyfile, group, key, &error);
  74   check_no_error (&error);
  75   g_assert (value != NULL);
  76
  77   if (strcmp (value, expected) != 0)
  78     {
  79       g_print ("Group %s key %s: "
  80                "expected string value '%s', actual value '%s'\n",
  81                group, key, expected, value);
  82       exit (1);
  83     }
  84
  85   g_free (value);
  86 }
  87
  88 static void
  89 check_boolean_value (GKeyFile    *keyfile,
  90                      const gchar *group,
  91                      const gchar *key,
  92                      gboolean     expected)
  93 {
  94   GError *error = NULL;
  95   gboolean value;
  96
  97   value = g_key_file_get_boolean (keyfile, group, key, &error);
  98   check_no_error (&error);
  99
 100   if (value != expected)
 101     {
 102       g_print ("Group %s key %s: "
 103                "expected boolean value '%s', actual value '%s'\n",
 104                group, key,
 105                expected ? "true" : "false",
 106                value ? "true" : "false");
 107       exit (1);
 108     }
 109 }
 110
 111 static void
 112 check_name (const gchar *what,
 113             const gchar *value,
 114             const gchar *expected,
 115             gint         position)
 116 {
 117   if (strcmp (expected, value) != 0)
 118     {
 119       g_print ("Wrong %s returned: got %s at %d, expected %s\n",
 120                what, value, position, expected);
 121       exit (1);
 122     }
 123 }
 124
 125 static void
 126 check_length (const gchar *what,
 127               gint         n_items,
 128               gint         length,
 129               gint         expected)
 130 {
 131   if (n_items != length || length != expected)
 132     {
 133       g_print ("Wrong number of %s returned: got %d items, length %d, expected %d\n",
 134                what, n_items, length, expected);
 135       exit (1);
 136     }
 137 }
 138
 139
 140 /* check that both \n and \r\n are accepted as line ends,
 141  * and that stray \r are passed through
 142  */
 143 static void
 144 test_line_ends (void)
 145 {
 146   GKeyFile *keyfile;
 147
 148   const gchar *data =
 149     "[group1]\n"
 150     "key1=value1\n"
 151     "key2=value2\r\n"
 152     "[group2]\r\n"
 153     "key3=value3\r\r\n"
 154     "key4=value4\n";
 155
 156   keyfile = load_data (data);
 157
 158   check_string_value (keyfile, "group1", "key1", "value1");
 159   check_string_value (keyfile, "group1", "key2", "value2");
 160   check_string_value (keyfile, "group2", "key3", "value3\r");
 161   check_string_value (keyfile, "group2", "key4", "value4");
 162
 163   g_key_file_free (keyfile);
 164 }
 165
 166 /* check handling of whitespace
 167  */
 168 static void
 169 test_whitespace (void)
 170 {
 171   GKeyFile *keyfile;
 172
 173   const gchar *data =
 174     "[group1]\n"
 175     "key1 = value1\n"
 176     "key2\t=\tvalue2\n"
 177     " [ group2 ] \n"
 178     "key3  =  value3  \n"
 179     "key4  =  value \t4\n"
 180     "  key5  =  value5\n";
 181
 182   keyfile = load_data (data);
 183
 184   check_string_value (keyfile, "group1", "key1", "value1");
 185   check_string_value (keyfile, "group1", "key2", "value2");
 186   check_string_value (keyfile, " group2 ", "key3", "value3  ");
 187   check_string_value (keyfile, " group2 ", "key4", "value \t4");
 188   check_string_value (keyfile, " group2 ", "key5", "value5");
 189
 190   g_key_file_free (keyfile);
 191 }
 192
 193 /* check key and group listing */
 194 static void
 195 test_listing (void)
 196 {
 197   GKeyFile *keyfile;
 198   gchar **names;
 199   gsize len;
 200   gchar *start;
 201   GError *error = NULL;
 202
 203   const gchar *data =
 204     "[group1]\n"
 205     "key1=value1\n"
 206     "key2=value2\n"
 207     "[group2]\n"
 208     "key3=value3\n"
 209     "key4=value4\n";
 210
 211   keyfile = load_data (data);
 212
 213   names = g_key_file_get_groups (keyfile, &len);
 214   if (names == NULL)
 215     {
 216       g_print ("Error listing groups\n");
 217       exit (1);
 218     }
 219
 220   check_length ("groups", g_strv_length (names), len, 2);
 221   check_name ("group name", names[0], "group1", 0);
 222   check_name ("group name", names[1], "group2", 1);
 223
 224   g_strfreev (names);
 225
 226   names = g_key_file_get_keys (keyfile, "group1", &len, &error);
 227   check_no_error (&error);
 228
 229   check_length ("keys", g_strv_length (names), len, 2);
 230   check_name ("key", names[0], "key1", 0);
 231   check_name ("key", names[1], "key2", 1);
 232
 233   g_strfreev (names);
 234
 235   names = g_key_file_get_keys (keyfile, "no-such-group", &len, &error);
 236   check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_GROUP_NOT_FOUND);
 237
 238   g_strfreev (names);
 239
 240   if (!g_key_file_has_group (keyfile, "group1") ||
 241       !g_key_file_has_group (keyfile, "group2") ||
 242       g_key_file_has_group (keyfile, "group10") ||
 243       g_key_file_has_group (keyfile, "group2 "))
 244     {
 245       g_print ("Group finding trouble\n");
 246       exit (1);
 247     }
 248
 249   start = g_key_file_get_start_group (keyfile);
 250   if (!start || strcmp (start, "group1") != 0)
 251     {
 252       g_print ("Start group finding trouble\n");
 253       exit (1);
 254     }
 255   g_free (start);
 256
 257   if (!g_key_file_has_key (keyfile, "group1", "key1", &error) ||
 258       !g_key_file_has_key (keyfile, "group2", "key3", &error) ||
 259       g_key_file_has_key (keyfile, "group2", "no-such-key", &error))
 260     {
 261       g_print ("Key finding trouble\n");
 262       exit (1);
 263     }
 264   check_no_error (&error);
 265
 266   g_key_file_has_key (keyfile, "no-such-group", "key", &error);
 267   check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_GROUP_NOT_FOUND);
 268
 269   g_key_file_free (keyfile);
 270 }
 271
 272 /* check parsing of string values */
 273 static void
 274 test_string (void)
 275 {
 276   GKeyFile *keyfile;
 277   GError *error = NULL;
 278   gchar *value;
 279
 280   const gchar *data =
 281     "[valid]\n"
 282     "key1=\\s\\n\\t\\r\\\\\n"
 283     "key2=\"quoted\"\n"
 284     "key3='quoted'\n"
 285     "key4=\xe2\x89\xa0\xe2\x89\xa0\n"
 286     "[invalid]\n"
 287     "key1=\\a\\b\\0800xff\n"
 288     "key2=blabla\\\n";
 289
 290   keyfile = load_data (data);
 291
 292   check_string_value (keyfile, "valid", "key1", " \n\t\r\\");
 293   check_string_value (keyfile, "valid", "key2", "\"quoted\"");
 294   check_string_value (keyfile, "valid", "key3", "'quoted'");
 295   check_string_value (keyfile, "valid", "key4", "\xe2\x89\xa0\xe2\x89\xa0");
 296
 297   value = g_key_file_get_string (keyfile, "invalid", "key1", &error);
 298   check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_INVALID_VALUE);
 299   g_free (value);
 300
 301   value = g_key_file_get_string (keyfile, "invalid", "key2", &error);
 302   check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_INVALID_VALUE);
 303   g_free (value);
 304
 305   g_key_file_free (keyfile);
 306 }
 307
 308 /* check parsing of boolean values */
 309 static void
 310 test_boolean (void)
 311 {
 312   GKeyFile *keyfile;
 313   GError *error = NULL;
 314
 315   const gchar *data =
 316     "[valid]\n"
 317     "key1=true\n"
 318     "key2=false\n"
 319     "key3=1\n"
 320     "key4=0\n"
 321     "[invalid]\n"
 322     "key1=t\n"
 323     "key2=f\n"
 324     "key3=yes\n"
 325     "key4=no\n";
 326
 327   keyfile = load_data (data);
 328   check_boolean_value (keyfile, "valid", "key1", TRUE);
 329   check_boolean_value (keyfile, "valid", "key2", FALSE);
 330   check_boolean_value (keyfile, "valid", "key3", TRUE);
 331   check_boolean_value (keyfile, "valid", "key4", FALSE);
 332
 333   g_key_file_get_boolean (keyfile, "invalid", "key1", &error);
 334   check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_INVALID_VALUE);
 335
 336   g_key_file_get_boolean (keyfile, "invalid", "key2", &error);
 337   check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_INVALID_VALUE);
 338
 339   g_key_file_get_boolean (keyfile, "invalid", "key3", &error);
 340   check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_INVALID_VALUE);
 341
 342   g_key_file_get_boolean (keyfile, "invalid", "key4", &error);
 343   check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_INVALID_VALUE);
 344 }
 345
 346 int
 347 main (int argc, char *argv[])
 348 {
 349   test_line_ends ();
 350   test_whitespace ();
 351   test_listing ();
 352   test_string ();
 353   test_boolean ();
 354
 355   return 0;
 356 }