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 "xml/default-irc-networks-sample.xml"
  14 #define USER_SAMPLE "xml/user-irc-networks-sample.xml"
  15 #define USER_FILE "xml/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
  82   mgr = empathy_irc_network_manager_new (GLOBAL_SAMPLE, NULL);
  83
  84   g_object_get (mgr,
  85       "global-file", &global_file,
  86       "user-file", &user_file,
  87       NULL);
  88   fail_if (global_file == NULL || strcmp (global_file, GLOBAL_SAMPLE) != 0);
  89   fail_if (user_file != NULL);
  90   g_free (global_file);
  91   g_free (user_file);
  92
  93   networks = empathy_irc_network_manager_get_networks (mgr);
  94   fail_if (g_slist_length (networks) != 4);
  95
  96   network_checked[0] = network_checked[1] = network_checked[2] =
  97     network_checked[3] = FALSE;
  98   /* check networks and servers */
  99   for (l = networks; l != NULL; l = g_slist_next (l))
 100     {
 101       gchar *name;
 102
 103       g_object_get (l->data, "name", &name, NULL);
 104       fail_if (name == NULL);
 105
 106       if (strcmp (name, "Freenode") == 0)
 107         {
 108           check_network (l->data, "Freenode", "UTF-8", freenode_servers, 2);
 109           network_checked[0] = TRUE;
 110         }
 111       else if (strcmp (name, "GIMPNet") == 0)
 112         {
 113           check_network (l->data, "GIMPNet", "UTF-8", gimpnet_servers, 2);
 114           network_checked[1] = TRUE;
 115         }
 116       else if (strcmp (name, "Test Server") == 0)
 117         {
 118           check_network (l->data, "Test Server", "ISO-8859-1", test_servers, 1);
 119           network_checked[2] = TRUE;
 120         }
 121       else if (strcmp (name, "Undernet") == 0)
 122         {
 123           check_network (l->data, "Undernet", "UTF-8", undernet_servers, 1);
 124           network_checked[3] = TRUE;
 125         }
 126       else
 127         {
 128           fail_if (TRUE);
 129         }
 130
 131       g_free (name);
 132     }
 133   fail_if (!network_checked[0] || !network_checked[1] || !network_checked[2] ||
 134       !network_checked[3]);
 135
 136   g_slist_foreach (networks, (GFunc) g_object_unref, NULL);
 137   g_slist_free (networks);
 138   g_object_unref (mgr);
 139 }
 140 END_TEST
 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       fail_if (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 START_TEST (test_empathy_irc_network_manager_remove)
 176 {
 177   EmpathyIrcNetworkManager *mgr;
 178   GSList *networks, *l;
 179   struct server_t freenode_servers[] = {
 180     { "irc.freenode.net", 6667, FALSE },
 181     { "irc.eu.freenode.net", 6667, FALSE }};
 182   struct server_t test_servers[] = {
 183     { "irc.test.org", 6669, TRUE }};
 184   struct server_t undernet_servers[] = {
 185     { "eu.undernet.org", 6667, FALSE }};
 186   gboolean network_checked[3];
 187   gboolean result;
 188
 189   mgr = empathy_irc_network_manager_new (GLOBAL_SAMPLE, NULL);
 190
 191   result = remove_network_named (mgr, "GIMPNet");
 192   fail_if (!result);
 193
 194   networks = empathy_irc_network_manager_get_networks (mgr);
 195   fail_if (g_slist_length (networks) != 3);
 196
 197   network_checked[0] = network_checked[1] = network_checked[2] = FALSE;
 198   /* check networks and servers */
 199   for (l = networks; l != NULL; l = g_slist_next (l))
 200     {
 201       gchar *name;
 202
 203       g_object_get (l->data, "name", &name, NULL);
 204       fail_if (name == NULL);
 205
 206       if (strcmp (name, "Freenode") == 0)
 207         {
 208           check_network (l->data, "Freenode", "UTF-8", freenode_servers, 2);
 209           network_checked[0] = TRUE;
 210         }
 211       else if (strcmp (name, "Test Server") == 0)
 212         {
 213           check_network (l->data, "Test Server", "ISO-8859-1", test_servers, 1);
 214           network_checked[1] = TRUE;
 215         }
 216       else if (strcmp (name, "Undernet") == 0)
 217         {
 218           check_network (l->data, "Undernet", "UTF-8", undernet_servers, 1);
 219           network_checked[2] = TRUE;
 220         }
 221       else
 222         {
 223           fail_if (TRUE);
 224         }
 225
 226       g_free (name);
 227     }
 228   fail_if (!network_checked[0] || !network_checked[1] || !network_checked[2]);
 229
 230   g_slist_foreach (networks, (GFunc) g_object_unref, NULL);
 231   g_slist_free (networks);
 232   g_object_unref (mgr);
 233 }
 234 END_TEST
 235
 236 static void
 237 copy_user_file (void)
 238 {
 239   gboolean result;
 240   gchar *buffer;
 241   gsize length;
 242
 243   result = g_file_get_contents (USER_SAMPLE, &buffer, &length, NULL);
 244   fail_if (!result);
 245
 246   result = g_file_set_contents (USER_FILE, buffer, length, NULL);
 247   fail_if (!result);
 248
 249   g_free (buffer);
 250 }
 251
 252 START_TEST (test_load_user_file)
 253 {
 254   EmpathyIrcNetworkManager *mgr;
 255   gchar *global_file, *user_file;
 256   GSList *networks, *l;
 257   struct server_t gimpnet_servers[] = {
 258     { "irc.gimp.org", 6667, FALSE },
 259     { "irc.us.gimp.org", 6667, FALSE },
 260     { "irc.au.gimp.org", 6667, FALSE }};
 261   struct server_t my_server[] = {
 262     { "irc.mysrv.net", 7495, TRUE }};
 263   struct server_t another_server[] = {
 264     { "irc.anothersrv.be", 6660, FALSE }};
 265   gboolean network_checked[3];
 266
 267   copy_user_file ();
 268   mgr = empathy_irc_network_manager_new (NULL, USER_FILE);
 269
 270   g_object_get (mgr,
 271       "global-file", &global_file,
 272       "user-file", &user_file,
 273       NULL);
 274   fail_if (global_file != NULL);
 275   fail_if (user_file == NULL || strcmp (user_file, USER_FILE) != 0);
 276   g_free (global_file);
 277   g_free (user_file);
 278
 279   networks = empathy_irc_network_manager_get_networks (mgr);
 280   fail_if (g_slist_length (networks) != 3);
 281
 282   network_checked[0] = network_checked[1] = network_checked[2] = FALSE;
 283   /* check networks and servers */
 284   for (l = networks; l != NULL; l = g_slist_next (l))
 285     {
 286       gchar *name;
 287
 288       g_object_get (l->data, "name", &name, NULL);
 289       fail_if (name == NULL);
 290
 291       if (strcmp (name, "GIMPNet") == 0)
 292         {
 293           check_network (l->data, "GIMPNet", "UTF-8", gimpnet_servers, 3);
 294           network_checked[0] = TRUE;
 295         }
 296       else if (strcmp (name, "My Server") == 0)
 297         {
 298           check_network (l->data, "My Server", "UTF-8", my_server, 1);
 299           network_checked[1] = TRUE;
 300         }
 301       else if (strcmp (name, "Another Server") == 0)
 302         {
 303           check_network (l->data, "Another Server", "UTF-8", another_server, 1);
 304           network_checked[2] = TRUE;
 305         }
 306       else
 307         {
 308           fail_if (TRUE);
 309         }
 310
 311       g_free (name);
 312     }
 313   fail_if (!network_checked[0] || !network_checked[1] || !network_checked[2]);
 314
 315   g_slist_foreach (networks, (GFunc) g_object_unref, NULL);
 316   g_slist_free (networks);
 317   g_object_unref (mgr);
 318 }
 319 END_TEST
 320
 321 START_TEST (test_load_both_files)
 322 {
 323   EmpathyIrcNetworkManager *mgr;
 324   gchar *global_file, *user_file;
 325   GSList *networks, *l;
 326   struct server_t freenode_servers[] = {
 327     { "irc.freenode.net", 6667, FALSE },
 328     { "irc.eu.freenode.net", 6667, FALSE }};
 329   struct server_t gimpnet_servers[] = {
 330     { "irc.gimp.org", 6667, FALSE },
 331     { "irc.us.gimp.org", 6667, FALSE },
 332     { "irc.au.gimp.org", 6667, FALSE }};
 333   struct server_t my_server[] = {
 334     { "irc.mysrv.net", 7495, TRUE }};
 335   struct server_t another_server[] = {
 336     { "irc.anothersrv.be", 6660, FALSE }};
 337   struct server_t undernet_servers[] = {
 338     { "eu.undernet.org", 6667, FALSE }};
 339   gboolean network_checked[5];
 340
 341   mgr = empathy_irc_network_manager_new (GLOBAL_SAMPLE, USER_FILE);
 342
 343   g_object_get (mgr,
 344       "global-file", &global_file,
 345       "user-file", &user_file,
 346       NULL);
 347   fail_if (global_file == NULL || strcmp (global_file, GLOBAL_SAMPLE) != 0);
 348   fail_if (user_file == NULL || strcmp (user_file, USER_FILE) != 0);
 349   g_free (global_file);
 350   g_free (user_file);
 351
 352   networks = empathy_irc_network_manager_get_networks (mgr);
 353   fail_if (g_slist_length (networks) != 5);
 354
 355   network_checked[0] = network_checked[1] = network_checked[2] =
 356     network_checked[3] = network_checked[4] = FALSE;
 357   /* check networks and servers */
 358   for (l = networks; l != NULL; l = g_slist_next (l))
 359     {
 360       gchar *name;
 361
 362       g_object_get (l->data, "name", &name, NULL);
 363       fail_if (name == NULL);
 364
 365       if (strcmp (name, "Freenode") == 0)
 366         {
 367           check_network (l->data, "Freenode", "UTF-8", freenode_servers, 2);
 368           network_checked[0] = TRUE;
 369         }
 370       else if (strcmp (name, "GIMPNet") == 0)
 371         {
 372           check_network (l->data, "GIMPNet", "UTF-8", gimpnet_servers, 3);
 373           network_checked[1] = TRUE;
 374         }
 375       else if (strcmp (name, "My Server") == 0)
 376         {
 377           check_network (l->data, "My Server", "UTF-8", my_server, 1);
 378           network_checked[2] = TRUE;
 379         }
 380       else if (strcmp (name, "Another Server") == 0)
 381         {
 382           check_network (l->data, "Another Server", "UTF-8", another_server, 1);
 383           network_checked[3] = TRUE;
 384         }
 385       else if (strcmp (name, "Undernet") == 0)
 386         {
 387           check_network (l->data, "Undernet", "UTF-8", undernet_servers, 1);
 388           network_checked[4] = TRUE;
 389         }
 390       else
 391         {
 392           fail_if (TRUE);
 393         }
 394
 395       g_free (name);
 396     }
 397   fail_if (!network_checked[0] || !network_checked[1] || !network_checked[2] ||
 398       !network_checked[3] || !network_checked[4]);
 399
 400   g_slist_foreach (networks, (GFunc) g_object_unref, NULL);
 401   g_slist_free (networks);
 402   g_object_unref (mgr);
 403 }
 404 END_TEST
 405
 406 START_TEST (test_modify_user_file)
 407 {
 408   EmpathyIrcNetworkManager *mgr;
 409   EmpathyIrcNetwork *network;
 410   EmpathyIrcServer *server;
 411   gchar *global_file, *user_file;
 412   GSList *networks, *l;
 413   struct server_t gimpnet_servers[] = {
 414     { "irc.gimp.org", 6667, TRUE },
 415     { "irc.us.gimp.org", 6668, FALSE }};
 416   struct server_t great_server[] = {
 417     { "irc.greatserver.com", 7873, TRUE }};
 418   struct server_t another_server[] = {
 419     { "irc.anothersrv.be", 6660, FALSE }};
 420   gboolean network_modified[2];
 421   gboolean network_checked[3];
 422
 423   copy_user_file ();
 424   mgr = empathy_irc_network_manager_new (NULL, USER_FILE);
 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) != 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);
 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
 589   copy_user_file ();
 590   mgr = empathy_irc_network_manager_new (GLOBAL_SAMPLE, USER_FILE);
 591
 592   g_object_get (mgr,
 593       "global-file", &global_file,
 594       "user-file", &user_file,
 595       NULL);
 596   fail_if (global_file == NULL || strcmp (global_file, GLOBAL_SAMPLE) != 0);
 597   fail_if (user_file == NULL || strcmp (user_file, USER_FILE) != 0);
 598   g_free (global_file);
 599   g_free (user_file);
 600
 601   networks = empathy_irc_network_manager_get_networks (mgr);
 602   fail_if (g_slist_length (networks) != 5);
 603
 604   network_modified[0] = network_modified[1] = network_modified[2] =
 605     network_modified[3] = FALSE;
 606   /* check networks and servers */
 607   for (l = networks; l != NULL; l = g_slist_next (l))
 608     {
 609       EmpathyIrcNetwork *network;
 610       gchar *name;
 611
 612       network = l->data;
 613       g_object_get (network, "name", &name, NULL);
 614       fail_if (name == NULL);
 615
 616       if (strcmp (name, "GIMPNet") == 0)
 617         {
 618           /* Modify user network */
 619           GSList *servers, *ll;
 620
 621           servers = empathy_irc_network_get_servers (network);
 622           for (ll = servers; ll != NULL; ll = g_slist_next (ll))
 623             {
 624               EmpathyIrcServer *server;
 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                   fail_if (TRUE);
 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           EmpathyIrcServer *server;
 673
 674           server = empathy_irc_server_new ("us.undernet.org", 6667, FALSE);
 675           empathy_irc_network_append_server (network, server);
 676           g_object_unref (server);
 677
 678           network_modified[3] = TRUE;
 679         }
 680       else if (strcmp (name, "Another Server") == 0)
 681         {
 682           /* Don't change this one */
 683         }
 684       else
 685         {
 686           fail_if (TRUE);
 687         }
 688
 689       g_free (name);
 690     }
 691   fail_if (!network_modified[0] || !network_modified[1] || !network_modified[2]
 692       || !network_modified[3]);
 693
 694   /* Add a new network */
 695   network = empathy_irc_network_new ("Great Server");
 696   server = empathy_irc_server_new ("irc.greatserver.com", 7873, TRUE);
 697   empathy_irc_network_append_server (network, server);
 698   empathy_irc_network_manager_add (mgr, network);
 699   g_object_unref (server);
 700   g_object_unref (network);
 701
 702   g_slist_foreach (networks, (GFunc) g_object_unref, NULL);
 703   g_slist_free (networks);
 704   g_object_unref (mgr);
 705
 706
 707   /* Now let's reload the file and check its contain */
 708   mgr = empathy_irc_network_manager_new (GLOBAL_SAMPLE, USER_FILE);
 709
 710   networks = empathy_irc_network_manager_get_networks (mgr);
 711   fail_if (g_slist_length (networks) != 4);
 712
 713   network_checked[0] = network_checked[1] = network_checked[2] =
 714     network_checked[3] = FALSE;
 715   /* check networks and servers */
 716   for (l = networks; l != NULL; l = g_slist_next (l))
 717     {
 718       gchar *name;
 719
 720       g_object_get (l->data, "name", &name, NULL);
 721       fail_if (name == NULL);
 722
 723       if (strcmp (name, "GIMPNet") == 0)
 724         {
 725           check_network (l->data, "GIMPNet", "UTF-8", gimpnet_servers, 2);
 726           network_checked[0] = TRUE;
 727         }
 728       else if (strcmp (name, "Great Server") == 0)
 729         {
 730           check_network (l->data, "Great Server", "UTF-8", great_server, 1);
 731           network_checked[1] = TRUE;
 732         }
 733       else if (strcmp (name, "Another Server") == 0)
 734         {
 735           check_network (l->data, "Another Server", "UTF-8", another_server, 1);
 736           network_checked[2] = TRUE;
 737         }
 738       else if (strcmp (name, "Undernet") == 0)
 739         {
 740           check_network (l->data, "Undernet", "UTF-8", undernet_servers, 2);
 741           network_checked[3] = TRUE;
 742         }
 743       else
 744         {
 745           fail_if (TRUE);
 746         }
 747
 748       g_free (name);
 749     }
 750   fail_if (!network_checked[0] || !network_checked[1] || !network_checked[2] ||
 751       !network_checked[3]);
 752
 753   g_slist_foreach (networks, (GFunc) g_object_unref, NULL);
 754   g_slist_free (networks);
 755   g_object_unref (mgr);
 756 }
 757 END_TEST
 758
 759 START_TEST (test_empathy_irc_network_manager_find_network_by_address)
 760 {
 761   EmpathyIrcNetworkManager *mgr;
 762   EmpathyIrcNetwork *network;
 763   struct server_t freenode_servers[] = {
 764     { "irc.freenode.net", 6667, FALSE },
 765     { "irc.eu.freenode.net", 6667, FALSE }};
 766
 767   mgr = empathy_irc_network_manager_new (GLOBAL_SAMPLE, NULL);
 768
 769   network = empathy_irc_network_manager_find_network_by_address (mgr,
 770       "irc.freenode.net");
 771   fail_if (network == NULL);
 772   check_network (network, "Freenode", "UTF-8", freenode_servers, 2);
 773
 774   network = empathy_irc_network_manager_find_network_by_address (mgr,
 775       "irc.eu.freenode.net");
 776   fail_if (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       "unknown");
 781   fail_if (network != NULL);
 782
 783   g_object_unref (mgr);
 784 }
 785 END_TEST
 786
 787 START_TEST (test_no_modify_with_empty_user_file)
 788 {
 789   EmpathyIrcNetworkManager *mgr;
 790   GSList *networks;
 791
 792   /* user don't have a networks file yet */
 793   g_unlink (USER_FILE);
 794
 795   mgr = empathy_irc_network_manager_new (GLOBAL_SAMPLE, USER_FILE);
 796   g_object_unref (mgr);
 797
 798   /* We didn't modify anything so USER_FILE should be empty */
 799   mgr = empathy_irc_network_manager_new (NULL, USER_FILE);
 800
 801   networks = empathy_irc_network_manager_get_networks (mgr);
 802   fail_if (g_slist_length (networks) != 0);
 803
 804   g_slist_foreach (networks, (GFunc) g_object_unref, NULL);
 805   g_slist_free (networks);
 806   g_object_unref (mgr);
 807 }
 808 END_TEST
 809
 810 TCase *
 811 make_empathy_irc_network_manager_tcase (void)
 812 {
 813     TCase *tc = tcase_create ("empathy-irc-network-manager");
 814     tcase_add_test (tc, test_empathy_irc_network_manager_add);
 815     tcase_add_test (tc, test_load_global_file);
 816     tcase_add_test (tc, test_empathy_irc_network_manager_remove);
 817     tcase_add_test (tc, test_load_user_file);
 818     tcase_add_test (tc, test_load_both_files);
 819     tcase_add_test (tc, test_modify_user_file);
 820     tcase_add_test (tc, test_modify_both_files);
 821     tcase_add_test (tc, test_empathy_irc_network_manager_find_network_by_address);
 822     tcase_add_test (tc, test_no_modify_with_empty_user_file);
 823     return tc;
 824 }