test/test-utils.c

   1 #include <config.h>
   2 #include "test-utils.h"
   3
   4 #ifndef DBUS_TEST_USE_INTERNAL
   5 # include <dbus/dbus.h>
   6 # include <dbus/dbus-glib-lowlevel.h>
   7 #endif
   8
   9 #ifdef DBUS_TEST_USE_INTERNAL
  10
  11 typedef struct
  12 {
  13   DBusLoop *loop;
  14   DBusConnection *connection;
  15
  16 } CData;
  17
  18 static dbus_bool_t
  19 add_watch (DBusWatch *watch,
  20            void      *data)
  21 {
  22   CData *cd = data;
  23
  24   return _dbus_loop_add_watch (cd->loop, watch);
  25 }
  26
  27 static void
  28 remove_watch (DBusWatch *watch,
  29               void      *data)
  30 {
  31   CData *cd = data;
  32
  33   _dbus_loop_remove_watch (cd->loop, watch);
  34 }
  35
  36 static void
  37 toggle_watch (DBusWatch  *watch,
  38               void       *data)
  39 {
  40   CData *cd = data;
  41
  42   _dbus_loop_toggle_watch (cd->loop, watch);
  43 }
  44
  45 static dbus_bool_t
  46 add_timeout (DBusTimeout *timeout,
  47              void        *data)
  48 {
  49   CData *cd = data;
  50
  51   return _dbus_loop_add_timeout (cd->loop, timeout);
  52 }
  53
  54 static void
  55 remove_timeout (DBusTimeout *timeout,
  56                 void        *data)
  57 {
  58   CData *cd = data;
  59
  60   _dbus_loop_remove_timeout (cd->loop, timeout);
  61 }
  62
  63 static void
  64 dispatch_status_function (DBusConnection    *connection,
  65                           DBusDispatchStatus new_status,
  66                           void              *data)
  67 {
  68   DBusLoop *loop = data;
  69
  70   if (new_status != DBUS_DISPATCH_COMPLETE)
  71     {
  72       while (!_dbus_loop_queue_dispatch (loop, connection))
  73         _dbus_wait_for_memory ();
  74     }
  75 }
  76
  77 static void
  78 cdata_free (void *data)
  79 {
  80   CData *cd = data;
  81
  82   dbus_connection_unref (cd->connection);
  83   _dbus_loop_unref (cd->loop);
  84
  85   dbus_free (cd);
  86 }
  87
  88 static CData*
  89 cdata_new (DBusLoop       *loop,
  90            DBusConnection *connection)
  91 {
  92   CData *cd;
  93
  94   cd = dbus_new0 (CData, 1);
  95   if (cd == NULL)
  96     return NULL;
  97
  98   cd->loop = loop;
  99   cd->connection = connection;
 100
 101   dbus_connection_ref (cd->connection);
 102   _dbus_loop_ref (cd->loop);
 103
 104   return cd;
 105 }
 106
 107 #endif /* DBUS_TEST_USE_INTERNAL */
 108
 109 dbus_bool_t
 110 test_connection_setup (TestMainContext *ctx,
 111                        DBusConnection *connection)
 112 {
 113 #ifdef DBUS_TEST_USE_INTERNAL
 114   DBusLoop *loop = ctx;
 115   CData *cd;
 116
 117   cd = NULL;
 118
 119   dbus_connection_set_dispatch_status_function (connection, dispatch_status_function,
 120                                                 loop, NULL);
 121
 122   cd = cdata_new (loop, connection);
 123   if (cd == NULL)
 124     goto nomem;
 125
 126   if (!dbus_connection_set_watch_functions (connection,
 127                                             add_watch,
 128                                             remove_watch,
 129                                             toggle_watch,
 130                                             cd, cdata_free))
 131     goto nomem;
 132
 133
 134   cd = cdata_new (loop, connection);
 135   if (cd == NULL)
 136     goto nomem;
 137
 138   if (!dbus_connection_set_timeout_functions (connection,
 139                                               add_timeout,
 140                                               remove_timeout,
 141                                               NULL,
 142                                               cd, cdata_free))
 143     goto nomem;
 144
 145   if (dbus_connection_get_dispatch_status (connection) != DBUS_DISPATCH_COMPLETE)
 146     {
 147       if (!_dbus_loop_queue_dispatch (loop, connection))
 148         goto nomem;
 149     }
 150
 151   return TRUE;
 152
 153  nomem:
 154   if (cd)
 155     cdata_free (cd);
 156
 157   dbus_connection_set_dispatch_status_function (connection, NULL, NULL, NULL);
 158   dbus_connection_set_watch_functions (connection, NULL, NULL, NULL, NULL, NULL);
 159   dbus_connection_set_timeout_functions (connection, NULL, NULL, NULL, NULL, NULL);
 160
 161   return FALSE;
 162 #else /* !DBUS_TEST_USE_INTERNAL */
 163
 164   dbus_connection_setup_with_g_main (connection, ctx);
 165   return TRUE;
 166
 167 #endif /* !DBUS_TEST_USE_INTERNAL */
 168 }
 169
 170 static void
 171 die (const char *message)
 172 {
 173   fprintf (stderr, "*** %s", message);
 174   exit (1);
 175 }
 176
 177 void
 178 test_connection_shutdown (TestMainContext *ctx,
 179                           DBusConnection *connection)
 180 {
 181   if (!dbus_connection_set_watch_functions (connection,
 182                                             NULL,
 183                                             NULL,
 184                                             NULL,
 185                                             NULL, NULL))
 186     die ("setting watch functions to NULL failed");
 187
 188   if (!dbus_connection_set_timeout_functions (connection,
 189                                               NULL,
 190                                               NULL,
 191                                               NULL,
 192                                               NULL, NULL))
 193     die ("setting timeout functions to NULL failed");
 194
 195   dbus_connection_set_dispatch_status_function (connection, NULL, NULL, NULL);
 196 }
 197
 198 #ifdef DBUS_TEST_USE_INTERNAL
 199
 200 typedef struct
 201 {
 202   DBusLoop *loop;
 203   DBusServer *server;
 204 } ServerData;
 205
 206 static void
 207 serverdata_free (void *data)
 208 {
 209   ServerData *sd = data;
 210
 211   dbus_server_unref (sd->server);
 212   _dbus_loop_unref (sd->loop);
 213
 214   dbus_free (sd);
 215 }
 216
 217 static ServerData*
 218 serverdata_new (DBusLoop       *loop,
 219                 DBusServer     *server)
 220 {
 221   ServerData *sd;
 222
 223   sd = dbus_new0 (ServerData, 1);
 224   if (sd == NULL)
 225     return NULL;
 226
 227   sd->loop = loop;
 228   sd->server = server;
 229
 230   dbus_server_ref (sd->server);
 231   _dbus_loop_ref (sd->loop);
 232
 233   return sd;
 234 }
 235
 236 static dbus_bool_t
 237 add_server_watch (DBusWatch  *watch,
 238                   void       *data)
 239 {
 240   ServerData *context = data;
 241
 242   return _dbus_loop_add_watch (context->loop, watch);
 243 }
 244
 245 static void
 246 toggle_server_watch (DBusWatch  *watch,
 247                      void       *data)
 248 {
 249   ServerData *context = data;
 250
 251   _dbus_loop_toggle_watch (context->loop, watch);
 252 }
 253
 254 static void
 255 remove_server_watch (DBusWatch  *watch,
 256                      void       *data)
 257 {
 258   ServerData *context = data;
 259
 260   _dbus_loop_remove_watch (context->loop, watch);
 261 }
 262
 263 static dbus_bool_t
 264 add_server_timeout (DBusTimeout *timeout,
 265                     void        *data)
 266 {
 267   ServerData *context = data;
 268
 269   return _dbus_loop_add_timeout (context->loop, timeout);
 270 }
 271
 272 static void
 273 remove_server_timeout (DBusTimeout *timeout,
 274                        void        *data)
 275 {
 276   ServerData *context = data;
 277
 278   _dbus_loop_remove_timeout (context->loop, timeout);
 279 }
 280
 281 #endif /* DBUS_TEST_USE_INTERNAL */
 282
 283 dbus_bool_t
 284 test_server_setup (TestMainContext *ctx,
 285                    DBusServer    *server)
 286 {
 287 #ifdef DBUS_TEST_USE_INTERNAL
 288   DBusLoop *loop = ctx;
 289   ServerData *sd;
 290
 291   sd = serverdata_new (loop, server);
 292   if (sd == NULL)
 293     goto nomem;
 294
 295   if (!dbus_server_set_watch_functions (server,
 296                                         add_server_watch,
 297                                         remove_server_watch,
 298                                         toggle_server_watch,
 299                                         sd,
 300                                         serverdata_free))
 301     {
 302       goto nomem;
 303     }
 304
 305   sd = serverdata_new (loop, server);
 306   if (sd == NULL)
 307     goto nomem;
 308
 309   if (!dbus_server_set_timeout_functions (server,
 310                                           add_server_timeout,
 311                                           remove_server_timeout,
 312                                           NULL,
 313                                           sd, serverdata_free))
 314     {
 315       goto nomem;
 316     }
 317   return TRUE;
 318
 319  nomem:
 320   if (sd)
 321     serverdata_free (sd);
 322
 323   test_server_shutdown (loop, server);
 324
 325   return FALSE;
 326
 327 #else /* !DBUS_TEST_USE_INTERNAL */
 328
 329   dbus_server_setup_with_g_main (server, ctx);
 330   return TRUE;
 331
 332 #endif /* !DBUS_TEST_USE_INTERNAL */
 333 }
 334
 335 void
 336 test_server_shutdown (TestMainContext  *ctx,
 337                       DBusServer       *server)
 338 {
 339   dbus_server_disconnect (server);
 340
 341   if (!dbus_server_set_watch_functions (server,
 342                                         NULL, NULL, NULL,
 343                                         NULL,
 344                                         NULL))
 345     die ("setting watch functions to NULL failed");
 346
 347   if (!dbus_server_set_timeout_functions (server,
 348                                           NULL, NULL, NULL,
 349                                           NULL,
 350                                           NULL))
 351     die ("setting timeout functions to NULL failed");
 352 }
 353
 354 TestMainContext *
 355 test_main_context_get (void)
 356 {
 357 #ifdef DBUS_TEST_USE_INTERNAL
 358   return _dbus_loop_new ();
 359 #else
 360   /* I suspect dbus-glib relies the default main context in some places */
 361   return g_main_context_ref (g_main_context_default ());
 362 #endif
 363 }
 364
 365 TestMainContext *
 366 test_main_context_ref (TestMainContext *ctx)
 367 {
 368 #ifdef DBUS_TEST_USE_INTERNAL
 369   return _dbus_loop_ref (ctx);
 370 #else
 371   return g_main_context_ref (ctx);
 372 #endif
 373 }
 374
 375 void test_main_context_unref (TestMainContext *ctx)
 376 {
 377 #ifdef DBUS_TEST_USE_INTERNAL
 378   _dbus_loop_unref (ctx);
 379 #else
 380   g_main_context_unref (ctx);
 381 #endif
 382 }
 383
 384 void test_main_context_iterate (TestMainContext *ctx,
 385                                 dbus_bool_t      may_block)
 386 {
 387 #ifdef DBUS_TEST_USE_INTERNAL
 388   _dbus_loop_iterate (ctx, may_block);
 389 #else
 390   g_main_context_iteration (ctx, may_block);
 391 #endif
 392 }