test/test-utils.c

   1 #include "test-utils.h"
   2
   3 typedef struct
   4 {
   5   DBusLoop *loop;
   6   DBusConnection *connection;
   7
   8 } CData;
   9
  10 static dbus_bool_t
  11 connection_watch_callback (DBusWatch     *watch,
  12                            unsigned int   condition,
  13                            void          *data)
  14 {
  15   return dbus_watch_handle (watch, condition);
  16 }
  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,
  25                                watch,
  26                                connection_watch_callback,
  27                                cd, NULL);
  28 }
  29
  30 static void
  31 remove_watch (DBusWatch *watch,
  32               void      *data)
  33 {
  34   CData *cd = data;
  35
  36   _dbus_loop_remove_watch (cd->loop,
  37                            watch, connection_watch_callback, cd);
  38 }
  39
  40 static void
  41 connection_timeout_callback (DBusTimeout   *timeout,
  42                              void          *data)
  43 {
  44   /* Can return FALSE on OOM but we just let it fire again later */
  45   dbus_timeout_handle (timeout);
  46 }
  47
  48 static dbus_bool_t
  49 add_timeout (DBusTimeout *timeout,
  50              void        *data)
  51 {
  52   CData *cd = data;
  53
  54   return _dbus_loop_add_timeout (cd->loop,
  55                                  timeout, connection_timeout_callback, cd, NULL);
  56 }
  57
  58 static void
  59 remove_timeout (DBusTimeout *timeout,
  60                 void        *data)
  61 {
  62   CData *cd = data;
  63
  64   _dbus_loop_remove_timeout (cd->loop,
  65                              timeout, connection_timeout_callback, cd);
  66 }
  67
  68 static void
  69 dispatch_status_function (DBusConnection    *connection,
  70                           DBusDispatchStatus new_status,
  71                           void              *data)
  72 {
  73   DBusLoop *loop = data;
  74
  75   if (new_status != DBUS_DISPATCH_COMPLETE)
  76     {
  77       while (!_dbus_loop_queue_dispatch (loop, connection))
  78         _dbus_wait_for_memory ();
  79     }
  80 }
  81
  82 static void
  83 cdata_free (void *data)
  84 {
  85   CData *cd = data;
  86
  87   dbus_connection_unref (cd->connection);
  88   _dbus_loop_unref (cd->loop);
  89
  90   dbus_free (cd);
  91 }
  92
  93 static CData*
  94 cdata_new (DBusLoop       *loop,
  95            DBusConnection *connection)
  96 {
  97   CData *cd;
  98
  99   cd = dbus_new0 (CData, 1);
 100   if (cd == NULL)
 101     return NULL;
 102
 103   cd->loop = loop;
 104   cd->connection = connection;
 105
 106   dbus_connection_ref (cd->connection);
 107   _dbus_loop_ref (cd->loop);
 108
 109   return cd;
 110 }
 111
 112 dbus_bool_t
 113 test_connection_setup (DBusLoop       *loop,
 114                        DBusConnection *connection)
 115 {
 116   CData *cd;
 117
 118   cd = NULL;
 119
 120   dbus_connection_set_dispatch_status_function (connection, dispatch_status_function,
 121                                                 loop, NULL);
 122
 123   cd = cdata_new (loop, connection);
 124   if (cd == NULL)
 125     goto nomem;
 126
 127   /* Because dbus-mainloop.c checks dbus_timeout_get_enabled(),
 128    * dbus_watch_get_enabled() directly, we don't have to provide
 129    * "toggled" callbacks.
 130    */
 131
 132   if (!dbus_connection_set_watch_functions (connection,
 133                                             add_watch,
 134                                             remove_watch,
 135                                             NULL,
 136                                             cd, cdata_free))
 137     goto nomem;
 138
 139
 140   cd = cdata_new (loop, connection);
 141   if (cd == NULL)
 142     goto nomem;
 143
 144   if (!dbus_connection_set_timeout_functions (connection,
 145                                               add_timeout,
 146                                               remove_timeout,
 147                                               NULL,
 148                                               cd, cdata_free))
 149     goto nomem;
 150
 151   if (dbus_connection_get_dispatch_status (connection) != DBUS_DISPATCH_COMPLETE)
 152     {
 153       if (!_dbus_loop_queue_dispatch (loop, connection))
 154         goto nomem;
 155     }
 156
 157   return TRUE;
 158
 159  nomem:
 160   if (cd)
 161     cdata_free (cd);
 162
 163   dbus_connection_set_dispatch_status_function (connection, NULL, NULL, NULL);
 164   dbus_connection_set_watch_functions (connection, NULL, NULL, NULL, NULL, NULL);
 165   dbus_connection_set_timeout_functions (connection, NULL, NULL, NULL, NULL, NULL);
 166
 167   return FALSE;
 168 }
 169
 170 void
 171 test_connection_shutdown (DBusLoop       *loop,
 172                           DBusConnection *connection)
 173 {
 174   if (!dbus_connection_set_watch_functions (connection,
 175                                             NULL,
 176                                             NULL,
 177                                             NULL,
 178                                             NULL, NULL))
 179     _dbus_assert_not_reached ("setting watch functions to NULL failed");
 180
 181   if (!dbus_connection_set_timeout_functions (connection,
 182                                               NULL,
 183                                               NULL,
 184                                               NULL,
 185                                               NULL, NULL))
 186     _dbus_assert_not_reached ("setting timeout functions to NULL failed");
 187
 188   dbus_connection_set_dispatch_status_function (connection, NULL, NULL, NULL);
 189 }
 190
 191 typedef struct
 192 {
 193   DBusLoop *loop;
 194   DBusServer *server;
 195 } ServerData;
 196
 197 static void
 198 serverdata_free (void *data)
 199 {
 200   ServerData *sd = data;
 201
 202   dbus_server_unref (sd->server);
 203   _dbus_loop_unref (sd->loop);
 204
 205   dbus_free (sd);
 206 }
 207
 208 static ServerData*
 209 serverdata_new (DBusLoop       *loop,
 210                 DBusServer     *server)
 211 {
 212   ServerData *sd;
 213
 214   sd = dbus_new0 (ServerData, 1);
 215   if (sd == NULL)
 216     return NULL;
 217
 218   sd->loop = loop;
 219   sd->server = server;
 220
 221   dbus_server_ref (sd->server);
 222   _dbus_loop_ref (sd->loop);
 223
 224   return sd;
 225 }
 226
 227 static dbus_bool_t
 228 server_watch_callback (DBusWatch     *watch,
 229                        unsigned int   condition,
 230                        void          *data)
 231 {
 232   /* FIXME this can be done in dbus-mainloop.c
 233    * if the code in activation.c for the babysitter
 234    * watch handler is fixed.
 235    */
 236
 237   return dbus_watch_handle (watch, condition);
 238 }
 239
 240 static dbus_bool_t
 241 add_server_watch (DBusWatch  *watch,
 242                   void       *data)
 243 {
 244   ServerData *context = data;
 245
 246   return _dbus_loop_add_watch (context->loop,
 247                                watch, server_watch_callback, context,
 248                                NULL);
 249 }
 250
 251 static void
 252 remove_server_watch (DBusWatch  *watch,
 253                      void       *data)
 254 {
 255   ServerData *context = data;
 256
 257   _dbus_loop_remove_watch (context->loop,
 258                            watch, server_watch_callback, context);
 259 }
 260
 261 static void
 262 server_timeout_callback (DBusTimeout   *timeout,
 263                          void          *data)
 264 {
 265   /* can return FALSE on OOM but we just let it fire again later */
 266   dbus_timeout_handle (timeout);
 267 }
 268
 269 static dbus_bool_t
 270 add_server_timeout (DBusTimeout *timeout,
 271                     void        *data)
 272 {
 273   ServerData *context = data;
 274
 275   return _dbus_loop_add_timeout (context->loop,
 276                                  timeout, server_timeout_callback, context, NULL);
 277 }
 278
 279 static void
 280 remove_server_timeout (DBusTimeout *timeout,
 281                        void        *data)
 282 {
 283   ServerData *context = data;
 284
 285   _dbus_loop_remove_timeout (context->loop,
 286                              timeout, server_timeout_callback, context);
 287 }
 288
 289 dbus_bool_t
 290 test_server_setup (DBusLoop      *loop,
 291                    DBusServer    *server)
 292 {
 293   ServerData *sd;
 294
 295   sd = serverdata_new (loop, server);
 296   if (sd == NULL)
 297     goto nomem;
 298
 299   if (!dbus_server_set_watch_functions (server,
 300                                         add_server_watch,
 301                                         remove_server_watch,
 302                                         NULL,
 303                                         sd,
 304                                         serverdata_free))
 305     {
 306       return FALSE;
 307     }
 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       return FALSE;
 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
 328 void
 329 test_server_shutdown (DBusLoop         *loop,
 330                       DBusServer       *server)
 331 {
 332   if (!dbus_server_set_watch_functions (server,
 333                                         NULL, NULL, NULL,
 334                                         NULL,
 335                                         NULL))
 336     _dbus_assert_not_reached ("setting watch functions to NULL failed");
 337
 338   if (!dbus_server_set_timeout_functions (server,
 339                                           NULL, NULL, NULL,
 340                                           NULL,
 341                                           NULL))
 342     _dbus_assert_not_reached ("setting timeout functions to NULL failed");
 343 }