src/tests/ibus-bus.c

   1 /* -*- mode: C; c-basic-offset: 4; indent-tabs-mode: nil; -*- */
   2
   3 #include <string.h>
   4 #include "ibus.h"
   5
   6 static IBusBus *bus;
   7
   8 static void
   9 print_engines (const GList *engines)
  10 {
  11     for (; engines; engines = g_list_next (engines)) {
  12         IBusEngineDesc *engine_desc = IBUS_ENGINE_DESC (engines->data);
  13         g_assert (engine_desc);
  14 #if 0
  15         g_debug ("%s (id:%s, icon:%s)",
  16                  ibus_engine_desc_get_longname (engine_desc),
  17                  ibus_engine_desc_get_name (engine_desc),
  18                  ibus_engine_desc_get_icon (engine_desc));
  19 #endif
  20     }
  21 }
  22
  23 static void
  24 test_list_active_engines (void)
  25 {
  26     GList *engines;
  27     IBUS_TYPE_ENGINE_DESC;
  28
  29     engines = ibus_bus_list_active_engines (bus);
  30     print_engines (engines);
  31
  32     g_list_foreach (engines, (GFunc) g_object_unref, NULL);
  33     g_list_free (engines);
  34 }
  35
  36 static void
  37 test_list_engines (void)
  38 {
  39     GList *engines;
  40     IBUS_TYPE_ENGINE_DESC;
  41
  42     engines = ibus_bus_list_engines (bus);
  43     print_engines (engines);
  44
  45     g_list_foreach (engines, (GFunc) g_object_unref, NULL);
  46     g_list_free (engines);
  47 }
  48
  49 static void call_next_async_function (void);
  50
  51 static void
  52 finish_request_name_async (GObject *source_object,
  53                            GAsyncResult *res,
  54                            gpointer user_data)
  55 {
  56     GError *error = NULL;
  57     guint id = ibus_bus_request_name_async_finish (bus,
  58                                                    res,
  59                                                    &error);
  60     g_assert (id != 0);
  61     g_debug ("ibus_bus_request_name_async_finish: OK");
  62     call_next_async_function ();
  63 }
  64
  65 static void
  66 start_request_name_async (void)
  67 {
  68     ibus_bus_request_name_async (bus,
  69                                  "org.freedesktop.IBus.IBusBusTest",
  70                                  0,
  71                                  -1, /* timeout */
  72                                  NULL, /* cancellable */
  73                                  finish_request_name_async,
  74                                  NULL); /* user_data */
  75 }
  76
  77
  78 static void
  79 finish_name_has_owner_async (GObject *source_object,
  80                              GAsyncResult *res,
  81                              gpointer user_data)
  82 {
  83     GError *error = NULL;
  84     gboolean has_owner = ibus_bus_name_has_owner_async_finish (bus,
  85                                                                res,
  86                                                                &error);
  87     g_assert (has_owner);
  88     g_debug ("ibus_bus_name_has_owner_async_finish: OK");
  89     call_next_async_function ();
  90 }
  91
  92 static void
  93 start_name_has_owner_async (void)
  94 {
  95     ibus_bus_name_has_owner_async (bus,
  96                                    "org.freedesktop.IBus.IBusBusTest",
  97                                    -1, /* timeout */
  98                                    NULL, /* cancellable */
  99                                    finish_name_has_owner_async,
 100                                    NULL); /* user_data */
 101 }
 102
 103 static void
 104 finish_get_name_owner_async (GObject *source_object,
 105                              GAsyncResult *res,
 106                              gpointer user_data)
 107 {
 108     GError *error = NULL;
 109     gchar *owner = ibus_bus_get_name_owner_async_finish (bus,
 110                                                          res,
 111                                                          &error);
 112     g_assert (owner);
 113     g_free (owner);
 114     g_debug ("ibus_bus_name_get_name_owner_async_finish: OK");
 115     call_next_async_function ();
 116 }
 117
 118 static void
 119 start_get_name_owner_async (void)
 120 {
 121     ibus_bus_get_name_owner_async (bus,
 122                                    "org.freedesktop.IBus.IBusBusTest",
 123                                    -1, /* timeout */
 124                                    NULL, /* cancellable */
 125                                    finish_get_name_owner_async,
 126                                    NULL); /* user_data */
 127 }
 128
 129 static void
 130 finish_release_name_async (GObject *source_object,
 131                            GAsyncResult *res,
 132                            gpointer user_data)
 133 {
 134     GError *error = NULL;
 135     guint id = ibus_bus_release_name_async_finish (bus,
 136                                                    res,
 137                                                    &error);
 138     g_assert (id != 0);
 139     g_debug ("ibus_bus_release_name_async_finish: OK");
 140     call_next_async_function ();
 141 }
 142
 143 static void
 144 start_release_name_async (void)
 145 {
 146     ibus_bus_release_name_async (bus,
 147                                  "org.freedesktop.IBus.IBusBusTest",
 148                                  -1, /* timeout */
 149                                  NULL, /* cancellable */
 150                                  finish_release_name_async,
 151                                  NULL); /* user_data */
 152 }
 153
 154 static void
 155 finish_add_match_async (GObject *source_object,
 156                         GAsyncResult *res,
 157                         gpointer user_data)
 158 {
 159     GError *error = NULL;
 160     gboolean result = ibus_bus_add_match_async_finish (bus,
 161                                                        res,
 162                                                        &error);
 163     g_assert (result);
 164     g_debug ("ibus_bus_add_match_finish: OK");
 165     call_next_async_function ();
 166 }
 167
 168 static void
 169 start_add_match_async (void)
 170 {
 171     ibus_bus_add_match_async (bus,
 172                               "type='signal'",
 173                               -1, /* timeout */
 174                               NULL, /* cancellable */
 175                               finish_add_match_async,
 176                               NULL); /* user_data */
 177 }
 178
 179 static void
 180 finish_remove_match_async (GObject *source_object,
 181                            GAsyncResult *res,
 182                            gpointer user_data)
 183 {
 184     GError *error = NULL;
 185     gboolean result = ibus_bus_remove_match_async_finish (bus,
 186                                                           res,
 187                                                           &error);
 188     g_assert (result);
 189     g_debug ("ibus_bus_remove_match_finish: OK");
 190     call_next_async_function ();
 191 }
 192
 193 static void
 194 start_remove_match_async (void)
 195 {
 196     ibus_bus_remove_match_async (bus,
 197                                  "type='signal'",
 198                                  -1, /* timeout */
 199                                  NULL, /* cancellable */
 200                                  finish_remove_match_async,
 201                                  NULL); /* user_data */
 202 }
 203
 204 static int create_input_context_count = 0;
 205 static void
 206 finish_create_input_context_async_sucess (GObject      *source_object,
 207                                           GAsyncResult *res,
 208                                           gpointer      user_data)
 209 {
 210     GMainLoop *loop = (GMainLoop *)user_data;
 211     GError *error = NULL;
 212     IBusInputContext *context =
 213           ibus_bus_create_input_context_async_finish (bus, res, &error);
 214
 215     g_assert (IBUS_IS_INPUT_CONTEXT (context));
 216     g_object_unref (context);
 217     if (--create_input_context_count == 0)
 218         g_main_loop_quit (loop);
 219 }
 220
 221 static void
 222 finish_create_input_context_async_failed (GObject      *source_object,
 223                                           GAsyncResult *res,
 224                                           gpointer      user_data)
 225 {
 226     GMainLoop *loop = (GMainLoop *)user_data;
 227     GError *error = NULL;
 228     IBusInputContext *context =
 229             ibus_bus_create_input_context_async_finish (bus, res, &error);
 230
 231     g_assert (context == NULL);
 232     g_assert (error != NULL);
 233     g_error_free (error);
 234     if (--create_input_context_count <= 0)
 235         g_main_loop_quit (loop);
 236 }
 237
 238 static void
 239 test_create_input_context_async (void)
 240 {
 241     GMainLoop *loop = NULL;
 242     GCancellable *cancellable = NULL;
 243
 244     /* create an IC */
 245     create_input_context_count = 1;
 246     loop = g_main_loop_new (NULL, TRUE);
 247     ibus_bus_create_input_context_async (bus,
 248             "test-async",
 249             -1, /* timeout */
 250             NULL, /* cancellable */
 251             finish_create_input_context_async_sucess,
 252             loop); /* user_data */
 253     g_main_loop_run (loop);
 254     g_main_loop_unref (loop);
 255
 256     /* call create, and then cancel */
 257     create_input_context_count = 1;
 258     loop = g_main_loop_new (NULL, TRUE);
 259     cancellable = g_cancellable_new ();
 260     ibus_bus_create_input_context_async (bus,
 261             "test-async",
 262             -1, /* timeout */
 263             cancellable, /* cancellable */
 264             finish_create_input_context_async_failed,
 265             loop); /* user_data */
 266     g_cancellable_cancel (cancellable);
 267     g_object_unref (cancellable);
 268     g_main_loop_run (loop);
 269     g_main_loop_unref (loop);
 270
 271     /* ceate four IC, and cancel two */
 272     create_input_context_count = 4;
 273     loop = g_main_loop_new (NULL, TRUE);
 274     cancellable = g_cancellable_new ();
 275     ibus_bus_create_input_context_async (bus,
 276             "test-async",
 277             -1, /* timeout */
 278             cancellable, /* cancellable */
 279             finish_create_input_context_async_failed,
 280             loop); /* user_data */
 281     ibus_bus_create_input_context_async (bus,
 282             "test-async",
 283             -1, /* timeout */
 284             NULL, /* cancellable */
 285             finish_create_input_context_async_sucess,
 286             loop); /* user_data */
 287     ibus_bus_create_input_context_async (bus,
 288             "test-async",
 289             -1, /* timeout */
 290             NULL, /* cancellable */
 291             finish_create_input_context_async_sucess,
 292             loop); /* user_data */
 293     ibus_bus_create_input_context_async (bus,
 294             "test-async",
 295             -1, /* timeout */
 296             cancellable, /* cancellable */
 297             finish_create_input_context_async_failed,
 298             loop); /* user_data */
 299     g_cancellable_cancel (cancellable);
 300     g_object_unref (cancellable);
 301
 302     g_main_loop_run (loop);
 303     g_main_loop_unref (loop);
 304 }
 305
 306 static void
 307 finish_current_input_context_async (GObject *source_object,
 308                                     GAsyncResult *res,
 309                                     gpointer user_data)
 310 {
 311     GError *error = NULL;
 312     g_free (ibus_bus_current_input_context_async_finish (bus,
 313                                                          res,
 314                                                          &error));
 315     // no null check.
 316     g_debug ("ibus_bus_current_input_context_finish: OK");
 317     call_next_async_function ();
 318 }
 319
 320 static void
 321 start_current_input_context_async (void)
 322 {
 323     ibus_bus_current_input_context_async (bus,
 324                                           -1, /* timeout */
 325                                           NULL, /* cancellable */
 326                                           finish_current_input_context_async,
 327                                           NULL); /* user_data */
 328 }
 329
 330 static void
 331 finish_list_engines_async (GObject *source_object,
 332                            GAsyncResult *res,
 333                            gpointer user_data)
 334 {
 335     GError *error = NULL;
 336     GList *engines = ibus_bus_list_engines_async_finish (bus,
 337                                                          res,
 338                                                          &error);
 339     // no null check.
 340     g_list_foreach (engines, (GFunc) g_object_unref, NULL);
 341     g_list_free (engines);
 342     g_debug ("ibus_bus_list_engines_finish: OK");
 343     call_next_async_function ();
 344 }
 345
 346 static void
 347 start_list_engines_async (void)
 348 {
 349     ibus_bus_list_engines_async (bus,
 350                                  -1, /* timeout */
 351                                  NULL, /* cancellable */
 352                                  finish_list_engines_async,
 353                                  NULL); /* user_data */
 354 }
 355
 356 static void
 357 finish_list_active_engines_async (GObject *source_object,
 358                                   GAsyncResult *res,
 359                                   gpointer user_data)
 360 {
 361     GError *error = NULL;
 362     GList *engines = ibus_bus_list_active_engines_async_finish (bus,
 363                                                                 res,
 364                                                                 &error);
 365     // no null check.
 366     g_list_foreach (engines, (GFunc) g_object_unref, NULL);
 367     g_list_free (engines);
 368     g_debug ("ibus_bus_list_active_engines_finish: OK");
 369     call_next_async_function ();
 370 }
 371
 372 static void
 373 start_list_active_engines_async (void)
 374 {
 375     ibus_bus_list_active_engines_async (bus,
 376                                         -1, /* timeout */
 377                                         NULL, /* cancellable */
 378                                         finish_list_active_engines_async,
 379                                         NULL); /* user_data */
 380 }
 381
 382 static void
 383 finish_get_use_sys_layout_async (GObject *source_object,
 384                                  GAsyncResult *res,
 385                                  gpointer user_data)
 386 {
 387     GError *error = NULL;
 388     ibus_bus_get_use_sys_layout_async_finish (bus,
 389                                               res,
 390                                               &error);
 391     g_debug ("ibus_bus_get_use_sys_layout_finish: OK");
 392     call_next_async_function ();
 393 }
 394
 395 static void
 396 start_get_use_sys_layout_async (void)
 397 {
 398     ibus_bus_get_use_sys_layout_async (bus,
 399                                        -1, /* timeout */
 400                                        NULL, /* cancellable */
 401                                        finish_get_use_sys_layout_async,
 402                                        NULL); /* user_data */
 403 }
 404
 405 static void
 406 finish_get_use_global_engine_async (GObject *source_object,
 407                                     GAsyncResult *res,
 408                                     gpointer user_data)
 409 {
 410     GError *error = NULL;
 411     ibus_bus_get_use_global_engine_async_finish (bus,
 412                                                  res,
 413                                                  &error);
 414     g_debug ("ibus_bus_get_use_global_engine_finish: OK");
 415     call_next_async_function ();
 416 }
 417
 418 static void
 419 start_get_use_global_engine_async (void)
 420 {
 421     ibus_bus_get_use_global_engine_async (bus,
 422                                           -1, /* timeout */
 423                                           NULL, /* cancellable */
 424                                           finish_get_use_global_engine_async,
 425                                           NULL); /* user_data */
 426 }
 427
 428 static void
 429 finish_is_global_engine_enabled_async (GObject *source_object,
 430                                        GAsyncResult *res,
 431                                        gpointer user_data)
 432 {
 433     GError *error = NULL;
 434     ibus_bus_is_global_engine_enabled_async_finish (bus,
 435                                                     res,
 436                                                     &error);
 437     g_debug ("ibus_bus_is_global_engine_enabled_finish: OK");
 438     call_next_async_function ();
 439 }
 440
 441 static void
 442 start_is_global_engine_enabled_async (void)
 443 {
 444     ibus_bus_is_global_engine_enabled_async (bus,
 445                                              -1, /* timeout */
 446                                              NULL, /* cancellable */
 447                                              finish_is_global_engine_enabled_async,
 448                                              NULL); /* user_data */
 449 }
 450
 451 static void
 452 finish_get_global_engine_async (GObject *source_object,
 453                                 GAsyncResult *res,
 454                                 gpointer user_data)
 455 {
 456     GError *error = NULL;
 457     IBusEngineDesc *desc = ibus_bus_get_global_engine_async_finish (bus,
 458                                                                     res,
 459                                                                     &error);
 460     if (desc)
 461         g_object_unref (desc);
 462     g_debug ("ibus_bus_get_global_engine_finish: OK");
 463     call_next_async_function ();
 464 }
 465
 466 static void
 467 start_get_global_engine_async (void)
 468 {
 469     ibus_bus_get_global_engine_async (bus,
 470                                       -1, /* timeout */
 471                                       NULL, /* cancellable */
 472                                       finish_get_global_engine_async,
 473                                       NULL); /* user_data */
 474 }
 475
 476 static void
 477 finish_set_global_engine_async (GObject *source_object,
 478                                 GAsyncResult *res,
 479                                 gpointer user_data)
 480 {
 481     GError *error = NULL;
 482     ibus_bus_set_global_engine_async_finish (bus,
 483                                              res,
 484                                              &error);
 485     g_debug ("ibus_bus_set_global_engine_finish: OK");
 486     call_next_async_function ();
 487 }
 488
 489 static void
 490 start_set_global_engine_async (void)
 491 {
 492     ibus_bus_set_global_engine_async (bus,
 493                                       "anthy",
 494                                       -1, /* timeout */
 495                                       NULL, /* cancellable */
 496                                       finish_set_global_engine_async,
 497                                       NULL); /* user_data */
 498 }
 499
 500 static void
 501 finish_preload_engines_async (GObject      *source_object,
 502                               GAsyncResult *res,
 503                               gpointer      user_data)
 504 {
 505     GError *error = NULL;
 506     ibus_bus_preload_engines_async_finish (bus, res, &error);
 507     g_debug ("ibus_bus_preload_engines_async_finish: OK");
 508     call_next_async_function ();
 509 }
 510
 511 static void
 512 start_preload_engines_async (void)
 513 {
 514     const gchar *preload_engines[] = { "xkb:us::eng", NULL };
 515
 516     ibus_bus_preload_engines_async (
 517             bus,
 518             preload_engines,
 519             -1, /* timeout */
 520             NULL, /* cancellable */
 521             finish_preload_engines_async,
 522             NULL); /* user_data */
 523 }
 524
 525 static void
 526 finish_exit_async (GObject *source_object,
 527                    GAsyncResult *res,
 528                    gpointer user_data)
 529 {
 530     GError *error = NULL;
 531     gboolean result = ibus_bus_exit_async_finish (bus,
 532                                                   res,
 533                                                   &error);
 534     g_assert (result);
 535     g_debug ("ibus_bus_exit_finish: OK");
 536     g_usleep (G_USEC_PER_SEC);
 537     call_next_async_function ();
 538 }
 539
 540 static void
 541 start_exit_async (void)
 542 {
 543     ibus_bus_exit_async (bus,
 544                          TRUE, /* restart */
 545                          -1, /* timeout */
 546                          NULL, /* cancellable */
 547                          finish_exit_async,
 548                          NULL); /* user_data */
 549 }
 550
 551 static gboolean
 552 test_async_apis_finish (gpointer user_data)
 553 {
 554     ibus_quit ();
 555     return FALSE;
 556 }
 557
 558 static void
 559 test_get_engines_by_names (void)
 560 {
 561     IBusEngineDesc **engines = NULL;
 562     const gchar *names[] = {
 563         "xkb:us::eng",
 564         "xkb:ca:eng:eng",
 565         "xkb:fr::fra",
 566         "xkb:jp::jpn",
 567         "invalid_engine_name",
 568         NULL,
 569     };
 570
 571     engines = ibus_bus_get_engines_by_names (bus, names);
 572
 573     g_assert(engines != NULL);
 574     IBusEngineDesc **p;
 575
 576     gint i = 0;
 577     for (p = engines; *p != NULL; p++) {
 578         g_assert (IBUS_IS_ENGINE_DESC (*p));
 579         g_assert_cmpstr (names[i], ==, ibus_engine_desc_get_name (*p));
 580         i++;
 581         g_object_unref (*p);
 582         // The ref should be zero, *p is released.
 583         g_assert (!IBUS_IS_ENGINE_DESC (*p));
 584     }
 585
 586     // The last engine does not exist.
 587     g_assert_cmpint (i, ==, G_N_ELEMENTS(names) - 2);
 588
 589     g_free (engines);
 590
 591     engines = NULL;
 592 }
 593
 594 static void
 595 test_async_apis (void)
 596 {
 597     g_debug ("start");
 598     call_next_async_function ();
 599     ibus_main ();
 600 }
 601
 602 static void
 603 call_next_async_function (void)
 604 {
 605     static void (*async_functions[])(void) = {
 606         start_request_name_async,
 607         start_name_has_owner_async,
 608         start_get_name_owner_async,
 609         start_release_name_async,
 610         start_add_match_async,
 611         start_remove_match_async,
 612         start_current_input_context_async,
 613         // FIXME test ibus_bus_register_component_async.
 614         start_list_engines_async,
 615         start_list_active_engines_async,
 616         start_get_use_sys_layout_async,
 617         start_get_use_global_engine_async,
 618         start_is_global_engine_enabled_async,
 619         start_set_global_engine_async,
 620         start_get_global_engine_async,
 621         start_preload_engines_async,
 622         start_exit_async,
 623     };
 624     static guint index = 0;
 625
 626     // Use g_timeout_add to make sure test_async_apis finishes even if async_functions is empty.
 627     if (index >= G_N_ELEMENTS (async_functions))
 628         g_timeout_add (1, test_async_apis_finish, NULL);
 629     else
 630         (*async_functions[index++])();
 631 }
 632
 633 static void
 634 _bus_connected_cb (IBusBus *bus,
 635                    gpointer user_data)
 636 {
 637     g_assert (ibus_bus_is_connected (bus));
 638     ibus_quit ();
 639 }
 640
 641 static void
 642 test_bus_new_async (void)
 643 {
 644     g_object_unref (bus);
 645     bus = ibus_bus_new_async ();
 646     g_signal_connect (bus, "connected", G_CALLBACK (_bus_connected_cb), NULL);
 647     ibus_main ();
 648 }
 649
 650 gint
 651 main (gint    argc,
 652       gchar **argv)
 653 {
 654     gint result;
 655     ibus_init ();
 656     g_test_init (&argc, &argv, NULL);
 657     bus = ibus_bus_new ();
 658     g_object_unref (bus);
 659     bus = ibus_bus_new (); // crosbug.com/17293
 660
 661     g_test_add_func ("/ibus/list-engines", test_list_engines);
 662     g_test_add_func ("/ibus/list-active-engines", test_list_active_engines);
 663     g_test_add_func ("/ibus/create-input-context-async",
 664                      test_create_input_context_async);
 665     g_test_add_func ("/ibus/get-engines-by-names", test_get_engines_by_names);
 666     g_test_add_func ("/ibus/async-apis", test_async_apis);
 667     g_test_add_func ("/ibus/bus-new-async", test_bus_new_async);
 668     g_test_add_func ("/ibus/bus-new-async/list-engines", test_list_engines);
 669     g_test_add_func ("/ibus/bus-new-async/list-active-engines", test_list_active_engines);
 670     g_test_add_func ("/ibus/bus-new-async/create-input-context-async",
 671                      test_create_input_context_async);
 672     g_test_add_func ("/ibus/bus-new-async/get-engines-by-names", test_get_engines_by_names);
 673     g_test_add_func ("/ibus/bus-new-async/async-apis", test_async_apis);
 674
 675     result = g_test_run ();
 676     g_object_unref (bus);
 677
 678     return result;
 679 }