glib/tests/keyfile.c

   1
   2 #include <glib.h>
   3 #include <locale.h>
   4 #include <string.h>
   5 #include <stdlib.h>
   6 #include <unistd.h>
   7
   8 static GKeyFile *
   9 load_data (const gchar   *data,
  10            GKeyFileFlags  flags)
  11 {
  12   GKeyFile *keyfile;
  13   GError *error = NULL;
  14
  15   keyfile = g_key_file_new ();
  16   g_key_file_load_from_data (keyfile, data, -1, flags, &error);
  17   g_assert_no_error (error);
  18   return keyfile;
  19 }
  20
  21 static void
  22 check_error (GError **error,
  23              GQuark   domain,
  24              gint     code)
  25 {
  26   g_assert_error (*error, domain, code);
  27   g_error_free (*error);
  28   *error = NULL;
  29 }
  30
  31 static void
  32 check_no_error (GError **error)
  33 {
  34   g_assert_no_error (*error);
  35 }
  36
  37 static void
  38 check_string_value (GKeyFile    *keyfile,
  39                     const gchar *group,
  40                     const gchar *key,
  41                     const gchar *expected)
  42 {
  43   GError *error = NULL;
  44   gchar *value;
  45
  46   value = g_key_file_get_string (keyfile, group, key, &error);
  47   check_no_error (&error);
  48   g_assert (value != NULL);
  49   g_assert_cmpstr (value, ==, expected);
  50   g_free (value);
  51 }
  52
  53 static void
  54 check_locale_string_value (GKeyFile    *keyfile,
  55                            const gchar *group,
  56                            const gchar *key,
  57                            const gchar *locale,
  58                            const gchar *expected)
  59 {
  60   GError *error = NULL;
  61   gchar *value;
  62
  63   value = g_key_file_get_locale_string (keyfile, group, key, locale, &error);
  64   check_no_error (&error);
  65   g_assert (value != NULL);
  66   g_assert_cmpstr (value, ==, expected);
  67   g_free (value);
  68 }
  69
  70 static void
  71 check_string_list_value (GKeyFile    *keyfile,
  72                          const gchar *group,
  73                          const gchar *key,
  74                          ...)
  75 {
  76   gint i;
  77   gchar *v, **value;
  78   va_list args;
  79   gsize len;
  80   GError *error = NULL;
  81
  82   value = g_key_file_get_string_list (keyfile, group, key, &len, &error);
  83   check_no_error (&error);
  84   g_assert (value != NULL);
  85
  86   va_start (args, key);
  87   i = 0;
  88   v = va_arg (args, gchar*);
  89   while (v)
  90     {
  91       g_assert (value[i] != NULL);
  92       g_assert_cmpstr (v, ==, value[i]);
  93       i++;
  94       v = va_arg (args, gchar*);
  95     }
  96
  97   va_end (args);
  98
  99   g_strfreev (value);
 100 }
 101
 102 static void
 103 check_locale_string_list_value (GKeyFile    *keyfile,
 104                                 const gchar *group,
 105                                 const gchar *key,
 106                                 const gchar *locale,
 107                                 ...)
 108 {
 109   gint i;
 110   gchar *v, **value;
 111   va_list args;
 112   gsize len;
 113   GError *error = NULL;
 114
 115   value = g_key_file_get_locale_string_list (keyfile, group, key, locale, &len, &error);
 116   check_no_error (&error);
 117   g_assert (value != NULL);
 118
 119   va_start (args, locale);
 120   i = 0;
 121   v = va_arg (args, gchar*);
 122   while (v)
 123     {
 124       g_assert (value[i] != NULL);
 125       g_assert_cmpstr (v, ==, value[i]);
 126       i++;
 127       v = va_arg (args, gchar*);
 128     }
 129
 130   va_end (args);
 131
 132   g_strfreev (value);
 133 }
 134
 135 static void
 136 check_integer_list_value (GKeyFile    *keyfile,
 137                           const gchar *group,
 138                           const gchar *key,
 139                           ...)
 140 {
 141   gint i;
 142   gint v, *value;
 143   va_list args;
 144   gsize len;
 145   GError *error = NULL;
 146
 147   value = g_key_file_get_integer_list (keyfile, group, key, &len, &error);
 148   check_no_error (&error);
 149   g_assert (value != NULL);
 150
 151   va_start (args, key);
 152   i = 0;
 153   v = va_arg (args, gint);
 154   while (v != -100)
 155     {
 156       g_assert_cmpint (i, <, len);
 157       g_assert_cmpint (value[i], ==, v);
 158       i++;
 159       v = va_arg (args, gint);
 160     }
 161
 162   va_end (args);
 163
 164   g_free (value);
 165 }
 166
 167 static void
 168 check_double_list_value (GKeyFile    *keyfile,
 169                           const gchar *group,
 170                           const gchar *key,
 171                           ...)
 172 {
 173   gint i;
 174   gdouble v, *value;
 175   va_list args;
 176   gsize len;
 177   GError *error = NULL;
 178
 179   value = g_key_file_get_double_list (keyfile, group, key, &len, &error);
 180   check_no_error (&error);
 181   g_assert (value != NULL);
 182
 183   va_start (args, key);
 184   i = 0;
 185   v = va_arg (args, gdouble);
 186   while (v != -100)
 187     {
 188       g_assert_cmpint (i, <, len);
 189       g_assert_cmpfloat (value[i], ==, v);
 190       i++;
 191       v = va_arg (args, gdouble);
 192     }
 193
 194   va_end (args);
 195
 196   g_free (value);
 197 }
 198
 199 static void
 200 check_boolean_list_value (GKeyFile    *keyfile,
 201                           const gchar *group,
 202                           const gchar *key,
 203                           ...)
 204 {
 205   gint i;
 206   gboolean v, *value;
 207   va_list args;
 208   gsize len;
 209   GError *error = NULL;
 210
 211   value = g_key_file_get_boolean_list (keyfile, group, key, &len, &error);
 212   check_no_error (&error);
 213   g_assert (value != NULL);
 214
 215   va_start (args, key);
 216   i = 0;
 217   v = va_arg (args, gboolean);
 218   while (v != -100)
 219     {
 220       g_assert_cmpint (i, <, len);
 221       g_assert_cmpint (value[i], ==, v);
 222       i++;
 223       v = va_arg (args, gboolean);
 224     }
 225
 226   va_end (args);
 227
 228   g_free (value);
 229 }
 230
 231 static void
 232 check_boolean_value (GKeyFile    *keyfile,
 233                      const gchar *group,
 234                      const gchar *key,
 235                      gboolean     expected)
 236 {
 237   GError *error = NULL;
 238   gboolean value;
 239
 240   value = g_key_file_get_boolean (keyfile, group, key, &error);
 241   check_no_error (&error);
 242   g_assert_cmpint (value, ==, expected);
 243 }
 244
 245 static void
 246 check_integer_value (GKeyFile    *keyfile,
 247                      const gchar *group,
 248                      const gchar *key,
 249                      gint         expected)
 250 {
 251   GError *error = NULL;
 252   gint value;
 253
 254   value = g_key_file_get_integer (keyfile, group, key, &error);
 255   check_no_error (&error);
 256   g_assert_cmpint (value, ==, expected);
 257 }
 258
 259 static void
 260 check_double_value (GKeyFile    *keyfile,
 261                      const gchar *group,
 262                      const gchar *key,
 263                      gdouble      expected)
 264 {
 265   GError *error = NULL;
 266   gdouble value;
 267
 268   value = g_key_file_get_double (keyfile, group, key, &error);
 269   check_no_error (&error);
 270   g_assert_cmpfloat (value, ==, expected);
 271 }
 272
 273 static void
 274 check_name (const gchar *what,
 275             const gchar *value,
 276             const gchar *expected,
 277             gint         position)
 278 {
 279   g_assert_cmpstr (value, ==, expected);
 280 }
 281
 282 static void
 283 check_length (const gchar *what,
 284               gint         n_items,
 285               gint         length,
 286               gint         expected)
 287 {
 288   g_assert_cmpint (n_items, ==, length);
 289   g_assert_cmpint (n_items, ==, expected);
 290 }
 291
 292
 293 /* check that both \n and \r\n are accepted as line ends,
 294  * and that stray \r are passed through
 295  */
 296 static void
 297 test_line_ends (void)
 298 {
 299   GKeyFile *keyfile;
 300
 301   const gchar *data =
 302     "[group1]\n"
 303     "key1=value1\n"
 304     "key2=value2\r\n"
 305     "[group2]\r\n"
 306     "key3=value3\r\r\n"
 307     "key4=value4\n";
 308
 309   keyfile = load_data (data, 0);
 310
 311   check_string_value (keyfile, "group1", "key1", "value1");
 312   check_string_value (keyfile, "group1", "key2", "value2");
 313   check_string_value (keyfile, "group2", "key3", "value3\r");
 314   check_string_value (keyfile, "group2", "key4", "value4");
 315
 316   g_key_file_free (keyfile);
 317 }
 318
 319 /* check handling of whitespace
 320  */
 321 static void
 322 test_whitespace (void)
 323 {
 324   GKeyFile *keyfile;
 325
 326   const gchar *data =
 327     "[group1]\n"
 328     "key1 = value1\n"
 329     "key2\t=\tvalue2\n"
 330     " [ group2 ] \n"
 331     "key3  =  value3  \n"
 332     "key4  =  value \t4\n"
 333     "  key5  =  value5\n";
 334
 335   keyfile = load_data (data, 0);
 336
 337   check_string_value (keyfile, "group1", "key1", "value1");
 338   check_string_value (keyfile, "group1", "key2", "value2");
 339   check_string_value (keyfile, " group2 ", "key3", "value3  ");
 340   check_string_value (keyfile, " group2 ", "key4", "value \t4");
 341   check_string_value (keyfile, " group2 ", "key5", "value5");
 342
 343   g_key_file_free (keyfile);
 344 }
 345
 346 /* check handling of comments
 347  */
 348 static void
 349 test_comments (void)
 350 {
 351   GKeyFile *keyfile;
 352   gchar **names;
 353   gsize len;
 354   GError *error = NULL;
 355   gchar *comment;
 356
 357   const gchar *data =
 358     "# top comment\n"
 359     "# top comment, continued\n"
 360     "[group1]\n"
 361     "key1 = value1\n"
 362     "# key comment\n"
 363     "# key comment, continued\n"
 364     "key2 = value2\n"
 365     "# line end check\r\n"
 366     "key3 = value3\n"
 367     "key4 = value4\n"
 368     "# group comment\n"
 369     "# group comment, continued\n"
 370     "[group2]\n";
 371
 372   const gchar *top_comment= " top comment\n top comment, continued\n";
 373   const gchar *group_comment= " group comment\n group comment, continued\n";
 374   const gchar *key_comment= " key comment\n key comment, continued\n";
 375
 376   keyfile = load_data (data, 0);
 377
 378   check_string_value (keyfile, "group1", "key1", "value1");
 379   check_string_value (keyfile, "group1", "key2", "value2");
 380   check_string_value (keyfile, "group1", "key3", "value3");
 381   check_string_value (keyfile, "group1", "key4", "value4");
 382
 383   names = g_key_file_get_keys (keyfile, "group1", &len, &error);
 384   check_no_error (&error);
 385
 386   check_length ("keys", g_strv_length (names), len, 4);
 387   check_name ("key", names[0], "key1", 0);
 388   check_name ("key", names[1], "key2", 1);
 389   check_name ("key", names[2], "key3", 2);
 390   check_name ("key", names[3], "key4", 3);
 391
 392   g_strfreev (names);
 393
 394   g_key_file_free (keyfile);
 395
 396   keyfile = load_data (data, G_KEY_FILE_KEEP_COMMENTS);
 397
 398   names = g_key_file_get_keys (keyfile, "group1", &len, &error);
 399   check_no_error (&error);
 400
 401   check_length ("keys", g_strv_length (names), len, 4);
 402   check_name ("key", names[0], "key1", 0);
 403   check_name ("key", names[1], "key2", 1);
 404   check_name ("key", names[2], "key3", 2);
 405   check_name ("key", names[3], "key4", 3);
 406
 407   g_strfreev (names);
 408
 409   comment = g_key_file_get_comment (keyfile, NULL, NULL, &error);
 410   check_no_error (&error);
 411   check_name ("top comment", comment, top_comment, 0);
 412   g_free (comment);
 413
 414   comment = g_key_file_get_comment (keyfile, "group1", "key2", &error);
 415   check_no_error (&error);
 416   check_name ("key comment", comment, key_comment, 0);
 417   g_free (comment);
 418
 419   g_key_file_remove_comment (keyfile, "group1", "key2", &error);
 420   check_no_error (&error);
 421   comment = g_key_file_get_comment (keyfile, "group1", "key2", &error);
 422   check_no_error (&error);
 423   g_assert (comment == NULL);
 424
 425   comment = g_key_file_get_comment (keyfile, "group2", NULL, &error);
 426   check_no_error (&error);
 427   check_name ("group comment", comment, group_comment, 0);
 428   g_free (comment);
 429
 430   comment = g_key_file_get_comment (keyfile, "group3", NULL, &error);
 431   check_error (&error,
 432                G_KEY_FILE_ERROR,
 433                G_KEY_FILE_ERROR_GROUP_NOT_FOUND);
 434   g_assert (comment == NULL);
 435
 436   g_key_file_free (keyfile);
 437 }
 438
 439
 440 /* check key and group listing */
 441 static void
 442 test_listing (void)
 443 {
 444   GKeyFile *keyfile;
 445   gchar **names;
 446   gsize len;
 447   gchar *start;
 448   GError *error = NULL;
 449
 450   const gchar *data =
 451     "[group1]\n"
 452     "key1=value1\n"
 453     "key2=value2\n"
 454     "[group2]\n"
 455     "key3=value3\n"
 456     "key4=value4\n";
 457
 458   keyfile = load_data (data, 0);
 459
 460   names = g_key_file_get_groups (keyfile, &len);
 461   g_assert (names != NULL);
 462
 463   check_length ("groups", g_strv_length (names), len, 2);
 464   check_name ("group name", names[0], "group1", 0);
 465   check_name ("group name", names[1], "group2", 1);
 466
 467   g_strfreev (names);
 468
 469   names = g_key_file_get_keys (keyfile, "group1", &len, &error);
 470   check_no_error (&error);
 471
 472   check_length ("keys", g_strv_length (names), len, 2);
 473   check_name ("key", names[0], "key1", 0);
 474   check_name ("key", names[1], "key2", 1);
 475
 476   g_strfreev (names);
 477
 478   names = g_key_file_get_keys (keyfile, "no-such-group", &len, &error);
 479   check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_GROUP_NOT_FOUND);
 480
 481   g_strfreev (names);
 482
 483   g_assert (g_key_file_has_group (keyfile, "group1"));
 484   g_assert (g_key_file_has_group (keyfile, "group2"));
 485   g_assert (!g_key_file_has_group (keyfile, "group10"));
 486   g_assert (!g_key_file_has_group (keyfile, "group20"));
 487
 488   start = g_key_file_get_start_group (keyfile);
 489   g_assert_cmpstr (start, ==, "group1");
 490   g_free (start);
 491
 492   g_assert (g_key_file_has_key (keyfile, "group1", "key1", &error));
 493   check_no_error (&error);
 494   g_assert (g_key_file_has_key (keyfile, "group2", "key3", &error));
 495   check_no_error (&error);
 496   g_assert (!g_key_file_has_key (keyfile, "group2", "no-such-key", NULL));
 497
 498   g_key_file_has_key (keyfile, "no-such-group", "key", &error);
 499   check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_GROUP_NOT_FOUND);
 500
 501   g_key_file_free (keyfile);
 502 }
 503
 504 /* check parsing of string values */
 505 static void
 506 test_string (void)
 507 {
 508   GKeyFile *keyfile;
 509   GError *error = NULL;
 510   gchar *value;
 511   const gchar const *list[3];
 512   const gchar *data =
 513     "[valid]\n"
 514     "key1=\\s\\n\\t\\r\\\\\n"
 515     "key2=\"quoted\"\n"
 516     "key3='quoted'\n"
 517     "key4=\xe2\x89\xa0\xe2\x89\xa0\n"
 518     "key5=  leading space\n"
 519     "key6=trailing space  \n"
 520     "[invalid]\n"
 521     "key1=\\a\\b\\0800xff\n"
 522     "key2=blabla\\\n";
 523
 524   keyfile = load_data (data, 0);
 525
 526   check_string_value (keyfile, "valid", "key1", " \n\t\r\\");
 527   check_string_value (keyfile, "valid", "key2", "\"quoted\"");
 528   check_string_value (keyfile, "valid", "key3", "'quoted'");
 529   check_string_value (keyfile, "valid", "key4", "\xe2\x89\xa0\xe2\x89\xa0");
 530   check_string_value (keyfile, "valid", "key5", "leading space");
 531   check_string_value (keyfile, "valid", "key6", "trailing space  ");
 532
 533   value = g_key_file_get_string (keyfile, "invalid", "key1", &error);
 534   check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_INVALID_VALUE);
 535   g_free (value);
 536
 537   value = g_key_file_get_string (keyfile, "invalid", "key2", &error);
 538   check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_INVALID_VALUE);
 539   g_free (value);
 540
 541   g_key_file_set_string (keyfile, "inserted", "key1", "simple");
 542   g_key_file_set_string (keyfile, "inserted", "key2", " leading space");
 543   g_key_file_set_string (keyfile, "inserted", "key3", "\tleading tab");
 544   g_key_file_set_string (keyfile, "inserted", "key4", "new\nline");
 545   g_key_file_set_string (keyfile, "inserted", "key5", "carriage\rreturn");
 546   g_key_file_set_string (keyfile, "inserted", "key6", "slash\\yay!");
 547   list[0] = "one";
 548   list[1] = "two;andahalf";
 549   list[2] = "3";
 550   g_key_file_set_string_list (keyfile, "inserted", "key7", list, 3);
 551
 552   check_string_value (keyfile, "inserted", "key1", "simple");
 553   check_string_value (keyfile, "inserted", "key2", " leading space");
 554   check_string_value (keyfile, "inserted", "key3", "\tleading tab");
 555   check_string_value (keyfile, "inserted", "key4", "new\nline");
 556   check_string_value (keyfile, "inserted", "key5", "carriage\rreturn");
 557   check_string_value (keyfile, "inserted", "key6", "slash\\yay!");
 558   check_string_list_value (keyfile, "inserted", "key7", "one", "two;andahalf", "3", NULL);
 559
 560   g_key_file_free (keyfile);
 561 }
 562
 563 /* check parsing of boolean values */
 564 static void
 565 test_boolean (void)
 566 {
 567   GKeyFile *keyfile;
 568   GError *error = NULL;
 569
 570   const gchar *data =
 571     "[valid]\n"
 572     "key1=true\n"
 573     "key2=false\n"
 574     "key3=1\n"
 575     "key4=0\n"
 576     "[invalid]\n"
 577     "key1=t\n"
 578     "key2=f\n"
 579     "key3=yes\n"
 580     "key4=no\n";
 581
 582   keyfile = load_data (data, 0);
 583
 584   check_boolean_value (keyfile, "valid", "key1", TRUE);
 585   check_boolean_value (keyfile, "valid", "key2", FALSE);
 586   check_boolean_value (keyfile, "valid", "key3", TRUE);
 587   check_boolean_value (keyfile, "valid", "key4", FALSE);
 588
 589   g_key_file_get_boolean (keyfile, "invalid", "key1", &error);
 590   check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_INVALID_VALUE);
 591
 592   g_key_file_get_boolean (keyfile, "invalid", "key2", &error);
 593   check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_INVALID_VALUE);
 594
 595   g_key_file_get_boolean (keyfile, "invalid", "key3", &error);
 596   check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_INVALID_VALUE);
 597
 598   g_key_file_get_boolean (keyfile, "invalid", "key4", &error);
 599   check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_INVALID_VALUE);
 600
 601   g_key_file_set_boolean (keyfile, "valid", "key1", FALSE);
 602   check_boolean_value (keyfile, "valid", "key1", FALSE);
 603
 604   g_key_file_free (keyfile);
 605 }
 606
 607 /* check parsing of integer and double values */
 608 static void
 609 test_number (void)
 610 {
 611   GKeyFile *keyfile;
 612   GError *error = NULL;
 613
 614   const gchar *data =
 615     "[valid]\n"
 616     "key1=0\n"
 617     "key2=1\n"
 618     "key3=-1\n"
 619     "key4=2324431\n"
 620     "key5=-2324431\n"
 621     "key6=000111\n"
 622     "dkey1=000111\n"
 623     "dkey2=145.45\n"
 624     "dkey3=-3453.7\n"
 625     "[invalid]\n"
 626     "key1=0xffff\n"
 627     "key2=0.5\n"
 628     "key3=1e37\n"
 629     "key4=ten\n"
 630     "key5=\n"
 631     "key6=1.0.0\n"
 632     "key7=2x2\n"
 633     "key8=abc\n";
 634
 635   keyfile = load_data (data, 0);
 636
 637   check_integer_value (keyfile, "valid", "key1", 0);
 638   check_integer_value (keyfile, "valid", "key2", 1);
 639   check_integer_value (keyfile, "valid", "key3", -1);
 640   check_integer_value (keyfile, "valid", "key4", 2324431);
 641   check_integer_value (keyfile, "valid", "key5", -2324431);
 642   check_integer_value (keyfile, "valid", "key6", 111);
 643   check_double_value (keyfile, "valid", "dkey1", 111.0);
 644   check_double_value (keyfile, "valid", "dkey2", 145.45);
 645   check_double_value (keyfile, "valid", "dkey3", -3453.7);
 646
 647   g_key_file_get_integer (keyfile, "invalid", "key1", &error);
 648   check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_INVALID_VALUE);
 649
 650   g_key_file_get_integer (keyfile, "invalid", "key2", &error);
 651   check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_INVALID_VALUE);
 652
 653   g_key_file_get_integer (keyfile, "invalid", "key3", &error);
 654   check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_INVALID_VALUE);
 655
 656   g_key_file_get_integer (keyfile, "invalid", "key4", &error);
 657   check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_INVALID_VALUE);
 658
 659   g_key_file_get_double (keyfile, "invalid", "key5", &error);
 660   check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_INVALID_VALUE);
 661
 662   g_key_file_get_double (keyfile, "invalid", "key6", &error);
 663   check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_INVALID_VALUE);
 664
 665   g_key_file_get_double (keyfile, "invalid", "key7", &error);
 666   check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_INVALID_VALUE);
 667
 668   g_key_file_get_double (keyfile, "invalid", "key8", &error);
 669   check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_INVALID_VALUE);
 670
 671   g_key_file_free (keyfile);
 672 }
 673
 674 /* check handling of translated strings */
 675 static void
 676 test_locale_string (void)
 677 {
 678   GKeyFile *keyfile;
 679   gchar *old_locale;
 680
 681   const gchar *data =
 682     "[valid]\n"
 683     "key1=v1\n"
 684     "key1[de]=v1-de\n"
 685     "key1[de_DE]=v1-de_DE\n"
 686     "key1[de_DE.UTF8]=v1-de_DE.UTF8\n"
 687     "key1[fr]=v1-fr\n"
 688     "key1[en] =v1-en\n"
 689     "key1[sr@Latn]=v1-sr\n";
 690
 691   keyfile = load_data (data, G_KEY_FILE_KEEP_TRANSLATIONS);
 692
 693   check_locale_string_value (keyfile, "valid", "key1", "it", "v1");
 694   check_locale_string_value (keyfile, "valid", "key1", "de", "v1-de");
 695   check_locale_string_value (keyfile, "valid", "key1", "de_DE", "v1-de_DE");
 696   check_locale_string_value (keyfile, "valid", "key1", "de_DE.UTF8", "v1-de_DE.UTF8");
 697   check_locale_string_value (keyfile, "valid", "key1", "fr", "v1-fr");
 698   check_locale_string_value (keyfile, "valid", "key1", "fr_FR", "v1-fr");
 699   check_locale_string_value (keyfile, "valid", "key1", "en", "v1-en");
 700   check_locale_string_value (keyfile, "valid", "key1", "sr@Latn", "v1-sr");
 701
 702   g_key_file_free (keyfile);
 703
 704   /* now test that translations are thrown away */
 705
 706   old_locale = g_strdup (setlocale (LC_ALL, NULL));
 707   g_setenv ("LANGUAGE", "de", TRUE);
 708   setlocale (LC_ALL, "");
 709
 710   keyfile = load_data (data, 0);
 711
 712   check_locale_string_value (keyfile, "valid", "key1", "it", "v1");
 713   check_locale_string_value (keyfile, "valid", "key1", "de", "v1-de");
 714   check_locale_string_value (keyfile, "valid", "key1", "de_DE", "v1-de");
 715   check_locale_string_value (keyfile, "valid", "key1", "de_DE.UTF8", "v1-de");
 716   check_locale_string_value (keyfile, "valid", "key1", "fr", "v1");
 717   check_locale_string_value (keyfile, "valid", "key1", "fr_FR", "v1");
 718   check_locale_string_value (keyfile, "valid", "key1", "en", "v1");
 719
 720   g_key_file_free (keyfile);
 721
 722   setlocale (LC_ALL, old_locale);
 723   g_free (old_locale);
 724 }
 725
 726 static void
 727 test_lists (void)
 728 {
 729   GKeyFile *keyfile;
 730
 731   const gchar *data =
 732     "[valid]\n"
 733     "key1=v1;v2\n"
 734     "key2=v1;v2;\n"
 735     "key3=v1,v2\n"
 736     "key4=v1\\;v2\n"
 737     "key5=true;false\n"
 738     "key6=1;0;-1\n"
 739     "key7= 1 ; 0 ; -1 \n"
 740     "key8=v1\\,v2\n"
 741     "key9=0;1.3456;-76532.456\n";
 742
 743   keyfile = load_data (data, 0);
 744
 745   check_string_list_value (keyfile, "valid", "key1", "v1", "v2", NULL);
 746   check_string_list_value (keyfile, "valid", "key2", "v1", "v2", NULL);
 747   check_string_list_value (keyfile, "valid", "key3", "v1,v2", NULL);
 748   check_string_list_value (keyfile, "valid", "key4", "v1;v2", NULL);
 749   check_boolean_list_value (keyfile, "valid", "key5", TRUE, FALSE, -100);
 750   check_integer_list_value (keyfile, "valid", "key6", 1, 0, -1, -100);
 751   check_double_list_value (keyfile, "valid", "key9", 0.0, 1.3456, -76532.456, -100.0);
 752   /* maybe these should be valid */
 753   /* check_integer_list_value (keyfile, "valid", "key7", 1, 0, -1, -100);*/
 754   /* check_string_list_value (keyfile, "valid", "key8", "v1\\,v2", NULL);*/
 755
 756   g_key_file_free (keyfile);
 757
 758   /* Now check an alternate separator */
 759
 760   keyfile = load_data (data, 0);
 761   g_key_file_set_list_separator (keyfile, ',');
 762
 763   check_string_list_value (keyfile, "valid", "key1", "v1;v2", NULL);
 764   check_string_list_value (keyfile, "valid", "key2", "v1;v2;", NULL);
 765   check_string_list_value (keyfile, "valid", "key3", "v1", "v2", NULL);
 766
 767   g_key_file_free (keyfile);
 768 }
 769
 770 static void
 771 test_lists_set_get (void)
 772 {
 773   GKeyFile *keyfile;
 774   static const char * const strings[] = { "v1", "v2" };
 775   static const char * const locale_strings[] = { "v1-l", "v2-l" };
 776   static int integers[] = { 1, -1, 2 };
 777   static gdouble doubles[] = { 3.14, 2.71 };
 778
 779   keyfile = g_key_file_new ();
 780   g_key_file_set_string_list (keyfile, "group0", "key1", strings, G_N_ELEMENTS (strings));
 781   g_key_file_set_locale_string_list (keyfile, "group0", "key1", "de", locale_strings, G_N_ELEMENTS (locale_strings));
 782   g_key_file_set_integer_list (keyfile, "group0", "key2", integers, G_N_ELEMENTS (integers));
 783   g_key_file_set_double_list (keyfile, "group0", "key3", doubles, G_N_ELEMENTS (doubles));
 784
 785   check_string_list_value (keyfile, "group0", "key1", strings[0], strings[1], NULL);
 786   check_locale_string_list_value (keyfile, "group0", "key1", "de", locale_strings[0], locale_strings[1], NULL);
 787   check_integer_list_value (keyfile, "group0", "key2", integers[0], integers[1], -100);
 788   check_double_list_value (keyfile, "group0", "key3", doubles[0], doubles[1], -100.0);
 789   g_key_file_free (keyfile);
 790
 791   /* and again with a different list separator */
 792   keyfile = g_key_file_new ();
 793   g_key_file_set_list_separator (keyfile, ',');
 794   g_key_file_set_string_list (keyfile, "group0", "key1", strings, G_N_ELEMENTS (strings));
 795   g_key_file_set_locale_string_list (keyfile, "group0", "key1", "de", locale_strings, G_N_ELEMENTS (locale_strings));
 796   g_key_file_set_integer_list (keyfile, "group0", "key2", integers, G_N_ELEMENTS (integers));
 797   g_key_file_set_double_list (keyfile, "group0", "key3", doubles, G_N_ELEMENTS (doubles));
 798
 799   check_string_list_value (keyfile, "group0", "key1", strings[0], strings[1], NULL);
 800   check_locale_string_list_value (keyfile, "group0", "key1", "de", locale_strings[0], locale_strings[1], NULL);
 801   check_integer_list_value (keyfile, "group0", "key2", integers[0], integers[1], -100);
 802   check_double_list_value (keyfile, "group0", "key3", doubles[0], doubles[1], -100.0);
 803   g_key_file_free (keyfile);
 804 }
 805
 806 static void
 807 test_group_remove (void)
 808 {
 809   GKeyFile *keyfile;
 810   gchar **names;
 811   gsize len;
 812   GError *error = NULL;
 813
 814   const gchar *data =
 815     "[group1]\n"
 816     "[group2]\n"
 817     "key1=bla\n"
 818     "key2=bla\n"
 819     "[group3]\n"
 820     "key1=bla\n"
 821     "key2=bla\n";
 822
 823   g_test_bug ("165887");
 824
 825   keyfile = load_data (data, 0);
 826
 827   names = g_key_file_get_groups (keyfile, &len);
 828   g_assert (names != NULL);
 829
 830   check_length ("groups", g_strv_length (names), len, 3);
 831   check_name ("group name", names[0], "group1", 0);
 832   check_name ("group name", names[1], "group2", 1);
 833   check_name ("group name", names[2], "group3", 2);
 834
 835   g_key_file_remove_group (keyfile, "group1", &error);
 836   check_no_error (&error);
 837
 838   g_strfreev (names);
 839
 840   names = g_key_file_get_groups (keyfile, &len);
 841   g_assert (names != NULL);
 842
 843   check_length ("groups", g_strv_length (names), len, 2);
 844   check_name ("group name", names[0], "group2", 0);
 845   check_name ("group name", names[1], "group3", 1);
 846
 847   g_key_file_remove_group (keyfile, "group2", &error);
 848   check_no_error (&error);
 849
 850   g_strfreev (names);
 851
 852   names = g_key_file_get_groups (keyfile, &len);
 853   g_assert (names != NULL);
 854
 855   check_length ("groups", g_strv_length (names), len, 1);
 856   check_name ("group name", names[0], "group3", 0);
 857
 858   g_key_file_remove_group (keyfile, "no such group", &error);
 859   check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_GROUP_NOT_FOUND);
 860
 861   g_strfreev (names);
 862
 863   g_key_file_free (keyfile);
 864 }
 865
 866 static void
 867 test_key_remove (void)
 868 {
 869   GKeyFile *keyfile;
 870   gchar *value;
 871   GError *error = NULL;
 872
 873   const gchar *data =
 874     "[group1]\n"
 875     "key1=bla\n"
 876     "key2=bla\n";
 877
 878   g_test_bug ("165980");
 879
 880   keyfile = load_data (data, 0);
 881
 882   check_string_value (keyfile, "group1", "key1", "bla");
 883
 884   g_key_file_remove_key (keyfile, "group1", "key1", &error);
 885   check_no_error (&error);
 886
 887   value = g_key_file_get_string (keyfile, "group1", "key1", &error);
 888   check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_KEY_NOT_FOUND);
 889   g_free (value);
 890
 891   g_key_file_remove_key (keyfile, "group1", "key1", &error);
 892   check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_KEY_NOT_FOUND);
 893
 894   g_key_file_remove_key (keyfile, "no such group", "key1", &error);
 895   check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_GROUP_NOT_FOUND);
 896
 897   g_key_file_free (keyfile);
 898 }
 899
 900
 901 static void
 902 test_groups (void)
 903 {
 904   GKeyFile *keyfile;
 905
 906   const gchar *data =
 907     "[1]\n"
 908     "key1=123\n"
 909     "[2]\n"
 910     "key2=123\n";
 911
 912   g_test_bug ("316309");
 913
 914   keyfile = load_data (data, 0);
 915
 916   check_string_value (keyfile, "1", "key1", "123");
 917   check_string_value (keyfile, "2", "key2", "123");
 918
 919   g_key_file_free (keyfile);
 920 }
 921
 922 static void
 923 test_group_names (void)
 924 {
 925   GKeyFile *keyfile;
 926   GError *error = NULL;
 927   const gchar *data;
 928   gchar *value;
 929
 930   /* [ in group name */
 931   data = "[a[b]\n"
 932          "key1=123\n";
 933   keyfile = g_key_file_new ();
 934   g_key_file_load_from_data (keyfile, data, -1, 0, &error);
 935   g_key_file_free (keyfile);
 936   check_error (&error,
 937                G_KEY_FILE_ERROR,
 938                G_KEY_FILE_ERROR_PARSE);
 939
 940   /* ] in group name */
 941   data = "[a]b]\n"
 942          "key1=123\n";
 943   keyfile = g_key_file_new ();
 944   g_key_file_load_from_data (keyfile, data, -1, 0, &error);
 945   g_key_file_free (keyfile);
 946   check_error (&error,
 947                G_KEY_FILE_ERROR,
 948                G_KEY_FILE_ERROR_PARSE);
 949
 950   /* control char in group name */
 951   data = "[a\tb]\n"
 952          "key1=123\n";
 953   keyfile = g_key_file_new ();
 954   g_key_file_load_from_data (keyfile, data, -1, 0, &error);
 955   g_key_file_free (keyfile);
 956   check_error (&error,
 957                G_KEY_FILE_ERROR,
 958                G_KEY_FILE_ERROR_PARSE);
 959
 960   /* empty group name */
 961   data = "[]\n"
 962          "key1=123\n";
 963   keyfile = g_key_file_new ();
 964   g_key_file_load_from_data (keyfile, data, -1, 0, &error);
 965   g_key_file_free (keyfile);
 966   check_error (&error,
 967                G_KEY_FILE_ERROR,
 968                G_KEY_FILE_ERROR_PARSE);
 969
 970   /* Unicode in group name */
 971   data = "[\xc2\xbd]\n"
 972          "key1=123\n";
 973   keyfile = g_key_file_new ();
 974   g_key_file_load_from_data (keyfile, data, -1, 0, &error);
 975   g_key_file_free (keyfile);
 976   check_no_error (&error);
 977
 978   keyfile = g_key_file_new ();
 979   /*g_key_file_set_string (keyfile, "a[b", "key1", "123");*/
 980   value = g_key_file_get_string (keyfile, "a[b", "key1", &error);
 981   check_error (&error,
 982                G_KEY_FILE_ERROR,
 983                G_KEY_FILE_ERROR_GROUP_NOT_FOUND);
 984   g_assert (value == NULL);
 985   g_key_file_free (keyfile);
 986
 987   keyfile = g_key_file_new ();
 988   /*g_key_file_set_string (keyfile, "a]b", "key1", "123");*/
 989   value = g_key_file_get_string (keyfile, "a]b", "key1", &error);
 990   check_error (&error,
 991                G_KEY_FILE_ERROR,
 992                G_KEY_FILE_ERROR_GROUP_NOT_FOUND);
 993   g_assert (value == NULL);
 994   g_key_file_free (keyfile);
 995
 996   keyfile = g_key_file_new ();
 997   /*g_key_file_set_string (keyfile, "a\tb", "key1", "123");*/
 998   value = g_key_file_get_string (keyfile, "a\tb", "key1", &error);
 999   check_error (&error,
1000                G_KEY_FILE_ERROR,
1001                G_KEY_FILE_ERROR_GROUP_NOT_FOUND);
1002   g_assert (value == NULL);
1003   g_key_file_free (keyfile);
1004
1005   keyfile = g_key_file_new ();
1006   g_key_file_set_string (keyfile, "\xc2\xbd", "key1", "123");
1007   check_string_value (keyfile, "\xc2\xbd", "key1", "123");
1008   g_key_file_free (keyfile);
1009 }
1010
1011 static void
1012 test_key_names (void)
1013 {
1014   GKeyFile *keyfile;
1015   GError *error = NULL;
1016   const gchar *data;
1017   gchar *value;
1018
1019   /* [ in key name */
1020   data = "[a]\n"
1021          "key[=123\n";
1022   keyfile = g_key_file_new ();
1023   g_key_file_load_from_data (keyfile, data, -1, 0, &error);
1024   g_key_file_free (keyfile);
1025   check_error (&error,
1026                G_KEY_FILE_ERROR,
1027                G_KEY_FILE_ERROR_PARSE);
1028
1029   /* empty key name */
1030   data = "[a]\n"
1031          " =123\n";
1032   keyfile = g_key_file_new ();
1033   g_key_file_load_from_data (keyfile, data, -1, 0, &error);
1034   g_key_file_free (keyfile);
1035   check_error (&error,
1036                G_KEY_FILE_ERROR,
1037                G_KEY_FILE_ERROR_PARSE);
1038
1039   /* empty key name */
1040   data = "[a]\n"
1041          " [de] =123\n";
1042   keyfile = g_key_file_new ();
1043   g_key_file_load_from_data (keyfile, data, -1, 0, &error);
1044   g_key_file_free (keyfile);
1045   check_error (&error,
1046                G_KEY_FILE_ERROR,
1047                G_KEY_FILE_ERROR_PARSE);
1048
1049   /* bad locale suffix */
1050   data = "[a]\n"
1051          "foo[@#!&%]=123\n";
1052   keyfile = g_key_file_new ();
1053   g_key_file_load_from_data (keyfile, data, -1, 0, &error);
1054   g_key_file_free (keyfile);
1055   check_error (&error,
1056                G_KEY_FILE_ERROR,
1057                G_KEY_FILE_ERROR_PARSE);
1058
1059   /* initial space */
1060   data = "[a]\n"
1061          " foo=123\n";
1062   keyfile = g_key_file_new ();
1063   g_key_file_load_from_data (keyfile, data, -1, 0, &error);
1064   check_no_error (&error);
1065   check_string_value (keyfile, "a", "foo", "123");
1066   g_key_file_free (keyfile);
1067
1068   /* final space */
1069   data = "[a]\n"
1070          "foo =123\n";
1071   keyfile = g_key_file_new ();
1072   g_key_file_load_from_data (keyfile, data, -1, 0, &error);
1073   check_no_error (&error);
1074   check_string_value (keyfile, "a", "foo", "123");
1075   g_key_file_free (keyfile);
1076
1077   /* inner space */
1078   data = "[a]\n"
1079          "foo bar=123\n";
1080   keyfile = g_key_file_new ();
1081   g_key_file_load_from_data (keyfile, data, -1, 0, &error);
1082   check_no_error (&error);
1083   check_string_value (keyfile, "a", "foo bar", "123");
1084   g_key_file_free (keyfile);
1085
1086   /* inner space */
1087   data = "[a]\n"
1088          "foo [de] =123\n";
1089   keyfile = g_key_file_new ();
1090   g_key_file_load_from_data (keyfile, data, -1, 0, &error);
1091   check_error (&error,
1092                G_KEY_FILE_ERROR,
1093                G_KEY_FILE_ERROR_PARSE);
1094   g_key_file_free (keyfile);
1095
1096   /* control char in key name */
1097   data = "[a]\n"
1098          "key\tfoo=123\n";
1099   keyfile = g_key_file_new ();
1100   g_key_file_load_from_data (keyfile, data, -1, 0, &error);
1101   g_key_file_free (keyfile);
1102   check_no_error (&error);
1103
1104   /* Unicode in key name */
1105   data = "[a]\n"
1106          "\xc2\xbd=123\n";
1107   keyfile = g_key_file_new ();
1108   g_key_file_load_from_data (keyfile, data, -1, 0, &error);
1109   g_key_file_free (keyfile);
1110   check_no_error (&error);
1111
1112   keyfile = g_key_file_new ();
1113   g_key_file_set_string (keyfile, "a", "x", "123");
1114   /*g_key_file_set_string (keyfile, "a", "key=", "123");*/
1115   value = g_key_file_get_string (keyfile, "a", "key=", &error);
1116   check_error (&error,
1117                G_KEY_FILE_ERROR,
1118                G_KEY_FILE_ERROR_KEY_NOT_FOUND);
1119   g_key_file_free (keyfile);
1120
1121   keyfile = g_key_file_new ();
1122   g_key_file_set_string (keyfile, "a", "x", "123");
1123   /*g_key_file_set_string (keyfile, "a", "key[", "123");*/
1124   value = g_key_file_get_string (keyfile, "a", "key[", &error);
1125   check_error (&error,
1126                G_KEY_FILE_ERROR,
1127                G_KEY_FILE_ERROR_KEY_NOT_FOUND);
1128   g_key_file_free (keyfile);
1129
1130   keyfile = g_key_file_new ();
1131   g_key_file_set_string (keyfile, "a", "x", "123");
1132   g_key_file_set_string (keyfile, "a", "key\tfoo", "123");
1133   value = g_key_file_get_string (keyfile, "a", "key\tfoo", &error);
1134   check_no_error (&error);
1135   g_free (value);
1136   g_key_file_free (keyfile);
1137
1138   keyfile = g_key_file_new ();
1139   g_key_file_set_string (keyfile, "a", "x", "123");
1140   /*g_key_file_set_string (keyfile, "a", " key", "123");*/
1141   value = g_key_file_get_string (keyfile, "a", " key", &error);
1142   check_error (&error,
1143                G_KEY_FILE_ERROR,
1144                G_KEY_FILE_ERROR_KEY_NOT_FOUND);
1145   g_key_file_free (keyfile);
1146
1147   keyfile = g_key_file_new ();
1148   g_key_file_set_string (keyfile, "a", "x", "123");
1149
1150   /* Unicode key */
1151   g_key_file_set_string (keyfile, "a", "\xc2\xbd", "123");
1152   check_string_value (keyfile, "a", "\xc2\xbd", "123");
1153
1154   /* Keys with / + . (as used by the gnome-vfs mime cache) */
1155   g_key_file_set_string (keyfile, "a", "foo/bar", "/");
1156   check_string_value (keyfile, "a", "foo/bar", "/");
1157   g_key_file_set_string (keyfile, "a", "foo+bar", "+");
1158   check_string_value (keyfile, "a", "foo+bar", "+");
1159   g_key_file_set_string (keyfile, "a", "foo.bar", ".");
1160   check_string_value (keyfile, "a", "foo.bar", ".");
1161
1162   g_key_file_free (keyfile);
1163 }
1164
1165 static void
1166 test_duplicate_keys (void)
1167 {
1168   GKeyFile *keyfile;
1169   const gchar *data =
1170     "[1]\n"
1171     "key1=123\n"
1172     "key1=345\n";
1173
1174   keyfile = load_data (data, 0);
1175   check_string_value (keyfile, "1", "key1", "345");
1176
1177   g_key_file_free (keyfile);
1178 }
1179
1180 static void
1181 test_duplicate_groups (void)
1182 {
1183   GKeyFile *keyfile;
1184   const gchar *data =
1185     "[Desktop Entry]\n"
1186     "key1=123\n"
1187     "[Desktop Entry]\n"
1188     "key2=123\n";
1189
1190   g_test_bug ("157877");
1191
1192   keyfile = load_data (data, 0);
1193   check_string_value (keyfile, "Desktop Entry", "key1", "123");
1194   check_string_value (keyfile, "Desktop Entry", "key2", "123");
1195
1196   g_key_file_free (keyfile);
1197 }
1198
1199 static void
1200 test_duplicate_groups2 (void)
1201 {
1202   GKeyFile *keyfile;
1203   const gchar *data =
1204     "[A]\n"
1205     "foo=bar\n"
1206     "[B]\n"
1207     "foo=baz\n"
1208     "[A]\n"
1209     "foo=bang\n";
1210
1211   g_test_bug ("385910");
1212
1213   keyfile = load_data (data, 0);
1214   check_string_value (keyfile, "A", "foo", "bang");
1215   check_string_value (keyfile, "B", "foo", "baz");
1216
1217   g_key_file_free (keyfile);
1218 }
1219
1220 static void
1221 test_reload_idempotency (void)
1222 {
1223   static const gchar *original_data=""
1224     "# Top comment\n"
1225     "\n"
1226     "# First comment\n"
1227     "[first]\n"
1228     "key=value\n"
1229     "# A random comment in the first group\n"
1230     "anotherkey=anothervalue\n"
1231     "# Second comment - one line\n"
1232     "[second]\n"
1233     "# Third comment - two lines\n"
1234     "# Third comment - two lines\n"
1235     "[third]\n"
1236     "blank_line=1\n"
1237     "\n"
1238     "blank_lines=2\n"
1239     "\n\n"
1240     "[fourth]\n"
1241     "[fifth]\n";
1242   GKeyFile *keyfile;
1243   GError *error = NULL;
1244   gchar *data1, *data2;
1245   gsize len1, len2;
1246
1247   g_test_bug ("420686");
1248
1249   /* check that we only insert a single new line between groups */
1250   keyfile = g_key_file_new ();
1251   g_key_file_load_from_data (keyfile,
1252                              original_data, strlen(original_data),
1253                              G_KEY_FILE_KEEP_COMMENTS,
1254                              &error);
1255   check_no_error (&error);
1256
1257   data1 = g_key_file_to_data (keyfile, &len1, &error);
1258   g_assert (data1 != NULL);
1259   g_key_file_free (keyfile);
1260
1261   keyfile = g_key_file_new ();
1262   g_key_file_load_from_data (keyfile,
1263                              data1, len1,
1264                              G_KEY_FILE_KEEP_COMMENTS,
1265                              &error);
1266   check_no_error (&error);
1267
1268   data2 = g_key_file_to_data (keyfile, &len2, &error);
1269   g_assert (data2 != NULL);
1270   g_key_file_free (keyfile);
1271
1272   g_assert_cmpstr (data1, ==, data2);
1273
1274   g_free (data2);
1275   g_free (data1);
1276 }
1277
1278 static const char int64_data[] =
1279 "[bees]\n"
1280 "a=1\n"
1281 "b=2\n"
1282 "c=123456789123456789\n"
1283 "d=-123456789123456789\n";
1284
1285 static void
1286 test_int64 (void)
1287 {
1288   GKeyFile *file;
1289   gboolean ok;
1290   guint64 c;
1291   gint64 d;
1292   gchar *value;
1293
1294   g_test_bug ("614864");
1295
1296   file = g_key_file_new ();
1297
1298   ok = g_key_file_load_from_data (file, int64_data, strlen (int64_data),
1299       0, NULL);
1300   g_assert (ok);
1301
1302   c = g_key_file_get_uint64 (file, "bees", "c", NULL);
1303   g_assert (c == G_GUINT64_CONSTANT (123456789123456789));
1304
1305   d = g_key_file_get_int64 (file, "bees", "d", NULL);
1306   g_assert (d == G_GINT64_CONSTANT (-123456789123456789));
1307
1308   g_key_file_set_uint64 (file, "bees", "c",
1309       G_GUINT64_CONSTANT (987654321987654321));
1310   value = g_key_file_get_value (file, "bees", "c", NULL);
1311   g_assert_cmpstr (value, ==, "987654321987654321");
1312   g_free (value);
1313
1314   g_key_file_set_int64 (file, "bees", "d",
1315       G_GINT64_CONSTANT (-987654321987654321));
1316   value = g_key_file_get_value (file, "bees", "d", NULL);
1317   g_assert_cmpstr (value, ==, "-987654321987654321");
1318   g_free (value);
1319
1320   g_key_file_free (file);
1321 }
1322
1323 static void
1324 test_load (void)
1325 {
1326   GKeyFile *file;
1327   GError *error;
1328   gboolean bools[2] = { TRUE, FALSE };
1329   gboolean loaded;
1330
1331   file = g_key_file_new ();
1332   error = NULL;
1333 #ifdef G_OS_UNIX
1334   /* Uses the value of $XDG_DATA_HOME we set in main() */
1335   loaded = g_key_file_load_from_data_dirs (file, "keyfiletest.ini", NULL, 0, &error);
1336 #else
1337   loaded = g_key_file_load_from_file (file, g_test_get_filename (G_TEST_DIST, "keyfiletest.ini", NULL), 0, &error);
1338 #endif
1339   g_assert_no_error (error);
1340   g_assert (loaded);
1341
1342   g_key_file_set_locale_string (file, "test", "key4", "de", "Vierter Schlüssel");
1343   g_key_file_set_boolean_list (file, "test", "key5", bools, 2);
1344   g_key_file_set_integer (file, "test", "key6", 22);
1345   g_key_file_set_double (file, "test", "key7", 2.5);
1346   g_key_file_set_comment (file, "test", "key7", "some float", NULL);
1347   g_key_file_set_comment (file, "test", NULL, "the test group", NULL);
1348   g_key_file_set_comment (file, NULL, NULL, "top comment", NULL);
1349
1350   g_key_file_free (file);
1351
1352   file = g_key_file_new ();
1353   error = NULL;
1354   g_assert (!g_key_file_load_from_data_dirs (file, "keyfile-test.ini", NULL, 0, &error));
1355   g_assert_error (error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_NOT_FOUND);
1356   g_error_free (error);
1357   g_key_file_free (file);
1358 }
1359
1360 static void
1361 test_save (void)
1362 {
1363   GKeyFile *kf;
1364   GKeyFile *kf2;
1365   static const char data[] =
1366     "[bees]\n"
1367     "a=1\n"
1368     "b=2\n"
1369     "c=123456789123456789\n"
1370     "d=-123456789123456789\n";
1371   gboolean ok;
1372   gchar *file;
1373   guint64 c;
1374   GError *error = NULL;
1375   int fd;
1376
1377   kf = g_key_file_new ();
1378   ok = g_key_file_load_from_data (kf, data, strlen (data), 0, NULL);
1379   g_assert (ok);
1380
1381   file = g_strdup ("key_file_XXXXXX");
1382   fd = g_mkstemp (file);
1383   g_assert (fd != -1);
1384   close (fd);
1385   ok = g_key_file_save_to_file (kf, file, &error);
1386   g_assert (ok);
1387   g_assert_no_error (error);
1388
1389   kf2 = g_key_file_new ();
1390   ok = g_key_file_load_from_file (kf2, file, 0, &error);
1391   g_assert (ok);
1392   g_assert_no_error (error);
1393
1394   c = g_key_file_get_uint64 (kf2, "bees", "c", NULL);
1395   g_assert (c == G_GUINT64_CONSTANT (123456789123456789));
1396
1397   g_free (file);
1398   g_key_file_free (kf);
1399   g_key_file_free (kf2);
1400 }
1401
1402 static void
1403 test_load_fail (void)
1404 {
1405   GKeyFile *file;
1406   GError *error;
1407
1408   file = g_key_file_new ();
1409   error = NULL;
1410   g_assert (!g_key_file_load_from_file (file, g_test_get_filename (G_TEST_DIST, "keyfile.c", NULL), 0, &error));
1411   g_assert_error (error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_PARSE);
1412   g_clear_error (&error);
1413   g_assert (!g_key_file_load_from_file (file, "/nosuchfile", 0, &error));
1414   g_assert_error (error, G_FILE_ERROR, G_FILE_ERROR_NOENT);
1415   g_clear_error (&error);
1416
1417   g_key_file_free (file);
1418 }
1419
1420 static void
1421 test_non_utf8 (void)
1422 {
1423   GKeyFile *file;
1424   static const char data[] =
1425 "[group]\n"
1426 "a=\230\230\230\n"
1427 "b=a;b;\230\230\230;\n"
1428 "c=a\\\n";
1429   gboolean ok;
1430   GError *error;
1431   gchar *s;
1432   gchar **l;
1433
1434   file = g_key_file_new ();
1435
1436   ok = g_key_file_load_from_data (file, data, strlen (data), 0, NULL);
1437   g_assert (ok);
1438
1439   error = NULL;
1440   s = g_key_file_get_string (file, "group", "a", &error);
1441   g_assert_error (error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_UNKNOWN_ENCODING);
1442   g_assert (s == NULL);
1443
1444   g_clear_error (&error);
1445   l = g_key_file_get_string_list (file, "group", "b", NULL, &error);
1446   g_assert_error (error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_UNKNOWN_ENCODING);
1447   g_assert (l == NULL);
1448
1449   g_clear_error (&error);
1450   l = g_key_file_get_string_list (file, "group", "c", NULL, &error);
1451   g_assert_error (error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_INVALID_VALUE);
1452   g_assert (l == NULL);
1453
1454   g_clear_error (&error);
1455
1456   g_key_file_free (file);
1457 }
1458
1459 static void
1460 test_page_boundary (void)
1461 {
1462   GKeyFile *file;
1463   GError *error;
1464   gint i;
1465
1466 #define GROUP "main_section"
1467 #define KEY_PREFIX "fill_abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvw_"
1468 #define FIRST_KEY 10
1469 #define LAST_KEY 99
1470 #define VALUE 92
1471
1472   g_test_bug ("640695");
1473
1474   file = g_key_file_new ();
1475
1476   error = NULL;
1477   g_key_file_load_from_file (file, g_test_get_filename (G_TEST_DIST, "pages.ini", NULL), G_KEY_FILE_NONE, &error);
1478   g_assert_no_error (error);
1479
1480   for (i = FIRST_KEY; i <= LAST_KEY; i++)
1481     {
1482       gchar *key;
1483       gint val;
1484
1485       key = g_strdup_printf (KEY_PREFIX "%d", i);
1486       val = g_key_file_get_integer (file, GROUP, key, &error);
1487       g_free (key);
1488       g_assert_no_error (error);
1489       g_assert_cmpint (val, ==, VALUE);
1490     }
1491
1492   g_key_file_free (file);
1493 }
1494
1495 static void
1496 test_ref (void)
1497 {
1498   GKeyFile *file;
1499   static const char data[] =
1500 "[group]\n"
1501 "a=1\n";
1502   gboolean ok;
1503
1504   file = g_key_file_new ();
1505
1506   ok = g_key_file_load_from_data (file, data, strlen (data), 0, NULL);
1507   g_assert (ok);
1508   g_assert (g_key_file_has_key (file, "group", "a", NULL));
1509   g_key_file_ref (file);
1510   g_key_file_free (file);
1511   g_key_file_unref (file);
1512 }
1513
1514 /* https://bugzilla.gnome.org/show_bug.cgi?id=634232 */
1515 static void
1516 test_replace_value (void)
1517 {
1518   GKeyFile *keyfile;
1519
1520   keyfile = g_key_file_new();
1521   g_key_file_set_value(keyfile, "grupo1", "chave1", "1234567890");
1522   g_key_file_set_value(keyfile, "grupo1", "chave1", "123123423423423432432423423");
1523   g_key_file_remove_group(keyfile, "grupo1", NULL);
1524   g_free (g_key_file_to_data (keyfile, NULL, NULL));
1525   g_key_file_unref (keyfile);
1526 }
1527
1528 static void
1529 test_list_separator (void)
1530 {
1531   GKeyFile *keyfile;
1532   GError *error = NULL;
1533
1534   const gchar *data =
1535     "[test]\n"
1536     "key1=v1,v2\n";
1537
1538   keyfile = g_key_file_new ();
1539   g_key_file_set_list_separator (keyfile, ',');
1540   g_key_file_load_from_data (keyfile, data, -1, 0, &error);
1541
1542   check_string_list_value (keyfile, "test", "key1", "v1", "v2", NULL);
1543   g_key_file_unref (keyfile);
1544 }
1545
1546 static void
1547 test_empty_string (void)
1548 {
1549   GError *error = NULL;
1550   GKeyFile *kf;
1551
1552   kf = g_key_file_new ();
1553
1554   g_key_file_load_from_data (kf, "", 0, 0, &error);
1555   g_assert_no_error (error);
1556
1557   g_key_file_load_from_data (kf, "", -1, 0, &error);
1558   g_assert_no_error (error);
1559
1560   /* NULL is a fine pointer to use if length is zero */
1561   g_key_file_load_from_data (kf, NULL, 0, 0, &error);
1562   g_assert_no_error (error);
1563
1564   /* should not attempt to access non-NULL pointer if length is zero */
1565   g_key_file_load_from_data (kf, GINT_TO_POINTER (1), 0, 0, &error);
1566   g_assert_no_error (error);
1567
1568   g_key_file_unref (kf);
1569 }
1570
1571 static void
1572 test_limbo (void)
1573 {
1574   GKeyFile *file;
1575   static const char data[] =
1576 "a=b\n"
1577 "[group]\n"
1578 "b=c\n";
1579   gboolean ok;
1580   GError *error;
1581
1582   file = g_key_file_new ();
1583
1584   error = NULL;
1585   ok = g_key_file_load_from_data (file, data, strlen (data), 0, &error);
1586   g_assert (!ok);
1587   g_assert_error (error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_GROUP_NOT_FOUND);
1588   g_clear_error (&error);
1589   g_key_file_free (file);
1590 }
1591
1592 static void
1593 test_utf8 (void)
1594 {
1595   GKeyFile *file;
1596   static const char data[] =
1597 "[group]\n"
1598 "Encoding=non-UTF-8\n";
1599   gboolean ok;
1600   GError *error;
1601
1602   file = g_key_file_new ();
1603
1604   error = NULL;
1605   ok = g_key_file_load_from_data (file, data, strlen (data), 0, &error);
1606   g_assert (!ok);
1607   g_assert_error (error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_UNKNOWN_ENCODING);
1608   g_clear_error (&error);
1609   g_key_file_free (file);
1610 }
1611
1612 static void
1613 test_roundtrip (void)
1614 {
1615   GKeyFile *kf;
1616   const gchar orig[] =
1617     "[Group1]\n"
1618     "key1=value1\n"
1619     "\n"
1620     "[Group2]\n"
1621     "key1=value1\n";
1622   gsize len;
1623   gchar *data;
1624
1625   kf = load_data (orig, G_KEY_FILE_KEEP_COMMENTS);
1626   g_key_file_set_integer (kf, "Group1", "key2", 0);
1627   g_key_file_remove_key (kf, "Group1", "key2", NULL);
1628
1629   data = g_key_file_to_data (kf, &len, NULL);
1630   g_assert_cmpstr (data, ==, orig);
1631
1632   g_free (data);
1633   g_key_file_free (kf);
1634 }
1635
1636 int
1637 main (int argc, char *argv[])
1638 {
1639   g_test_init (&argc, &argv, NULL);
1640
1641 #ifdef G_OS_UNIX
1642   g_setenv ("XDG_DATA_HOME", g_test_get_dir (G_TEST_DIST), TRUE);
1643 #endif
1644
1645   g_test_bug_base ("http://bugzilla.gnome.org/");
1646
1647   g_test_add_func ("/keyfile/line-ends", test_line_ends);
1648   g_test_add_func ("/keyfile/whitespace", test_whitespace);
1649   g_test_add_func ("/keyfile/comments", test_comments);
1650   g_test_add_func ("/keyfile/listing", test_listing);
1651   g_test_add_func ("/keyfile/string", test_string);
1652   g_test_add_func ("/keyfile/boolean", test_boolean);
1653   g_test_add_func ("/keyfile/number", test_number);
1654   g_test_add_func ("/keyfile/locale-string", test_locale_string);
1655   g_test_add_func ("/keyfile/lists", test_lists);
1656   g_test_add_func ("/keyfile/lists-set-get", test_lists_set_get);
1657   g_test_add_func ("/keyfile/group-remove", test_group_remove);
1658   g_test_add_func ("/keyfile/key-remove", test_key_remove);
1659   g_test_add_func ("/keyfile/groups", test_groups);
1660   g_test_add_func ("/keyfile/duplicate-keys", test_duplicate_keys);
1661   g_test_add_func ("/keyfile/duplicate-groups", test_duplicate_groups);
1662   g_test_add_func ("/keyfile/duplicate-groups2", test_duplicate_groups2);
1663   g_test_add_func ("/keyfile/group-names", test_group_names);
1664   g_test_add_func ("/keyfile/key-names", test_key_names);
1665   g_test_add_func ("/keyfile/reload", test_reload_idempotency);
1666   g_test_add_func ("/keyfile/int64", test_int64);
1667   g_test_add_func ("/keyfile/load", test_load);
1668   g_test_add_func ("/keyfile/save", test_save);
1669   g_test_add_func ("/keyfile/load-fail", test_load_fail);
1670   g_test_add_func ("/keyfile/non-utf8", test_non_utf8);
1671   g_test_add_func ("/keyfile/page-boundary", test_page_boundary);
1672   g_test_add_func ("/keyfile/ref", test_ref);
1673   g_test_add_func ("/keyfile/replace-value", test_replace_value);
1674   g_test_add_func ("/keyfile/list-separator", test_list_separator);
1675   g_test_add_func ("/keyfile/empty-string", test_empty_string);
1676   g_test_add_func ("/keyfile/limbo", test_limbo);
1677   g_test_add_func ("/keyfile/utf8", test_utf8);
1678   g_test_add_func ("/keyfile/roundtrip", test_roundtrip);
1679
1680   return g_test_run ();
1681 }