c626e0456632ebd186a9f170e2de08674a25adaa
[platform/upstream/connman.git] / unit / test-session.c
1 /*
2  *
3  *  Connection Manager
4  *
5  *  Copyright (C) 2011  BWM CarIT GmbH. All rights reserved.
6  *
7  *  This program is free software; you can redistribute it and/or modify
8  *  it under the terms of the GNU General Public License version 2 as
9  *  published by the Free Software Foundation.
10  *
11  *  This program is distributed in the hope that it will be useful,
12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  *  GNU General Public License for more details.
15  *
16  *  You should have received a copy of the GNU General Public License
17  *  along with this program; if not, write to the Free Software
18  *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
19  *
20  */
21
22 #ifdef HAVE_CONFIG_H
23 #include <config.h>
24 #endif
25
26 #include <stdio.h>
27
28 #include "gdbus/gdbus.h"
29
30 #include "test-connman.h"
31
32 enum test_session_state {
33         TEST_SESSION_STATE_0 = 0,
34         TEST_SESSION_STATE_1 = 1,
35         TEST_SESSION_STATE_2 = 2,
36         TEST_SESSION_STATE_3 = 3,
37 };
38
39 static enum test_session_state get_session_state(struct test_session *session)
40 {
41         return GPOINTER_TO_UINT(session->fix->user_data);
42 }
43
44 static void set_session_state(struct test_session *session,
45                                 enum test_session_state state)
46 {
47         session->fix->user_data = GUINT_TO_POINTER(state);
48 }
49
50 static struct test_session *get_session(struct test_session *session,
51                                         unsigned int index)
52 {
53         return &session->fix->session[index];
54 }
55
56 static gboolean test_session_create_no_notify(gpointer data)
57 {
58         struct test_fix *fix = data;
59         DBusMessage *msg;
60
61         util_session_create(fix, 1);
62
63         msg = manager_create_session(fix->session->connection,
64                                         fix->session->info, "/foo");
65         g_assert(msg != NULL);
66         g_assert(dbus_message_get_type(msg) != DBUS_MESSAGE_TYPE_ERROR);
67
68         dbus_message_unref(msg);
69
70         util_idle_call(fix, util_quit_loop, util_session_destroy);
71
72         return FALSE;
73 }
74
75 static gboolean test_session_destroy_no_notify(gpointer data)
76 {
77         struct test_fix *fix = data;
78         DBusMessage *msg;
79
80         util_session_create(fix, 1);
81
82         msg = manager_destroy_session(fix->session->connection, "/foo");
83         g_assert(msg == NULL);
84
85         util_idle_call(fix, util_quit_loop, util_session_destroy);
86
87         return FALSE;
88 }
89
90 static void test_session_create_notify(struct test_session *session)
91 {
92         LOG("session %p", session);
93
94         util_idle_call(session->fix, util_quit_loop, util_session_destroy);
95 }
96
97 static gboolean test_session_create(gpointer data)
98 {
99         struct test_fix *fix = data;
100         struct test_session *session;
101         DBusMessage *msg;
102         int err;
103
104         util_session_create(fix, 1);
105         session = fix->session;
106
107         session->notify_path = "/foo";
108         session->notify = test_session_create_notify;
109
110         err = session_notify_register(session, session->notify_path);
111         g_assert(err == 0);
112
113         msg = manager_create_session(session->connection,
114                                         session->info,
115                                         session->notify_path);
116         g_assert(msg != NULL);
117         g_assert(dbus_message_get_type(msg) != DBUS_MESSAGE_TYPE_ERROR);
118
119         dbus_message_unref(msg);
120
121         return FALSE;
122 }
123
124 static gboolean test_session_create_destroy(gpointer data)
125 {
126         struct test_fix *fix = data;
127         struct test_session *session;
128
129         util_session_create(fix, 1);
130         session = fix->session;
131
132         session->notify_path = g_strdup("/foo");
133
134         util_session_init(fix->session);
135         util_session_cleanup(fix->session);
136
137         util_idle_call(fix, util_quit_loop, util_session_destroy);
138
139         return FALSE;
140 }
141
142 static gboolean test_session_create_already_exists(gpointer data)
143 {
144         struct test_fix *fix = data;
145         struct test_session *session0, *session1;
146         DBusMessage *msg;
147
148         util_session_create(fix, 2);
149         session0 = &fix->session[0];
150         session1 = &fix->session[1];
151
152         session0->notify_path = g_strdup("/foo");
153         session1->notify_path = session0->notify_path;
154
155         util_session_init(session0);
156
157         msg = manager_create_session(session1->connection,
158                                         session1->info,
159                                         session1->notify_path);
160         g_assert(msg == NULL);
161
162         util_session_cleanup(session0);
163
164         util_idle_call(fix, util_quit_loop, util_session_destroy);
165
166         return FALSE;
167 }
168
169 static void test_session_create_many_notify(struct test_session *session)
170 {
171         unsigned int nr;
172
173         LOG("session %p", session);
174
175         nr = GPOINTER_TO_UINT(session->fix->user_data);
176         nr--;
177         session->fix->user_data = GUINT_TO_POINTER(nr);
178
179         if (nr > 0)
180                 return;
181
182         util_idle_call(session->fix, util_quit_loop, util_session_destroy);
183 }
184
185 static gboolean test_session_create_many(gpointer data)
186 {
187         struct test_fix *fix = data;
188         struct test_session *session;
189         unsigned int i, max;
190
191         max = 100;
192
193         fix->user_data = GUINT_TO_POINTER(max);
194
195         util_session_create(fix, max);
196
197         for (i = 0; i < max; i++) {
198                 session = &fix->session[i];
199
200                 session->notify_path = g_strdup_printf("/foo/%d", i);
201                 session->notify = test_session_create_many_notify;
202
203                 util_session_init(session);
204         }
205
206         return FALSE;
207 }
208
209 static void set_session_mode(struct test_fix *fix,
210                                         connman_bool_t enable)
211 {
212         DBusMessage *msg;
213
214         msg = manager_set_session_mode(fix->main_connection, enable);
215         g_assert(msg != NULL);
216         g_assert(dbus_message_get_type(msg) != DBUS_MESSAGE_TYPE_ERROR);
217
218         dbus_message_unref(msg);
219
220         util_idle_call(fix, util_quit_loop, NULL);
221 }
222
223 static void test_session_connect_notify(struct test_session *session)
224 {
225         LOG("session %p online %d", session, session->info->online);
226
227         if (session->info->online != TRUE)
228                 return;
229
230         util_session_cleanup(session);
231
232         util_idle_call(session->fix, util_quit_loop, util_session_destroy);
233 }
234
235 static gboolean test_session_connect(gpointer data)
236 {
237         struct test_fix *fix = data;
238         struct test_session *session;
239         DBusMessage *msg;
240
241         util_session_create(fix, 1);
242         session = fix->session;
243
244         session->notify_path = g_strdup("/foo");
245         session->notify =  test_session_connect_notify;
246         util_session_init(session);
247
248         msg = session_connect(session->connection, session);
249         g_assert(msg != NULL);
250         g_assert(dbus_message_get_type(msg) != DBUS_MESSAGE_TYPE_ERROR);
251
252         dbus_message_unref(msg);
253
254         return FALSE;
255 }
256
257 static void test_session_disconnect_notify(struct test_session *session)
258 {
259         LOG("session %p online %d", session, session->info->online);
260
261         if (session->info->online != FALSE)
262                 return;
263
264         util_session_cleanup(session);
265
266         util_idle_call(session->fix, util_quit_loop, util_session_destroy);
267 }
268
269 static gboolean test_session_disconnect(gpointer data)
270 {
271         struct test_fix *fix = data;
272         struct test_session *session;
273         DBusMessage *msg;
274
275         util_session_create(fix, 1);
276         session = fix->session;
277
278         session->notify_path = g_strdup("/foo");
279         session->notify =  test_session_disconnect_notify;
280         util_session_init(session);
281
282         msg = session_disconnect(session->connection, session);
283         g_assert(msg != NULL);
284         dbus_message_unref(msg);
285
286         return FALSE;
287 }
288
289 static void test_session_connect_disconnect_notify(struct test_session *session)
290 {
291         DBusMessage *msg;
292
293         LOG("session %p online %d", session, session->info->online);
294
295         if (session->info->online != TRUE)
296                 return;
297
298         msg = session_disconnect(session->connection, session);
299         g_assert(msg != NULL);
300         dbus_message_unref(msg);
301
302         util_session_cleanup(session);
303
304         util_idle_call(session->fix, util_quit_loop, util_session_destroy);
305 }
306
307 static gboolean test_session_connect_disconnect(gpointer data)
308 {
309         struct test_fix *fix = data;
310         struct test_session *session;
311         DBusMessage *msg;
312
313         util_session_create(fix, 1);
314         session = fix->session;
315
316         session->notify_path = g_strdup("/foo");
317         session->notify =  test_session_connect_disconnect_notify;
318         util_session_init(session);
319
320         msg = session_connect(session->connection, session);
321         g_assert(msg != NULL);
322         g_assert(dbus_message_get_type(msg) != DBUS_MESSAGE_TYPE_ERROR);
323
324         dbus_message_unref(msg);
325
326         return FALSE;
327 }
328
329 static void test_session_connect_free_ride_notify(struct test_session *session)
330 {
331         struct test_session *session0 = get_session(session, 0);
332         struct test_session *session1 = get_session(session, 1);
333         enum test_session_state state = get_session_state(session);
334         enum test_session_state next_state = state;
335         DBusMessage *msg;
336
337         LOG("state %d session %p %s online %d", state, session,
338                 session->notify_path, session->info->online);
339
340         switch (state) {
341         case TEST_SESSION_STATE_0:
342                 if (session0->info->online == FALSE &&
343                                 session1->info->online == FALSE) {
344                         next_state = TEST_SESSION_STATE_1;
345                 }
346
347                 break;
348         case TEST_SESSION_STATE_1:
349                 if (session0->info->online == TRUE &&
350                                 session1->info->online == TRUE) {
351                         next_state = TEST_SESSION_STATE_2;
352                 }
353
354                 break;
355         case TEST_SESSION_STATE_2:
356                 if (session0->info->online == FALSE &&
357                                 session1->info->online == FALSE) {
358                         next_state = TEST_SESSION_STATE_3;
359                 }
360
361                 break;
362         case TEST_SESSION_STATE_3:
363
364                 return;
365         }
366
367         if (state == next_state)
368                 return;
369
370         set_session_state(session, next_state);
371
372         LOG("next_state %d", next_state);
373
374         switch (next_state) {
375         case TEST_SESSION_STATE_0:
376
377                 return;
378         case TEST_SESSION_STATE_1:
379                 msg = session_connect(session0->connection, session0);
380                 g_assert(msg != NULL);
381                 dbus_message_unref(msg);
382
383                 return;
384
385         case TEST_SESSION_STATE_2:
386                 msg = session_disconnect(session0->connection, session0);
387                 g_assert(msg != NULL);
388                 dbus_message_unref(msg);
389
390                 return;
391         case TEST_SESSION_STATE_3:
392                 util_session_cleanup(session0);
393                 util_session_cleanup(session1);
394
395                 util_idle_call(session0->fix, util_quit_loop,
396                                 util_session_destroy);
397
398                 return;
399         }
400 }
401
402 static gboolean test_session_connect_free_ride(gpointer data)
403 {
404         struct test_fix *fix = data;
405         struct test_session *session0, *session1;
406
407         /*
408          * +-------------------+
409          * |       START       |
410          * +-------------------+
411          *   |
412          *   | connect foo
413          *   v
414          * +-------------------+
415          * |   FOO-CONNECTED   |
416          * +-------------------+
417          *   |
418          *   | free-ride bar
419          *   v
420          * +-------------------+
421          * | FOO-BAR-CONNECTED |
422          * +-------------------+
423          *  |
424          *  | disconnect foo
425          *  v
426          * +-------------------+
427          * |        END        |
428          * +-------------------+
429          */
430
431         util_session_create(fix, 2);
432         session0 = &fix->session[0];
433         session1 = &fix->session[1];
434
435         session0->notify_path = g_strdup("/foo");
436         session1->notify_path = g_strdup("/bar");
437         session0->notify = test_session_connect_free_ride_notify;
438         session1->notify = test_session_connect_free_ride_notify;
439
440         util_session_init(session0);
441         util_session_init(session1);
442
443         set_session_state(session0, TEST_SESSION_STATE_0);
444
445         return FALSE;
446 }
447
448 static gboolean enable_session_mode(gpointer data)
449 {
450         struct test_fix *fix = data;
451
452         set_session_mode(fix, TRUE);
453
454         return FALSE;
455 }
456
457 static gboolean disable_session_mode(gpointer data)
458 {
459         struct test_fix *fix = data;
460
461         set_session_mode(fix, FALSE);
462
463         return FALSE;
464 }
465
466 static void setup_cb(struct test_fix *fix, gconstpointer data)
467 {
468         util_setup(fix, data);
469
470         util_call(fix, enable_session_mode, NULL);
471         g_main_loop_run(fix->main_loop);
472 }
473
474 static void teardown_cb(struct test_fix *fix, gconstpointer data)
475 {
476         util_call(fix, disable_session_mode, NULL);
477         g_main_loop_run(fix->main_loop);
478
479         util_teardown(fix, data);
480 }
481
482 int main(int argc, char *argv[])
483 {
484         g_test_init(&argc, &argv, NULL);
485
486         util_test_add("/manager/session create no notify",
487                 test_session_create_no_notify, setup_cb, teardown_cb);
488         util_test_add("/manager/session destroy no notify",
489                 test_session_destroy_no_notify, setup_cb, teardown_cb);
490         util_test_add("/manager/session create",
491                 test_session_create, setup_cb, teardown_cb);
492         util_test_add("/manager/session create destroy",
493                 test_session_create_destroy, setup_cb, teardown_cb);
494         util_test_add("/manager/session create already exists",
495                 test_session_create_already_exists, setup_cb, teardown_cb);
496         util_test_add("/manager/session create many",
497                 test_session_create_many, setup_cb, teardown_cb);
498
499         util_test_add("/session/connect",
500                 test_session_connect, setup_cb, teardown_cb);
501         util_test_add("/session/disconnect",
502                 test_session_disconnect, setup_cb, teardown_cb);
503         util_test_add("/session/connect disconnect",
504                 test_session_connect_disconnect, setup_cb, teardown_cb);
505         util_test_add("/session/connect free-ride",
506                 test_session_connect_free_ride, setup_cb, teardown_cb);
507
508         return g_test_run();
509 }