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