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