glib/tests/keyfile.c

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