← Back to branch summary

~bcurtiswx/ubuntu/precise/empathy/3.4.2.1-0ubuntu1

« back to all changes in this revision

Viewing changes to tests/empathy-chatroom-manager-test.c

  • Committer: Bazaar Package Importer
  • Author(s): Laurent Bigonville
  • Date: 2009-11-16 23:40:52 UTC
  • mfrom: (1.1.39 upstream)
  • mto: (6.3.7 experimental)
  • mto: This revision was merged to the branch mainline in revision 80.
  • Revision ID: james.westby@ubuntu.com-20091116234052-7hhwrpeln4mwdyw7
Tags: upstream-2.29.2
Import upstream version 2.29.2

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/empathy-chatroom-manager-test.c
 
1
#include <stdlib.h>
 
2
#include <stdio.h>
 
3
#include <string.h>
 
4
#include <glib/gstdio.h>
 
5
 
 
6
#include <gconf/gconf.h>
 
7
#include <gconf/gconf-client.h>
 
8
#include <telepathy-glib/account-manager.h>
 
9
#include <telepathy-glib/util.h>
 
10
 
 
11
#include <libempathy/empathy-chatroom-manager.h>
 
12
 
 
13
#include "test-helper.h"
 
14
 
 
15
#define CHATROOM_SAMPLE "chatrooms-sample.xml"
 
16
#define CHATROOM_FILE "chatrooms.xml"
 
17
 
 
18
#if 0
 
19
static void
 
20
check_chatroom (EmpathyChatroom *chatroom,
 
21
                const gchar *name,
 
22
                const gchar *room,
 
23
                gboolean auto_connect,
 
24
                gboolean favorite)
 
25
{
 
26
  gboolean _favorite;
 
27
 
 
28
  fail_if (tp_strdiff (empathy_chatroom_get_name (chatroom), name));
 
29
  fail_if (tp_strdiff (empathy_chatroom_get_room (chatroom), room));
 
30
  fail_if (empathy_chatroom_get_auto_connect (chatroom) != auto_connect);
 
31
  g_object_get (chatroom, "favorite", &_favorite, NULL);
 
32
  fail_if (favorite != _favorite);
 
33
}
 
34
 
 
35
struct chatroom_t
 
36
{
 
37
  gchar *name;
 
38
  gchar *room;
 
39
  gboolean auto_connect;
 
40
  gboolean favorite;
 
41
};
 
42
 
 
43
static void
 
44
check_chatrooms_list (EmpathyChatroomManager *mgr,
 
45
                      EmpathyAccount *account,
 
46
                      struct chatroom_t *_chatrooms,
 
47
                      guint nb_chatrooms)
 
48
{
 
49
  GList *chatrooms, *l;
 
50
  guint i;
 
51
  GHashTable *found;
 
52
 
 
53
  fail_if (empathy_chatroom_manager_get_count (mgr, account) != nb_chatrooms);
 
54
 
 
55
  found = g_hash_table_new (g_str_hash, g_str_equal);
 
56
  for (i = 0; i < nb_chatrooms; i++)
 
57
    {
 
58
      g_hash_table_insert (found, _chatrooms[i].room, &_chatrooms[i]);
 
59
    }
 
60
 
 
61
  chatrooms = empathy_chatroom_manager_get_chatrooms (mgr, account);
 
62
  fail_if (g_list_length (chatrooms) != nb_chatrooms);
 
63
 
 
64
  for (l = chatrooms; l != NULL; l = g_list_next (l))
 
65
    {
 
66
      EmpathyChatroom *chatroom = l->data;
 
67
      struct chatroom_t *tmp;
 
68
 
 
69
      tmp = g_hash_table_lookup (found, empathy_chatroom_get_room (chatroom));
 
70
      fail_if (tmp == NULL);
 
71
 
 
72
      check_chatroom (chatroom, tmp->name, tmp->room, tmp->auto_connect,
 
73
          tmp->favorite);
 
74
 
 
75
      g_hash_table_remove (found, empathy_chatroom_get_room (chatroom));
 
76
    }
 
77
 
 
78
  fail_if (g_hash_table_size (found) != 0);
 
79
 
 
80
  g_list_free (chatrooms);
 
81
  g_hash_table_destroy (found);
 
82
}
 
83
 
 
84
static gboolean
 
85
change_account_name_in_file (EmpathyAccount *account,
 
86
                             const gchar *file)
 
87
{
 
88
  gchar *cmd;
 
89
 
 
90
  cmd = g_strdup_printf ("sed -i 's/CHANGE_ME/%s/' %s",
 
91
      empathy_account_get_unique_name (account), file);
 
92
 
 
93
  if (system (cmd) == -1)
 
94
    {
 
95
      g_print ("'%s' call failed\n", cmd);
 
96
      g_free (cmd);
 
97
      return FALSE;
 
98
    }
 
99
 
 
100
  g_free (cmd);
 
101
  return TRUE;
 
102
}
 
103
 
 
104
START_TEST (test_empathy_chatroom_manager_dup_singleton)
 
105
{
 
106
  EmpathyChatroomManager *mgr;
 
107
  gchar *file;
 
108
  EmpathyAccount *account;
 
109
  EmpathyAccountManager *account_manager;
 
110
  struct chatroom_t chatrooms[] = {
 
111
        { "name1", "room1", TRUE, TRUE },
 
112
        { "name2", "room2", FALSE, TRUE }};
 
113
 
 
114
  account_manager = empathy_account_manager_dup_singleton ();
 
115
  account = get_test_account ();
 
116
 
 
117
  copy_xml_file (CHATROOM_SAMPLE, CHATROOM_FILE);
 
118
 
 
119
  file = get_user_xml_file (CHATROOM_FILE);
 
120
 
 
121
  /* change the chatrooms XML file to use the account we just created */
 
122
  if (!change_account_name_in_file (account, file))
 
123
    return;
 
124
 
 
125
  mgr = empathy_chatroom_manager_dup_singleton (file);
 
126
  check_chatrooms_list (mgr, account, chatrooms, 2);
 
127
 
 
128
  g_free (file);
 
129
  g_object_unref (mgr);
 
130
  g_object_unref (account_manager);
 
131
  g_object_unref (account);
 
132
}
 
133
END_TEST
 
134
 
 
135
START_TEST (test_empathy_chatroom_manager_add)
 
136
{
 
137
  EmpathyChatroomManager *mgr;
 
138
  gchar *file;
 
139
  EmpathyAccount *account;
 
140
  EmpathyAccountManager *account_manager;
 
141
  struct chatroom_t chatrooms[] = {
 
142
        { "name1", "room1", TRUE, TRUE },
 
143
        { "name2", "room2", FALSE, TRUE },
 
144
        { "name3", "room3", FALSE, TRUE },
 
145
        { "name4", "room4", FALSE, FALSE }};
 
146
  EmpathyChatroom *chatroom;
 
147
 
 
148
  account_manager = empathy_account_manager_dup_singleton ();
 
149
 
 
150
  account = get_test_account ();
 
151
 
 
152
  copy_xml_file (CHATROOM_SAMPLE, CHATROOM_FILE);
 
153
 
 
154
  file = get_user_xml_file (CHATROOM_FILE);
 
155
 
 
156
  /* change the chatrooms XML file to use the account we just created */
 
157
  fail_unless (change_account_name_in_file (account, file));
 
158
 
 
159
  mgr = empathy_chatroom_manager_dup_singleton (file);
 
160
 
 
161
  /* add a favorite chatroom */
 
162
  chatroom = empathy_chatroom_new_full (account, "room3", "name3", FALSE);
 
163
  g_object_set (chatroom, "favorite", TRUE, NULL);
 
164
  empathy_chatroom_manager_add (mgr, chatroom);
 
165
  g_object_unref (chatroom);
 
166
 
 
167
  check_chatrooms_list (mgr, account, chatrooms, 3);
 
168
 
 
169
  /* reload chatrooms file */
 
170
  g_object_unref (mgr);
 
171
  mgr = empathy_chatroom_manager_dup_singleton (file);
 
172
 
 
173
  /* chatroom has been added to the XML file as it's a favorite */
 
174
  check_chatrooms_list (mgr, account, chatrooms, 3);
 
175
 
 
176
  /* add a non favorite chatroom */
 
177
  chatroom = empathy_chatroom_new_full (account, "room4", "name4", FALSE);
 
178
  g_object_set (chatroom, "favorite", FALSE, NULL);
 
179
  empathy_chatroom_manager_add (mgr, chatroom);
 
180
  g_object_unref (chatroom);
 
181
 
 
182
  check_chatrooms_list (mgr, account, chatrooms, 4);
 
183
 
 
184
  /* reload chatrooms file */
 
185
  g_object_unref (mgr);
 
186
  mgr = empathy_chatroom_manager_dup_singleton (file);
 
187
 
 
188
  /* chatrooms has not been added to the XML file */
 
189
  check_chatrooms_list (mgr, account, chatrooms, 3);
 
190
 
 
191
  g_object_unref (mgr);
 
192
  g_free (file);
 
193
  g_object_unref (account_manager);
 
194
  g_object_unref (account);
 
195
}
 
196
END_TEST
 
197
 
 
198
START_TEST (test_empathy_chatroom_manager_remove)
 
199
{
 
200
  EmpathyChatroomManager *mgr;
 
201
  gchar *file;
 
202
  EmpathyAccount *account;
 
203
  struct chatroom_t chatrooms[] = {
 
204
        { "name2", "room2", FALSE, TRUE }};
 
205
  EmpathyChatroom *chatroom;
 
206
  EmpathyAccountManager *account_mgr;
 
207
 
 
208
  account_mgr = empathy_account_manager_dup_singleton ();
 
209
  account = get_test_account ();
 
210
 
 
211
  copy_xml_file (CHATROOM_SAMPLE, CHATROOM_FILE);
 
212
 
 
213
  file = get_user_xml_file (CHATROOM_FILE);
 
214
 
 
215
  /* change the chatrooms XML file to use the account we just created */
 
216
  fail_unless (change_account_name_in_file (account, file));
 
217
 
 
218
  mgr = empathy_chatroom_manager_dup_singleton (file);
 
219
 
 
220
  /* remove room1 */
 
221
  chatroom = empathy_chatroom_manager_find (mgr, account, "room1");
 
222
  fail_if (chatroom == NULL);
 
223
  empathy_chatroom_manager_remove (mgr, chatroom);
 
224
 
 
225
  check_chatrooms_list (mgr, account, chatrooms, 1);
 
226
 
 
227
  /* reload chatrooms file */
 
228
  g_object_unref (mgr);
 
229
  mgr = empathy_chatroom_manager_dup_singleton (file);
 
230
 
 
231
  check_chatrooms_list (mgr, account, chatrooms, 1);
 
232
 
 
233
  /* remove room1 */
 
234
  chatroom = empathy_chatroom_manager_find (mgr, account, "room2");
 
235
  fail_if (chatroom == NULL);
 
236
 
 
237
  empathy_chatroom_manager_remove (mgr, chatroom);
 
238
 
 
239
  check_chatrooms_list (mgr, account, chatrooms, 0);
 
240
 
 
241
  /* reload chatrooms file */
 
242
  g_object_unref (mgr);
 
243
  mgr = empathy_chatroom_manager_dup_singleton (file);
 
244
 
 
245
  check_chatrooms_list (mgr, account, chatrooms, 0);
 
246
 
 
247
  g_object_unref (mgr);
 
248
  g_free (file);
 
249
  g_object_unref (account);
 
250
  g_object_unref (account_mgr);
 
251
}
 
252
END_TEST
 
253
 
 
254
START_TEST (test_empathy_chatroom_manager_change_favorite)
 
255
{
 
256
  EmpathyChatroomManager *mgr;
 
257
  gchar *file;
 
258
  EmpathyAccount *account;
 
259
  EmpathyAccountManager *account_manager;
 
260
  struct chatroom_t chatrooms[] = {
 
261
        { "name1", "room1", TRUE, TRUE },
 
262
        { "name2", "room2", FALSE, FALSE }};
 
263
  EmpathyChatroom *chatroom;
 
264
 
 
265
  account_manager = empathy_account_manager_dup_singleton ();
 
266
  account = get_test_account ();
 
267
 
 
268
  copy_xml_file (CHATROOM_SAMPLE, CHATROOM_FILE);
 
269
 
 
270
  file = get_user_xml_file (CHATROOM_FILE);
 
271
 
 
272
  /* change the chatrooms XML file to use the account we just created */
 
273
  fail_unless (change_account_name_in_file (account, file));
 
274
 
 
275
  mgr = empathy_chatroom_manager_dup_singleton (file);
 
276
 
 
277
  /* room2 is not favorite anymore */
 
278
  chatroom = empathy_chatroom_manager_find (mgr, account, "room2");
 
279
  fail_if (chatroom == NULL);
 
280
  g_object_set (chatroom, "favorite", FALSE, NULL);
 
281
 
 
282
  check_chatrooms_list (mgr, account, chatrooms, 2);
 
283
 
 
284
  /* reload chatrooms file */
 
285
  g_object_unref (mgr);
 
286
  mgr = empathy_chatroom_manager_dup_singleton (file);
 
287
 
 
288
  /* room2 is not present in the XML file anymore as it's not a favorite */
 
289
  check_chatrooms_list (mgr, account, chatrooms, 1);
 
290
 
 
291
  /* re-add room2 */
 
292
  chatroom = empathy_chatroom_new_full (account, "room2", "name2", FALSE);
 
293
  empathy_chatroom_manager_add (mgr, chatroom);
 
294
 
 
295
  check_chatrooms_list (mgr, account, chatrooms, 2);
 
296
 
 
297
  /* set room2 as favorite */
 
298
  g_object_set (chatroom, "favorite", TRUE, NULL);
 
299
 
 
300
  chatrooms[1].favorite = TRUE;
 
301
  check_chatrooms_list (mgr, account, chatrooms, 2);
 
302
 
 
303
  /* reload chatrooms file */
 
304
  g_object_unref (mgr);
 
305
  mgr = empathy_chatroom_manager_dup_singleton (file);
 
306
 
 
307
  /* room2 is back in the XML file now */
 
308
  check_chatrooms_list (mgr, account, chatrooms, 2);
 
309
 
 
310
  g_object_unref (mgr);
 
311
  g_object_unref (chatroom);
 
312
  g_free (file);
 
313
  g_object_unref (account_manager);
 
314
  g_object_unref (account);
 
315
}
 
316
END_TEST
 
317
 
 
318
START_TEST (test_empathy_chatroom_manager_change_chatroom)
 
319
{
 
320
  EmpathyChatroomManager *mgr;
 
321
  gchar *file;
 
322
  EmpathyAccount *account;
 
323
  EmpathyAccountManager *account_manager;
 
324
  struct chatroom_t chatrooms[] = {
 
325
        { "name1", "room1", TRUE, TRUE },
 
326
        { "name2", "room2", FALSE, TRUE }};
 
327
  EmpathyChatroom *chatroom;
 
328
 
 
329
  account_manager = empathy_account_manager_dup_singleton ();
 
330
  account = get_test_account ();
 
331
 
 
332
  copy_xml_file (CHATROOM_SAMPLE, "foo.xml");
 
333
 
 
334
  file = get_user_xml_file ("foo.xml");
 
335
 
 
336
  /* change the chatrooms XML file to use the account we just created */
 
337
  fail_unless (change_account_name_in_file (account, file));
 
338
 
 
339
  mgr = empathy_chatroom_manager_dup_singleton (file);
 
340
 
 
341
  check_chatrooms_list (mgr, account, chatrooms, 2);
 
342
 
 
343
  /* change room2 name */
 
344
  chatroom = empathy_chatroom_manager_find (mgr, account, "room2");
 
345
  fail_if (chatroom == NULL);
 
346
  empathy_chatroom_set_name (chatroom, "new_name");
 
347
 
 
348
  /* reload chatrooms file */
 
349
  g_object_unref (mgr);
 
350
  mgr = empathy_chatroom_manager_dup_singleton (file);
 
351
 
 
352
  chatrooms[1].name = "new_name";
 
353
  check_chatrooms_list (mgr, account, chatrooms, 2);
 
354
 
 
355
  /* change room2 auto-connect status */
 
356
  chatroom = empathy_chatroom_manager_find (mgr, account, "room2");
 
357
  fail_if (chatroom == NULL);
 
358
  empathy_chatroom_set_auto_connect (chatroom, TRUE);
 
359
 
 
360
  /* reload chatrooms file */
 
361
  g_object_unref (mgr);
 
362
  mgr = empathy_chatroom_manager_dup_singleton (file);
 
363
 
 
364
  chatrooms[1].auto_connect = TRUE;
 
365
  check_chatrooms_list (mgr, account, chatrooms, 2);
 
366
 
 
367
  /* change room2 room */
 
368
  chatroom = empathy_chatroom_manager_find (mgr, account, "room2");
 
369
  fail_if (chatroom == NULL);
 
370
  empathy_chatroom_set_room (chatroom, "new_room");
 
371
 
 
372
  /* reload chatrooms file */
 
373
  g_object_unref (mgr);
 
374
  mgr = empathy_chatroom_manager_dup_singleton (file);
 
375
 
 
376
  chatrooms[1].room = "new_room";
 
377
  check_chatrooms_list (mgr, account, chatrooms, 2);
 
378
 
 
379
  g_object_unref (mgr);
 
380
  g_free (file);
 
381
  g_object_unref (account);
 
382
  g_object_unref (account_manager);
 
383
}
 
384
END_TEST
 
385
#endif
 
386
 
 
387
int
 
388
main (int argc,
 
389
    char **argv)
 
390
{
 
391
  int result;
 
392
 
 
393
  test_init (argc, argv);
 
394
 
 
395
#if 0
 
396
  g_test_add_func ("/chatroom-manager/dup-singleton",
 
397
      test_empathy_chatroom_manager_dup_singleton);
 
398
  g_test_add_func ("/chatroom-manager/add", test_empathy_chatroom_manager_add);
 
399
  g_test_add_func ("/chatroom-manager/remove",
 
400
      test_empathy_chatroom_manager_remove);
 
401
  g_test_add_func ("/chatroom-manager/change-favorite",
 
402
      test_empathy_chatroom_manager_change_favorite);
 
403
  g_test_add_func ("/chatroom-manager/change-chatroom",
 
404
      test_empathy_chatroom_manager_change_chatroom);
 
405
#endif
 
406
 
 
407
  result = g_test_run ();
 
408
  test_deinit ();
 
409
  return result;
 
410
}