tests/check-empathy-irc-network-manager.c

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