test/test-utils.c

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