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       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               gchar *address;
 460
 461               server = ll->data;
 462               g_object_get (server, "address", &address, NULL);
 463               if (strcmp (address, "irc.gimp.org") == 0)
 464                 {
 465                   /* change SSL */
 466                   g_object_set (server, "ssl", TRUE, NULL);
 467                 }
 468               else if (strcmp (address, "irc.us.gimp.org") == 0)
 469                 {
 470                   /* change port */
 471                   g_object_set (server, "port", 6668, NULL);
 472                 }
 473               else if (strcmp (address, "irc.au.gimp.org") == 0)
 474                 {
 475                   /* remove this server */
 476                   empathy_irc_network_remove_server (network, server);
 477                 }
 478               else
 479                 {
 480                   fail_if (TRUE);
 481                 }
 482
 483               g_free (address);
 484             }
 485
 486           network_modified[0] = TRUE;
 487
 488           g_slist_foreach (servers, (GFunc) g_object_unref, NULL);
 489           g_slist_free (servers);
 490         }
 491       else if (strcmp (name, "My Server") == 0)
 492         {
 493           /* remove this network */
 494           empathy_irc_network_manager_remove (mgr, network);
 495           network_modified[1] = TRUE;
 496         }
 497       else if (strcmp (name, "Another Server") == 0)
 498         {
 499           /* Don't change this one */
 500         }
 501       else
 502         {
 503           fail_if (TRUE);
 504         }
 505
 506       g_free (name);
 507     }
 508   fail_if (!network_modified[0] || !network_modified[1]);
 509
 510   /* Add a new network */
 511   network = empathy_irc_network_new ("Great Server");
 512   server = empathy_irc_server_new ("irc.greatserver.com", 7873, TRUE);
 513   empathy_irc_network_append_server (network, server);
 514   empathy_irc_network_manager_add (mgr, network);
 515   g_object_unref (server);
 516   g_object_unref (network);
 517
 518   g_slist_foreach (networks, (GFunc) g_object_unref, NULL);
 519   g_slist_free (networks);
 520   g_object_unref (mgr);
 521
 522
 523   /* Now let's reload the file and check its contain */
 524   mgr = empathy_irc_network_manager_new (NULL, user_file_orig);
 525   g_free (user_file_orig);
 526
 527   networks = empathy_irc_network_manager_get_networks (mgr);
 528   fail_if (g_slist_length (networks) != 3);
 529
 530   network_checked[0] = network_checked[1] = network_checked[2] = FALSE;
 531   /* check networks and servers */
 532   for (l = networks; l != NULL; l = g_slist_next (l))
 533     {
 534       gchar *name;
 535
 536       g_object_get (l->data, "name", &name, NULL);
 537       fail_if (name == NULL);
 538
 539       if (strcmp (name, "GIMPNet") == 0)
 540         {
 541           check_network (l->data, "GIMPNet", "ISO-8859-1", gimpnet_servers, 2);
 542           network_checked[0] = TRUE;
 543         }
 544       else if (strcmp (name, "Great Server") == 0)
 545         {
 546           check_network (l->data, "Great Server", "UTF-8", great_server, 1);
 547           network_checked[1] = TRUE;
 548         }
 549       else if (strcmp (name, "Another Server") == 0)
 550         {
 551           check_network (l->data, "Another Server", "UTF-8", another_server, 1);
 552           network_checked[2] = TRUE;
 553         }
 554       else
 555         {
 556           fail_if (TRUE);
 557         }
 558
 559       g_free (name);
 560     }
 561   fail_if (!network_checked[0] || !network_checked[1] || !network_checked[2]);
 562
 563   g_slist_foreach (networks, (GFunc) g_object_unref, NULL);
 564   g_slist_free (networks);
 565   g_object_unref (mgr);
 566 }
 567 END_TEST
 568
 569 START_TEST (test_modify_both_files)
 570 {
 571   EmpathyIrcNetworkManager *mgr;
 572   EmpathyIrcNetwork *network;
 573   EmpathyIrcServer *server;
 574   gchar *global_file, *user_file;
 575   GSList *networks, *l;
 576   struct server_t gimpnet_servers[] = {
 577     { "irc.gimp.org", 6667, TRUE },
 578     { "irc.us.gimp.org", 6668, FALSE }};
 579   struct server_t great_server[] = {
 580     { "irc.greatserver.com", 7873, TRUE }};
 581   struct server_t another_server[] = {
 582     { "irc.anothersrv.be", 6660, FALSE }};
 583   struct server_t undernet_servers[] = {
 584     { "eu.undernet.org", 6667, FALSE },
 585     { "us.undernet.org", 6667, FALSE }};
 586   gboolean network_modified[4];
 587   gboolean network_checked[4];
 588   gchar *global_file_orig, *user_file_orig;
 589
 590   copy_xml_file (USER_SAMPLE, USER_FILE);
 591   global_file_orig = get_xml_file (GLOBAL_SAMPLE);
 592   user_file_orig = get_user_xml_file (USER_FILE);
 593   mgr = empathy_irc_network_manager_new (global_file_orig, user_file_orig);
 594
 595   g_object_get (mgr,
 596       "global-file", &global_file,
 597       "user-file", &user_file,
 598       NULL);
 599   fail_if (global_file == NULL || strcmp (global_file, global_file_orig) != 0);
 600   fail_if (user_file == NULL || strcmp (user_file, user_file_orig) != 0);
 601   g_free (global_file);
 602   g_free (global_file_orig);
 603   g_free (user_file);
 604   g_free (user_file_orig);
 605
 606   networks = empathy_irc_network_manager_get_networks (mgr);
 607   fail_if (g_slist_length (networks) != 5);
 608
 609   network_modified[0] = network_modified[1] = network_modified[2] =
 610     network_modified[3] = FALSE;
 611   /* check networks and servers */
 612   for (l = networks; l != NULL; l = g_slist_next (l))
 613     {
 614       gchar *name;
 615
 616       network = l->data;
 617       g_object_get (network, "name", &name, NULL);
 618       fail_if (name == NULL);
 619
 620       if (strcmp (name, "GIMPNet") == 0)
 621         {
 622           /* Modify user network */
 623           GSList *servers, *ll;
 624
 625           servers = empathy_irc_network_get_servers (network);
 626           for (ll = servers; ll != NULL; ll = g_slist_next (ll))
 627             {
 628               gchar *address;
 629
 630               server = ll->data;
 631               g_object_get (server, "address", &address, NULL);
 632               if (strcmp (address, "irc.gimp.org") == 0)
 633                 {
 634                   /* change SSL */
 635                   g_object_set (server, "ssl", TRUE, NULL);
 636                 }
 637               else if (strcmp (address, "irc.us.gimp.org") == 0)
 638                 {
 639                   /* change port */
 640                   g_object_set (server, "port", 6668, NULL);
 641                 }
 642               else if (strcmp (address, "irc.au.gimp.org") == 0)
 643                 {
 644                   /* remove this server */
 645                   empathy_irc_network_remove_server (network, server);
 646                 }
 647               else
 648                 {
 649                   fail_if (TRUE);
 650                 }
 651
 652               g_free (address);
 653             }
 654
 655           network_modified[0] = TRUE;
 656
 657           g_slist_foreach (servers, (GFunc) g_object_unref, NULL);
 658           g_slist_free (servers);
 659         }
 660       else if (strcmp (name, "My Server") == 0)
 661         {
 662           /* remove user network */
 663           empathy_irc_network_manager_remove (mgr, network);
 664           network_modified[1] = TRUE;
 665         }
 666       else if (strcmp (name, "Freenode") == 0)
 667         {
 668           /* remove global network */
 669           empathy_irc_network_manager_remove (mgr, network);
 670           network_modified[2] = TRUE;
 671         }
 672       else if (strcmp (name, "Undernet") == 0)
 673         {
 674           /* modify global network */
 675           server = empathy_irc_server_new ("us.undernet.org", 6667, FALSE);
 676           empathy_irc_network_append_server (network, server);
 677           g_object_unref (server);
 678
 679           network_modified[3] = TRUE;
 680         }
 681       else if (strcmp (name, "Another Server") == 0)
 682         {
 683           /* Don't change this one */
 684         }
 685       else
 686         {
 687           fail_if (TRUE);
 688         }
 689
 690       g_free (name);
 691     }
 692   fail_if (!network_modified[0] || !network_modified[1] || !network_modified[2]
 693       || !network_modified[3]);
 694
 695   /* Add a new network */
 696   network = empathy_irc_network_new ("Great Server");
 697   server = empathy_irc_server_new ("irc.greatserver.com", 7873, TRUE);
 698   empathy_irc_network_append_server (network, server);
 699   empathy_irc_network_manager_add (mgr, network);
 700   g_object_unref (server);
 701   g_object_unref (network);
 702
 703   g_slist_foreach (networks, (GFunc) g_object_unref, NULL);
 704   g_slist_free (networks);
 705   g_object_unref (mgr);
 706
 707
 708   /* Now let's reload the file and check its contain */
 709   global_file_orig = get_xml_file (GLOBAL_SAMPLE);
 710   user_file_orig = get_user_xml_file (USER_FILE);
 711   mgr = empathy_irc_network_manager_new (global_file_orig, user_file_orig);
 712   g_free (global_file_orig);
 713   g_free (user_file_orig);
 714
 715   networks = empathy_irc_network_manager_get_networks (mgr);
 716   fail_if (g_slist_length (networks) != 4);
 717
 718   network_checked[0] = network_checked[1] = network_checked[2] =
 719     network_checked[3] = FALSE;
 720   /* check networks and servers */
 721   for (l = networks; l != NULL; l = g_slist_next (l))
 722     {
 723       gchar *name;
 724
 725       g_object_get (l->data, "name", &name, NULL);
 726       fail_if (name == NULL);
 727
 728       if (strcmp (name, "GIMPNet") == 0)
 729         {
 730           check_network (l->data, "GIMPNet", "UTF-8", gimpnet_servers, 2);
 731           network_checked[0] = TRUE;
 732         }
 733       else if (strcmp (name, "Great Server") == 0)
 734         {
 735           check_network (l->data, "Great Server", "UTF-8", great_server, 1);
 736           network_checked[1] = TRUE;
 737         }
 738       else if (strcmp (name, "Another Server") == 0)
 739         {
 740           check_network (l->data, "Another Server", "UTF-8", another_server, 1);
 741           network_checked[2] = TRUE;
 742         }
 743       else if (strcmp (name, "Undernet") == 0)
 744         {
 745           check_network (l->data, "Undernet", "UTF-8", undernet_servers, 2);
 746           network_checked[3] = TRUE;
 747         }
 748       else
 749         {
 750           fail_if (TRUE);
 751         }
 752
 753       g_free (name);
 754     }
 755   fail_if (!network_checked[0] || !network_checked[1] || !network_checked[2] ||
 756       !network_checked[3]);
 757
 758   g_slist_foreach (networks, (GFunc) g_object_unref, NULL);
 759   g_slist_free (networks);
 760   g_object_unref (mgr);
 761 }
 762 END_TEST
 763
 764 START_TEST (test_empathy_irc_network_manager_find_network_by_address)
 765 {
 766   EmpathyIrcNetworkManager *mgr;
 767   EmpathyIrcNetwork *network;
 768   struct server_t freenode_servers[] = {
 769     { "irc.freenode.net", 6667, FALSE },
 770     { "irc.eu.freenode.net", 6667, FALSE }};
 771   gchar *global_file_orig;
 772
 773   global_file_orig = get_xml_file (GLOBAL_SAMPLE);
 774   mgr = empathy_irc_network_manager_new (global_file_orig, NULL);
 775   g_free (global_file_orig);
 776
 777   network = empathy_irc_network_manager_find_network_by_address (mgr,
 778       "irc.freenode.net");
 779   fail_if (network == NULL);
 780   check_network (network, "Freenode", "UTF-8", freenode_servers, 2);
 781
 782   network = empathy_irc_network_manager_find_network_by_address (mgr,
 783       "irc.eu.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       "unknown");
 789   fail_if (network != NULL);
 790
 791   g_object_unref (mgr);
 792 }
 793 END_TEST
 794
 795 START_TEST (test_no_modify_with_empty_user_file)
 796 {
 797   EmpathyIrcNetworkManager *mgr;
 798   GSList *networks;
 799   gchar *global_file_orig;
 800   gchar *user_file_orig;
 801
 802   /* user don't have a networks file yet */
 803   user_file_orig = get_user_xml_file (USER_FILE);
 804   g_unlink (user_file_orig);
 805
 806   global_file_orig = get_xml_file (GLOBAL_SAMPLE);
 807   mgr = empathy_irc_network_manager_new (global_file_orig, user_file_orig);
 808   g_free (global_file_orig);
 809   g_object_unref (mgr);
 810
 811   /* We didn't modify anything so USER_FILE should be empty */
 812   mgr = empathy_irc_network_manager_new (NULL, user_file_orig);
 813   g_free (user_file_orig);
 814
 815   networks = empathy_irc_network_manager_get_networks (mgr);
 816   fail_if (g_slist_length (networks) != 0);
 817
 818   g_slist_foreach (networks, (GFunc) g_object_unref, NULL);
 819   g_slist_free (networks);
 820   g_object_unref (mgr);
 821 }
 822 END_TEST
 823
 824 TCase *
 825 make_empathy_irc_network_manager_tcase (void)
 826 {
 827     TCase *tc = tcase_create ("empathy-irc-network-manager");
 828     tcase_add_test (tc, test_empathy_irc_network_manager_add);
 829     tcase_add_test (tc, test_load_global_file);
 830     tcase_add_test (tc, test_empathy_irc_network_manager_remove);
 831     tcase_add_test (tc, test_load_user_file);
 832     tcase_add_test (tc, test_load_both_files);
 833     tcase_add_test (tc, test_modify_user_file);
 834     tcase_add_test (tc, test_modify_both_files);
 835     tcase_add_test (tc, test_empathy_irc_network_manager_find_network_by_address);
 836     tcase_add_test (tc, test_no_modify_with_empty_user_file);
 837     return tc;
 838 }