Updated Polish translation
[empathy.git] / tests / empathy-irc-network-manager-test.c
1 #include <stdlib.h>
2 #include <stdio.h>
3 #include <string.h>
4 #include <glib/gstdio.h>
5
6 #include "test-irc-helper.h"
7 #include "test-helper.h"
8
9 #include <libempathy/empathy-irc-network-manager.h>
10
11 #define GLOBAL_SAMPLE "default-irc-networks-sample.xml"
12 #define USER_SAMPLE "user-irc-networks-sample.xml"
13 #define USER_FILE "user-irc-networks.xml"
14
15 static void
16 test_empathy_irc_network_manager_add (void)
17 {
18   EmpathyIrcNetworkManager *mgr;
19   EmpathyIrcNetwork *network;
20   GSList *networks;
21   gchar *name;
22
23   mgr = empathy_irc_network_manager_new (NULL, NULL);
24   g_assert (mgr != NULL);
25
26   networks = empathy_irc_network_manager_get_networks (mgr);
27   g_assert (networks == NULL);
28
29   /* add a network */
30   network = empathy_irc_network_new ("My Network");
31   g_assert (network != NULL);
32   empathy_irc_network_manager_add (mgr, network);
33   g_object_unref (network);
34
35   networks = empathy_irc_network_manager_get_networks (mgr);
36   g_assert (g_slist_length (networks) == 1);
37   g_object_get (networks->data, "name", &name, NULL);
38   g_assert (name != NULL && strcmp (name, "My Network") == 0);
39   g_free (name);
40   g_slist_foreach (networks, (GFunc) g_object_unref, NULL);
41   g_slist_free (networks);
42
43   /* add another network having the same name */
44   network = empathy_irc_network_new ("My Network");
45   g_assert (network != NULL);
46   empathy_irc_network_manager_add (mgr, network);
47   g_object_unref (network);
48
49   networks = empathy_irc_network_manager_get_networks (mgr);
50   g_assert (g_slist_length (networks) == 2);
51   g_object_get (networks->data, "name", &name, NULL);
52   g_assert (name != NULL && strcmp (name, "My Network") == 0);
53   g_free (name);
54   g_object_get (g_slist_next (networks)->data, "name", &name, NULL);
55   g_assert (name != NULL || strcmp (name, "My Network") == 0);
56   g_free (name);
57   g_slist_foreach (networks, (GFunc) g_object_unref, NULL);
58   g_slist_free (networks);
59
60   g_object_unref (mgr);
61 }
62
63 static void
64 test_load_global_file (void)
65 {
66   EmpathyIrcNetworkManager *mgr;
67   gchar *global_file, *user_file;
68   GSList *networks, *l;
69   struct server_t freenode_servers[] = {
70     { "irc.freenode.net", 6667, FALSE },
71     { "irc.eu.freenode.net", 6667, FALSE }};
72   struct server_t gimpnet_servers[] = {
73     { "irc.gimp.org", 6667, FALSE },
74     { "irc.us.gimp.org", 6667, FALSE }};
75   struct server_t test_servers[] = {
76     { "irc.test.org", 6669, TRUE }};
77   struct server_t undernet_servers[] = {
78     { "eu.undernet.org", 6667, FALSE }};
79   gboolean network_checked[4];
80   gchar *global_file_orig;
81
82   global_file_orig = get_xml_file (GLOBAL_SAMPLE);
83   mgr = empathy_irc_network_manager_new (global_file_orig, NULL);
84
85   g_object_get (mgr,
86       "global-file", &global_file,
87       "user-file", &user_file,
88       NULL);
89   g_assert (global_file != NULL || strcmp (global_file, global_file_orig) == 0);
90   g_assert (user_file == NULL);
91   g_free (global_file);
92   g_free (global_file_orig);
93   g_free (user_file);
94
95   networks = empathy_irc_network_manager_get_networks (mgr);
96   g_assert (g_slist_length (networks) == 4);
97
98   network_checked[0] = network_checked[1] = network_checked[2] =
99     network_checked[3] = FALSE;
100   /* check networks and servers */
101   for (l = networks; l != NULL; l = g_slist_next (l))
102     {
103       gchar *name;
104
105       g_object_get (l->data, "name", &name, NULL);
106       g_assert (name != NULL);
107
108       if (strcmp (name, "Freenode") == 0)
109         {
110           check_network (l->data, "Freenode", "UTF-8", freenode_servers, 2);
111           network_checked[0] = TRUE;
112         }
113       else if (strcmp (name, "GIMPNet") == 0)
114         {
115           check_network (l->data, "GIMPNet", "UTF-8", gimpnet_servers, 2);
116           network_checked[1] = TRUE;
117         }
118       else if (strcmp (name, "Test Server") == 0)
119         {
120           check_network (l->data, "Test Server", "ISO-8859-1", test_servers, 1);
121           network_checked[2] = TRUE;
122         }
123       else if (strcmp (name, "Undernet") == 0)
124         {
125           check_network (l->data, "Undernet", "UTF-8", undernet_servers, 1);
126           network_checked[3] = TRUE;
127         }
128       else
129         {
130           g_assert_not_reached ();
131         }
132
133       g_free (name);
134     }
135   g_assert (network_checked[0] && network_checked[1] && network_checked[2] &&
136       network_checked[3]);
137
138   g_slist_foreach (networks, (GFunc) g_object_unref, NULL);
139   g_slist_free (networks);
140   g_object_unref (mgr);
141 }
142
143 static gboolean
144 remove_network_named (EmpathyIrcNetworkManager *mgr,
145                       const gchar *network_name)
146 {
147   GSList *networks, *l;
148   gboolean removed = FALSE;
149
150   networks = empathy_irc_network_manager_get_networks (mgr);
151
152   /* check networks and servers */
153   for (l = networks; l != NULL && !removed; l = g_slist_next (l))
154     {
155       EmpathyIrcNetwork *network = l->data;
156       gchar *name;
157
158       g_object_get (network, "name", &name, NULL);
159       g_assert (name != NULL);
160
161       if (strcmp (name, network_name) == 0)
162         {
163           empathy_irc_network_manager_remove (mgr, network);
164           removed = TRUE;
165         }
166
167       g_free (name);
168     }
169
170   g_slist_foreach (networks, (GFunc) g_object_unref, NULL);
171   g_slist_free (networks);
172
173   return removed;
174 }
175
176 static void
177 test_empathy_irc_network_manager_remove (void)
178 {
179   EmpathyIrcNetworkManager *mgr;
180   GSList *networks, *l;
181   struct server_t freenode_servers[] = {
182     { "irc.freenode.net", 6667, FALSE },
183     { "irc.eu.freenode.net", 6667, FALSE }};
184   struct server_t test_servers[] = {
185     { "irc.test.org", 6669, TRUE }};
186   struct server_t undernet_servers[] = {
187     { "eu.undernet.org", 6667, FALSE }};
188   gboolean network_checked[3];
189   gboolean result;
190   gchar *global_file_orig;
191
192   global_file_orig = get_xml_file (GLOBAL_SAMPLE);
193   mgr = empathy_irc_network_manager_new (global_file_orig, NULL);
194   g_free (global_file_orig);
195
196   result = remove_network_named (mgr, "GIMPNet");
197   g_assert (result);
198
199   networks = empathy_irc_network_manager_get_networks (mgr);
200   g_assert (g_slist_length (networks) == 3);
201
202   network_checked[0] = network_checked[1] = network_checked[2] = FALSE;
203   /* check networks and servers */
204   for (l = networks; l != NULL; l = g_slist_next (l))
205     {
206       gchar *name;
207
208       g_object_get (l->data, "name", &name, NULL);
209       g_assert (name != NULL);
210
211       if (strcmp (name, "Freenode") == 0)
212         {
213           check_network (l->data, "Freenode", "UTF-8", freenode_servers, 2);
214           network_checked[0] = TRUE;
215         }
216       else if (strcmp (name, "Test Server") == 0)
217         {
218           check_network (l->data, "Test Server", "ISO-8859-1", test_servers, 1);
219           network_checked[1] = TRUE;
220         }
221       else if (strcmp (name, "Undernet") == 0)
222         {
223           check_network (l->data, "Undernet", "UTF-8", undernet_servers, 1);
224           network_checked[2] = TRUE;
225         }
226       else
227         {
228           g_assert_not_reached ();
229         }
230
231       g_free (name);
232     }
233   g_assert (network_checked[0] && network_checked[1] && network_checked[2]);
234
235   g_slist_foreach (networks, (GFunc) g_object_unref, NULL);
236   g_slist_free (networks);
237   g_object_unref (mgr);
238 }
239
240 static void
241 test_load_user_file (void)
242 {
243   EmpathyIrcNetworkManager *mgr;
244   gchar *global_file, *user_file;
245   GSList *networks, *l;
246   struct server_t gimpnet_servers[] = {
247     { "irc.gimp.org", 6667, FALSE },
248     { "irc.us.gimp.org", 6667, FALSE },
249     { "irc.au.gimp.org", 6667, FALSE }};
250   struct server_t my_server[] = {
251     { "irc.mysrv.net", 7495, TRUE }};
252   struct server_t another_server[] = {
253     { "irc.anothersrv.be", 6660, FALSE }};
254   gboolean network_checked[3];
255   gchar *user_file_orig;
256
257   copy_xml_file (USER_SAMPLE, USER_FILE);
258   user_file_orig = get_user_xml_file (USER_FILE);
259   mgr = empathy_irc_network_manager_new (NULL, user_file_orig);
260
261   g_object_get (mgr,
262       "global-file", &global_file,
263       "user-file", &user_file,
264       NULL);
265   g_assert (global_file == NULL);
266   g_assert (user_file != NULL && strcmp (user_file, user_file_orig) == 0);
267   g_free (global_file);
268   g_free (user_file);
269   g_free (user_file_orig);
270
271   networks = empathy_irc_network_manager_get_networks (mgr);
272   g_assert (g_slist_length (networks) == 3);
273
274   network_checked[0] = network_checked[1] = network_checked[2] = FALSE;
275   /* check networks and servers */
276   for (l = networks; l != NULL; l = g_slist_next (l))
277     {
278       gchar *name;
279
280       g_object_get (l->data, "name", &name, NULL);
281       g_assert (name != NULL);
282
283       if (strcmp (name, "GIMPNet") == 0)
284         {
285           check_network (l->data, "GIMPNet", "UTF-8", gimpnet_servers, 3);
286           network_checked[0] = TRUE;
287         }
288       else if (strcmp (name, "My Server") == 0)
289         {
290           check_network (l->data, "My Server", "UTF-8", my_server, 1);
291           network_checked[1] = TRUE;
292         }
293       else if (strcmp (name, "Another Server") == 0)
294         {
295           check_network (l->data, "Another Server", "UTF-8", another_server, 1);
296           network_checked[2] = TRUE;
297         }
298       else
299         {
300           g_assert_not_reached ();
301         }
302
303       g_free (name);
304     }
305   g_assert (network_checked[0] && network_checked[1] && network_checked[2]);
306
307   g_slist_foreach (networks, (GFunc) g_object_unref, NULL);
308   g_slist_free (networks);
309   g_object_unref (mgr);
310 }
311
312 static void
313 test_load_both_files (void)
314 {
315   EmpathyIrcNetworkManager *mgr;
316   gchar *global_file, *user_file;
317   GSList *networks, *l;
318   struct server_t freenode_servers[] = {
319     { "irc.freenode.net", 6667, FALSE },
320     { "irc.eu.freenode.net", 6667, FALSE }};
321   struct server_t gimpnet_servers[] = {
322     { "irc.gimp.org", 6667, FALSE },
323     { "irc.us.gimp.org", 6667, FALSE },
324     { "irc.au.gimp.org", 6667, FALSE }};
325   struct server_t my_server[] = {
326     { "irc.mysrv.net", 7495, TRUE }};
327   struct server_t another_server[] = {
328     { "irc.anothersrv.be", 6660, FALSE }};
329   struct server_t undernet_servers[] = {
330     { "eu.undernet.org", 6667, FALSE }};
331   gboolean network_checked[5];
332   gchar *global_file_orig, *user_file_orig;
333
334   global_file_orig = get_xml_file (GLOBAL_SAMPLE);
335   user_file_orig = get_user_xml_file (USER_FILE);
336   mgr = empathy_irc_network_manager_new (global_file_orig, user_file_orig);
337
338   g_object_get (mgr,
339       "global-file", &global_file,
340       "user-file", &user_file,
341       NULL);
342   g_assert (global_file != NULL && strcmp (global_file, global_file_orig) == 0);
343   g_assert (user_file != NULL && strcmp (user_file, user_file_orig) == 0);
344   g_free (global_file);
345   g_free (global_file_orig);
346   g_free (user_file);
347   g_free (user_file_orig);
348
349   networks = empathy_irc_network_manager_get_networks (mgr);
350   g_assert (g_slist_length (networks) == 5);
351
352   network_checked[0] = network_checked[1] = network_checked[2] =
353     network_checked[3] = network_checked[4] = FALSE;
354   /* check networks and servers */
355   for (l = networks; l != NULL; l = g_slist_next (l))
356     {
357       gchar *name;
358
359       g_object_get (l->data, "name", &name, NULL);
360       g_assert (name != NULL);
361
362       if (strcmp (name, "Freenode") == 0)
363         {
364           check_network (l->data, "Freenode", "UTF-8", freenode_servers, 2);
365           network_checked[0] = TRUE;
366         }
367       else if (strcmp (name, "GIMPNet") == 0)
368         {
369           check_network (l->data, "GIMPNet", "UTF-8", gimpnet_servers, 3);
370           network_checked[1] = TRUE;
371         }
372       else if (strcmp (name, "My Server") == 0)
373         {
374           check_network (l->data, "My Server", "UTF-8", my_server, 1);
375           network_checked[2] = TRUE;
376         }
377       else if (strcmp (name, "Another Server") == 0)
378         {
379           check_network (l->data, "Another Server", "UTF-8", another_server, 1);
380           network_checked[3] = TRUE;
381         }
382       else if (strcmp (name, "Undernet") == 0)
383         {
384           check_network (l->data, "Undernet", "UTF-8", undernet_servers, 1);
385           network_checked[4] = TRUE;
386         }
387       else
388         {
389           g_assert_not_reached ();
390         }
391
392       g_free (name);
393     }
394   g_assert (network_checked[0] && network_checked[1] && network_checked[2] &&
395       network_checked[3] && network_checked[4]);
396
397   g_slist_foreach (networks, (GFunc) g_object_unref, NULL);
398   g_slist_free (networks);
399   g_object_unref (mgr);
400 }
401
402 static void
403 test_modify_user_file (void)
404 {
405   EmpathyIrcNetworkManager *mgr;
406   EmpathyIrcNetwork *network;
407   EmpathyIrcServer *server;
408   gchar *global_file, *user_file;
409   GSList *networks, *l;
410   struct server_t gimpnet_servers[] = {
411     { "irc.gimp.org", 6667, TRUE },
412     { "irc.us.gimp.org", 6668, FALSE }};
413   struct server_t great_server[] = {
414     { "irc.greatserver.com", 7873, TRUE }};
415   struct server_t another_server[] = {
416     { "irc.anothersrv.be", 6660, FALSE }};
417   gboolean network_modified[2];
418   gboolean network_checked[3];
419   gchar *user_file_orig;
420
421   copy_xml_file (USER_SAMPLE, USER_FILE);
422   user_file_orig = get_user_xml_file (USER_FILE);
423   mgr = empathy_irc_network_manager_new (NULL, user_file_orig);
424
425   g_object_get (mgr,
426       "global-file", &global_file,
427       "user-file", &user_file,
428       NULL);
429   g_assert (global_file == NULL);
430   g_assert (user_file != NULL && strcmp (user_file, user_file_orig) == 0);
431   g_free (global_file);
432   g_free (user_file);
433
434   networks = empathy_irc_network_manager_get_networks (mgr);
435   g_assert (g_slist_length (networks) == 3);
436
437   network_modified[0] = network_modified[1] = FALSE;
438   /* check networks and servers */
439   for (l = networks; l != NULL; l = g_slist_next (l))
440     {
441       gchar *name;
442
443       network = l->data;
444       g_object_get (network, "name", &name, NULL);
445       g_assert (name != NULL);
446
447       if (strcmp (name, "GIMPNet") == 0)
448         {
449           GSList *servers, *ll;
450
451           /* change charset */
452           g_object_set (network, "charset", "ISO-8859-1", NULL);
453
454           servers = empathy_irc_network_get_servers (network);
455           for (ll = servers; ll != NULL; ll = g_slist_next (ll))
456             {
457               gchar *address;
458
459               server = ll->data;
460               g_object_get (server, "address", &address, NULL);
461               if (strcmp (address, "irc.gimp.org") == 0)
462                 {
463                   /* change SSL */
464                   g_object_set (server, "ssl", TRUE, NULL);
465                 }
466               else if (strcmp (address, "irc.us.gimp.org") == 0)
467                 {
468                   /* change port */
469                   g_object_set (server, "port", 6668, NULL);
470                 }
471               else if (strcmp (address, "irc.au.gimp.org") == 0)
472                 {
473                   /* remove this server */
474                   empathy_irc_network_remove_server (network, server);
475                 }
476               else
477                 {
478                   g_assert_not_reached ();
479                 }
480
481               g_free (address);
482             }
483
484           network_modified[0] = TRUE;
485
486           g_slist_foreach (servers, (GFunc) g_object_unref, NULL);
487           g_slist_free (servers);
488         }
489       else if (strcmp (name, "My Server") == 0)
490         {
491           /* remove this network */
492           empathy_irc_network_manager_remove (mgr, network);
493           network_modified[1] = TRUE;
494         }
495       else if (strcmp (name, "Another Server") == 0)
496         {
497           /* Don't change this one */
498         }
499       else
500         {
501           g_assert_not_reached ();
502         }
503
504       g_free (name);
505     }
506   g_assert (network_modified[0] && network_modified[1]);
507
508   /* Add a new network */
509   network = empathy_irc_network_new ("Great Server");
510   server = empathy_irc_server_new ("irc.greatserver.com", 7873, TRUE);
511   empathy_irc_network_append_server (network, server);
512   empathy_irc_network_manager_add (mgr, network);
513   g_object_unref (server);
514   g_object_unref (network);
515
516   g_slist_foreach (networks, (GFunc) g_object_unref, NULL);
517   g_slist_free (networks);
518   g_object_unref (mgr);
519
520
521   /* Now let's reload the file and check its contain */
522   mgr = empathy_irc_network_manager_new (NULL, user_file_orig);
523   g_free (user_file_orig);
524
525   networks = empathy_irc_network_manager_get_networks (mgr);
526   g_assert (g_slist_length (networks) == 3);
527
528   network_checked[0] = network_checked[1] = network_checked[2] = FALSE;
529   /* check networks and servers */
530   for (l = networks; l != NULL; l = g_slist_next (l))
531     {
532       gchar *name;
533
534       g_object_get (l->data, "name", &name, NULL);
535       g_assert (name != NULL);
536
537       if (strcmp (name, "GIMPNet") == 0)
538         {
539           check_network (l->data, "GIMPNet", "ISO-8859-1", gimpnet_servers, 2);
540           network_checked[0] = TRUE;
541         }
542       else if (strcmp (name, "Great Server") == 0)
543         {
544           check_network (l->data, "Great Server", "UTF-8", great_server, 1);
545           network_checked[1] = TRUE;
546         }
547       else if (strcmp (name, "Another Server") == 0)
548         {
549           check_network (l->data, "Another Server", "UTF-8", another_server, 1);
550           network_checked[2] = TRUE;
551         }
552       else
553         {
554           g_assert_not_reached ();
555         }
556
557       g_free (name);
558     }
559   g_assert (network_checked[0] && network_checked[1] && network_checked[2]);
560
561   g_slist_foreach (networks, (GFunc) g_object_unref, NULL);
562   g_slist_free (networks);
563   g_object_unref (mgr);
564 }
565
566 static void
567 test_modify_both_files (void)
568 {
569   EmpathyIrcNetworkManager *mgr;
570   EmpathyIrcNetwork *network;
571   EmpathyIrcServer *server;
572   gchar *global_file, *user_file;
573   GSList *networks, *l;
574   struct server_t gimpnet_servers[] = {
575     { "irc.gimp.org", 6667, TRUE },
576     { "irc.us.gimp.org", 6668, FALSE }};
577   struct server_t great_server[] = {
578     { "irc.greatserver.com", 7873, TRUE }};
579   struct server_t another_server[] = {
580     { "irc.anothersrv.be", 6660, FALSE }};
581   struct server_t undernet_servers[] = {
582     { "eu.undernet.org", 6667, FALSE },
583     { "us.undernet.org", 6667, FALSE }};
584   gboolean network_modified[4];
585   gboolean network_checked[4];
586   gchar *global_file_orig, *user_file_orig;
587
588   copy_xml_file (USER_SAMPLE, USER_FILE);
589   global_file_orig = get_xml_file (GLOBAL_SAMPLE);
590   user_file_orig = get_user_xml_file (USER_FILE);
591   mgr = empathy_irc_network_manager_new (global_file_orig, user_file_orig);
592
593   g_object_get (mgr,
594       "global-file", &global_file,
595       "user-file", &user_file,
596       NULL);
597   g_assert (global_file != NULL && strcmp (global_file, global_file_orig) == 0);
598   g_assert (user_file != NULL && strcmp (user_file, user_file_orig) == 0);
599   g_free (global_file);
600   g_free (global_file_orig);
601   g_free (user_file);
602   g_free (user_file_orig);
603
604   networks = empathy_irc_network_manager_get_networks (mgr);
605   g_assert (g_slist_length (networks) == 5);
606
607   network_modified[0] = network_modified[1] = network_modified[2] =
608     network_modified[3] = FALSE;
609   /* check networks and servers */
610   for (l = networks; l != NULL; l = g_slist_next (l))
611     {
612       gchar *name;
613
614       network = l->data;
615       g_object_get (network, "name", &name, NULL);
616       g_assert (name != NULL);
617
618       if (strcmp (name, "GIMPNet") == 0)
619         {
620           /* Modify user network */
621           GSList *servers, *ll;
622
623           servers = empathy_irc_network_get_servers (network);
624           for (ll = servers; ll != NULL; ll = g_slist_next (ll))
625             {
626               gchar *address;
627
628               server = ll->data;
629               g_object_get (server, "address", &address, NULL);
630               if (strcmp (address, "irc.gimp.org") == 0)
631                 {
632                   /* change SSL */
633                   g_object_set (server, "ssl", TRUE, NULL);
634                 }
635               else if (strcmp (address, "irc.us.gimp.org") == 0)
636                 {
637                   /* change port */
638                   g_object_set (server, "port", 6668, NULL);
639                 }
640               else if (strcmp (address, "irc.au.gimp.org") == 0)
641                 {
642                   /* remove this server */
643                   empathy_irc_network_remove_server (network, server);
644                 }
645               else
646                 {
647                   g_assert_not_reached ();
648                 }
649
650               g_free (address);
651             }
652
653           network_modified[0] = TRUE;
654
655           g_slist_foreach (servers, (GFunc) g_object_unref, NULL);
656           g_slist_free (servers);
657         }
658       else if (strcmp (name, "My Server") == 0)
659         {
660           /* remove user network */
661           empathy_irc_network_manager_remove (mgr, network);
662           network_modified[1] = TRUE;
663         }
664       else if (strcmp (name, "Freenode") == 0)
665         {
666           /* remove global network */
667           empathy_irc_network_manager_remove (mgr, network);
668           network_modified[2] = TRUE;
669         }
670       else if (strcmp (name, "Undernet") == 0)
671         {
672           /* modify global network */
673           server = empathy_irc_server_new ("us.undernet.org", 6667, FALSE);
674           empathy_irc_network_append_server (network, server);
675           g_object_unref (server);
676
677           network_modified[3] = TRUE;
678         }
679       else if (strcmp (name, "Another Server") == 0)
680         {
681           /* Don't change this one */
682         }
683       else
684         {
685           g_assert_not_reached ();
686         }
687
688       g_free (name);
689     }
690   g_assert (network_modified[0] && network_modified[1] && network_modified[2]
691       && network_modified[3]);
692
693   /* Add a new network */
694   network = empathy_irc_network_new ("Great Server");
695   server = empathy_irc_server_new ("irc.greatserver.com", 7873, TRUE);
696   empathy_irc_network_append_server (network, server);
697   empathy_irc_network_manager_add (mgr, network);
698   g_object_unref (server);
699   g_object_unref (network);
700
701   g_slist_foreach (networks, (GFunc) g_object_unref, NULL);
702   g_slist_free (networks);
703   g_object_unref (mgr);
704
705
706   /* Now let's reload the file and check its contain */
707   global_file_orig = get_xml_file (GLOBAL_SAMPLE);
708   user_file_orig = get_user_xml_file (USER_FILE);
709   mgr = empathy_irc_network_manager_new (global_file_orig, user_file_orig);
710   g_free (global_file_orig);
711   g_free (user_file_orig);
712
713   networks = empathy_irc_network_manager_get_networks (mgr);
714   g_assert (g_slist_length (networks) == 4);
715
716   network_checked[0] = network_checked[1] = network_checked[2] =
717     network_checked[3] = FALSE;
718   /* check networks and servers */
719   for (l = networks; l != NULL; l = g_slist_next (l))
720     {
721       gchar *name;
722
723       g_object_get (l->data, "name", &name, NULL);
724       g_assert (name != NULL);
725
726       if (strcmp (name, "GIMPNet") == 0)
727         {
728           check_network (l->data, "GIMPNet", "UTF-8", gimpnet_servers, 2);
729           network_checked[0] = TRUE;
730         }
731       else if (strcmp (name, "Great Server") == 0)
732         {
733           check_network (l->data, "Great Server", "UTF-8", great_server, 1);
734           network_checked[1] = TRUE;
735         }
736       else if (strcmp (name, "Another Server") == 0)
737         {
738           check_network (l->data, "Another Server", "UTF-8", another_server, 1);
739           network_checked[2] = TRUE;
740         }
741       else if (strcmp (name, "Undernet") == 0)
742         {
743           check_network (l->data, "Undernet", "UTF-8", undernet_servers, 2);
744           network_checked[3] = TRUE;
745         }
746       else
747         {
748           g_assert_not_reached ();
749         }
750
751       g_free (name);
752     }
753   g_assert (network_checked[0] && network_checked[1] && network_checked[2] &&
754       network_checked[3]);
755
756   g_slist_foreach (networks, (GFunc) g_object_unref, NULL);
757   g_slist_free (networks);
758   g_object_unref (mgr);
759 }
760
761 static void
762 test_empathy_irc_network_manager_find_network_by_address (void)
763 {
764   EmpathyIrcNetworkManager *mgr;
765   EmpathyIrcNetwork *network;
766   struct server_t freenode_servers[] = {
767     { "irc.freenode.net", 6667, FALSE },
768     { "irc.eu.freenode.net", 6667, FALSE }};
769   gchar *global_file_orig;
770
771   global_file_orig = get_xml_file (GLOBAL_SAMPLE);
772   mgr = empathy_irc_network_manager_new (global_file_orig, NULL);
773   g_free (global_file_orig);
774
775   network = empathy_irc_network_manager_find_network_by_address (mgr,
776       "irc.freenode.net");
777   g_assert (network != NULL);
778   check_network (network, "Freenode", "UTF-8", freenode_servers, 2);
779
780   network = empathy_irc_network_manager_find_network_by_address (mgr,
781       "irc.eu.freenode.net");
782   g_assert (network != NULL);
783   check_network (network, "Freenode", "UTF-8", freenode_servers, 2);
784
785   network = empathy_irc_network_manager_find_network_by_address (mgr,
786       "unknown");
787   g_assert (network == NULL);
788
789   g_object_unref (mgr);
790 }
791
792 static void
793 test_no_modify_with_empty_user_file (void)
794 {
795   EmpathyIrcNetworkManager *mgr;
796   GSList *networks;
797   gchar *global_file_orig;
798   gchar *user_file_orig;
799
800   /* user don't have a networks file yet */
801   user_file_orig = get_user_xml_file (USER_FILE);
802   g_unlink (user_file_orig);
803
804   global_file_orig = get_xml_file (GLOBAL_SAMPLE);
805   mgr = empathy_irc_network_manager_new (global_file_orig, user_file_orig);
806   g_free (global_file_orig);
807   g_object_unref (mgr);
808
809   /* We didn't modify anything so USER_FILE should be empty */
810   mgr = empathy_irc_network_manager_new (NULL, user_file_orig);
811   g_free (user_file_orig);
812
813   networks = empathy_irc_network_manager_get_networks (mgr);
814   g_assert (g_slist_length (networks) == 0);
815
816   g_slist_foreach (networks, (GFunc) g_object_unref, NULL);
817   g_slist_free (networks);
818   g_object_unref (mgr);
819 }
820
821 int
822 main (int argc,
823     char **argv)
824 {
825   int result;
826
827   test_init (argc, argv);
828
829   g_test_add_func ("/irc-network-manager/add",
830       test_empathy_irc_network_manager_add);
831   g_test_add_func ("/irc-network-manager/load-global-file",
832       test_load_global_file);
833   g_test_add_func ("/irc-network-manager/remove",
834       test_empathy_irc_network_manager_remove);
835   g_test_add_func ("/irc-network-manager/load-user-file", test_load_user_file);
836   g_test_add_func ("/irc-network-manager/load-both-files",
837       test_load_both_files);
838   g_test_add_func ("/irc-network-manager/modify-user-file",
839       test_modify_user_file);
840   g_test_add_func ("/irc-network-manager/modify-both-files",
841       test_modify_both_files);
842   g_test_add_func ("/irc-network-manager/find-network-by-address",
843       test_empathy_irc_network_manager_find_network_by_address);
844   g_test_add_func ("/irc-network-manager/no-modify-with-empty-user-file",
845       test_no_modify_with_empty_user_file);
846
847   result = g_test_run ();
848   test_deinit ();
849   return result;
850 }