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

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