glib/tests/keyfile.c

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