gio/tests/gsettings.c

   1 #include <stdlib.h>
   2 #include <locale.h>
   3 #include <libintl.h>
   4 #include <gio/gio.h>
   5 #include <gstdio.h>
   6 #define G_SETTINGS_ENABLE_BACKEND
   7 #include <gio/gsettingsbackend.h>
   8
   9 #include "testenum.h"
  10
  11 static gboolean backend_set;
  12
  13 /* These tests rely on the schemas in org.gtk.test.gschema.xml
  14  * to be compiled and installed in the same directory.
  15  */
  16
  17 static void
  18 check_and_free (GVariant    *value,
  19                 const gchar *expected)
  20 {
  21   gchar *printed;
  22
  23   printed = g_variant_print (value, TRUE);
  24   g_assert_cmpstr (printed, ==, expected);
  25   g_free (printed);
  26
  27   g_variant_unref (value);
  28 }
  29
  30
  31 /* Just to get warmed up: Read and set a string, and
  32  * verify that can read the changed string back
  33  */
  34 static void
  35 test_basic (void)
  36 {
  37   gchar *str = NULL;
  38   GSettings *settings;
  39
  40   settings = g_settings_new ("org.gtk.test");
  41
  42   g_object_get (settings, "schema", &str, NULL);
  43   g_assert_cmpstr (str, ==, "org.gtk.test");
  44   g_free (str);
  45
  46   g_settings_get (settings, "greeting", "s", &str);
  47   g_assert_cmpstr (str, ==, "Hello, earthlings");
  48   g_free (str);
  49
  50   g_settings_set (settings, "greeting", "s", "goodbye world");
  51   g_settings_get (settings, "greeting", "s", &str);
  52   g_assert_cmpstr (str, ==, "goodbye world");
  53   g_free (str);
  54   str = NULL;
  55
  56   if (!backend_set && g_test_undefined ())
  57     {
  58       if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDERR))
  59         {
  60           settings = g_settings_new ("org.gtk.test");
  61           g_settings_set (settings, "greeting", "i", 555);
  62           abort ();
  63         }
  64       g_test_trap_assert_failed ();
  65       g_test_trap_assert_stderr ("*g_settings_set_value*expects type*");
  66     }
  67
  68   g_settings_get (settings, "greeting", "s", &str);
  69   g_assert_cmpstr (str, ==, "goodbye world");
  70   g_free (str);
  71   str = NULL;
  72
  73   g_settings_reset (settings, "greeting");
  74   str = g_settings_get_string (settings, "greeting");
  75   g_assert_cmpstr (str, ==, "Hello, earthlings");
  76   g_free (str);
  77
  78   g_settings_set (settings, "greeting", "s", "this is the end");
  79   g_object_unref (settings);
  80 }
  81
  82 /* Check that we get an error when getting a key
  83  * that is not in the schema
  84  */
  85 static void
  86 test_unknown_key (void)
  87 {
  88   if (!g_test_undefined ())
  89     return;
  90
  91   if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDERR))
  92     {
  93       GSettings *settings;
  94       GVariant *value;
  95
  96       settings = g_settings_new ("org.gtk.test");
  97       value = g_settings_get_value (settings, "no_such_key");
  98
  99       g_assert (value == NULL);
 100
 101       g_object_unref (settings);
 102     }
 103   g_test_trap_assert_failed ();
 104   g_test_trap_assert_stderr ("*does not contain*");
 105 }
 106
 107 /* Check that we get an error when the schema
 108  * has not been installed
 109  */
 110 static void
 111 test_no_schema (void)
 112 {
 113   if (!g_test_undefined ())
 114     return;
 115
 116   if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDERR))
 117     {
 118       GSettings *settings;
 119
 120       settings = g_settings_new ("no.such.schema");
 121
 122       g_assert (settings == NULL);
 123     }
 124
 125   g_test_trap_assert_failed ();
 126   g_test_trap_assert_stderr ("*Settings schema 'no.such.schema' is not installed*");
 127 }
 128
 129 /* Check that we get an error when passing a type string
 130  * that does not match the schema
 131  */
 132 static void
 133 test_wrong_type (void)
 134 {
 135   if (!g_test_undefined ())
 136     return;
 137
 138   if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDERR))
 139     {
 140       GSettings *settings;
 141       gchar *str = NULL;
 142
 143       settings = g_settings_new ("org.gtk.test");
 144
 145       g_settings_get (settings, "greeting", "o", &str);
 146
 147       g_assert (str == NULL);
 148     }
 149   g_test_trap_assert_failed ();
 150   g_test_trap_assert_stderr ("*CRITICAL*");
 151
 152   if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDERR))
 153     {
 154       GSettings *settings;
 155
 156       settings = g_settings_new ("org.gtk.test");
 157
 158       g_settings_set (settings, "greeting", "o", "/a/path");
 159     }
 160   g_test_trap_assert_failed ();
 161   g_test_trap_assert_stderr ("*CRITICAL*");
 162 }
 163
 164 /* Check errors with explicit paths */
 165 static void
 166 test_wrong_path (void)
 167 {
 168   if (!g_test_undefined ())
 169     return;
 170
 171   if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDERR))
 172     {
 173       GSettings *settings G_GNUC_UNUSED;
 174
 175       settings = g_settings_new_with_path ("org.gtk.test", "/wrong-path/");
 176     }
 177
 178   g_test_trap_assert_failed ();
 179   g_test_trap_assert_stderr ("*but path * specified by schema*");
 180 }
 181
 182 static void
 183 test_no_path (void)
 184 {
 185   if (!g_test_undefined ())
 186     return;
 187
 188   if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDERR))
 189     {
 190       GSettings *settings G_GNUC_UNUSED;
 191
 192       settings = g_settings_new ("org.gtk.test.no-path");
 193     }
 194
 195   g_test_trap_assert_failed ();
 196   g_test_trap_assert_stderr ("*attempting to create schema * without a path**");
 197 }
 198
 199
 200 /* Check that we can successfully read and set the full
 201  * range of all basic types
 202  */
 203 static void
 204 test_basic_types (void)
 205 {
 206   GSettings *settings;
 207   gboolean b;
 208   guint8 byte;
 209   gint16 i16;
 210   guint16 u16;
 211   gint32 i32;
 212   guint32 u32;
 213   gint64 i64;
 214   guint64 u64;
 215   gdouble d;
 216   gchar *str;
 217
 218   settings = g_settings_new ("org.gtk.test.basic-types");
 219
 220   g_settings_get (settings, "test-boolean", "b", &b);
 221   g_assert_cmpint (b, ==, 1);
 222
 223   g_settings_set (settings, "test-boolean", "b", 0);
 224   g_settings_get (settings, "test-boolean", "b", &b);
 225   g_assert_cmpint (b, ==, 0);
 226
 227   g_settings_get (settings, "test-byte", "y", &byte);
 228   g_assert_cmpint (byte, ==, 25);
 229
 230   g_settings_set (settings, "test-byte", "y", G_MAXUINT8);
 231   g_settings_get (settings, "test-byte", "y", &byte);
 232   g_assert_cmpint (byte, ==, G_MAXUINT8);
 233
 234   g_settings_get (settings, "test-int16", "n", &i16);
 235   g_assert_cmpint (i16, ==, -1234);
 236
 237   g_settings_set (settings, "test-int16", "n", G_MININT16);
 238   g_settings_get (settings, "test-int16", "n", &i16);
 239   g_assert_cmpint (i16, ==, G_MININT16);
 240
 241   g_settings_set (settings, "test-int16", "n", G_MAXINT16);
 242   g_settings_get (settings, "test-int16", "n", &i16);
 243   g_assert_cmpint (i16, ==, G_MAXINT16);
 244
 245   g_settings_get (settings, "test-uint16", "q", &u16);
 246   g_assert_cmpuint (u16, ==, 1234);
 247
 248   g_settings_set (settings, "test-uint16", "q", G_MAXUINT16);
 249   g_settings_get (settings, "test-uint16", "q", &u16);
 250   g_assert_cmpuint (u16, ==, G_MAXUINT16);
 251
 252   g_settings_get (settings, "test-int32", "i", &i32);
 253   g_assert_cmpint (i32, ==, -123456);
 254
 255   g_settings_set (settings, "test-int32", "i", G_MININT32);
 256   g_settings_get (settings, "test-int32", "i", &i32);
 257   g_assert_cmpint (i32, ==, G_MININT32);
 258
 259   g_settings_set (settings, "test-int32", "i", G_MAXINT32);
 260   g_settings_get (settings, "test-int32", "i", &i32);
 261   g_assert_cmpint (i32, ==, G_MAXINT32);
 262
 263   g_settings_get (settings, "test-uint32", "u", &u32);
 264   g_assert_cmpuint (u32, ==, 123456);
 265
 266   g_settings_set (settings, "test-uint32", "u", G_MAXUINT32);
 267   g_settings_get (settings, "test-uint32", "u", &u32);
 268   g_assert_cmpuint (u32, ==, G_MAXUINT32);
 269
 270   g_settings_get (settings, "test-int64", "x", &i64);
 271   g_assert_cmpuint (i64, ==, -123456789);
 272
 273   g_settings_set (settings, "test-int64", "x", G_MININT64);
 274   g_settings_get (settings, "test-int64", "x", &i64);
 275   g_assert_cmpuint (i64, ==, G_MININT64);
 276
 277   g_settings_set (settings, "test-int64", "x", G_MAXINT64);
 278   g_settings_get (settings, "test-int64", "x", &i64);
 279   g_assert_cmpuint (i64, ==, G_MAXINT64);
 280
 281   g_settings_get (settings, "test-uint64", "t", &u64);
 282   g_assert_cmpuint (u64, ==, 123456789);
 283
 284   g_settings_set (settings, "test-uint64", "t", G_MAXUINT64);
 285   g_settings_get (settings, "test-uint64", "t", &u64);
 286   g_assert_cmpuint (u64, ==, G_MAXUINT64);
 287
 288   g_settings_get (settings, "test-double", "d", &d);
 289   g_assert_cmpfloat (d, ==, 123.456);
 290
 291   g_settings_set (settings, "test-double", "d", G_MINDOUBLE);
 292   g_settings_get (settings, "test-double", "d", &d);
 293   g_assert_cmpfloat (d, ==, G_MINDOUBLE);
 294
 295   g_settings_set (settings, "test-double", "d", G_MAXDOUBLE);
 296   g_settings_get (settings, "test-double", "d", &d);
 297   g_assert_cmpfloat (d, ==, G_MAXDOUBLE);
 298
 299   g_settings_get (settings, "test-string", "s", &str);
 300   g_assert_cmpstr (str, ==, "a string, it seems");
 301   g_free (str);
 302   str = NULL;
 303
 304   g_settings_get (settings, "test-objectpath", "o", &str);
 305   g_assert_cmpstr (str, ==, "/a/object/path");
 306   g_object_unref (settings);
 307   g_free (str);
 308   str = NULL;
 309 }
 310
 311 /* Check that we can read an set complex types like
 312  * tuples, arrays and dictionaries
 313  */
 314 static void
 315 test_complex_types (void)
 316 {
 317   GSettings *settings;
 318   gchar *s;
 319   gint i1, i2;
 320   GVariantIter *iter = NULL;
 321
 322   settings = g_settings_new ("org.gtk.test.complex-types");
 323
 324   g_settings_get (settings, "test-tuple", "(s(ii))", &s, &i1, &i2);
 325   g_assert_cmpstr (s, ==, "one");
 326   g_assert_cmpint (i1,==, 2);
 327   g_assert_cmpint (i2,==, 3);
 328   g_free (s) ;
 329   s = NULL;
 330
 331   g_settings_set (settings, "test-tuple", "(s(ii))", "none", 0, 0);
 332   g_settings_get (settings, "test-tuple", "(s(ii))", &s, &i1, &i2);
 333   g_assert_cmpstr (s, ==, "none");
 334   g_assert_cmpint (i1,==, 0);
 335   g_assert_cmpint (i2,==, 0);
 336   g_free (s);
 337   s = NULL;
 338
 339   g_settings_get (settings, "test-array", "ai", &iter);
 340   g_assert_cmpint (g_variant_iter_n_children (iter), ==, 6);
 341   g_assert (g_variant_iter_next (iter, "i", &i1));
 342   g_assert_cmpint (i1, ==, 0);
 343   g_assert (g_variant_iter_next (iter, "i", &i1));
 344   g_assert_cmpint (i1, ==, 1);
 345   g_assert (g_variant_iter_next (iter, "i", &i1));
 346   g_assert_cmpint (i1, ==, 2);
 347   g_assert (g_variant_iter_next (iter, "i", &i1));
 348   g_assert_cmpint (i1, ==, 3);
 349   g_assert (g_variant_iter_next (iter, "i", &i1));
 350   g_assert_cmpint (i1, ==, 4);
 351   g_assert (g_variant_iter_next (iter, "i", &i1));
 352   g_assert_cmpint (i1, ==, 5);
 353   g_assert (!g_variant_iter_next (iter, "i", &i1));
 354   g_variant_iter_free (iter);
 355
 356   g_object_unref (settings);
 357 }
 358
 359 static gboolean changed_cb_called;
 360
 361 static void
 362 changed_cb (GSettings   *settings,
 363             const gchar *key,
 364             gpointer     data)
 365 {
 366   changed_cb_called = TRUE;
 367
 368   g_assert_cmpstr (key, ==, data);
 369 }
 370
 371 /* Test that basic change notification with the changed signal works.
 372  */
 373 static void
 374 test_changes (void)
 375 {
 376   GSettings *settings;
 377   GSettings *settings2;
 378
 379   settings = g_settings_new ("org.gtk.test");
 380
 381   g_signal_connect (settings, "changed",
 382                     G_CALLBACK (changed_cb), "greeting");
 383
 384   changed_cb_called = FALSE;
 385
 386   g_settings_set (settings, "greeting", "s", "new greeting");
 387   g_assert (changed_cb_called);
 388
 389   settings2 = g_settings_new ("org.gtk.test");
 390
 391   changed_cb_called = FALSE;
 392
 393   g_settings_set (settings2, "greeting", "s", "hi");
 394   g_assert (changed_cb_called);
 395
 396   g_object_unref (settings2);
 397   g_object_unref (settings);
 398 }
 399
 400 static gboolean changed_cb_called2;
 401
 402 static void
 403 changed_cb2 (GSettings   *settings,
 404              const gchar *key,
 405              gpointer     data)
 406 {
 407   gboolean *p = data;
 408
 409   *p = TRUE;
 410 }
 411
 412 /* Test that changes done to a delay-mode instance
 413  * don't appear to the outside world until apply. Also
 414  * check that we get change notification when they are
 415  * applied.
 416  * Also test that the has-unapplied property is properly
 417  * maintained.
 418  */
 419 static void
 420 test_delay_apply (void)
 421 {
 422   GSettings *settings;
 423   GSettings *settings2;
 424   gchar *str;
 425
 426   settings = g_settings_new ("org.gtk.test");
 427   settings2 = g_settings_new ("org.gtk.test");
 428
 429   g_settings_set (settings2, "greeting", "s", "top o' the morning");
 430
 431   changed_cb_called = FALSE;
 432   changed_cb_called2 = FALSE;
 433
 434   g_signal_connect (settings, "changed",
 435                     G_CALLBACK (changed_cb2), &changed_cb_called);
 436   g_signal_connect (settings2, "changed",
 437                     G_CALLBACK (changed_cb2), &changed_cb_called2);
 438
 439   g_settings_delay (settings);
 440
 441   g_settings_set (settings, "greeting", "s", "greetings from test_delay_apply");
 442
 443   g_assert (changed_cb_called);
 444   g_assert (!changed_cb_called2);
 445
 446   g_settings_get (settings, "greeting", "s", &str);
 447   g_assert_cmpstr (str, ==, "greetings from test_delay_apply");
 448   g_free (str);
 449   str = NULL;
 450
 451   g_settings_get (settings2, "greeting", "s", &str);
 452   g_assert_cmpstr (str, ==, "top o' the morning");
 453   g_free (str);
 454   str = NULL;
 455
 456   g_assert (g_settings_get_has_unapplied (settings));
 457   g_assert (!g_settings_get_has_unapplied (settings2));
 458
 459   changed_cb_called = FALSE;
 460   changed_cb_called2 = FALSE;
 461
 462   g_settings_apply (settings);
 463
 464   g_assert (!changed_cb_called);
 465   g_assert (changed_cb_called2);
 466
 467   g_settings_get (settings, "greeting", "s", &str);
 468   g_assert_cmpstr (str, ==, "greetings from test_delay_apply");
 469   g_free (str);
 470   str = NULL;
 471
 472   g_settings_get (settings2, "greeting", "s", &str);
 473   g_assert_cmpstr (str, ==, "greetings from test_delay_apply");
 474   g_free (str);
 475   str = NULL;
 476
 477   g_assert (!g_settings_get_has_unapplied (settings));
 478   g_assert (!g_settings_get_has_unapplied (settings2));
 479
 480   g_object_unref (settings2);
 481   g_object_unref (settings);
 482 }
 483
 484 /* Test that reverting unapplied changes in a delay-apply
 485  * settings instance works.
 486  */
 487 static void
 488 test_delay_revert (void)
 489 {
 490   GSettings *settings;
 491   GSettings *settings2;
 492   gchar *str;
 493
 494   settings = g_settings_new ("org.gtk.test");
 495   settings2 = g_settings_new ("org.gtk.test");
 496
 497   g_settings_set (settings2, "greeting", "s", "top o' the morning");
 498
 499   g_settings_delay (settings);
 500
 501   g_settings_set (settings, "greeting", "s", "greetings from test_delay_revert");
 502
 503   g_settings_get (settings, "greeting", "s", &str);
 504   g_assert_cmpstr (str, ==, "greetings from test_delay_revert");
 505   g_free (str);
 506   str = NULL;
 507
 508   g_settings_get (settings2, "greeting", "s", &str);
 509   g_assert_cmpstr (str, ==, "top o' the morning");
 510   g_free (str);
 511   str = NULL;
 512
 513   g_assert (g_settings_get_has_unapplied (settings));
 514
 515   g_settings_revert (settings);
 516
 517   g_assert (!g_settings_get_has_unapplied (settings));
 518
 519   g_settings_get (settings, "greeting", "s", &str);
 520   g_assert_cmpstr (str, ==, "top o' the morning");
 521   g_free (str);
 522   str = NULL;
 523
 524   g_settings_get (settings2, "greeting", "s", &str);
 525   g_assert_cmpstr (str, ==, "top o' the morning");
 526   g_free (str);
 527   str = NULL;
 528
 529   g_object_unref (settings2);
 530   g_object_unref (settings);
 531 }
 532
 533 static void
 534 keys_changed_cb (GSettings    *settings,
 535                  const GQuark *keys,
 536                  gint          n_keys)
 537 {
 538   gchar *str;
 539
 540   g_assert_cmpint (n_keys, ==, 2);
 541
 542   g_assert ((keys[0] == g_quark_from_static_string ("greeting") &&
 543              keys[1] == g_quark_from_static_string ("farewell")) ||
 544             (keys[1] == g_quark_from_static_string ("greeting") &&
 545              keys[0] == g_quark_from_static_string ("farewell")));
 546
 547   g_settings_get (settings, "greeting", "s", &str);
 548   g_assert_cmpstr (str, ==, "greetings from test_atomic");
 549   g_free (str);
 550   str = NULL;
 551
 552   g_settings_get (settings, "farewell", "s", &str);
 553   g_assert_cmpstr (str, ==, "atomic bye-bye");
 554   g_free (str);
 555   str = NULL;
 556 }
 557
 558 /* Check that delay-applied changes appear atomically.
 559  * More specifically, verify that all changed keys appear
 560  * with their new value while handling the change-event signal.
 561  */
 562 static void
 563 test_atomic (void)
 564 {
 565   GSettings *settings;
 566   GSettings *settings2;
 567   gchar *str;
 568
 569   settings = g_settings_new ("org.gtk.test");
 570   settings2 = g_settings_new ("org.gtk.test");
 571
 572   g_settings_set (settings2, "greeting", "s", "top o' the morning");
 573
 574   changed_cb_called = FALSE;
 575   changed_cb_called2 = FALSE;
 576
 577   g_signal_connect (settings2, "change-event",
 578                     G_CALLBACK (keys_changed_cb), NULL);
 579
 580   g_settings_delay (settings);
 581
 582   g_settings_set (settings, "greeting", "s", "greetings from test_atomic");
 583   g_settings_set (settings, "farewell", "s", "atomic bye-bye");
 584
 585   g_settings_apply (settings);
 586
 587   g_settings_get (settings, "greeting", "s", &str);
 588   g_assert_cmpstr (str, ==, "greetings from test_atomic");
 589   g_free (str);
 590   str = NULL;
 591
 592   g_settings_get (settings, "farewell", "s", &str);
 593   g_assert_cmpstr (str, ==, "atomic bye-bye");
 594   g_free (str);
 595   str = NULL;
 596
 597   g_settings_get (settings2, "greeting", "s", &str);
 598   g_assert_cmpstr (str, ==, "greetings from test_atomic");
 599   g_free (str);
 600   str = NULL;
 601
 602   g_settings_get (settings2, "farewell", "s", &str);
 603   g_assert_cmpstr (str, ==, "atomic bye-bye");
 604   g_free (str);
 605   str = NULL;
 606
 607   g_object_unref (settings2);
 608   g_object_unref (settings);
 609 }
 610
 611 /* On Windows the interaction between the C library locale and libintl
 612  * (from GNU gettext) is not like on POSIX, so just skip these tests
 613  * for now.
 614  *
 615  * There are several issues:
 616  *
 617  * 1) The C library doesn't use LC_MESSAGES, that is implemented only
 618  * in libintl (defined in its <libintl.h>).
 619  *
 620  * 2) The locale names that setlocale() accepts and returns aren't in
 621  * the "de_DE" style, but like "German_Germany".
 622  *
 623  * 3) libintl looks at the Win32 thread locale and not the C library
 624  * locale. (And even if libintl would use the C library's locale, as
 625  * there are several alternative C library DLLs, libintl might be
 626  * linked to a different one than the application code, so they
 627  * wouldn't have the same C library locale anyway.)
 628  */
 629
 630 /* Test that translations work for schema defaults.
 631  *
 632  * This test relies on the de.po file in the same directory
 633  * to be compiled into ./de/LC_MESSAGES/test.mo
 634  */
 635 static void
 636 test_l10n (void)
 637 {
 638   GSettings *settings;
 639   gchar *str;
 640   gchar *locale;
 641
 642   bindtextdomain ("test", ".");
 643   bind_textdomain_codeset ("test", "UTF-8");
 644
 645   locale = g_strdup (setlocale (LC_MESSAGES, NULL));
 646
 647   settings = g_settings_new ("org.gtk.test.localized");
 648
 649   setlocale (LC_MESSAGES, "C");
 650   str = g_settings_get_string (settings, "error-message");
 651   setlocale (LC_MESSAGES, locale);
 652
 653   g_assert_cmpstr (str, ==, "Unnamed");
 654   g_free (str);
 655   str = NULL;
 656
 657   setlocale (LC_MESSAGES, "de_DE");
 658   str = g_settings_get_string (settings, "error-message");
 659   setlocale (LC_MESSAGES, locale);
 660
 661   g_assert_cmpstr (str, ==, "Unbenannt");
 662   g_object_unref (settings);
 663   g_free (str);
 664   str = NULL;
 665
 666   g_free (locale);
 667 }
 668
 669 /* Test that message context works as expected with translated
 670  * schema defaults. Also, verify that non-ASCII UTF-8 content
 671  * works.
 672  *
 673  * This test relies on the de.po file in the same directory
 674  * to be compiled into ./de/LC_MESSAGES/test.mo
 675  */
 676 static void
 677 test_l10n_context (void)
 678 {
 679   GSettings *settings;
 680   gchar *str;
 681   gchar *locale;
 682
 683   bindtextdomain ("test", ".");
 684   bind_textdomain_codeset ("test", "UTF-8");
 685
 686   locale = g_strdup (setlocale (LC_MESSAGES, NULL));
 687
 688   settings = g_settings_new ("org.gtk.test.localized");
 689
 690   setlocale (LC_MESSAGES, "C");
 691   g_settings_get (settings, "backspace", "s", &str);
 692   setlocale (LC_MESSAGES, locale);
 693
 694   g_assert_cmpstr (str, ==, "BackSpace");
 695   g_free (str);
 696   str = NULL;
 697
 698   setlocale (LC_MESSAGES, "de_DE");
 699   g_settings_get (settings, "backspace", "s", &str);
 700   setlocale (LC_MESSAGES, locale);
 701
 702   g_assert_cmpstr (str, ==, "Löschen");
 703   g_object_unref (settings);
 704   g_free (str);
 705   str = NULL;
 706
 707   g_free (locale);
 708 }
 709
 710 enum
 711 {
 712   PROP_0,
 713   PROP_BOOL,
 714   PROP_ANTI_BOOL,
 715   PROP_BYTE,
 716   PROP_INT16,
 717   PROP_UINT16,
 718   PROP_INT,
 719   PROP_UINT,
 720   PROP_INT64,
 721   PROP_UINT64,
 722   PROP_DOUBLE,
 723   PROP_STRING,
 724   PROP_NO_READ,
 725   PROP_NO_WRITE,
 726   PROP_STRV,
 727   PROP_ENUM
 728 };
 729
 730 typedef struct
 731 {
 732   GObject parent_instance;
 733
 734   gboolean bool_prop;
 735   gboolean anti_bool_prop;
 736   gint8 byte_prop;
 737   gint int16_prop;
 738   guint16 uint16_prop;
 739   gint int_prop;
 740   guint uint_prop;
 741   gint64 int64_prop;
 742   guint64 uint64_prop;
 743   gdouble double_prop;
 744   gchar *string_prop;
 745   gchar *no_read_prop;
 746   gchar *no_write_prop;
 747   gchar **strv_prop;
 748   guint enum_prop;
 749 } TestObject;
 750
 751 typedef struct
 752 {
 753   GObjectClass parent_class;
 754 } TestObjectClass;
 755
 756 static GType test_object_get_type (void);
 757 G_DEFINE_TYPE (TestObject, test_object, G_TYPE_OBJECT)
 758
 759 static void
 760 test_object_init (TestObject *object)
 761 {
 762 }
 763
 764 static void
 765 test_object_finalize (GObject *object)
 766 {
 767   TestObject *testo = (TestObject*)object;
 768   g_strfreev (testo->strv_prop);
 769   g_free (testo->string_prop);
 770   G_OBJECT_CLASS (test_object_parent_class)->finalize (object);
 771 }
 772
 773 static void
 774 test_object_get_property (GObject    *object,
 775                           guint       prop_id,
 776                           GValue     *value,
 777                           GParamSpec *pspec)
 778 {
 779   TestObject *test_object = (TestObject *)object;
 780
 781   switch (prop_id)
 782     {
 783     case PROP_BOOL:
 784       g_value_set_boolean (value, test_object->bool_prop);
 785       break;
 786     case PROP_ANTI_BOOL:
 787       g_value_set_boolean (value, test_object->anti_bool_prop);
 788       break;
 789     case PROP_BYTE:
 790       g_value_set_schar (value, test_object->byte_prop);
 791       break;
 792     case PROP_UINT16:
 793       g_value_set_uint (value, test_object->uint16_prop);
 794       break;
 795     case PROP_INT16:
 796       g_value_set_int (value, test_object->int16_prop);
 797       break;
 798     case PROP_INT:
 799       g_value_set_int (value, test_object->int_prop);
 800       break;
 801     case PROP_UINT:
 802       g_value_set_uint (value, test_object->uint_prop);
 803       break;
 804     case PROP_INT64:
 805       g_value_set_int64 (value, test_object->int64_prop);
 806       break;
 807     case PROP_UINT64:
 808       g_value_set_uint64 (value, test_object->uint64_prop);
 809       break;
 810     case PROP_DOUBLE:
 811       g_value_set_double (value, test_object->double_prop);
 812       break;
 813     case PROP_STRING:
 814       g_value_set_string (value, test_object->string_prop);
 815       break;
 816     case PROP_NO_WRITE:
 817       g_value_set_string (value, test_object->no_write_prop);
 818       break;
 819     case PROP_STRV:
 820       g_value_set_boxed (value, test_object->strv_prop);
 821       break;
 822     case PROP_ENUM:
 823       g_value_set_enum (value, test_object->enum_prop);
 824       break;
 825     default:
 826       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 827       break;
 828     }
 829 }
 830
 831 static void
 832 test_object_set_property (GObject      *object,
 833                           guint         prop_id,
 834                           const GValue *value,
 835                           GParamSpec   *pspec)
 836 {
 837   TestObject *test_object = (TestObject *)object;
 838
 839   switch (prop_id)
 840     {
 841     case PROP_BOOL:
 842       test_object->bool_prop = g_value_get_boolean (value);
 843       break;
 844     case PROP_ANTI_BOOL:
 845       test_object->anti_bool_prop = g_value_get_boolean (value);
 846       break;
 847     case PROP_BYTE:
 848       test_object->byte_prop = g_value_get_schar (value);
 849       break;
 850     case PROP_INT16:
 851       test_object->int16_prop = g_value_get_int (value);
 852       break;
 853     case PROP_UINT16:
 854       test_object->uint16_prop = g_value_get_uint (value);
 855       break;
 856     case PROP_INT:
 857       test_object->int_prop = g_value_get_int (value);
 858       break;
 859     case PROP_UINT:
 860       test_object->uint_prop = g_value_get_uint (value);
 861       break;
 862     case PROP_INT64:
 863       test_object->int64_prop = g_value_get_int64 (value);
 864       break;
 865     case PROP_UINT64:
 866       test_object->uint64_prop = g_value_get_uint64 (value);
 867       break;
 868     case PROP_DOUBLE:
 869       test_object->double_prop = g_value_get_double (value);
 870       break;
 871     case PROP_STRING:
 872       g_free (test_object->string_prop);
 873       test_object->string_prop = g_value_dup_string (value);
 874       break;
 875     case PROP_NO_READ:
 876       g_free (test_object->no_read_prop);
 877       test_object->no_read_prop = g_value_dup_string (value);
 878       break;
 879     case PROP_STRV:
 880       g_strfreev (test_object->strv_prop);
 881       test_object->strv_prop = g_value_dup_boxed (value);
 882       break;
 883     case PROP_ENUM:
 884       test_object->enum_prop = g_value_get_enum (value);
 885       break;
 886     default:
 887       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 888       break;
 889     }
 890 }
 891
 892 static GType
 893 test_enum_get_type (void)
 894 {
 895   static volatile gsize define_type_id = 0;
 896
 897   if (g_once_init_enter (&define_type_id))
 898     {
 899       static const GEnumValue values[] = {
 900         { TEST_ENUM_FOO, "TEST_ENUM_FOO", "foo" },
 901         { TEST_ENUM_BAR, "TEST_ENUM_BAR", "bar" },
 902         { TEST_ENUM_BAZ, "TEST_ENUM_BAZ", "baz" },
 903         { TEST_ENUM_QUUX, "TEST_ENUM_QUUX", "quux" },
 904         { 0, NULL, NULL }
 905       };
 906
 907       GType type_id = g_enum_register_static ("TestEnum", values);
 908       g_once_init_leave (&define_type_id, type_id);
 909     }
 910
 911   return define_type_id;
 912 }
 913
 914 static void
 915 test_object_class_init (TestObjectClass *class)
 916 {
 917   GObjectClass *gobject_class = G_OBJECT_CLASS (class);
 918
 919   gobject_class->get_property = test_object_get_property;
 920   gobject_class->set_property = test_object_set_property;
 921   gobject_class->finalize = test_object_finalize;
 922
 923   g_object_class_install_property (gobject_class, PROP_BOOL,
 924     g_param_spec_boolean ("bool", "", "", FALSE, G_PARAM_READWRITE));
 925   g_object_class_install_property (gobject_class, PROP_ANTI_BOOL,
 926     g_param_spec_boolean ("anti-bool", "", "", FALSE, G_PARAM_READWRITE));
 927   g_object_class_install_property (gobject_class, PROP_BYTE,
 928     g_param_spec_char ("byte", "", "", G_MININT8, G_MAXINT8, 0, G_PARAM_READWRITE));
 929   g_object_class_install_property (gobject_class, PROP_INT16,
 930     g_param_spec_int ("int16", "", "", -G_MAXINT16, G_MAXINT16, 0, G_PARAM_READWRITE));
 931   g_object_class_install_property (gobject_class, PROP_UINT16,
 932     g_param_spec_uint ("uint16", "", "", 0, G_MAXUINT16, 0, G_PARAM_READWRITE));
 933   g_object_class_install_property (gobject_class, PROP_INT,
 934     g_param_spec_int ("int", "", "", G_MININT, G_MAXINT, 0, G_PARAM_READWRITE));
 935   g_object_class_install_property (gobject_class, PROP_UINT,
 936     g_param_spec_uint ("uint", "", "", 0, G_MAXUINT, 0, G_PARAM_READWRITE));
 937   g_object_class_install_property (gobject_class, PROP_INT64,
 938     g_param_spec_int64 ("int64", "", "", G_MININT64, G_MAXINT64, 0, G_PARAM_READWRITE));
 939   g_object_class_install_property (gobject_class, PROP_UINT64,
 940     g_param_spec_uint64 ("uint64", "", "", 0, G_MAXUINT64, 0, G_PARAM_READWRITE));
 941   g_object_class_install_property (gobject_class, PROP_DOUBLE,
 942     g_param_spec_double ("double", "", "", -G_MAXDOUBLE, G_MAXDOUBLE, 0.0, G_PARAM_READWRITE));
 943   g_object_class_install_property (gobject_class, PROP_STRING,
 944     g_param_spec_string ("string", "", "", NULL, G_PARAM_READWRITE));
 945   g_object_class_install_property (gobject_class, PROP_NO_WRITE,
 946     g_param_spec_string ("no-write", "", "", NULL, G_PARAM_READABLE));
 947   g_object_class_install_property (gobject_class, PROP_NO_READ,
 948     g_param_spec_string ("no-read", "", "", NULL, G_PARAM_WRITABLE));
 949   g_object_class_install_property (gobject_class, PROP_STRV,
 950     g_param_spec_boxed ("strv", "", "", G_TYPE_STRV, G_PARAM_READWRITE));
 951   g_object_class_install_property (gobject_class, PROP_ENUM,
 952     g_param_spec_enum ("enum", "", "", test_enum_get_type (), TEST_ENUM_FOO, G_PARAM_READWRITE));
 953 }
 954
 955 static TestObject *
 956 test_object_new (void)
 957 {
 958   return (TestObject*)g_object_new (test_object_get_type (), NULL);
 959 }
 960
 961 /* Test basic binding functionality for simple types.
 962  * Verify that with bidirectional bindings, changes on either side
 963  * are notified on the other end.
 964  */
 965 static void
 966 test_simple_binding (void)
 967 {
 968   TestObject *obj;
 969   GSettings *settings;
 970   gboolean b;
 971   gchar y;
 972   gint i;
 973   guint u;
 974   gint16 n;
 975   guint16 q;
 976   gint n2;
 977   guint q2;
 978   gint64 i64;
 979   guint64 u64;
 980   gdouble d;
 981   gchar *s;
 982   GVariant *value;
 983   gchar **strv;
 984
 985   settings = g_settings_new ("org.gtk.test.binding");
 986   obj = test_object_new ();
 987
 988   g_settings_bind (settings, "bool", obj, "bool", G_SETTINGS_BIND_DEFAULT);
 989   g_object_set (obj, "bool", TRUE, NULL);
 990   g_assert_cmpint (g_settings_get_boolean (settings, "bool"), ==, TRUE);
 991
 992   g_settings_set_boolean (settings, "bool", FALSE);
 993   b = TRUE;
 994   g_object_get (obj, "bool", &b, NULL);
 995   g_assert_cmpint (b, ==, FALSE);
 996
 997   g_settings_bind (settings, "anti-bool", obj, "anti-bool",
 998                    G_SETTINGS_BIND_INVERT_BOOLEAN);
 999   g_object_set (obj, "anti-bool", FALSE, NULL);
1000   g_assert_cmpint (g_settings_get_boolean (settings, "anti-bool"), ==, TRUE);
1001
1002   g_settings_set_boolean (settings, "anti-bool", FALSE);
1003   b = FALSE;
1004   g_object_get (obj, "anti-bool", &b, NULL);
1005   g_assert_cmpint (b, ==, TRUE);
1006
1007   g_settings_bind (settings, "byte", obj, "byte", G_SETTINGS_BIND_DEFAULT);
1008
1009   g_object_set (obj, "byte", 123, NULL);
1010   y = 'c';
1011   g_settings_get (settings, "byte", "y", &y);
1012   g_assert_cmpint (y, ==, 123);
1013
1014   g_settings_set (settings, "byte", "y", 54);
1015   y = 'c';
1016   g_object_get (obj, "byte", &y, NULL);
1017   g_assert_cmpint (y, ==, 54);
1018
1019   g_settings_bind (settings, "int16", obj, "int16", G_SETTINGS_BIND_DEFAULT);
1020
1021   g_object_set (obj, "int16", 1234, NULL);
1022   n = 4321;
1023   g_settings_get (settings, "int16", "n", &n);
1024   g_assert_cmpint (n, ==, 1234);
1025
1026   g_settings_set (settings, "int16", "n", 4321);
1027   n2 = 1111;
1028   g_object_get (obj, "int16", &n2, NULL);
1029   g_assert_cmpint (n2, ==, 4321);
1030
1031   g_settings_bind (settings, "uint16", obj, "uint16", G_SETTINGS_BIND_DEFAULT);
1032
1033   g_object_set (obj, "uint16", (guint16) G_MAXUINT16, NULL);
1034   q = 1111;
1035   g_settings_get (settings, "uint16", "q", &q);
1036   g_assert_cmpuint (q, ==, G_MAXUINT16);
1037
1038   g_settings_set (settings, "uint16", "q", (guint16) G_MAXINT16);
1039   q2 = 1111;
1040   g_object_get (obj, "uint16", &q2, NULL);
1041   g_assert_cmpuint (q2, ==, (guint16) G_MAXINT16);
1042
1043   g_settings_bind (settings, "int", obj, "int", G_SETTINGS_BIND_DEFAULT);
1044
1045   g_object_set (obj, "int", 12345, NULL);
1046   g_assert_cmpint (g_settings_get_int (settings, "int"), ==, 12345);
1047
1048   g_settings_set_int (settings, "int", 54321);
1049   i = 1111;
1050   g_object_get (obj, "int", &i, NULL);
1051   g_assert_cmpint (i, ==, 54321);
1052
1053   g_settings_bind (settings, "uint", obj, "uint", G_SETTINGS_BIND_DEFAULT);
1054
1055   g_object_set (obj, "uint", 12345, NULL);
1056   g_assert_cmpuint (g_settings_get_uint (settings, "uint"), ==, 12345);
1057
1058   g_settings_set_uint (settings, "uint", 54321);
1059   u = 1111;
1060   g_object_get (obj, "uint", &u, NULL);
1061   g_assert_cmpuint (u, ==, 54321);
1062
1063   g_settings_bind (settings, "int64", obj, "int64", G_SETTINGS_BIND_DEFAULT);
1064
1065   g_object_set (obj, "int64", (gint64) G_MAXINT64, NULL);
1066   i64 = 1111;
1067   g_settings_get (settings, "int64", "x", &i64);
1068   g_assert_cmpint (i64, ==, G_MAXINT64);
1069
1070   g_settings_set (settings, "int64", "x", (gint64) G_MININT64);
1071   i64 = 1111;
1072   g_object_get (obj, "int64", &i64, NULL);
1073   g_assert_cmpint (i64, ==, G_MININT64);
1074
1075   g_settings_bind (settings, "uint64", obj, "uint64", G_SETTINGS_BIND_DEFAULT);
1076
1077   g_object_set (obj, "uint64", (guint64) G_MAXUINT64, NULL);
1078   u64 = 1111;
1079   g_settings_get (settings, "uint64", "t", &u64);
1080   g_assert_cmpuint (u64, ==, G_MAXUINT64);
1081
1082   g_settings_set (settings, "uint64", "t", (guint64) G_MAXINT64);
1083   u64 = 1111;
1084   g_object_get (obj, "uint64", &u64, NULL);
1085   g_assert_cmpuint (u64, ==, (guint64) G_MAXINT64);
1086
1087   g_settings_bind (settings, "string", obj, "string", G_SETTINGS_BIND_DEFAULT);
1088
1089   g_object_set (obj, "string", "bu ba", NULL);
1090   s = g_settings_get_string (settings, "string");
1091   g_assert_cmpstr (s, ==, "bu ba");
1092   g_free (s);
1093
1094   g_settings_set_string (settings, "string", "bla bla");
1095   g_object_get (obj, "string", &s, NULL);
1096   g_assert_cmpstr (s, ==, "bla bla");
1097   g_free (s);
1098
1099   g_settings_bind (settings, "chararray", obj, "string", G_SETTINGS_BIND_DEFAULT);
1100
1101   g_object_set (obj, "string", "non-unicode:\315", NULL);
1102   value = g_settings_get_value (settings, "chararray");
1103   g_assert_cmpstr (g_variant_get_bytestring (value), ==, "non-unicode:\315");
1104   g_variant_unref (value);
1105
1106   g_settings_bind (settings, "double", obj, "double", G_SETTINGS_BIND_DEFAULT);
1107
1108   g_object_set (obj, "double", G_MAXFLOAT, NULL);
1109   g_assert_cmpfloat (g_settings_get_double (settings, "double"), ==, G_MAXFLOAT);
1110
1111   g_settings_set_double (settings, "double", G_MINFLOAT);
1112   d = 1.0;
1113   g_object_get (obj, "double", &d, NULL);
1114   g_assert_cmpfloat (d, ==, G_MINFLOAT);
1115
1116   g_object_set (obj, "double", G_MAXDOUBLE, NULL);
1117   g_assert_cmpfloat (g_settings_get_double (settings, "double"), ==, G_MAXDOUBLE);
1118
1119   g_settings_set_double (settings, "double", -G_MINDOUBLE);
1120   d = 1.0;
1121   g_object_get (obj, "double", &d, NULL);
1122   g_assert_cmpfloat (d, ==, -G_MINDOUBLE);
1123
1124   strv = g_strsplit ("plastic bag,middle class,polyethylene", ",", 0);
1125   g_settings_bind (settings, "strv", obj, "strv", G_SETTINGS_BIND_DEFAULT);
1126   g_object_set (obj, "strv", strv, NULL);
1127   g_strfreev (strv);
1128   strv = g_settings_get_strv (settings, "strv");
1129   s = g_strjoinv (",", strv);
1130   g_assert_cmpstr (s, ==, "plastic bag,middle class,polyethylene");
1131   g_strfreev (strv);
1132   g_free (s);
1133   strv = g_strsplit ("decaffeinate,unleaded,keep all surfaces clean", ",", 0);
1134   g_settings_set_strv (settings, "strv", (const gchar **) strv);
1135   g_strfreev (strv);
1136   g_object_get (obj, "strv", &strv, NULL);
1137   s = g_strjoinv (",", strv);
1138   g_assert_cmpstr (s, ==, "decaffeinate,unleaded,keep all surfaces clean");
1139   g_strfreev (strv);
1140   g_free (s);
1141
1142   g_settings_bind (settings, "enum", obj, "enum", G_SETTINGS_BIND_DEFAULT);
1143   g_object_set (obj, "enum", TEST_ENUM_BAZ, NULL);
1144   s = g_settings_get_string (settings, "enum");
1145   g_assert_cmpstr (s, ==, "baz");
1146   g_free (s);
1147   g_assert_cmpint (g_settings_get_enum (settings, "enum"), ==, TEST_ENUM_BAZ);
1148
1149   g_settings_set_enum (settings, "enum", TEST_ENUM_QUUX);
1150   i = 230;
1151   g_object_get (obj, "enum", &i, NULL);
1152   g_assert_cmpint (i, ==, TEST_ENUM_QUUX);
1153
1154   g_settings_set_string (settings, "enum", "baz");
1155   i = 230;
1156   g_object_get (obj, "enum", &i, NULL);
1157   g_assert_cmpint (i, ==, TEST_ENUM_BAZ);
1158
1159   g_object_unref (obj);
1160   g_object_unref (settings);
1161 }
1162
1163 static void
1164 test_unbind (void)
1165 {
1166   TestObject *obj;
1167   GSettings *settings;
1168
1169   settings = g_settings_new ("org.gtk.test.binding");
1170   obj = test_object_new ();
1171
1172   g_settings_bind (settings, "int", obj, "int", G_SETTINGS_BIND_DEFAULT);
1173
1174   g_object_set (obj, "int", 12345, NULL);
1175   g_assert_cmpint (g_settings_get_int (settings, "int"), ==, 12345);
1176
1177   g_settings_unbind (obj, "int");
1178
1179   g_object_set (obj, "int", 54321, NULL);
1180   g_assert_cmpint (g_settings_get_int (settings, "int"), ==, 12345);
1181
1182   g_object_unref (obj);
1183   g_object_unref (settings);
1184 }
1185
1186 static void
1187 test_bind_writable (void)
1188 {
1189   TestObject *obj;
1190   GSettings *settings;
1191   gboolean b;
1192
1193   settings = g_settings_new ("org.gtk.test.binding");
1194   obj = test_object_new ();
1195
1196   g_object_set (obj, "bool", FALSE, NULL);
1197
1198   g_settings_bind_writable (settings, "int", obj, "bool", FALSE);
1199
1200   g_object_get (obj, "bool", &b, NULL);
1201   g_assert (b);
1202
1203   g_settings_unbind (obj, "bool");
1204
1205   g_settings_bind_writable (settings, "int", obj, "bool", TRUE);
1206
1207   g_object_get (obj, "bool", &b, NULL);
1208   g_assert (!b);
1209
1210   g_object_unref (obj);
1211   g_object_unref (settings);
1212 }
1213
1214 /* Test one-way bindings.
1215  * Verify that changes on one side show up on the other,
1216  * but not vice versa
1217  */
1218 static void
1219 test_directional_binding (void)
1220 {
1221   TestObject *obj;
1222   GSettings *settings;
1223   gboolean b;
1224   gint i;
1225
1226   settings = g_settings_new ("org.gtk.test.binding");
1227   obj = test_object_new ();
1228
1229   g_object_set (obj, "bool", FALSE, NULL);
1230   g_settings_set_boolean (settings, "bool", FALSE);
1231
1232   g_settings_bind (settings, "bool", obj, "bool", G_SETTINGS_BIND_GET);
1233
1234   g_settings_set_boolean (settings, "bool", TRUE);
1235   g_object_get (obj, "bool", &b, NULL);
1236   g_assert_cmpint (b, ==, TRUE);
1237
1238   g_object_set (obj, "bool", FALSE, NULL);
1239   g_assert_cmpint (g_settings_get_boolean (settings, "bool"), ==, TRUE);
1240
1241   g_object_set (obj, "int", 20, NULL);
1242   g_settings_set_int (settings, "int", 20);
1243
1244   g_settings_bind (settings, "int", obj, "int", G_SETTINGS_BIND_SET);
1245
1246   g_object_set (obj, "int", 32, NULL);
1247   g_assert_cmpint (g_settings_get_int (settings, "int"), ==, 32);
1248
1249   g_settings_set_int (settings, "int", 20);
1250   g_object_get (obj, "int", &i, NULL);
1251   g_assert_cmpint (i, ==, 32);
1252
1253   g_object_unref (obj);
1254   g_object_unref (settings);
1255 }
1256
1257 /* Test that type mismatch is caught when creating a binding
1258  */
1259 static void
1260 test_typesafe_binding (void)
1261 {
1262   if (!g_test_undefined ())
1263     return;
1264
1265   if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDERR))
1266     {
1267       TestObject *obj;
1268       GSettings *settings;
1269
1270       settings = g_settings_new ("org.gtk.test.binding");
1271       obj = test_object_new ();
1272
1273       g_settings_bind (settings, "string", obj, "int", G_SETTINGS_BIND_DEFAULT);
1274
1275       g_object_unref (obj);
1276       g_object_unref (settings);
1277     }
1278   g_test_trap_assert_failed ();
1279   g_test_trap_assert_stderr ("*not compatible*");
1280 }
1281
1282 static gboolean
1283 string_to_bool (GValue   *value,
1284                 GVariant *variant,
1285                 gpointer  user_data)
1286 {
1287   const gchar *s;
1288
1289   s = g_variant_get_string (variant, NULL);
1290   g_value_set_boolean (value, g_strcmp0 (s, "true") == 0);
1291
1292   return TRUE;
1293 }
1294
1295 static GVariant *
1296 bool_to_string (const GValue       *value,
1297                 const GVariantType *expected_type,
1298                 gpointer            user_data)
1299 {
1300   if (g_value_get_boolean (value))
1301     return g_variant_new_string ("true");
1302   else
1303     return g_variant_new_string ("false");
1304 }
1305
1306 /* Test custom bindings.
1307  * Translate strings to booleans and back
1308  */
1309 static void
1310 test_custom_binding (void)
1311 {
1312   TestObject *obj;
1313   GSettings *settings;
1314   gchar *s;
1315   gboolean b;
1316
1317   settings = g_settings_new ("org.gtk.test.binding");
1318   obj = test_object_new ();
1319
1320   g_settings_set_string (settings, "string", "true");
1321
1322   g_settings_bind_with_mapping (settings, "string",
1323                                 obj, "bool",
1324                                 G_SETTINGS_BIND_DEFAULT,
1325                                 string_to_bool,
1326                                 bool_to_string,
1327                                 NULL, NULL);
1328
1329   g_settings_set_string (settings, "string", "false");
1330   g_object_get (obj, "bool", &b, NULL);
1331   g_assert_cmpint (b, ==, FALSE);
1332
1333   g_settings_set_string (settings, "string", "not true");
1334   g_object_get (obj, "bool", &b, NULL);
1335   g_assert_cmpint (b, ==, FALSE);
1336
1337   g_object_set (obj, "bool", TRUE, NULL);
1338   s = g_settings_get_string (settings, "string");
1339   g_assert_cmpstr (s, ==, "true");
1340   g_free (s);
1341
1342   g_object_unref (obj);
1343   g_object_unref (settings);
1344 }
1345
1346 /* Test that with G_SETTINGS_BIND_NO_CHANGES, the
1347  * initial settings value is transported to the object
1348  * side, but later settings changes do not affect the
1349  * object
1350  */
1351 static void
1352 test_no_change_binding (void)
1353 {
1354   TestObject *obj;
1355   GSettings *settings;
1356   gboolean b;
1357
1358   settings = g_settings_new ("org.gtk.test.binding");
1359   obj = test_object_new ();
1360
1361   g_object_set (obj, "bool", TRUE, NULL);
1362   g_settings_set_boolean (settings, "bool", FALSE);
1363
1364   g_settings_bind (settings, "bool", obj, "bool", G_SETTINGS_BIND_GET_NO_CHANGES);
1365
1366   g_object_get (obj, "bool", &b, NULL);
1367   g_assert_cmpint (b, ==, FALSE);
1368
1369   g_settings_set_boolean (settings, "bool", TRUE);
1370   g_object_get (obj, "bool", &b, NULL);
1371   g_assert_cmpint (b, ==, FALSE);
1372
1373   g_settings_set_boolean (settings, "bool", FALSE);
1374   g_object_set (obj, "bool", TRUE, NULL);
1375   b = g_settings_get_boolean (settings, "bool");
1376   g_assert_cmpint (b, ==, TRUE);
1377
1378   g_object_unref (obj);
1379   g_object_unref (settings);
1380 }
1381
1382 /* Test that binding a non-readable property only
1383  * works in 'GET' mode.
1384  */
1385 static void
1386 test_no_read_binding (void)
1387 {
1388   if (g_test_undefined ())
1389     {
1390       if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDERR))
1391         {
1392           TestObject *obj;
1393           GSettings *settings;
1394
1395           settings = g_settings_new ("org.gtk.test.binding");
1396           obj = test_object_new ();
1397
1398           g_settings_bind (settings, "string", obj, "no-read", 0);
1399         }
1400       g_test_trap_assert_failed ();
1401       g_test_trap_assert_stderr ("*property*is not readable*");
1402     }
1403
1404   if (g_test_trap_fork (0, 0))
1405     {
1406       TestObject *obj;
1407       GSettings *settings;
1408
1409       settings = g_settings_new ("org.gtk.test.binding");
1410       obj = test_object_new ();
1411
1412       g_settings_bind (settings, "string", obj, "no-read", G_SETTINGS_BIND_GET);
1413
1414       exit (0);
1415     }
1416   g_test_trap_assert_passed ();
1417 }
1418
1419 /* Test that binding a non-writable property only
1420  * works in 'SET' mode.
1421  */
1422 static void
1423 test_no_write_binding (void)
1424 {
1425   if (g_test_undefined ())
1426     {
1427       if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDERR))
1428         {
1429           TestObject *obj;
1430           GSettings *settings;
1431
1432           settings = g_settings_new ("org.gtk.test.binding");
1433           obj = test_object_new ();
1434
1435           g_settings_bind (settings, "string", obj, "no-write", 0);
1436         }
1437       g_test_trap_assert_failed ();
1438       g_test_trap_assert_stderr ("*property*is not writable*");
1439     }
1440
1441   if (g_test_trap_fork (0, 0))
1442     {
1443       TestObject *obj;
1444       GSettings *settings;
1445
1446       settings = g_settings_new ("org.gtk.test.binding");
1447       obj = test_object_new ();
1448
1449       g_settings_bind (settings, "string", obj, "no-write", G_SETTINGS_BIND_SET);
1450
1451       exit (0);
1452     }
1453   g_test_trap_assert_passed ();
1454 }
1455
1456 /*
1457  * Test that using a keyfile works
1458  */
1459 static void
1460 test_keyfile (void)
1461 {
1462   GSettingsBackend *kf_backend;
1463   GSettings *settings;
1464   GKeyFile *keyfile;
1465   gchar *str;
1466
1467   g_remove ("gsettings.store");
1468
1469   kf_backend = g_keyfile_settings_backend_new ("gsettings.store", "/", "root");
1470   settings = g_settings_new_with_backend ("org.gtk.test", kf_backend);
1471   g_object_unref (kf_backend);
1472
1473   g_settings_set (settings, "greeting", "s", "see if this works");
1474
1475   keyfile = g_key_file_new ();
1476   g_assert (g_key_file_load_from_file (keyfile, "gsettings.store", 0, NULL));
1477
1478   str = g_key_file_get_string (keyfile, "tests", "greeting", NULL);
1479   g_assert_cmpstr (str, ==, "'see if this works'");
1480
1481   g_free (str);
1482   g_key_file_free (keyfile);
1483   g_object_unref (settings);
1484 }
1485
1486 /* Test that getting child schemas works
1487  */
1488 static void
1489 test_child_schema (void)
1490 {
1491   GSettings *settings;
1492   GSettings *child;
1493   guint8 byte;
1494
1495   /* first establish some known conditions */
1496   settings = g_settings_new ("org.gtk.test.basic-types");
1497   g_settings_set (settings, "test-byte", "y", 36);
1498
1499   g_settings_get (settings, "test-byte", "y", &byte);
1500   g_assert_cmpint (byte, ==, 36);
1501
1502   g_object_unref (settings);
1503
1504   settings = g_settings_new ("org.gtk.test");
1505   child = g_settings_get_child (settings, "basic-types");
1506   g_assert (child != NULL);
1507
1508   g_settings_get (child, "test-byte", "y", &byte);
1509   g_assert_cmpint (byte, ==, 36);
1510
1511   g_object_unref (child);
1512   g_object_unref (settings);
1513 }
1514
1515 static gboolean
1516 glib_translations_work (void)
1517 {
1518   gboolean works;
1519   gchar *locale;
1520   gchar *orig = "Unnamed";
1521
1522   locale = g_strdup (setlocale (LC_MESSAGES, NULL));
1523   if (!setlocale (LC_MESSAGES, "de"))
1524     works = FALSE;
1525   else
1526     works = dgettext ("glib20", orig) != orig;
1527   setlocale (LC_MESSAGES, locale);
1528   g_free (locale);
1529
1530   return works;
1531 }
1532
1533 #include "../strinfo.c"
1534
1535 static void
1536 test_strinfo (void)
1537 {
1538   /*  "foo" has a value of 1
1539    *  "bar" has a value of 2
1540    *  "baz" is an alias for "bar"
1541    */
1542   gchar array[] =
1543     "\1\0\0\0"      "\xff""foo"     "\0\0\0\xff"    "\2\0\0\0"
1544     "\xff" "bar"    "\0\0\0\xff"    "\3\0\0\0"      "\xfe""baz"
1545     "\0\0\0\xff";
1546   const guint32 *strinfo = (guint32 *) array;
1547   guint length = sizeof array / 4;
1548   guint result;
1549
1550   {
1551     /* build it and compare */
1552     GString *builder;
1553
1554     builder = g_string_new (NULL);
1555     strinfo_builder_append_item (builder, "foo", 1);
1556     strinfo_builder_append_item (builder, "bar", 2);
1557     g_assert (strinfo_builder_append_alias (builder, "baz", "bar"));
1558     g_assert_cmpint (builder->len % 4, ==, 0);
1559     g_assert_cmpint (builder->len / 4, ==, length);
1560     g_assert (memcmp (builder->str, strinfo, length * 4) == 0);
1561     g_string_free (builder, TRUE);
1562   }
1563
1564   g_assert_cmpstr (strinfo_string_from_alias (strinfo, length, "foo"),
1565                    ==, NULL);
1566   g_assert_cmpstr (strinfo_string_from_alias (strinfo, length, "bar"),
1567                    ==, NULL);
1568   g_assert_cmpstr (strinfo_string_from_alias (strinfo, length, "baz"),
1569                    ==, "bar");
1570   g_assert_cmpstr (strinfo_string_from_alias (strinfo, length, "quux"),
1571                    ==, NULL);
1572
1573   g_assert (strinfo_enum_from_string (strinfo, length, "foo", &result));
1574   g_assert_cmpint (result, ==, 1);
1575   g_assert (strinfo_enum_from_string (strinfo, length, "bar", &result));
1576   g_assert_cmpint (result, ==, 2);
1577   g_assert (!strinfo_enum_from_string (strinfo, length, "baz", &result));
1578   g_assert (!strinfo_enum_from_string (strinfo, length, "quux", &result));
1579
1580   g_assert_cmpstr (strinfo_string_from_enum (strinfo, length, 0), ==, NULL);
1581   g_assert_cmpstr (strinfo_string_from_enum (strinfo, length, 1), ==, "foo");
1582   g_assert_cmpstr (strinfo_string_from_enum (strinfo, length, 2), ==, "bar");
1583   g_assert_cmpstr (strinfo_string_from_enum (strinfo, length, 3), ==, NULL);
1584
1585   g_assert (strinfo_is_string_valid (strinfo, length, "foo"));
1586   g_assert (strinfo_is_string_valid (strinfo, length, "bar"));
1587   g_assert (!strinfo_is_string_valid (strinfo, length, "baz"));
1588   g_assert (!strinfo_is_string_valid (strinfo, length, "quux"));
1589 }
1590
1591 static void
1592 test_enums (void)
1593 {
1594   GSettings *settings, *direct;
1595   gchar *str;
1596
1597   settings = g_settings_new ("org.gtk.test.enums");
1598   direct = g_settings_new ("org.gtk.test.enums.direct");
1599
1600   if (g_test_undefined () && !backend_set)
1601     {
1602       if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDERR))
1603         g_settings_get_enum (direct, "test");
1604       g_test_trap_assert_failed ();
1605       g_test_trap_assert_stderr ("*not associated with an enum*");
1606
1607       if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDERR))
1608         g_settings_set_enum (settings, "test", 42);
1609       g_test_trap_assert_failed ();
1610       g_test_trap_assert_stderr ("*invalid enum value 42*");
1611
1612       if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDERR))
1613         g_settings_set_string (settings, "test", "qux");
1614       g_test_trap_assert_failed ();
1615       g_test_trap_assert_stderr ("*g_settings_set_value*valid range*");
1616
1617       if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDERR))
1618         g_settings_get_flags (settings, "test");
1619       g_test_trap_assert_failed ();
1620       g_test_trap_assert_stderr ("*not associated with a flags*");
1621     }
1622
1623   str = g_settings_get_string (settings, "test");
1624   g_assert_cmpstr (str, ==, "bar");
1625   g_free (str);
1626
1627   g_settings_set_enum (settings, "test", TEST_ENUM_FOO);
1628
1629   str = g_settings_get_string (settings, "test");
1630   g_assert_cmpstr (str, ==, "foo");
1631   g_free (str);
1632
1633   g_assert_cmpint (g_settings_get_enum (settings, "test"), ==, TEST_ENUM_FOO);
1634
1635   g_settings_set_string (direct, "test", "qux");
1636
1637   str = g_settings_get_string (direct, "test");
1638   g_assert_cmpstr (str, ==, "qux");
1639   g_free (str);
1640
1641   str = g_settings_get_string (settings, "test");
1642   g_assert_cmpstr (str, ==, "quux");
1643   g_free (str);
1644
1645   g_assert_cmpint (g_settings_get_enum (settings, "test"), ==, TEST_ENUM_QUUX);
1646 }
1647
1648 static void
1649 test_flags (void)
1650 {
1651   GSettings *settings, *direct;
1652   gchar **strv;
1653   gchar *str;
1654
1655   settings = g_settings_new ("org.gtk.test.enums");
1656   direct = g_settings_new ("org.gtk.test.enums.direct");
1657
1658   if (g_test_undefined () && !backend_set)
1659     {
1660       if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDERR))
1661         g_settings_get_flags (direct, "test");
1662       g_test_trap_assert_failed ();
1663       g_test_trap_assert_stderr ("*not associated with a flags*");
1664
1665       if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDERR))
1666         g_settings_set_flags (settings, "f-test", 0x42);
1667       g_test_trap_assert_failed ();
1668       g_test_trap_assert_stderr ("*invalid flags value 0x00000042*");
1669
1670       if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDERR))
1671         g_settings_set_strv (settings, "f-test",
1672                              (const gchar **) g_strsplit ("rock", ",", 0));
1673       g_test_trap_assert_failed ();
1674       g_test_trap_assert_stderr ("*g_settings_set_value*valid range*");
1675
1676       if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDERR))
1677         g_settings_get_enum (settings, "f-test");
1678       g_test_trap_assert_failed ();
1679       g_test_trap_assert_stderr ("*not associated with an enum*");
1680     }
1681
1682   strv = g_settings_get_strv (settings, "f-test");
1683   str = g_strjoinv (",", strv);
1684   g_assert_cmpstr (str, ==, "");
1685   g_strfreev (strv);
1686   g_free (str);
1687
1688   g_settings_set_flags (settings, "f-test",
1689                         TEST_FLAGS_WALKING | TEST_FLAGS_TALKING);
1690
1691   strv = g_settings_get_strv (settings, "f-test");
1692   str = g_strjoinv (",", strv);
1693   g_assert_cmpstr (str, ==, "talking,walking");
1694   g_strfreev (strv);
1695   g_free (str);
1696
1697   g_assert_cmpint (g_settings_get_flags (settings, "f-test"), ==,
1698                    TEST_FLAGS_WALKING | TEST_FLAGS_TALKING);
1699
1700   strv = g_strsplit ("speaking,laughing", ",", 0);
1701   g_settings_set_strv (direct, "f-test", (const gchar **) strv);
1702   g_strfreev (strv);
1703
1704   strv = g_settings_get_strv (direct, "f-test");
1705   str = g_strjoinv (",", strv);
1706   g_assert_cmpstr (str, ==, "speaking,laughing");
1707   g_strfreev (strv);
1708   g_free (str);
1709
1710   strv = g_settings_get_strv (settings, "f-test");
1711   str = g_strjoinv (",", strv);
1712   g_assert_cmpstr (str, ==, "talking,laughing");
1713   g_strfreev (strv);
1714   g_free (str);
1715
1716   g_assert_cmpint (g_settings_get_flags (settings, "f-test"), ==,
1717                    TEST_FLAGS_TALKING | TEST_FLAGS_LAUGHING);
1718 }
1719
1720 static void
1721 test_range (void)
1722 {
1723   GSettings *settings, *direct;
1724
1725   settings = g_settings_new ("org.gtk.test.range");
1726   direct = g_settings_new ("org.gtk.test.range.direct");
1727
1728   if (g_test_undefined () && !backend_set)
1729     {
1730       if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDERR))
1731         g_settings_set_int (settings, "val", 45);
1732       g_test_trap_assert_failed ();
1733       g_test_trap_assert_stderr ("*g_settings_set_value*valid range*");
1734
1735       if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDERR))
1736         g_settings_set_int (settings, "val", 1);
1737       g_test_trap_assert_failed ();
1738       g_test_trap_assert_stderr ("*g_settings_set_value*valid range*");
1739     }
1740
1741   g_assert_cmpint (g_settings_get_int (settings, "val"), ==, 33);
1742   g_settings_set_int (direct, "val", 22);
1743   g_assert_cmpint (g_settings_get_int (direct, "val"), ==, 22);
1744   g_assert_cmpint (g_settings_get_int (settings, "val"), ==, 22);
1745   g_settings_set_int (direct, "val", 45);
1746   g_assert_cmpint (g_settings_get_int (direct, "val"), ==, 45);
1747   g_assert_cmpint (g_settings_get_int (settings, "val"), ==, 33);
1748   g_settings_set_int (direct, "val", 1);
1749   g_assert_cmpint (g_settings_get_int (direct, "val"), ==, 1);
1750   g_assert_cmpint (g_settings_get_int (settings, "val"), ==, 33);
1751 }
1752
1753 static gboolean
1754 strv_has_string (gchar       **haystack,
1755                  const gchar  *needle)
1756 {
1757   guint n;
1758
1759   for (n = 0; haystack != NULL && haystack[n] != NULL; n++)
1760     {
1761       if (g_strcmp0 (haystack[n], needle) == 0)
1762         return TRUE;
1763     }
1764   return FALSE;
1765 }
1766
1767 static gboolean
1768 strv_set_equal (gchar **strv, ...)
1769 {
1770   gint count;
1771   va_list list;
1772   const gchar *str;
1773   gboolean res;
1774
1775   res = TRUE;
1776   count = 0;
1777   va_start (list, strv);
1778   while (1)
1779     {
1780       str = va_arg (list, const gchar *);
1781       if (str == NULL)
1782         break;
1783       if (!strv_has_string (strv, str))
1784         {
1785           res = FALSE;
1786           break;
1787         }
1788       count++;
1789     }
1790   va_end (list);
1791
1792   if (res)
1793     res = g_strv_length ((gchar**)strv) == count;
1794
1795   return res;
1796 }
1797
1798 static void
1799 test_list_items (void)
1800 {
1801   GSettings *settings;
1802   gchar **children;
1803   gchar **keys;
1804
1805   settings = g_settings_new ("org.gtk.test");
1806   children = g_settings_list_children (settings);
1807   keys = g_settings_list_keys (settings);
1808
1809   g_assert (strv_set_equal (children, "basic-types", "complex-types", "localized", NULL));
1810   g_assert (strv_set_equal (keys, "greeting", "farewell", NULL));
1811
1812   g_strfreev (children);
1813   g_strfreev (keys);
1814
1815   g_object_unref (settings);
1816 }
1817
1818 static void
1819 test_list_schemas (void)
1820 {
1821   const gchar * const *schemas;
1822   const gchar * const *relocs;
1823
1824   relocs = g_settings_list_relocatable_schemas ();
1825   schemas = g_settings_list_schemas ();
1826
1827   g_assert (strv_set_equal ((gchar **)relocs,
1828                             "org.gtk.test.no-path",
1829                             NULL));
1830
1831   g_assert (strv_set_equal ((gchar **)schemas,
1832                             "org.gtk.test",
1833                             "org.gtk.test.basic-types",
1834                             "org.gtk.test.complex-types",
1835                             "org.gtk.test.localized",
1836                             "org.gtk.test.binding",
1837                             "org.gtk.test.enums",
1838                             "org.gtk.test.enums.direct",
1839                             "org.gtk.test.range",
1840                             "org.gtk.test.range.direct",
1841                             "org.gtk.test.mapped",
1842                             NULL));
1843 }
1844
1845 static gboolean
1846 map_func (GVariant *value,
1847           gpointer *result,
1848           gpointer  user_data)
1849 {
1850   gint *state = user_data;
1851   gint v;
1852
1853   if (value)
1854     v = g_variant_get_int32 (value);
1855   else
1856     v = -1;
1857
1858   if (*state == 0)
1859     {
1860       g_assert_cmpint (v, ==, 1);
1861       (*state)++;
1862       return FALSE;
1863     }
1864   else if (*state == 1)
1865     {
1866       g_assert_cmpint (v, ==, 0);
1867       (*state)++;
1868       return FALSE;
1869     }
1870   else
1871     {
1872       g_assert (value == NULL);
1873       *result = g_variant_new_int32 (5);
1874       return TRUE;
1875     }
1876 }
1877
1878 static void
1879 test_get_mapped (void)
1880 {
1881   GSettings *settings;
1882   gint state;
1883   gpointer p;
1884   gint val;
1885
1886   settings = g_settings_new ("org.gtk.test.mapped");
1887   g_settings_set_int (settings, "val", 1);
1888
1889   state = 0;
1890   p = g_settings_get_mapped (settings, "val", map_func, &state);
1891   val = g_variant_get_int32 ((GVariant*)p);
1892   g_assert_cmpint (val, ==, 5);
1893
1894   g_variant_unref (p);
1895   g_object_unref (settings);
1896 }
1897
1898 static void
1899 test_get_range (void)
1900 {
1901   GSettings *settings;
1902   GVariant *range;
1903
1904   settings = g_settings_new ("org.gtk.test.range");
1905   range = g_settings_get_range (settings, "val");
1906   check_and_free (range, "('range', <(2, 44)>)");
1907   g_object_unref (settings);
1908
1909   settings = g_settings_new ("org.gtk.test.enums");
1910   range = g_settings_get_range (settings, "test");
1911   check_and_free (range, "('enum', <['foo', 'bar', 'baz', 'quux']>)");
1912   g_object_unref (settings);
1913
1914   settings = g_settings_new ("org.gtk.test.enums");
1915   range = g_settings_get_range (settings, "f-test");
1916   check_and_free (range, "('flags', "
1917                   "<['mourning', 'laughing', 'talking', 'walking']>)");
1918   g_object_unref (settings);
1919
1920   settings = g_settings_new ("org.gtk.test");
1921   range = g_settings_get_range (settings, "greeting");
1922   check_and_free (range, "('type', <@as []>)");
1923   g_object_unref (settings);
1924 }
1925
1926 static void
1927 test_schema_source (void)
1928 {
1929   GSettingsSchemaSource *parent;
1930   GSettingsSchemaSource *source;
1931   GSettingsBackend *backend;
1932   GSettingsSchema *schema;
1933   GError *error = NULL;
1934   GSettings *settings;
1935   gboolean enabled;
1936
1937   backend = g_settings_backend_get_default ();
1938
1939   /* make sure it fails properly */
1940   parent = g_settings_schema_source_get_default ();
1941   source = g_settings_schema_source_new_from_directory ("/path/that/does/not/exist", parent,  TRUE, &error);
1942   g_assert (source == NULL);
1943   g_assert_error (error, G_FILE_ERROR, G_FILE_ERROR_NOENT);
1944   g_clear_error (&error);
1945
1946   /* create a source with the parent */
1947   source = g_settings_schema_source_new_from_directory ("schema-source", parent, TRUE, &error);
1948   g_assert_no_error (error);
1949   g_assert (source != NULL);
1950
1951   /* check recursive lookups are working */
1952   schema = g_settings_schema_source_lookup (source, "org.gtk.test", TRUE);
1953   g_assert (schema != NULL);
1954   g_settings_schema_unref (schema);
1955
1956   /* check recursive lookups for non-existent schemas */
1957   schema = g_settings_schema_source_lookup (source, "org.gtk.doesnotexist", TRUE);
1958   g_assert (schema == NULL);
1959
1960   /* check non-recursive for schema that only exists in lower layers */
1961   schema = g_settings_schema_source_lookup (source, "org.gtk.test", FALSE);
1962   g_assert (schema == NULL);
1963
1964   /* check non-recursive lookup for non-existent */
1965   schema = g_settings_schema_source_lookup (source, "org.gtk.doesnotexist", FALSE);
1966   g_assert (schema == NULL);
1967
1968   /* check non-recursive for schema that exists in toplevel */
1969   schema = g_settings_schema_source_lookup (source, "org.gtk.schemasourcecheck", FALSE);
1970   g_assert (schema != NULL);
1971   g_settings_schema_unref (schema);
1972
1973   /* check recursive for schema that exists in toplevel */
1974   schema = g_settings_schema_source_lookup (source, "org.gtk.schemasourcecheck", TRUE);
1975   g_assert (schema != NULL);
1976
1977   /* try to use it for something */
1978   settings = g_settings_new_full (schema, backend, g_settings_schema_get_path (schema));
1979   g_settings_schema_unref (schema);
1980   enabled = FALSE;
1981   g_settings_get (settings, "enabled", "b", &enabled);
1982   g_assert (enabled);
1983   g_object_unref (settings);
1984
1985   g_settings_schema_source_unref (source);
1986
1987   /* try again, but with no parent */
1988   source = g_settings_schema_source_new_from_directory ("schema-source", NULL, FALSE, NULL);
1989   g_assert (source != NULL);
1990
1991   /* should not find it this time, even if recursive... */
1992   schema = g_settings_schema_source_lookup (source, "org.gtk.test", FALSE);
1993   g_assert (schema == NULL);
1994   schema = g_settings_schema_source_lookup (source, "org.gtk.test", TRUE);
1995   g_assert (schema == NULL);
1996
1997   /* should still find our own... */
1998   schema = g_settings_schema_source_lookup (source, "org.gtk.schemasourcecheck", TRUE);
1999   g_assert (schema != NULL);
2000   g_settings_schema_unref (schema);
2001   schema = g_settings_schema_source_lookup (source, "org.gtk.schemasourcecheck", FALSE);
2002   g_assert (schema != NULL);
2003   g_settings_schema_unref (schema);
2004
2005   g_settings_schema_source_unref (source);
2006 }
2007
2008 static void
2009 test_actions (void)
2010 {
2011   GAction *string, *toggle;
2012   gboolean c1, c2, c3;
2013   GSettings *settings;
2014
2015   settings = g_settings_new ("org.gtk.test.basic-types");
2016   string = g_settings_create_action (settings, "test-string");
2017   toggle = g_settings_create_action (settings, "test-boolean");
2018   g_object_unref (settings); /* should be held by the actions */
2019
2020   g_signal_connect (settings, "changed", G_CALLBACK (changed_cb2), &c1);
2021   g_signal_connect (string, "notify::state", G_CALLBACK (changed_cb2), &c2);
2022   g_signal_connect (toggle, "notify::state", G_CALLBACK (changed_cb2), &c3);
2023
2024   c1 = c2 = c3 = FALSE;
2025   g_settings_set_string (settings, "test-string", "hello world");
2026   check_and_free (g_action_get_state (string), "'hello world'");
2027   g_assert (c1 && c2 && !c3);
2028   c1 = c2 = c3 = FALSE;
2029
2030   g_action_activate (string, g_variant_new_string ("hihi"));
2031   check_and_free (g_settings_get_value (settings, "test-string"), "'hihi'");
2032   g_assert (c1 && c2 && !c3);
2033   c1 = c2 = c3 = FALSE;
2034
2035   g_action_change_state (string, g_variant_new_string ("kthxbye"));
2036   check_and_free (g_settings_get_value (settings, "test-string"), "'kthxbye'");
2037   g_assert (c1 && c2 && !c3);
2038   c1 = c2 = c3 = FALSE;
2039
2040   g_action_change_state (toggle, g_variant_new_boolean (TRUE));
2041   g_assert (g_settings_get_boolean (settings, "test-boolean"));
2042   g_assert (c1 && !c2 && c3);
2043   c1 = c2 = c3 = FALSE;
2044
2045   g_action_activate (toggle, NULL);
2046   g_assert (!g_settings_get_boolean (settings, "test-boolean"));
2047   g_assert (c1 && !c2 && c3);
2048
2049   g_object_unref (string);
2050   g_object_unref (toggle);
2051 }
2052
2053 int
2054 main (int argc, char *argv[])
2055 {
2056   gchar *enums;
2057   gint result;
2058
2059   setlocale (LC_ALL, "");
2060
2061   backend_set = g_getenv ("GSETTINGS_BACKEND") != NULL;
2062
2063   g_setenv ("XDG_DATA_DIRS", ".", TRUE);
2064   g_setenv ("GSETTINGS_SCHEMA_DIR", ".", TRUE);
2065
2066   if (!backend_set)
2067     g_setenv ("GSETTINGS_BACKEND", "memory", TRUE);
2068
2069   g_type_init ();
2070   g_test_init (&argc, &argv, NULL);
2071
2072   g_remove ("org.gtk.test.enums.xml");
2073   g_assert (g_spawn_command_line_sync ("../../gobject/glib-mkenums "
2074                                        "--template " SRCDIR "/enums.xml.template "
2075                                        SRCDIR "/testenum.h",
2076                                        &enums, NULL, &result, NULL));
2077   g_assert (result == 0);
2078   g_assert (g_file_set_contents ("org.gtk.test.enums.xml", enums, -1, NULL));
2079   g_free (enums);
2080
2081   g_remove ("gschemas.compiled");
2082   g_assert (g_spawn_command_line_sync ("../glib-compile-schemas --targetdir=. "
2083                                        "--schema-file=org.gtk.test.enums.xml "
2084                                        "--schema-file=" SRCDIR "/org.gtk.test.gschema.xml",
2085                                        NULL, NULL, &result, NULL));
2086   g_assert (result == 0);
2087
2088   g_remove ("schema-source/gschemas.compiled");
2089   g_mkdir ("schema-source", 0777);
2090   g_assert (g_spawn_command_line_sync ("../glib-compile-schemas --targetdir=schema-source "
2091                                        "--schema-file=" SRCDIR "/org.gtk.schemasourcecheck.gschema.xml",
2092                                        NULL, NULL, &result, NULL));
2093   g_assert (result == 0);
2094
2095   g_test_add_func ("/gsettings/basic", test_basic);
2096
2097   if (!backend_set)
2098     {
2099       g_test_add_func ("/gsettings/no-schema", test_no_schema);
2100       g_test_add_func ("/gsettings/unknown-key", test_unknown_key);
2101       g_test_add_func ("/gsettings/wrong-type", test_wrong_type);
2102       g_test_add_func ("/gsettings/wrong-path", test_wrong_path);
2103       g_test_add_func ("/gsettings/no-path", test_no_path);
2104     }
2105
2106   g_test_add_func ("/gsettings/basic-types", test_basic_types);
2107   g_test_add_func ("/gsettings/complex-types", test_complex_types);
2108   g_test_add_func ("/gsettings/changes", test_changes);
2109
2110   if (glib_translations_work ())
2111     {
2112       g_test_add_func ("/gsettings/l10n", test_l10n);
2113       g_test_add_func ("/gsettings/l10n-context", test_l10n_context);
2114     }
2115
2116   g_test_add_func ("/gsettings/delay-apply", test_delay_apply);
2117   g_test_add_func ("/gsettings/delay-revert", test_delay_revert);
2118   g_test_add_func ("/gsettings/atomic", test_atomic);
2119
2120   g_test_add_func ("/gsettings/simple-binding", test_simple_binding);
2121   g_test_add_func ("/gsettings/directional-binding", test_directional_binding);
2122   g_test_add_func ("/gsettings/custom-binding", test_custom_binding);
2123   g_test_add_func ("/gsettings/no-change-binding", test_no_change_binding);
2124   g_test_add_func ("/gsettings/unbinding", test_unbind);
2125   g_test_add_func ("/gsettings/writable-binding", test_bind_writable);
2126
2127   if (!backend_set)
2128     {
2129       g_test_add_func ("/gsettings/typesafe-binding", test_typesafe_binding);
2130       g_test_add_func ("/gsettings/no-read-binding", test_no_read_binding);
2131       g_test_add_func ("/gsettings/no-write-binding", test_no_write_binding);
2132     }
2133
2134   g_test_add_func ("/gsettings/keyfile", test_keyfile);
2135   g_test_add_func ("/gsettings/child-schema", test_child_schema);
2136   g_test_add_func ("/gsettings/strinfo", test_strinfo);
2137   g_test_add_func ("/gsettings/enums", test_enums);
2138   g_test_add_func ("/gsettings/flags", test_flags);
2139   g_test_add_func ("/gsettings/range", test_range);
2140   g_test_add_func ("/gsettings/list-items", test_list_items);
2141   g_test_add_func ("/gsettings/list-schemas", test_list_schemas);
2142   g_test_add_func ("/gsettings/mapped", test_get_mapped);
2143   g_test_add_func ("/gsettings/get-range", test_get_range);
2144   g_test_add_func ("/gsettings/schema-source", test_schema_source);
2145   g_test_add_func ("/gsettings/actions", test_actions);
2146
2147   result = g_test_run ();
2148
2149   g_settings_sync ();
2150
2151   return result;
2152 }