Bug 21161 - Update the FSF address
[platform/upstream/dbus.git] / bus / test.c
1 /* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
2 /* test.c  unit test routines
3  *
4  * Copyright (C) 2003 Red Hat, Inc.
5  *
6  * Licensed under the Academic Free License version 2.1
7  * 
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 2 of the License, or
11  * (at your option) any later version.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  * 
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
21  *
22  */
23
24 #include <config.h>
25
26 #ifdef DBUS_BUILD_TESTS
27 #include "test.h"
28 #include <dbus/dbus-internals.h>
29 #include <dbus/dbus-list.h>
30 #include <dbus/dbus-sysdeps.h>
31
32 /* The "debug client" watch/timeout handlers don't dispatch messages,
33  * as we manually pull them in order to verify them. This is why they
34  * are different from the real handlers in connection.c
35  */
36 static DBusList *clients = NULL;
37 static DBusLoop *client_loop = NULL;
38
39 static dbus_bool_t
40 client_watch_callback (DBusWatch     *watch,
41                        unsigned int   condition,
42                        void          *data)
43 {
44   /* FIXME this can be done in dbus-mainloop.c
45    * if the code in activation.c for the babysitter
46    * watch handler is fixed.
47    */
48  
49   return dbus_watch_handle (watch, condition);
50 }
51
52 static dbus_bool_t
53 add_client_watch (DBusWatch      *watch,
54                   void           *data)
55 {
56   DBusConnection *connection = data;
57   
58   return _dbus_loop_add_watch (client_loop,
59                                watch, client_watch_callback, connection,
60                                NULL);
61 }
62
63 static void
64 remove_client_watch (DBusWatch      *watch,
65                      void           *data)
66 {
67   DBusConnection *connection = data;
68   
69   _dbus_loop_remove_watch (client_loop,
70                            watch, client_watch_callback, connection);
71 }
72
73 static void
74 client_timeout_callback (DBusTimeout   *timeout,
75                          void          *data)
76 {
77   DBusConnection *connection = data;
78
79   dbus_connection_ref (connection);
80
81   /* can return FALSE on OOM but we just let it fire again later */
82   dbus_timeout_handle (timeout);
83
84   dbus_connection_unref (connection);
85 }
86
87 static dbus_bool_t
88 add_client_timeout (DBusTimeout    *timeout,
89                     void           *data)
90 {
91   DBusConnection *connection = data;
92   
93   return _dbus_loop_add_timeout (client_loop, timeout, client_timeout_callback, connection, NULL);
94 }
95
96 static void
97 remove_client_timeout (DBusTimeout    *timeout,
98                        void           *data)
99 {
100   DBusConnection *connection = data;
101   
102   _dbus_loop_remove_timeout (client_loop, timeout, client_timeout_callback, connection);
103 }
104
105 static DBusHandlerResult
106 client_disconnect_filter (DBusConnection     *connection,
107                           DBusMessage        *message,
108                           void               *user_data)
109 {
110   if (!dbus_message_is_signal (message,
111                                DBUS_INTERFACE_LOCAL,
112                                "Disconnected"))
113     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
114     
115   _dbus_verbose ("Removing client %p in disconnect handler\n",
116                  connection);
117   
118   _dbus_list_remove (&clients, connection);
119
120   dbus_connection_unref (connection);
121   
122   if (clients == NULL)
123     {
124       _dbus_loop_unref (client_loop);
125       client_loop = NULL;
126     }
127   
128   return DBUS_HANDLER_RESULT_HANDLED;
129 }
130
131 dbus_bool_t
132 bus_setup_debug_client (DBusConnection *connection)
133 {
134   dbus_bool_t retval;  
135
136   if (!dbus_connection_add_filter (connection,
137                                    client_disconnect_filter,
138                                    NULL, NULL))
139     return FALSE;
140
141   retval = FALSE;
142
143   if (client_loop == NULL)
144     {
145       client_loop = _dbus_loop_new ();
146       if (client_loop == NULL)
147         goto out;
148     }
149   
150   if (!dbus_connection_set_watch_functions (connection,
151                                             add_client_watch,
152                                             remove_client_watch,
153                                             NULL,
154                                             connection,
155                                             NULL))
156     goto out;
157       
158   if (!dbus_connection_set_timeout_functions (connection,
159                                               add_client_timeout,
160                                               remove_client_timeout,
161                                               NULL,
162                                               connection, NULL))
163     goto out;
164
165   if (!_dbus_list_append (&clients, connection))
166     goto out;
167   
168   retval = TRUE;
169   
170  out:
171   if (!retval)
172     {
173       dbus_connection_remove_filter (connection,
174                                      client_disconnect_filter,
175                                      NULL);
176       
177       dbus_connection_set_watch_functions (connection,
178                                            NULL, NULL, NULL, NULL, NULL);
179       dbus_connection_set_timeout_functions (connection,
180                                              NULL, NULL, NULL, NULL, NULL);
181
182       _dbus_list_remove_last (&clients, connection);
183
184       if (clients == NULL)
185         {
186           _dbus_loop_unref (client_loop);
187           client_loop = NULL;
188         }
189     }
190       
191   return retval;
192 }
193
194 void
195 bus_test_clients_foreach (BusConnectionForeachFunction  function,
196                           void                         *data)
197 {
198   DBusList *link;
199   
200   link = _dbus_list_get_first_link (&clients);
201   while (link != NULL)
202     {
203       DBusConnection *connection = link->data;
204       DBusList *next = _dbus_list_get_next_link (&clients, link);
205
206       if (!(* function) (connection, data))
207         break;
208       
209       link = next;
210     }
211 }
212
213 dbus_bool_t
214 bus_test_client_listed (DBusConnection *connection)
215 {
216   DBusList *link;
217   
218   link = _dbus_list_get_first_link (&clients);
219   while (link != NULL)
220     {
221       DBusConnection *c = link->data;
222       DBusList *next = _dbus_list_get_next_link (&clients, link);
223
224       if (c == connection)
225         return TRUE;
226       
227       link = next;
228     }
229
230   return FALSE;
231 }
232
233 void
234 bus_test_run_clients_loop (dbus_bool_t block_once)
235 {  
236   if (client_loop == NULL)
237     return;
238
239   _dbus_verbose ("---> Dispatching on \"client side\"\n");
240   
241   /* dispatch before we block so pending dispatches
242    * won't make our block return early
243    */
244   _dbus_loop_dispatch (client_loop);
245   
246   /* Do one blocking wait, since we're expecting data */
247   if (block_once)
248     {
249       _dbus_verbose ("---> blocking on \"client side\"\n");
250       _dbus_loop_iterate (client_loop, TRUE);
251     }
252
253   /* Then mop everything up */
254   while (_dbus_loop_iterate (client_loop, FALSE))
255     ;
256
257   _dbus_verbose ("---> Done dispatching on \"client side\"\n");
258 }
259
260 void
261 bus_test_run_bus_loop (BusContext *context,
262                        dbus_bool_t block_once)
263 {
264   _dbus_verbose ("---> Dispatching on \"server side\"\n");
265   
266   /* dispatch before we block so pending dispatches
267    * won't make our block return early
268    */
269   _dbus_loop_dispatch (bus_context_get_loop (context));
270   
271   /* Do one blocking wait, since we're expecting data */
272   if (block_once)
273     {
274       _dbus_verbose ("---> blocking on \"server side\"\n");
275       _dbus_loop_iterate (bus_context_get_loop (context), TRUE);
276     }
277
278   /* Then mop everything up */
279   while (_dbus_loop_iterate (bus_context_get_loop (context), FALSE))
280     ;
281
282   _dbus_verbose ("---> Done dispatching on \"server side\"\n");
283 }
284
285 void
286 bus_test_run_everything (BusContext *context)
287 {
288   while (_dbus_loop_iterate (bus_context_get_loop (context), FALSE) ||
289          (client_loop == NULL || _dbus_loop_iterate (client_loop, FALSE)))
290     ;
291 }
292
293 BusContext*
294 bus_context_new_test (const DBusString *test_data_dir,
295                       const char       *filename)
296 {
297   DBusError error;
298   DBusString config_file;
299   DBusString relative;
300   BusContext *context;
301   
302   if (!_dbus_string_init (&config_file))
303     {
304       _dbus_warn ("No memory\n");
305       return NULL;
306     }
307
308   if (!_dbus_string_copy (test_data_dir, 0,
309                           &config_file, 0))
310     {
311       _dbus_warn ("No memory\n");
312       _dbus_string_free (&config_file);
313       return NULL;
314     }
315
316   _dbus_string_init_const (&relative, filename);
317
318   if (!_dbus_concat_dir_and_file (&config_file, &relative))
319     {
320       _dbus_warn ("No memory\n");
321       _dbus_string_free (&config_file);
322       return NULL;
323     }
324   
325   dbus_error_init (&error);
326   context = bus_context_new (&config_file, FALSE, NULL, NULL, &error);
327   if (context == NULL)
328     {
329       _DBUS_ASSERT_ERROR_IS_SET (&error);
330       
331       _dbus_warn ("Failed to create debug bus context from configuration file %s: %s\n",
332                   filename, error.message);
333
334       dbus_error_free (&error);
335       
336       _dbus_string_free (&config_file);
337       
338       return NULL;
339     }
340
341   _dbus_string_free (&config_file);
342   
343   return context;
344 }
345
346 #endif