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