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
 448   const gchar *data =
 449     "[group1]\n"
 450     "key1=value1\n"
 451     "key2=value2\n"
 452     "[group2]\n"
 453     "key3=value3\n"
 454     "key4=value4\n";
 455
 456   keyfile = load_data (data, 0);
 457
 458   names = g_key_file_get_groups (keyfile, &len);
 459   g_assert (names != NULL);
 460
 461   check_length ("groups", g_strv_length (names), len, 2);
 462   check_name ("group name", names[0], "group1", 0);
 463   check_name ("group name", names[1], "group2", 1);
 464
 465   g_strfreev (names);
 466
 467   names = g_key_file_get_keys (keyfile, "group1", &len, &error);
 468   check_no_error (&error);
 469
 470   check_length ("keys", g_strv_length (names), len, 2);
 471   check_name ("key", names[0], "key1", 0);
 472   check_name ("key", names[1], "key2", 1);
 473
 474   g_strfreev (names);
 475
 476   names = g_key_file_get_keys (keyfile, "no-such-group", &len, &error);
 477   check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_GROUP_NOT_FOUND);
 478
 479   g_strfreev (names);
 480
 481   g_assert (g_key_file_has_group (keyfile, "group1"));
 482   g_assert (g_key_file_has_group (keyfile, "group2"));
 483   g_assert (!g_key_file_has_group (keyfile, "group10"));
 484   g_assert (!g_key_file_has_group (keyfile, "group20"));
 485
 486   start = g_key_file_get_start_group (keyfile);
 487   g_assert_cmpstr (start, ==, "group1");
 488   g_free (start);
 489
 490   g_assert (g_key_file_has_key (keyfile, "group1", "key1", &error));
 491   check_no_error (&error);
 492   g_assert (g_key_file_has_key (keyfile, "group2", "key3", &error));
 493   check_no_error (&error);
 494   g_assert (!g_key_file_has_key (keyfile, "group2", "no-such-key", NULL));
 495
 496   g_key_file_has_key (keyfile, "no-such-group", "key", &error);
 497   check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_GROUP_NOT_FOUND);
 498
 499   g_key_file_free (keyfile);
 500 }
 501
 502 /* check parsing of string values */
 503 static void
 504 test_string (void)
 505 {
 506   GKeyFile *keyfile;
 507   GError *error = NULL;
 508   gchar *value;
 509
 510   const gchar *data =
 511     "[valid]\n"
 512     "key1=\\s\\n\\t\\r\\\\\n"
 513     "key2=\"quoted\"\n"
 514     "key3='quoted'\n"
 515     "key4=\xe2\x89\xa0\xe2\x89\xa0\n"
 516     "[invalid]\n"
 517     "key1=\\a\\b\\0800xff\n"
 518     "key2=blabla\\\n";
 519
 520   keyfile = load_data (data, 0);
 521
 522   check_string_value (keyfile, "valid", "key1", " \n\t\r\\");
 523   check_string_value (keyfile, "valid", "key2", "\"quoted\"");
 524   check_string_value (keyfile, "valid", "key3", "'quoted'");
 525   check_string_value (keyfile, "valid", "key4", "\xe2\x89\xa0\xe2\x89\xa0");
 526
 527   value = g_key_file_get_string (keyfile, "invalid", "key1", &error);
 528   check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_INVALID_VALUE);
 529   g_free (value);
 530
 531   value = g_key_file_get_string (keyfile, "invalid", "key2", &error);
 532   check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_INVALID_VALUE);
 533   g_free (value);
 534
 535   g_key_file_free (keyfile);
 536 }
 537
 538 /* check parsing of boolean values */
 539 static void
 540 test_boolean (void)
 541 {
 542   GKeyFile *keyfile;
 543   GError *error = NULL;
 544
 545   const gchar *data =
 546     "[valid]\n"
 547     "key1=true\n"
 548     "key2=false\n"
 549     "key3=1\n"
 550     "key4=0\n"
 551     "[invalid]\n"
 552     "key1=t\n"
 553     "key2=f\n"
 554     "key3=yes\n"
 555     "key4=no\n";
 556
 557   keyfile = load_data (data, 0);
 558
 559   check_boolean_value (keyfile, "valid", "key1", TRUE);
 560   check_boolean_value (keyfile, "valid", "key2", FALSE);
 561   check_boolean_value (keyfile, "valid", "key3", TRUE);
 562   check_boolean_value (keyfile, "valid", "key4", FALSE);
 563
 564   g_key_file_get_boolean (keyfile, "invalid", "key1", &error);
 565   check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_INVALID_VALUE);
 566
 567   g_key_file_get_boolean (keyfile, "invalid", "key2", &error);
 568   check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_INVALID_VALUE);
 569
 570   g_key_file_get_boolean (keyfile, "invalid", "key3", &error);
 571   check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_INVALID_VALUE);
 572
 573   g_key_file_get_boolean (keyfile, "invalid", "key4", &error);
 574   check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_INVALID_VALUE);
 575
 576   g_key_file_free (keyfile);
 577 }
 578
 579 /* check parsing of integer and double values */
 580 static void
 581 test_number (void)
 582 {
 583   GKeyFile *keyfile;
 584   GError *error = NULL;
 585
 586   const gchar *data =
 587     "[valid]\n"
 588     "key1=0\n"
 589     "key2=1\n"
 590     "key3=-1\n"
 591     "key4=2324431\n"
 592     "key5=-2324431\n"
 593     "key6=000111\n"
 594     "dkey1=000111\n"
 595     "dkey2=145.45\n"
 596     "dkey3=-3453.7\n"
 597     "[invalid]\n"
 598     "key1=0xffff\n"
 599     "key2=0.5\n"
 600     "key3=1e37\n"
 601     "key4=ten\n"
 602     "key5=\n"
 603     "key6=1.0.0\n"
 604     "key7=2x2\n"
 605     "key8=abc\n";
 606
 607   keyfile = load_data (data, 0);
 608
 609   check_integer_value (keyfile, "valid", "key1", 0);
 610   check_integer_value (keyfile, "valid", "key2", 1);
 611   check_integer_value (keyfile, "valid", "key3", -1);
 612   check_integer_value (keyfile, "valid", "key4", 2324431);
 613   check_integer_value (keyfile, "valid", "key5", -2324431);
 614   check_integer_value (keyfile, "valid", "key6", 111);
 615   check_double_value (keyfile, "valid", "dkey1", 111.0);
 616   check_double_value (keyfile, "valid", "dkey2", 145.45);
 617   check_double_value (keyfile, "valid", "dkey3", -3453.7);
 618
 619   g_key_file_get_integer (keyfile, "invalid", "key1", &error);
 620   check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_INVALID_VALUE);
 621
 622   g_key_file_get_integer (keyfile, "invalid", "key2", &error);
 623   check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_INVALID_VALUE);
 624
 625   g_key_file_get_integer (keyfile, "invalid", "key3", &error);
 626   check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_INVALID_VALUE);
 627
 628   g_key_file_get_integer (keyfile, "invalid", "key4", &error);
 629   check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_INVALID_VALUE);
 630
 631   g_key_file_get_double (keyfile, "invalid", "key5", &error);
 632   check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_INVALID_VALUE);
 633
 634   g_key_file_get_double (keyfile, "invalid", "key6", &error);
 635   check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_INVALID_VALUE);
 636
 637   g_key_file_get_double (keyfile, "invalid", "key7", &error);
 638   check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_INVALID_VALUE);
 639
 640   g_key_file_get_double (keyfile, "invalid", "key8", &error);
 641   check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_INVALID_VALUE);
 642
 643   g_key_file_free (keyfile);
 644 }
 645
 646 /* check handling of translated strings */
 647 static void
 648 test_locale_string (void)
 649 {
 650   GKeyFile *keyfile;
 651
 652   const gchar *data =
 653     "[valid]\n"
 654     "key1=v1\n"
 655     "key1[de]=v1-de\n"
 656     "key1[de_DE]=v1-de_DE\n"
 657     "key1[de_DE.UTF8]=v1-de_DE.UTF8\n"
 658     "key1[fr]=v1-fr\n"
 659     "key1[en] =v1-en\n"
 660     "key1[sr@Latn]=v1-sr\n";
 661
 662   keyfile = load_data (data, G_KEY_FILE_KEEP_TRANSLATIONS);
 663
 664   check_locale_string_value (keyfile, "valid", "key1", "it", "v1");
 665   check_locale_string_value (keyfile, "valid", "key1", "de", "v1-de");
 666   check_locale_string_value (keyfile, "valid", "key1", "de_DE", "v1-de_DE");
 667   check_locale_string_value (keyfile, "valid", "key1", "de_DE.UTF8", "v1-de_DE.UTF8");
 668   check_locale_string_value (keyfile, "valid", "key1", "fr", "v1-fr");
 669   check_locale_string_value (keyfile, "valid", "key1", "fr_FR", "v1-fr");
 670   check_locale_string_value (keyfile, "valid", "key1", "en", "v1-en");
 671   check_locale_string_value (keyfile, "valid", "key1", "sr@Latn", "v1-sr");
 672
 673   g_key_file_free (keyfile);
 674
 675   /* now test that translations are thrown away */
 676
 677   g_setenv ("LANGUAGE", "de", TRUE);
 678   setlocale (LC_ALL, "");
 679
 680   keyfile = load_data (data, 0);
 681
 682   check_locale_string_value (keyfile, "valid", "key1", "it", "v1");
 683   check_locale_string_value (keyfile, "valid", "key1", "de", "v1-de");
 684   check_locale_string_value (keyfile, "valid", "key1", "de_DE", "v1-de");
 685   check_locale_string_value (keyfile, "valid", "key1", "de_DE.UTF8", "v1-de");
 686   check_locale_string_value (keyfile, "valid", "key1", "fr", "v1");
 687   check_locale_string_value (keyfile, "valid", "key1", "fr_FR", "v1");
 688   check_locale_string_value (keyfile, "valid", "key1", "en", "v1");
 689
 690   g_key_file_free (keyfile);
 691 }
 692
 693 static void
 694 test_lists (void)
 695 {
 696   GKeyFile *keyfile;
 697
 698   const gchar *data =
 699     "[valid]\n"
 700     "key1=v1;v2\n"
 701     "key2=v1;v2;\n"
 702     "key3=v1,v2\n"
 703     "key4=v1\\;v2\n"
 704     "key5=true;false\n"
 705     "key6=1;0;-1\n"
 706     "key7= 1 ; 0 ; -1 \n"
 707     "key8=v1\\,v2\n"
 708     "key9=0;1.3456;-76532.456\n";
 709
 710   keyfile = load_data (data, 0);
 711
 712   check_string_list_value (keyfile, "valid", "key1", "v1", "v2", NULL);
 713   check_string_list_value (keyfile, "valid", "key2", "v1", "v2", NULL);
 714   check_string_list_value (keyfile, "valid", "key3", "v1,v2", NULL);
 715   check_string_list_value (keyfile, "valid", "key4", "v1;v2", NULL);
 716   check_boolean_list_value (keyfile, "valid", "key5", TRUE, FALSE, -100);
 717   check_integer_list_value (keyfile, "valid", "key6", 1, 0, -1, -100);
 718   check_double_list_value (keyfile, "valid", "key9", 0.0, 1.3456, -76532.456, -100.0);
 719   /* maybe these should be valid */
 720   /* check_integer_list_value (keyfile, "valid", "key7", 1, 0, -1, -100);*/
 721   /* check_string_list_value (keyfile, "valid", "key8", "v1\\,v2", NULL);*/
 722
 723   g_key_file_free (keyfile);
 724
 725   /* Now check an alternate separator */
 726
 727   keyfile = load_data (data, 0);
 728   g_key_file_set_list_separator (keyfile, ',');
 729
 730   check_string_list_value (keyfile, "valid", "key1", "v1;v2", NULL);
 731   check_string_list_value (keyfile, "valid", "key2", "v1;v2;", NULL);
 732   check_string_list_value (keyfile, "valid", "key3", "v1", "v2", NULL);
 733
 734   g_key_file_free (keyfile);
 735 }
 736
 737 static void
 738 test_lists_set_get (void)
 739 {
 740   GKeyFile *keyfile;
 741   static const char * const strings[] = { "v1", "v2" };
 742   static const char * const locale_strings[] = { "v1-l", "v2-l" };
 743   static int integers[] = { 1, -1, 2 };
 744   static gdouble doubles[] = { 3.14, 2.71 };
 745
 746   keyfile = g_key_file_new ();
 747   g_key_file_set_string_list (keyfile, "group0", "key1", strings, G_N_ELEMENTS (strings));
 748   g_key_file_set_locale_string_list (keyfile, "group0", "key1", "de", locale_strings, G_N_ELEMENTS (locale_strings));
 749   g_key_file_set_integer_list (keyfile, "group0", "key2", integers, G_N_ELEMENTS (integers));
 750   g_key_file_set_double_list (keyfile, "group0", "key3", doubles, G_N_ELEMENTS (doubles));
 751
 752   check_string_list_value (keyfile, "group0", "key1", strings[0], strings[1], NULL);
 753   check_locale_string_list_value (keyfile, "group0", "key1", "de", locale_strings[0], locale_strings[1], NULL);
 754   check_integer_list_value (keyfile, "group0", "key2", integers[0], integers[1], -100);
 755   check_double_list_value (keyfile, "group0", "key3", doubles[0], doubles[1], -100.0);
 756   g_key_file_free (keyfile);
 757
 758   /* and again with a different list separator */
 759   keyfile = g_key_file_new ();
 760   g_key_file_set_list_separator (keyfile, ',');
 761   g_key_file_set_string_list (keyfile, "group0", "key1", strings, G_N_ELEMENTS (strings));
 762   g_key_file_set_locale_string_list (keyfile, "group0", "key1", "de", locale_strings, G_N_ELEMENTS (locale_strings));
 763   g_key_file_set_integer_list (keyfile, "group0", "key2", integers, G_N_ELEMENTS (integers));
 764   g_key_file_set_double_list (keyfile, "group0", "key3", doubles, G_N_ELEMENTS (doubles));
 765
 766   check_string_list_value (keyfile, "group0", "key1", strings[0], strings[1], NULL);
 767   check_locale_string_list_value (keyfile, "group0", "key1", "de", locale_strings[0], locale_strings[1], NULL);
 768   check_integer_list_value (keyfile, "group0", "key2", integers[0], integers[1], -100);
 769   check_double_list_value (keyfile, "group0", "key3", doubles[0], doubles[1], -100.0);
 770   g_key_file_free (keyfile);
 771 }
 772
 773 static void
 774 test_group_remove (void)
 775 {
 776   GKeyFile *keyfile;
 777   gchar **names;
 778   gsize len;
 779   GError *error = NULL;
 780
 781   const gchar *data =
 782     "[group1]\n"
 783     "[group2]\n"
 784     "key1=bla\n"
 785     "key2=bla\n"
 786     "[group3]\n"
 787     "key1=bla\n"
 788     "key2=bla\n";
 789
 790   g_test_bug ("165887");
 791
 792   keyfile = load_data (data, 0);
 793
 794   names = g_key_file_get_groups (keyfile, &len);
 795   g_assert (names != NULL);
 796
 797   check_length ("groups", g_strv_length (names), len, 3);
 798   check_name ("group name", names[0], "group1", 0);
 799   check_name ("group name", names[1], "group2", 1);
 800   check_name ("group name", names[2], "group3", 2);
 801
 802   g_key_file_remove_group (keyfile, "group1", &error);
 803   check_no_error (&error);
 804
 805   g_strfreev (names);
 806
 807   names = g_key_file_get_groups (keyfile, &len);
 808   g_assert (names != NULL);
 809
 810   check_length ("groups", g_strv_length (names), len, 2);
 811   check_name ("group name", names[0], "group2", 0);
 812   check_name ("group name", names[1], "group3", 1);
 813
 814   g_key_file_remove_group (keyfile, "group2", &error);
 815   check_no_error (&error);
 816
 817   g_strfreev (names);
 818
 819   names = g_key_file_get_groups (keyfile, &len);
 820   g_assert (names != NULL);
 821
 822   check_length ("groups", g_strv_length (names), len, 1);
 823   check_name ("group name", names[0], "group3", 0);
 824
 825   g_key_file_remove_group (keyfile, "no such group", &error);
 826   check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_GROUP_NOT_FOUND);
 827
 828   g_strfreev (names);
 829
 830   g_key_file_free (keyfile);
 831 }
 832
 833 static void
 834 test_key_remove (void)
 835 {
 836   GKeyFile *keyfile;
 837   gchar *value;
 838   GError *error = NULL;
 839
 840   const gchar *data =
 841     "[group1]\n"
 842     "key1=bla\n"
 843     "key2=bla\n";
 844
 845   g_test_bug ("165980");
 846
 847   keyfile = load_data (data, 0);
 848
 849   check_string_value (keyfile, "group1", "key1", "bla");
 850
 851   g_key_file_remove_key (keyfile, "group1", "key1", &error);
 852   check_no_error (&error);
 853
 854   value = g_key_file_get_string (keyfile, "group1", "key1", &error);
 855   check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_KEY_NOT_FOUND);
 856   g_free (value);
 857
 858   g_key_file_remove_key (keyfile, "group1", "key1", &error);
 859   check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_KEY_NOT_FOUND);
 860
 861   g_key_file_remove_key (keyfile, "no such group", "key1", &error);
 862   check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_GROUP_NOT_FOUND);
 863
 864   g_key_file_free (keyfile);
 865 }
 866
 867
 868 static void
 869 test_groups (void)
 870 {
 871   GKeyFile *keyfile;
 872
 873   const gchar *data =
 874     "[1]\n"
 875     "key1=123\n"
 876     "[2]\n"
 877     "key2=123\n";
 878
 879   g_test_bug ("316309");
 880
 881   keyfile = load_data (data, 0);
 882
 883   check_string_value (keyfile, "1", "key1", "123");
 884   check_string_value (keyfile, "2", "key2", "123");
 885
 886   g_key_file_free (keyfile);
 887 }
 888
 889 static void
 890 test_group_names (void)
 891 {
 892   GKeyFile *keyfile;
 893   GError *error = NULL;
 894   const gchar *data;
 895   gchar *value;
 896
 897   /* [ in group name */
 898   data = "[a[b]\n"
 899          "key1=123\n";
 900   keyfile = g_key_file_new ();
 901   g_key_file_load_from_data (keyfile, data, -1, 0, &error);
 902   g_key_file_free (keyfile);
 903   check_error (&error,
 904                G_KEY_FILE_ERROR,
 905                G_KEY_FILE_ERROR_PARSE);
 906
 907   /* ] in group name */
 908   data = "[a]b]\n"
 909          "key1=123\n";
 910   keyfile = g_key_file_new ();
 911   g_key_file_load_from_data (keyfile, data, -1, 0, &error);
 912   g_key_file_free (keyfile);
 913   check_error (&error,
 914                G_KEY_FILE_ERROR,
 915                G_KEY_FILE_ERROR_PARSE);
 916
 917   /* control char in group name */
 918   data = "[a\tb]\n"
 919          "key1=123\n";
 920   keyfile = g_key_file_new ();
 921   g_key_file_load_from_data (keyfile, data, -1, 0, &error);
 922   g_key_file_free (keyfile);
 923   check_error (&error,
 924                G_KEY_FILE_ERROR,
 925                G_KEY_FILE_ERROR_PARSE);
 926
 927   /* empty group name */
 928   data = "[]\n"
 929          "key1=123\n";
 930   keyfile = g_key_file_new ();
 931   g_key_file_load_from_data (keyfile, data, -1, 0, &error);
 932   g_key_file_free (keyfile);
 933   check_error (&error,
 934                G_KEY_FILE_ERROR,
 935                G_KEY_FILE_ERROR_PARSE);
 936
 937   /* Unicode in group name */
 938   data = "[\xc2\xbd]\n"
 939          "key1=123\n";
 940   keyfile = g_key_file_new ();
 941   g_key_file_load_from_data (keyfile, data, -1, 0, &error);
 942   g_key_file_free (keyfile);
 943   check_no_error (&error);
 944
 945   keyfile = g_key_file_new ();
 946   /*g_key_file_set_string (keyfile, "a[b", "key1", "123");*/
 947   value = g_key_file_get_string (keyfile, "a[b", "key1", &error);
 948   check_error (&error,
 949                G_KEY_FILE_ERROR,
 950                G_KEY_FILE_ERROR_GROUP_NOT_FOUND);
 951   g_assert (value == NULL);
 952   g_key_file_free (keyfile);
 953
 954   keyfile = g_key_file_new ();
 955   /*g_key_file_set_string (keyfile, "a]b", "key1", "123");*/
 956   value = g_key_file_get_string (keyfile, "a]b", "key1", &error);
 957   check_error (&error,
 958                G_KEY_FILE_ERROR,
 959                G_KEY_FILE_ERROR_GROUP_NOT_FOUND);
 960   g_assert (value == NULL);
 961   g_key_file_free (keyfile);
 962
 963   keyfile = g_key_file_new ();
 964   /*g_key_file_set_string (keyfile, "a\tb", "key1", "123");*/
 965   value = g_key_file_get_string (keyfile, "a\tb", "key1", &error);
 966   check_error (&error,
 967                G_KEY_FILE_ERROR,
 968                G_KEY_FILE_ERROR_GROUP_NOT_FOUND);
 969   g_assert (value == NULL);
 970   g_key_file_free (keyfile);
 971
 972   keyfile = g_key_file_new ();
 973   g_key_file_set_string (keyfile, "\xc2\xbd", "key1", "123");
 974   check_string_value (keyfile, "\xc2\xbd", "key1", "123");
 975   g_key_file_free (keyfile);
 976 }
 977
 978 static void
 979 test_key_names (void)
 980 {
 981   GKeyFile *keyfile;
 982   GError *error = NULL;
 983   const gchar *data;
 984   gchar *value;
 985
 986   /* [ in key name */
 987   data = "[a]\n"
 988          "key[=123\n";
 989   keyfile = g_key_file_new ();
 990   g_key_file_load_from_data (keyfile, data, -1, 0, &error);
 991   g_key_file_free (keyfile);
 992   check_error (&error,
 993                G_KEY_FILE_ERROR,
 994                G_KEY_FILE_ERROR_PARSE);
 995
 996   /* empty key name */
 997   data = "[a]\n"
 998          " =123\n";
 999   keyfile = g_key_file_new ();
1000   g_key_file_load_from_data (keyfile, data, -1, 0, &error);
1001   g_key_file_free (keyfile);
1002   check_error (&error,
1003                G_KEY_FILE_ERROR,
1004                G_KEY_FILE_ERROR_PARSE);
1005
1006   /* empty key name */
1007   data = "[a]\n"
1008          " [de] =123\n";
1009   keyfile = g_key_file_new ();
1010   g_key_file_load_from_data (keyfile, data, -1, 0, &error);
1011   g_key_file_free (keyfile);
1012   check_error (&error,
1013                G_KEY_FILE_ERROR,
1014                G_KEY_FILE_ERROR_PARSE);
1015
1016   /* bad locale suffix */
1017   data = "[a]\n"
1018          "foo[@#!&%]=123\n";
1019   keyfile = g_key_file_new ();
1020   g_key_file_load_from_data (keyfile, data, -1, 0, &error);
1021   g_key_file_free (keyfile);
1022   check_error (&error,
1023                G_KEY_FILE_ERROR,
1024                G_KEY_FILE_ERROR_PARSE);
1025
1026   /* initial space */
1027   data = "[a]\n"
1028          " foo=123\n";
1029   keyfile = g_key_file_new ();
1030   g_key_file_load_from_data (keyfile, data, -1, 0, &error);
1031   check_no_error (&error);
1032   check_string_value (keyfile, "a", "foo", "123");
1033   g_key_file_free (keyfile);
1034
1035   /* final space */
1036   data = "[a]\n"
1037          "foo =123\n";
1038   keyfile = g_key_file_new ();
1039   g_key_file_load_from_data (keyfile, data, -1, 0, &error);
1040   check_no_error (&error);
1041   check_string_value (keyfile, "a", "foo", "123");
1042   g_key_file_free (keyfile);
1043
1044   /* inner space */
1045   data = "[a]\n"
1046          "foo bar=123\n";
1047   keyfile = g_key_file_new ();
1048   g_key_file_load_from_data (keyfile, data, -1, 0, &error);
1049   check_no_error (&error);
1050   check_string_value (keyfile, "a", "foo bar", "123");
1051   g_key_file_free (keyfile);
1052
1053   /* inner space */
1054   data = "[a]\n"
1055          "foo [de] =123\n";
1056   keyfile = g_key_file_new ();
1057   g_key_file_load_from_data (keyfile, data, -1, 0, &error);
1058   check_error (&error,
1059                G_KEY_FILE_ERROR,
1060                G_KEY_FILE_ERROR_PARSE);
1061   g_key_file_free (keyfile);
1062
1063   /* control char in key name */
1064   data = "[a]\n"
1065          "key\tfoo=123\n";
1066   keyfile = g_key_file_new ();
1067   g_key_file_load_from_data (keyfile, data, -1, 0, &error);
1068   g_key_file_free (keyfile);
1069   check_no_error (&error);
1070
1071   /* Unicode in key name */
1072   data = "[a]\n"
1073          "\xc2\xbd=123\n";
1074   keyfile = g_key_file_new ();
1075   g_key_file_load_from_data (keyfile, data, -1, 0, &error);
1076   g_key_file_free (keyfile);
1077   check_no_error (&error);
1078
1079   keyfile = g_key_file_new ();
1080   g_key_file_set_string (keyfile, "a", "x", "123");
1081   /*g_key_file_set_string (keyfile, "a", "key=", "123");*/
1082   value = g_key_file_get_string (keyfile, "a", "key=", &error);
1083   check_error (&error,
1084                G_KEY_FILE_ERROR,
1085                G_KEY_FILE_ERROR_KEY_NOT_FOUND);
1086   g_key_file_free (keyfile);
1087
1088   keyfile = g_key_file_new ();
1089   g_key_file_set_string (keyfile, "a", "x", "123");
1090   /*g_key_file_set_string (keyfile, "a", "key[", "123");*/
1091   value = g_key_file_get_string (keyfile, "a", "key[", &error);
1092   check_error (&error,
1093                G_KEY_FILE_ERROR,
1094                G_KEY_FILE_ERROR_KEY_NOT_FOUND);
1095   g_key_file_free (keyfile);
1096
1097   keyfile = g_key_file_new ();
1098   g_key_file_set_string (keyfile, "a", "x", "123");
1099   g_key_file_set_string (keyfile, "a", "key\tfoo", "123");
1100   value = g_key_file_get_string (keyfile, "a", "key\tfoo", &error);
1101   check_no_error (&error);
1102   g_free (value);
1103   g_key_file_free (keyfile);
1104
1105   keyfile = g_key_file_new ();
1106   g_key_file_set_string (keyfile, "a", "x", "123");
1107   /*g_key_file_set_string (keyfile, "a", " key", "123");*/
1108   value = g_key_file_get_string (keyfile, "a", " key", &error);
1109   check_error (&error,
1110                G_KEY_FILE_ERROR,
1111                G_KEY_FILE_ERROR_KEY_NOT_FOUND);
1112   g_key_file_free (keyfile);
1113
1114   keyfile = g_key_file_new ();
1115   g_key_file_set_string (keyfile, "a", "x", "123");
1116
1117   /* Unicode key */
1118   g_key_file_set_string (keyfile, "a", "\xc2\xbd", "123");
1119   check_string_value (keyfile, "a", "\xc2\xbd", "123");
1120
1121   /* Keys with / + . (as used by the gnome-vfs mime cache) */
1122   g_key_file_set_string (keyfile, "a", "foo/bar", "/");
1123   check_string_value (keyfile, "a", "foo/bar", "/");
1124   g_key_file_set_string (keyfile, "a", "foo+bar", "+");
1125   check_string_value (keyfile, "a", "foo+bar", "+");
1126   g_key_file_set_string (keyfile, "a", "foo.bar", ".");
1127   check_string_value (keyfile, "a", "foo.bar", ".");
1128
1129   g_key_file_free (keyfile);
1130 }
1131
1132 static void
1133 test_duplicate_keys (void)
1134 {
1135   GKeyFile *keyfile;
1136   const gchar *data =
1137     "[1]\n"
1138     "key1=123\n"
1139     "key1=345\n";
1140
1141   keyfile = load_data (data, 0);
1142   check_string_value (keyfile, "1", "key1", "345");
1143
1144   g_key_file_free (keyfile);
1145 }
1146
1147 static void
1148 test_duplicate_groups (void)
1149 {
1150   GKeyFile *keyfile;
1151   const gchar *data =
1152     "[Desktop Entry]\n"
1153     "key1=123\n"
1154     "[Desktop Entry]\n"
1155     "key2=123\n";
1156
1157   g_test_bug ("157877");
1158
1159   keyfile = load_data (data, 0);
1160   check_string_value (keyfile, "Desktop Entry", "key1", "123");
1161   check_string_value (keyfile, "Desktop Entry", "key2", "123");
1162
1163   g_key_file_free (keyfile);
1164 }
1165
1166 static void
1167 test_duplicate_groups2 (void)
1168 {
1169   GKeyFile *keyfile;
1170   const gchar *data =
1171     "[A]\n"
1172     "foo=bar\n"
1173     "[B]\n"
1174     "foo=baz\n"
1175     "[A]\n"
1176     "foo=bang\n";
1177
1178   g_test_bug ("385910");
1179
1180   keyfile = load_data (data, 0);
1181   check_string_value (keyfile, "A", "foo", "bang");
1182   check_string_value (keyfile, "B", "foo", "baz");
1183
1184   g_key_file_free (keyfile);
1185 }
1186
1187 static void
1188 test_reload_idempotency (void)
1189 {
1190   static const gchar *original_data=""
1191     "# Top comment\n"
1192     "\n"
1193     "# First comment\n"
1194     "[first]\n"
1195     "key=value\n"
1196     "# A random comment in the first group\n"
1197     "anotherkey=anothervalue\n"
1198     "# Second comment - one line\n"
1199     "[second]\n"
1200     "# Third comment - two lines\n"
1201     "# Third comment - two lines\n"
1202     "[third]\n"
1203     "blank_line=1\n"
1204     "\n"
1205     "blank_lines=2\n"
1206     "\n\n"
1207     "[fourth]\n"
1208     "[fifth]\n";
1209   GKeyFile *keyfile;
1210   GError *error = NULL;
1211   gchar *data1, *data2;
1212   gsize len1, len2;
1213
1214   g_test_bug ("420686");
1215
1216   /* check that we only insert a single new line between groups */
1217   keyfile = g_key_file_new ();
1218   g_key_file_load_from_data (keyfile,
1219                              original_data, strlen(original_data),
1220                              G_KEY_FILE_KEEP_COMMENTS,
1221                              &error);
1222   check_no_error (&error);
1223
1224   data1 = g_key_file_to_data (keyfile, &len1, &error);
1225   g_assert (data1 != NULL);
1226   g_key_file_free (keyfile);
1227
1228   keyfile = g_key_file_new ();
1229   g_key_file_load_from_data (keyfile,
1230                              data1, len1,
1231                              G_KEY_FILE_KEEP_COMMENTS,
1232                              &error);
1233   check_no_error (&error);
1234
1235   data2 = g_key_file_to_data (keyfile, &len2, &error);
1236   g_assert (data2 != NULL);
1237   g_key_file_free (keyfile);
1238
1239   g_assert_cmpstr (data1, ==, data2);
1240
1241   g_free (data2);
1242   g_free (data1);
1243 }
1244
1245 static const char int64_data[] =
1246 "[bees]\n"
1247 "a=1\n"
1248 "b=2\n"
1249 "c=123456789123456789\n"
1250 "d=-123456789123456789\n";
1251
1252 static void
1253 test_int64 (void)
1254 {
1255   GKeyFile *file;
1256   gboolean ok;
1257   guint64 c;
1258   gint64 d;
1259   gchar *value;
1260
1261   g_test_bug ("614864");
1262
1263   file = g_key_file_new ();
1264
1265   ok = g_key_file_load_from_data (file, int64_data, strlen (int64_data),
1266       0, NULL);
1267   g_assert (ok);
1268
1269   c = g_key_file_get_uint64 (file, "bees", "c", NULL);
1270   g_assert (c == G_GUINT64_CONSTANT (123456789123456789));
1271
1272   d = g_key_file_get_int64 (file, "bees", "d", NULL);
1273   g_assert (d == G_GINT64_CONSTANT (-123456789123456789));
1274
1275   g_key_file_set_uint64 (file, "bees", "c",
1276       G_GUINT64_CONSTANT (987654321987654321));
1277   value = g_key_file_get_value (file, "bees", "c", NULL);
1278   g_assert_cmpstr (value, ==, "987654321987654321");
1279   g_free (value);
1280
1281   g_key_file_set_int64 (file, "bees", "d",
1282       G_GINT64_CONSTANT (-987654321987654321));
1283   value = g_key_file_get_value (file, "bees", "d", NULL);
1284   g_assert_cmpstr (value, ==, "-987654321987654321");
1285   g_free (value);
1286
1287   g_key_file_free (file);
1288 }
1289
1290 static void
1291 test_load (void)
1292 {
1293   GKeyFile *file;
1294   GError *error;
1295   gboolean bools[2] = { TRUE, FALSE };
1296
1297   file = g_key_file_new ();
1298   error = NULL;
1299   g_assert (g_key_file_load_from_data_dirs (file, "keyfiletest.ini", NULL, 0, &error));
1300   g_assert_no_error (error);
1301
1302   g_key_file_set_locale_string (file, "test", "key4", "de", "Vierter Schlüssel");
1303   g_key_file_set_boolean_list (file, "test", "key5", bools, 2);
1304   g_key_file_set_integer (file, "test", "key6", 22);
1305   g_key_file_set_double (file, "test", "key7", 2.5);
1306   g_key_file_set_comment (file, "test", "key7", "some float", NULL);
1307   g_key_file_set_comment (file, "test", NULL, "the test group", NULL);
1308   g_key_file_set_comment (file, NULL, NULL, "top comment", NULL);
1309
1310   g_key_file_free (file);
1311 }
1312
1313 static void
1314 test_non_utf8 (void)
1315 {
1316   GKeyFile *file;
1317   static const char data[] =
1318 "[group]\n"
1319 "a=\230\230\230\n"
1320 "b=a;b;\230\230\230;\n"
1321 "c=a\\\n";
1322   gboolean ok;
1323   GError *error;
1324   gchar *s;
1325   gchar **l;
1326
1327   file = g_key_file_new ();
1328
1329   ok = g_key_file_load_from_data (file, data, strlen (data), 0, NULL);
1330   g_assert (ok);
1331
1332   error = NULL;
1333   s = g_key_file_get_string (file, "group", "a", &error);
1334   g_assert_error (error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_UNKNOWN_ENCODING);
1335   g_assert (s == NULL);
1336
1337   g_clear_error (&error);
1338   l = g_key_file_get_string_list (file, "group", "b", NULL, &error);
1339   g_assert_error (error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_UNKNOWN_ENCODING);
1340   g_assert (l == NULL);
1341
1342   g_clear_error (&error);
1343   l = g_key_file_get_string_list (file, "group", "c", NULL, &error);
1344   g_assert_error (error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_INVALID_VALUE);
1345   g_assert (l == NULL);
1346
1347   g_clear_error (&error);
1348
1349   g_key_file_free (file);
1350 }
1351
1352 #ifndef SRCDIR
1353 #define SRCDIR "."
1354 #endif
1355
1356 static void
1357 test_page_boundary (void)
1358 {
1359   GKeyFile *file;
1360   GError *error;
1361   gint i;
1362
1363 #define GROUP "main_section"
1364 #define KEY_PREFIX "fill_abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvw_"
1365 #define FIRST_KEY 10
1366 #define LAST_KEY 99
1367 #define VALUE 92
1368
1369   g_test_bug ("640695");
1370
1371   file = g_key_file_new ();
1372
1373   error = NULL;
1374   g_key_file_load_from_file (file, SRCDIR "/pages.ini", G_KEY_FILE_NONE, &error);
1375   g_assert_no_error (error);
1376
1377   for (i = FIRST_KEY; i <= LAST_KEY; i++)
1378     {
1379       gchar *key;
1380       gint val;
1381
1382       key = g_strdup_printf (KEY_PREFIX "%d", i);
1383       val = g_key_file_get_integer (file, GROUP, key, &error);
1384       g_free (key);
1385       g_assert_no_error (error);
1386       g_assert_cmpint (val, ==, VALUE);
1387     }
1388
1389 }
1390
1391 int
1392 main (int argc, char *argv[])
1393 {
1394   g_setenv ("XDG_DATA_HOME", SRCDIR, TRUE);
1395
1396   g_test_init (&argc, &argv, NULL);
1397   g_test_bug_base ("http://bugzilla.gnome.org/");
1398
1399   g_test_add_func ("/keyfile/line-ends", test_line_ends);
1400   g_test_add_func ("/keyfile/whitespace", test_whitespace);
1401   g_test_add_func ("/keyfile/comments", test_comments);
1402   g_test_add_func ("/keyfile/listing", test_listing);
1403   g_test_add_func ("/keyfile/string", test_string);
1404   g_test_add_func ("/keyfile/boolean", test_boolean);
1405   g_test_add_func ("/keyfile/number", test_number);
1406   g_test_add_func ("/keyfile/locale-string", test_locale_string);
1407   g_test_add_func ("/keyfile/lists", test_lists);
1408   g_test_add_func ("/keyfile/lists-set-get", test_lists_set_get);
1409   g_test_add_func ("/keyfile/group-remove", test_group_remove);
1410   g_test_add_func ("/keyfile/key-remove", test_key_remove);
1411   g_test_add_func ("/keyfile/groups", test_groups);
1412   g_test_add_func ("/keyfile/duplicate-keys", test_duplicate_keys);
1413   g_test_add_func ("/keyfile/duplicate-groups", test_duplicate_groups);
1414   g_test_add_func ("/keyfile/duplicate-groups2", test_duplicate_groups2);
1415   g_test_add_func ("/keyfile/group-names", test_group_names);
1416   g_test_add_func ("/keyfile/key-names", test_key_names);
1417   g_test_add_func ("/keyfile/reload", test_reload_idempotency);
1418   g_test_add_func ("/keyfile/int64", test_int64);
1419   g_test_add_func ("/keyfile/load", test_load);
1420   g_test_add_func ("/keyfile/non-utf8", test_non_utf8);
1421   g_test_add_func ("/keyfile/page-boundary", test_page_boundary);
1422
1423   return g_test_run ();
1424 }