mcs/class/System/Test/System.Net/CookieContainerTest.cs

   1 //
   2 // System.Net.CookieContainerTest - CookieContainer tests
   3 //
   4 // Authors:
   5 //      Gonzalo Paniagua Javier (gonzalo@novell.com)
   6 //      Daniel Nauck    (dna(at)mono-project(dot)de)
   7 //
   8 // (c) Copyright 2004 Novell, Inc. (http://www.novell.com)
   9 //
  10
  11 using System;
  12 using System.Net;
  13 using System.Reflection;
  14
  15 using NUnit.Framework;
  16
  17 namespace MonoTests.System.Net
  18 {
  19         [TestFixture]
  20         public class CookieContainerTest
  21         {
  22                 [Test] // .ctor ()
  23                 public void Constructor1 ()
  24                 {
  25                         CookieContainer c = new CookieContainer ();
  26                         Assert.AreEqual (0, c.Count, "Count");
  27                         Assert.AreEqual (CookieContainer.DefaultCookieLimit, c.Capacity, "Capacity");
  28                         Assert.AreEqual (CookieContainer.DefaultCookieLengthLimit, c.MaxCookieSize, "MaxCookieSize");
  29                         Assert.AreEqual (CookieContainer.DefaultPerDomainCookieLimit, c.PerDomainCapacity, "PerDomainCapacity");
  30                 }
  31
  32                 [Test] // .ctor (Int32)
  33                 public void Constructor2 ()
  34                 {
  35                         CookieContainer c = new CookieContainer (234);
  36                         Assert.AreEqual (0, c.Count, "Count");
  37                         Assert.AreEqual (234, c.Capacity, "Capacity");
  38                         Assert.AreEqual (CookieContainer.DefaultCookieLengthLimit, c.MaxCookieSize, "MaxCookieSize");
  39                         Assert.AreEqual (CookieContainer.DefaultPerDomainCookieLimit, c.PerDomainCapacity, "PerDomainCapacity");
  40                 }
  41
  42                 [Test]
  43                 public void Constructor2_Capacity_Invalid ()
  44                 {
  45                         // Capacity <= 0
  46                         try {
  47                                 new CookieContainer (0);
  48                                 Assert.Fail ("#A1");
  49                         } catch (ArgumentException ex) {
  50                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
  51                                 Assert.IsNull (ex.InnerException, "#A3");
  52 #if NET_2_0
  53                                 // The specified value must be greater than 0
  54                                 Assert.IsNotNull (ex.Message, "#A4");
  55                                 Assert.AreEqual ("Capacity", ex.ParamName, "#A5");
  56 #else
  57                                 Assert.AreEqual ("Capacity", ex.Message, "#A4");
  58                                 Assert.IsNull (ex.ParamName, "#A5");
  59 #endif
  60                         }
  61
  62                         // Capacity <= 0
  63                         try {
  64                                 new CookieContainer (-10);
  65                                 Assert.Fail ("#B1");
  66                         } catch (ArgumentException ex) {
  67                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
  68                                 Assert.IsNull (ex.InnerException, "#B3");
  69 #if NET_2_0
  70                                 // The specified value must be greater than 0
  71                                 Assert.IsNotNull (ex.Message, "#B4");
  72                                 Assert.AreEqual ("Capacity", ex.ParamName, "#B5");
  73 #else
  74                                 Assert.AreEqual ("Capacity", ex.Message, "#B4");
  75                                 Assert.IsNull (ex.ParamName, "#B5");
  76 #endif
  77                         }
  78                 }
  79
  80                 [Test] // .ctor (Int32, Int32, Int32)
  81                 public void Constructor3 ()
  82                 {
  83                         CookieContainer c;
  84
  85                         c = new CookieContainer (100, 50, 1000);
  86                         Assert.AreEqual (100, c.Capacity, "#A1");
  87                         Assert.AreEqual (50, c.PerDomainCapacity, "#A2");
  88                         Assert.AreEqual (1000, c.MaxCookieSize, "#A3");
  89
  90                         c = new CookieContainer (234, int.MaxValue, 650);
  91                         Assert.AreEqual (234, c.Capacity, "#A1");
  92                         Assert.AreEqual (int.MaxValue, c.PerDomainCapacity, "#A2");
  93                         Assert.AreEqual (650, c.MaxCookieSize, "#A3");
  94
  95                         c = new CookieContainer (234, 234, 100);
  96                         Assert.AreEqual (234, c.Capacity, "#A1");
  97                         Assert.AreEqual (234, c.PerDomainCapacity, "#A2");
  98                         Assert.AreEqual (100, c.MaxCookieSize, "#A3");
  99                 }
 100
 101                 [Test]
 102                 public void Constructor3_Capacity_Invalid ()
 103                 {
 104                         // Capacity <= 0
 105                         try {
 106                                 new CookieContainer (0, 0, 100);
 107                                 Assert.Fail ("#A1");
 108                         } catch (ArgumentException ex) {
 109                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
 110                                 Assert.IsNull (ex.InnerException, "#A3");
 111 #if NET_2_0
 112                                 // The specified value must be greater than 0
 113                                 Assert.IsNotNull (ex.Message, "#A4");
 114                                 Assert.AreEqual ("Capacity", ex.ParamName, "#A5");
 115 #else
 116                                 Assert.AreEqual ("Capacity", ex.Message, "#A4");
 117                                 Assert.IsNull (ex.ParamName, "#A5");
 118 #endif
 119                         }
 120
 121                         // Capacity <= 0
 122                         try {
 123                                 new CookieContainer (-10, 0, 100);
 124                                 Assert.Fail ("#B1");
 125                         } catch (ArgumentException ex) {
 126                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
 127                                 Assert.IsNull (ex.InnerException, "#B3");
 128 #if NET_2_0
 129                                 // The specified value must be greater than 0
 130                                 Assert.IsNotNull (ex.Message, "#B4");
 131                                 Assert.AreEqual ("Capacity", ex.ParamName, "#B5");
 132 #else
 133                                 Assert.AreEqual ("Capacity", ex.Message, "#B4");
 134                                 Assert.IsNull (ex.ParamName, "#B5");
 135 #endif
 136                         }
 137                 }
 138
 139                 [Test] // .ctor (Int32, Int32, Int32)
 140                 public void Constructor3_MaxCookieSize_Invalid ()
 141                 {
 142                         CookieContainer c;
 143
 144                         // MaxCookieSize <= 0
 145                         try {
 146                                 new CookieContainer (100, 50, 0);
 147                                 Assert.Fail ("#A1");
 148                         } catch (ArgumentException ex) {
 149                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
 150                                 Assert.IsNull (ex.InnerException, "#A3");
 151 #if NET_2_0
 152                                 // The specified value must be greater than 0
 153                                 Assert.IsNotNull (ex.Message, "#A3");
 154                                 Assert.AreEqual ("MaxCookieSize", ex.ParamName, "#A4");
 155 #else
 156                                 Assert.AreEqual ("MaxCookieSize", ex.Message, "#A4");
 157                                 Assert.IsNull (ex.ParamName, "#A5");
 158 #endif
 159                         }
 160
 161                         // MaxCookieSize <= 0
 162                         try {
 163                                 new CookieContainer (100, 50, -4);
 164                                 Assert.Fail ("#B1");
 165                         } catch (ArgumentException ex) {
 166                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
 167                                 Assert.IsNull (ex.InnerException, "#B3");
 168 #if NET_2_0
 169                                 // The specified value must be greater than 0
 170                                 Assert.IsNotNull (ex.Message, "#B3");
 171                                 Assert.AreEqual ("MaxCookieSize", ex.ParamName, "#B4");
 172 #else
 173                                 Assert.AreEqual ("MaxCookieSize", ex.Message, "#B4");
 174                                 Assert.IsNull (ex.ParamName, "#B5");
 175 #endif
 176                         }
 177                 }
 178
 179                 [Test] // .ctor (Int32, Int32, Int32)
 180                 public void Constructor3_PerDomainCapacity_Invalid ()
 181                 {
 182                         CookieContainer c;
 183
 184                         // PerDomainCapacity <= 0
 185                         try {
 186                                 new CookieContainer (432, 0, 1000);
 187                                 Assert.Fail ("#B1");
 188 #if NET_2_0
 189                         } catch (ArgumentOutOfRangeException ex) {
 190                                 // 'PerDomainCapacity' has to be greater than
 191                                 // '0' and less than '432'
 192                                 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#B2");
 193                                 Assert.IsNull (ex.InnerException, "#B3");
 194                                 Assert.IsNotNull (ex.Message, "#B4");
 195                                 Assert.AreEqual ("perDomainCapacity", ex.ParamName, "#B5");
 196                         }
 197 #else
 198                         } catch (ArgumentException ex) {
 199                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
 200                                 Assert.IsNull (ex.InnerException, "#B3");
 201                                 Assert.AreEqual ("PerDomainCapacity", ex.Message, "#B4");
 202                                 Assert.IsNull (ex.ParamName, "#B5");
 203                         }
 204 #endif
 205
 206                         // PerDomainCapacity <= 0
 207                         try {
 208                                 new CookieContainer (432, -1, 1000);
 209                                 Assert.Fail ("#C1");
 210 #if NET_2_0
 211                         } catch (ArgumentOutOfRangeException ex) {
 212                                 // 'PerDomainCapacity' has to be greater than
 213                                 // '0' and less than '432'
 214                                 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#C2");
 215                                 Assert.IsNull (ex.InnerException, "#C3");
 216                                 Assert.IsNotNull (ex.Message, "#C4");
 217                                 Assert.AreEqual ("perDomainCapacity", ex.ParamName, "#C5");
 218                         }
 219 #else
 220                         } catch (ArgumentException ex) {
 221                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#C2");
 222                                 Assert.IsNull (ex.InnerException, "#C3");
 223                                 Assert.AreEqual ("PerDomainCapacity", ex.Message, "#C4");
 224                                 Assert.IsNull (ex.ParamName, "#C5");
 225                         }
 226 #endif
 227
 228                         // PerDomainCapacity > Capacity (and != Int32.MaxValue)
 229                         try {
 230                                 new CookieContainer (432, 433, 1000);
 231                                 Assert.Fail ("#C1");
 232 #if NET_2_0
 233                         } catch (ArgumentOutOfRangeException ex) {
 234                                 // 'PerDomainCapacity' has to be greater than
 235                                 // '0' and less than '432'
 236                                 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#C2");
 237                                 Assert.IsNull (ex.InnerException, "#C3");
 238                                 Assert.IsNotNull (ex.Message, "#C4");
 239                                 Assert.AreEqual ("perDomainCapacity", ex.ParamName, "#C5");
 240                         }
 241 #else
 242                         } catch (ArgumentException ex) {
 243                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#C2");
 244                                 Assert.IsNull (ex.InnerException, "#C3");
 245                                 Assert.AreEqual ("PerDomainCapacity", ex.Message, "#C4");
 246                                 Assert.IsNull (ex.ParamName, "#C5");
 247                         }
 248 #endif
 249                 }
 250
 251                 [Test]
 252                 public void TestDefaultLimits ()
 253                 {
 254                         Assert.AreEqual (4096, CookieContainer.DefaultCookieLengthLimit, "#1");
 255                         Assert.AreEqual (300, CookieContainer.DefaultCookieLimit, "#2");
 256                         Assert.AreEqual (20, CookieContainer.DefaultPerDomainCookieLimit, "#3");
 257                 }
 258
 259                 [Test]
 260                 public void Capacity ()
 261                 {
 262                         CookieContainer c = new CookieContainer ();
 263                         c.Capacity = c.PerDomainCapacity;
 264                         Assert.AreEqual (c.PerDomainCapacity, c.Capacity, "#A1");
 265                         Assert.AreEqual (CookieContainer.DefaultCookieLengthLimit, c.MaxCookieSize, "#A2");
 266                         Assert.AreEqual (CookieContainer.DefaultPerDomainCookieLimit, c.PerDomainCapacity, "#A3");
 267                         c.Capacity = int.MaxValue;
 268                         Assert.AreEqual (int.MaxValue, c.Capacity, "#B1");
 269                         Assert.AreEqual (CookieContainer.DefaultCookieLengthLimit, c.MaxCookieSize, "#B2");
 270                         Assert.AreEqual (CookieContainer.DefaultPerDomainCookieLimit, c.PerDomainCapacity, "#B3");
 271                         c.PerDomainCapacity = int.MaxValue;
 272                         c.Capacity = (c.PerDomainCapacity - 1);
 273                         Assert.AreEqual ((c.PerDomainCapacity - 1), c.Capacity, "#C1");
 274                         Assert.AreEqual (CookieContainer.DefaultCookieLengthLimit, c.MaxCookieSize, "#C2");
 275                         Assert.AreEqual (int.MaxValue, c.PerDomainCapacity, "#C3");
 276                 }
 277
 278                 [Test]
 279                 public void Capacity_Value_Invalid ()
 280                 {
 281                         CookieContainer c = new CookieContainer ();
 282
 283                         // Capacity <= 0
 284                         try {
 285                                 c.Capacity = -5;
 286                                 Assert.Fail ("#A1");
 287                         } catch (ArgumentOutOfRangeException ex) {
 288                                 // 'Capacity' has to be greater than '0' and
 289                                 // less than '20'
 290                                 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#A2");
 291                                 Assert.IsNull (ex.InnerException, "#A3");
 292                                 Assert.IsNotNull (ex.Message, "#A4");
 293                                 Assert.AreEqual ("value", ex.ParamName, "#A5");
 294                         }
 295
 296                         // Capacity <= 0
 297                         try {
 298                                 c.Capacity = 0;
 299                                 Assert.Fail ("#B1");
 300                         } catch (ArgumentOutOfRangeException ex) {
 301                                 // 'Capacity' has to be greater than '0' and
 302                                 // less than '20'
 303                                 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#B2");
 304                                 Assert.IsNull (ex.InnerException, "#B3");
 305                                 Assert.IsNotNull (ex.Message, "#B4");
 306                                 Assert.AreEqual ("value", ex.ParamName, "#B5");
 307                         }
 308
 309                         // Capacity < PerDomainCapacity (and PerDomainCapacity != Int32.MaxValue)
 310                         try {
 311                                 c.Capacity = 5;
 312                                 Assert.Fail ("#C1");
 313                         } catch (ArgumentOutOfRangeException ex) {
 314                                 // 'Capacity' has to be greater than '0' and
 315                                 // less than '20'
 316                                 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#C2");
 317                                 Assert.IsNull (ex.InnerException, "#C3");
 318                                 Assert.IsNotNull (ex.Message, "#C4");
 319                                 Assert.AreEqual ("value", ex.ParamName, "#C5");
 320                         }
 321                 }
 322
 323                 [Test]
 324                 public void MaxCookieSize ()
 325                 {
 326                         CookieContainer c = new CookieContainer ();
 327                         c.MaxCookieSize = 80000;
 328                         Assert.AreEqual (CookieContainer.DefaultCookieLimit, c.Capacity, "#A1");
 329                         Assert.AreEqual (80000, c.MaxCookieSize, "#A2");
 330                         Assert.AreEqual (CookieContainer.DefaultPerDomainCookieLimit, c.PerDomainCapacity, "#A3");
 331                         c.MaxCookieSize = int.MaxValue;
 332                         Assert.AreEqual (CookieContainer.DefaultCookieLimit, c.Capacity, "#B1");
 333                         Assert.AreEqual (int.MaxValue, c.MaxCookieSize, "#B2");
 334                         Assert.AreEqual (CookieContainer.DefaultPerDomainCookieLimit, c.PerDomainCapacity, "#B3");
 335                         c.MaxCookieSize = 1;
 336                         Assert.AreEqual (CookieContainer.DefaultCookieLimit, c.Capacity, "#C1");
 337                         Assert.AreEqual (1, c.MaxCookieSize, "#C2");
 338                         Assert.AreEqual (CookieContainer.DefaultPerDomainCookieLimit, c.PerDomainCapacity, "#C3");
 339                 }
 340
 341                 [Test]
 342                 public void MaxCookieSize_Value_Invalid ()
 343                 {
 344                         CookieContainer c = new CookieContainer ();
 345
 346                         // MaxCookieSize <= 0
 347                         try {
 348                                 c.MaxCookieSize = -5;
 349                                 Assert.Fail ("#A1");
 350                         } catch (ArgumentOutOfRangeException ex) {
 351                                 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#A2");
 352                                 Assert.IsNull (ex.InnerException, "#A3");
 353                                 Assert.IsNotNull (ex.Message, "#A4");
 354                                 Assert.AreEqual ("value", ex.ParamName, "#A5");
 355                         }
 356
 357                         // MaxCookieSize <= 0
 358                         try {
 359                                 c.MaxCookieSize = -1;
 360                                 Assert.Fail ("#B1");
 361                         } catch (ArgumentOutOfRangeException ex) {
 362                                 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#B2");
 363                                 Assert.IsNull (ex.InnerException, "#B3");
 364                                 Assert.IsNotNull (ex.Message, "#B4");
 365                                 Assert.AreEqual ("value", ex.ParamName, "#B5");
 366                         }
 367
 368                         // MaxCookieSize <= 0
 369                         try {
 370                                 c.MaxCookieSize = 0;
 371                                 Assert.Fail ("#C1");
 372                         } catch (ArgumentOutOfRangeException ex) {
 373                                 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#C2");
 374                                 Assert.IsNull (ex.InnerException, "#C3");
 375                                 Assert.IsNotNull (ex.Message, "#C4");
 376                                 Assert.AreEqual ("value", ex.ParamName, "#C5");
 377                         }
 378                 }
 379
 380                 [Test]
 381                 public void PerDomainCapacity ()
 382                 {
 383                         CookieContainer c = new CookieContainer ();
 384                         c.PerDomainCapacity = c.Capacity;
 385                         Assert.AreEqual (c.Capacity, c.PerDomainCapacity, "#1");
 386                         c.PerDomainCapacity = int.MaxValue;
 387                         Assert.AreEqual (int.MaxValue, c.PerDomainCapacity, "#2");
 388                         c.PerDomainCapacity = c.Capacity - 5;
 389                         Assert.AreEqual ((c.Capacity - 5), c.PerDomainCapacity, "#3");
 390                         c.PerDomainCapacity = 1;
 391                         Assert.AreEqual (1, c.PerDomainCapacity, "#4");
 392                 }
 393
 394                 [Test]
 395                 public void PerDomainCapacity_Value_Invalid ()
 396                 {
 397                         CookieContainer c = new CookieContainer ();
 398
 399                         // PerDomainCapacity <= 0
 400                         try {
 401                                 c.PerDomainCapacity = -5;
 402                                 Assert.Fail ("#A1");
 403                         } catch (ArgumentOutOfRangeException ex) {
 404                                 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#A2");
 405                                 Assert.IsNull (ex.InnerException, "#A3");
 406                                 Assert.IsNotNull (ex.Message, "#A4");
 407                                 Assert.AreEqual ("value", ex.ParamName, "#A5");
 408                         }
 409
 410                         // PerDomainCapacity <= 0
 411                         try {
 412                                 c.PerDomainCapacity = 0;
 413                                 Assert.Fail ("#B1");
 414                         } catch (ArgumentOutOfRangeException ex) {
 415                                 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#B2");
 416                                 Assert.IsNull (ex.InnerException, "#B3");
 417                                 Assert.IsNotNull (ex.Message, "#B4");
 418                                 Assert.AreEqual ("value", ex.ParamName, "#B5");
 419                         }
 420
 421                         c.Capacity = (c.PerDomainCapacity + 5);
 422
 423                         // PerDomainCapacity > Capacity (and != Int32.MaxValue)
 424                         try {
 425                                 c.PerDomainCapacity = (c.Capacity + 1);
 426                                 Assert.Fail ("#C1");
 427                         } catch (ArgumentOutOfRangeException ex) {
 428                                 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#C2");
 429                                 Assert.IsNull (ex.InnerException, "#C3");
 430                                 Assert.IsNotNull (ex.Message, "#C4");
 431                                 Assert.AreEqual ("value", ex.ParamName, "#C5");
 432                         }
 433                 }
 434
 435                 [Test] // Add (Cookie)
 436                 public void Add1 ()
 437                 {
 438                         Cookie cookie;
 439                         CookieCollection cookies;
 440
 441                         CookieContainer cc = new CookieContainer ();
 442                         cookie = new Cookie ("Age", "28", string.Empty, "localhost");
 443                         cc.Add (cookie);
 444                         Assert.AreEqual (1, cc.Count, "#A1");
 445                         cookies = cc.GetCookies (new Uri ("http://localhost/Whatever"));
 446                         Assert.AreEqual (1, cookies.Count, "#A2");
 447                         cookie = cookies [0];
 448                         Assert.AreEqual ("Age", cookie.Name, "#A3");
 449                         Assert.AreEqual ("28", cookie.Value, "#A4");
 450 #if false
 451                         Assert.AreEqual ("/", cookie.Path, "#A5");
 452 #endif
 453                         Assert.AreEqual ("localhost", cookie.Domain, "#A6");
 454                 }
 455
 456                 [Test] // Add (Cookie)
 457                 public void Add1_Domain_Empty ()
 458                 {
 459                         CookieContainer cc = new CookieContainer ();
 460                         Cookie cookie = new Cookie ("Age", "28");
 461                         try {
 462                                 cc.Add (cookie);
 463                                 Assert.Fail ("#1");
 464                         } catch (ArgumentException ex) {
 465                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 466                                 Assert.IsNull (ex.InnerException, "#3");
 467 #if NET_2_0
 468                                 Assert.IsNotNull (ex.Message, "#4");
 469                                 Assert.AreEqual ("cookie.Domain", ex.ParamName, "#5");
 470 #else
 471                                 Assert.AreEqual ("cookie.Domain", ex.Message, "#4");
 472                                 Assert.IsNull (ex.ParamName, "#5");
 473 #endif
 474                         }
 475                 }
 476
 477                 [Test] // Add (CookieCollection)
 478                 public void Add2_Cookies_Null ()
 479                 {
 480                         CookieContainer cc = new CookieContainer ();
 481                         try {
 482                                 cc.Add ((CookieCollection) null);
 483                                 Assert.Fail ("#1");
 484                         } catch (ArgumentNullException ex) {
 485                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 486                                 Assert.IsNull (ex.InnerException, "#3");
 487                                 Assert.IsNotNull (ex.Message, "#4");
 488                                 Assert.AreEqual ("cookies", ex.ParamName, "#5");
 489                         }
 490                 }
 491
 492                 [Test] // Add (Uri, Cookie)
 493                 public void Add3_Uri_Null ()
 494                 {
 495                         CookieContainer cc = new CookieContainer ();
 496                         Cookie cookie = new Cookie ("Age", "28", "", "localhost");
 497                         try {
 498                                 cc.Add ((Uri) null, cookie);
 499                                 Assert.Fail ("#1");
 500                         } catch (ArgumentNullException ex) {
 501                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 502                                 Assert.IsNull (ex.InnerException, "#3");
 503                                 Assert.IsNotNull (ex.Message, "#4");
 504                                 Assert.AreEqual ("uri", ex.ParamName, "#5");
 505                         }
 506                 }
 507
 508                 [Test] // Add (Uri, Cookie)
 509                 public void Add3_Cookie_Null ()
 510                 {
 511                         CookieContainer cc = new CookieContainer ();
 512                         Uri uri = new Uri ("http://www.contoso.com");
 513                         try {
 514                                 cc.Add (uri, (Cookie) null);
 515                                 Assert.Fail ("#1");
 516                         } catch (ArgumentNullException ex) {
 517                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 518                                 Assert.IsNull (ex.InnerException, "#3");
 519                                 Assert.IsNotNull (ex.Message, "#4");
 520                                 Assert.AreEqual ("cookie", ex.ParamName, "#5");
 521                         }
 522                 }
 523
 524                 [Test] // Add (Uri, CookieCollection)
 525                 public void Add4_Uri_Null ()
 526                 {
 527                         CookieContainer cc = new CookieContainer ();
 528                         CookieCollection cookies = new CookieCollection ();
 529                         try {
 530                                 cc.Add ((Uri) null, cookies);
 531                                 Assert.Fail ("#1");
 532                         } catch (ArgumentNullException ex) {
 533                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 534                                 Assert.IsNull (ex.InnerException, "#3");
 535                                 Assert.IsNotNull (ex.Message, "#4");
 536                                 Assert.AreEqual ("uri", ex.ParamName, "#5");
 537                         }
 538                 }
 539
 540                 [Test] // Add (Uri, CookieCollection)
 541                 public void Add4_Cookie_Null ()
 542                 {
 543                         CookieContainer cc = new CookieContainer ();
 544                         Uri uri = new Uri ("http://www.contoso.com");
 545                         try {
 546                                 cc.Add (uri, (CookieCollection) null);
 547                                 Assert.Fail ("#1");
 548                         } catch (ArgumentNullException ex) {
 549                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 550                                 Assert.IsNull (ex.InnerException, "#3");
 551                                 Assert.IsNotNull (ex.Message, "#4");
 552                                 Assert.AreEqual ("cookies", ex.ParamName, "#5");
 553                         }
 554                 }
 555
 556                 [Test]
 557                 public void TestAdd_Cookie ()
 558                 {
 559                         CookieContainer cc = new CookieContainer ();
 560                         Uri uri = new Uri ("http://www.contoso.com");
 561                         cc.Add (uri, new CookieCollection ());
 562                         DateTime timestamp = DateTime.Now;
 563                         cc.Add (uri, new Cookie ("hola", "Adios"));
 564                         CookieCollection coll = cc.GetCookies (uri);
 565                         Cookie cookie = coll [0];
 566                         Assert.AreEqual ("", cookie.Comment, "#1");
 567                         Assert.IsNull (cookie.CommentUri, "#2");
 568                         Assert.AreEqual ("www.contoso.com", cookie.Domain, "#3");
 569                         Assert.IsFalse (cookie.Expired, "#4");
 570                         Assert.AreEqual (DateTime.MinValue, cookie.Expires, "#5");
 571                         Assert.AreEqual ("hola", cookie.Name, "#6");
 572                         Assert.AreEqual ("/", cookie.Path, "#7");
 573                         Assert.AreEqual ("", cookie.Port, "#8");
 574                         Assert.IsFalse (cookie.Secure, "#9");
 575                         // FIX the next test
 576                         TimeSpan ts = cookie.TimeStamp - timestamp;
 577                         if (ts.TotalMilliseconds > 500)
 578                                 Assert.Fail ("#10");
 579
 580                         Assert.AreEqual ("Adios", cookie.Value, "#11");
 581                         Assert.AreEqual (0, cookie.Version, "#12");
 582                 }
 583
 584                 [Test]
 585                 [Category ("NotWorking")]
 586                 public void TestAddExpired_Cookie ()
 587                 {
 588                         CookieContainer cc = new CookieContainer ();
 589                         Uri uri = new Uri ("http://www.contoso.com");
 590                         DateTime expires = DateTime.Now.Subtract (new TimeSpan (1, 30, 0));
 591
 592                         //expired cookie
 593                         Cookie c1 = new Cookie ("TEST", "MyValue", "/", uri.Host);
 594                         c1.Expires = expires;
 595                         cc.Add (c1);
 596                         Assert.AreEqual (1, cc.Count, "#A1");
 597                         CookieCollection coll = cc.GetCookies (uri);
 598                         Assert.AreEqual (1, coll.Count, "#A1.1");
 599                         Cookie cookie = coll [0];
 600                         Assert.AreEqual ("", cookie.Comment, "#A2");
 601                         Assert.IsNull (cookie.CommentUri, "#A3");
 602                         Assert.AreEqual ("www.contoso.com", cookie.Domain, "#A4");
 603                         Assert.IsFalse (cookie.Expired, "#A5");
 604                         Assert.AreEqual (DateTime.MinValue, cookie.Expires, "#A6");
 605                         Assert.AreEqual ("TEST", cookie.Name, "#A7");
 606                         Assert.AreEqual ("MyValue", cookie.Value, "#A8");
 607                         Assert.AreEqual ("/", cookie.Path, "#A9");
 608                         Assert.AreEqual ("", cookie.Port, "#A10");
 609                         Assert.IsFalse (cookie.Secure, "#A11");
 610
 611                         //expired cookie
 612                         Cookie c2 = new Cookie ("TEST2", "MyValue2");
 613                         c2.Expires = expires;
 614                         cc.Add (uri, c2);
 615                         Assert.AreEqual (1, cc.Count, "#B1");
 616                         coll = cc.GetCookies (uri);
 617                         Assert.AreEqual (1, coll.Count, "#B1.1");
 618                         cookie = coll [0];
 619                         Assert.AreEqual ("", cookie.Comment, "#B2");
 620                         Assert.IsNull (cookie.CommentUri, "#B3");
 621                         Assert.AreEqual ("www.contoso.com", cookie.Domain, "#B4");
 622                         Assert.IsFalse (cookie.Expired, "#B5");
 623                         Assert.AreEqual (DateTime.MinValue, cookie.Expires, "#B6");
 624                         Assert.AreEqual ("TEST", cookie.Name, "#B7");
 625                         Assert.AreEqual ("MyValue", cookie.Value, "#B8");
 626                         Assert.AreEqual ("/", cookie.Path, "#B9");
 627                         Assert.AreEqual ("", cookie.Port, "#B10");
 628                         Assert.IsFalse (cookie.Secure, "#B11");
 629
 630                         //not expired cookie
 631                         Cookie c3 = new Cookie ("TEST3", "MyValue3");
 632                         cc.Add (uri, c3);
 633                         Assert.AreEqual (2, cc.Count, "#C1");
 634                         coll = cc.GetCookies (uri);
 635                         Assert.AreEqual (2, coll.Count, "#C1.1");
 636                         cookie = coll [1];
 637                         Assert.AreEqual ("", cookie.Comment, "#C2");
 638                         Assert.IsNull (cookie.CommentUri, "#C3");
 639                         Assert.AreEqual ("www.contoso.com", cookie.Domain, "#C4");
 640                         Assert.IsFalse (cookie.Expired, "#C5");
 641                         Assert.AreEqual (DateTime.MinValue, cookie.Expires, "#C6");
 642                         Assert.AreEqual ("TEST3", cookie.Name, "#C7");
 643                         Assert.AreEqual ("MyValue3", cookie.Value, "#C8");
 644                         Assert.AreEqual ("/", cookie.Path, "#C9");
 645                         Assert.AreEqual ("", cookie.Port, "#C10");
 646                         Assert.IsFalse (cookie.Secure, "#C11");
 647
 648                         Assert.AreEqual (2, cc.Count, "#D1");
 649                         coll = cc.GetCookies (new Uri("http://contoso.com"));
 650                         Assert.AreEqual (0, coll.Count, "#D1.1");
 651
 652                         //not expired cookie
 653                         Cookie c4 = new Cookie ("TEST4", "MyValue4", "/", ".contoso.com");
 654                         cc.Add (uri, c4);
 655                         Assert.AreEqual (3, cc.Count, "#E1");
 656                         coll = cc.GetCookies (uri);
 657                         Assert.AreEqual (3, coll.Count, "#E1.1");
 658
 659                         //expired cookie
 660                         Cookie c5 = new Cookie ("TEST5", "MyValue5", "/", ".contoso.com");
 661                         c5.Expires = expires;
 662                         cc.Add (c5);
 663                         Assert.AreEqual (4, cc.Count, "#F1");
 664                         coll = cc.GetCookies (uri);
 665                         Assert.AreEqual (4, coll.Count, "#F1.1");
 666                         cookie = coll ["TEST5"];
 667                         Assert.AreEqual (".contoso.com", cookie.Domain, "#F2");
 668                         Assert.IsFalse (cookie.Expired, "#F3");
 669                         Assert.AreEqual (DateTime.MinValue, cookie.Expires, "#F4");
 670                         Assert.AreEqual ("TEST5", cookie.Name, "#F5");
 671                         Assert.AreEqual ("MyValue5", cookie.Value, "#F6");
 672                         Assert.AreEqual ("/", cookie.Path, "#F7");
 673
 674                         //expired cookie
 675                         Cookie c6 = new Cookie ("TEST6", "MyValue6", "/", ".contoso.com");
 676                         c5.Expires = expires;
 677                         cc.Add (uri, c6);
 678                         Assert.AreEqual (5, cc.Count, "#G1");
 679                         coll = cc.GetCookies (uri);
 680                         Assert.AreEqual (5, coll.Count, "#G1.1");
 681                         cookie = coll ["TEST6"];
 682                         Assert.AreEqual (".contoso.com", cookie.Domain, "#G2");
 683                         Assert.IsFalse (cookie.Expired, "#G3");
 684                         Assert.AreEqual (DateTime.MinValue, cookie.Expires, "#G4");
 685                         Assert.AreEqual ("TEST6", cookie.Name, "#G5");
 686                         Assert.AreEqual ("MyValue6", cookie.Value, "#G6");
 687                         Assert.AreEqual ("/", cookie.Path, "#G7");
 688                 }
 689
 690                 [Test]
 691                 [Category ("NotWorking")]
 692                 public void GetCookieHeader1 ()
 693                 {
 694                         CookieContainer cc;
 695                         Cookie cookie;
 696
 697                         cc = new CookieContainer ();
 698                         cookie = new Cookie ("name1", "value1", "/path", "localhost");
 699                         cookie.Comment = "Short name";
 700                         cookie.Expires = DateTime.Now.Add (new TimeSpan (3, 2, 5));
 701                         cookie.Version = 0;
 702                         cc.Add (cookie);
 703                         cookie = new Cookie ("name2", "value2", "/path/sub", "localhost");
 704                         cookie.Comment = "Description";
 705                         cookie.Expires = DateTime.Now.Add (new TimeSpan (3, 2, 5));
 706                         cookie.Version = 1;
 707                         cc.Add (cookie);
 708                         Assert.AreEqual ("$Version=1; name2=value2; $Path=/path/sub; name1=value1", cc.GetCookieHeader (new Uri ("http://localhost/path/sub")), "#A1");
 709                         Assert.AreEqual ("name1=value1", cc.GetCookieHeader (new Uri ("http://localhost/path")), "#A2");
 710                         Assert.AreEqual (string.Empty, cc.GetCookieHeader (new Uri ("http://localhost/whatever")), "#A3");
 711                 }
 712
 713                 [Test]
 714                 [Category ("NotWorking")]
 715                 public void GetCookieHeader2 ()
 716                 {
 717                         CookieContainer cc;
 718                         Cookie cookie;
 719
 720                         cc = new CookieContainer ();
 721                         cookie = new Cookie ("Country", "Belgium", "/path", "mono.com");
 722                         cc.Add (cookie);
 723                         cookie = new Cookie ("Age", "26", "/path", "dev.mono.com");
 724                         cc.Add (cookie);
 725
 726                         Assert.AreEqual ("Age=26", cc.GetCookieHeader (new Uri ("http://dev.mono.com/path/ok")), "#A1");
 727                         Assert.AreEqual ("Country=Belgium", cc.GetCookieHeader (new Uri ("http://mono.com/path")), "#A2");
 728                         Assert.AreEqual ("", cc.GetCookieHeader (new Uri ("http://test.mono.com/path")), "#A3");
 729                         Assert.AreEqual ("", cc.GetCookieHeader (new Uri ("http://us.dev.mono.com/path")), "#A4");
 730
 731                         cc = new CookieContainer ();
 732                         cookie = new Cookie ("Country", "Belgium", "/path", ".mono.com");
 733                         cc.Add (cookie);
 734                         cookie = new Cookie ("Age", "26", "/path", ".dev.mono.com");
 735                         cc.Add (cookie);
 736
 737                         Assert.AreEqual ("Country=Belgium", cc.GetCookieHeader (new Uri ("http://dev.mono.com/path/ok")), "#C1");
 738                         Assert.AreEqual ("", cc.GetCookieHeader (new Uri ("http://mono.com/path")), "#C2");
 739                         Assert.AreEqual ("Country=Belgium", cc.GetCookieHeader (new Uri ("http://test.mono.com/path")), "#C3");
 740                         Assert.AreEqual ("Age=26; Country=Belgium", cc.GetCookieHeader (new Uri ("http://us.dev.mono.com/path")), "#C4");
 741                 }
 742
 743                 [Test]
 744                 [Category ("NotWorking")]
 745                 public void GetCookieHeader3 ()
 746                 {
 747                         CookieContainer cc;
 748
 749                         cc = new CookieContainer ();
 750                         cc.SetCookies (new Uri ("http://dev.test.mono.com/Whatever/Do"),
 751                                 "Country=Belgium; path=/Whatever; domain=mono.com;" +
 752                                 "Age=26; path=/Whatever; domain=test.mono.com," +
 753                                 "Weight=87; path=/Whatever/Do; domain=.mono.com");
 754                         Assert.AreEqual ("Weight=87; Country=Belgium", cc.GetCookieHeader (new Uri ("http://dev.mono.com/Whatever/Do")), "#C1");
 755                         Assert.AreEqual ("Weight=87; Country=Belgium", cc.GetCookieHeader (new Uri ("http://test.mono.com/Whatever/Do")), "#C2");
 756                         Assert.AreEqual ("", cc.GetCookieHeader (new Uri ("http://mono.com/Whatever/Do")), "#C3");
 757                         Assert.AreEqual ("Weight=87; Country=Belgium", cc.GetCookieHeader (new Uri ("http://us.test.mono.com/Whatever/Do")), "#C4");
 758                 }
 759
 760                 [Test]
 761                 [Category ("NotWorking")]
 762                 public void GetCookieHeader4 ()
 763                 {
 764                         CookieContainer cc;
 765                         Cookie cookie;
 766
 767                         cc = new CookieContainer ();
 768                         cookie = new Cookie ("Height", "178", "/Whatever", "mono.com");
 769                         cc.Add (cookie);
 770                         cookie = new Cookie ("Town", "Brussels", "/Whatever", ".mono.com");
 771                         cc.Add (cookie);
 772                         cookie = new Cookie ("Income", "34445", "/Whatever/", ".test.mono.com");
 773                         cc.Add (cookie);
 774                         cookie = new Cookie ("Sex", "Male", "/WhateveR/DO", ".test.mono.com");
 775                         cc.Add (cookie);
 776                         cc.SetCookies (new Uri ("http://dev.test.mono.com/Whatever/Do/You"),
 777                                 "Country=Belgium," +
 778                                 "Age=26; path=/Whatever/Do; domain=test.mono.com," +
 779                                 "Weight=87; path=/");
 780                         Assert.AreEqual ("Age=26; Income=34445; Town=Brussels",
 781                                 cc.GetCookieHeader (new Uri ("http://us.test.mono.com/Whatever/Do/Ok")),
 782                                 "#D");
 783                 }
 784
 785                 [Test]
 786                 [Category ("NotWorking")]
 787                 public void GetCookieHeader5 ()
 788                 {
 789                         CookieContainer cc;
 790                         Cookie cookie;
 791
 792                         cc = new CookieContainer ();
 793                         cookie = new Cookie ("name1", "value1", "", "localhost");
 794                         cookie.Comment = "Short name";
 795                         cookie.Expires = DateTime.Now.Add (new TimeSpan (3, 2, 5));
 796                         cookie.Version = 1;
 797                         cc.Add (cookie);
 798                         Assert.AreEqual ("$Version=1; name1=value1; $Path=/",
 799                                 cc.GetCookieHeader (new Uri ("http://localhost/path/sub")), "#E1");
 800                 }
 801
 802                 [Test]
 803                 public void GetCookieHeader6 ()
 804                 {
 805                         CookieContainer cc;
 806                         Cookie cookie;
 807
 808                         cc = new CookieContainer ();
 809                         cookie = new Cookie ("name1", "value1", "", "localhost");
 810                         cookie.Comment = "Short name";
 811                         cookie.Expires = DateTime.Now.Add (new TimeSpan (3, 2, 5));
 812                         cookie.Version = 0;
 813                         cc.Add (cookie);
 814                         Assert.AreEqual ("name1=value1",
 815                                 cc.GetCookieHeader (new Uri ("http://localhost/path/sub")), "#E2");
 816                 }
 817
 818                 [Test]
 819                 [Category ("NotWorking")]
 820                 public void GetCookieHeader7 ()
 821                 {
 822                         CookieContainer cc;
 823                         Cookie cookie;
 824
 825                         cc = new CookieContainer ();
 826                         cookie = new Cookie ("name1", "value1", "/path", ".mono.com");
 827                         cookie.Comment = "Short name";
 828                         cookie.Expires = DateTime.Now.Add (new TimeSpan (3, 2, 5));
 829                         cookie.Version = 0;
 830                         cc.Add (cookie);
 831                         cookie = new Cookie ("name2", "value2", "/path/sub", ".mono.com");
 832                         cookie.Comment = "Description";
 833                         cookie.Expires = DateTime.Now.Add (new TimeSpan (3, 2, 5));
 834                         cookie.Version = 1;
 835                         cc.Add (cookie);
 836                         Assert.AreEqual ("$Version=1; name2=value2; $Path=/path/sub; $Domain=.mono.com; name1=value1", cc.GetCookieHeader (new Uri ("http://live.mono.com/path/sub")), "#A1");
 837                         Assert.AreEqual ("name1=value1", cc.GetCookieHeader (new Uri ("http://live.mono.com/path")), "#A2");
 838                         Assert.AreEqual (string.Empty, cc.GetCookieHeader (new Uri ("http://live.mono.com/whatever")), "#A3");
 839                         Assert.AreEqual (string.Empty, cc.GetCookieHeader (new Uri ("http://gomono.com/path/sub")), "#A4");
 840                         Assert.AreEqual (string.Empty, cc.GetCookieHeader (new Uri ("http://mono.com/path/sub")), "#A5");
 841
 842                         cc = new CookieContainer ();
 843                         cookie = new Cookie ("name1", "value1", "/path", "live.mono.com");
 844                         cookie.Comment = "Short name";
 845                         cookie.Expires = DateTime.Now.Add (new TimeSpan (3, 2, 5));
 846                         cookie.Version = 0;
 847                         cc.Add (cookie);
 848                         cookie = new Cookie ("name2", "value2", "/path/sub", "live.mono.com");
 849                         cookie.Comment = "Description";
 850                         cookie.Expires = DateTime.Now.Add (new TimeSpan (3, 2, 5));
 851                         cookie.Version = 1;
 852                         cc.Add (cookie);
 853                         Assert.AreEqual ("$Version=1; name2=value2; $Path=/path/sub; name1=value1", cc.GetCookieHeader (new Uri ("http://live.mono.com/path/sub")), "#B1");
 854                         Assert.AreEqual ("name1=value1", cc.GetCookieHeader (new Uri ("http://live.mono.com/path")), "#B2");
 855                         Assert.AreEqual (string.Empty, cc.GetCookieHeader (new Uri ("http://live.mono.com/whatever")), "#B3");
 856                         Assert.AreEqual (string.Empty, cc.GetCookieHeader (new Uri ("http://go.live.mono.com/path/sub")), "#B4");
 857                         Assert.AreEqual (string.Empty, cc.GetCookieHeader (new Uri ("http://go.live.mono.com/path")), "#B5");
 858                         Assert.AreEqual (string.Empty, cc.GetCookieHeader (new Uri ("http://go.live.mono.com/whatever")), "#B6");
 859                         Assert.AreEqual (string.Empty, cc.GetCookieHeader (new Uri ("http://golive.mono.com/whatever")), "#B7");
 860                 }
 861
 862                 [Test]
 863                 public void GetCookieHeader_Uri_Null ()
 864                 {
 865                         CookieContainer cc = new CookieContainer ();
 866                         try {
 867                                 cc.GetCookieHeader ((Uri) null);
 868                                 Assert.Fail ("#1");
 869                         } catch (ArgumentNullException ex) {
 870                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 871                                 Assert.IsNull (ex.InnerException, "#3");
 872                                 Assert.IsNotNull (ex.Message, "#4");
 873                                 Assert.AreEqual ("uri", ex.ParamName, "#5");
 874                         }
 875                 }
 876
 877                 [Test]
 878                 public void GetCookies ()
 879                 {
 880                         CookieContainer container = new CookieContainer ();
 881                         container.Add (new Cookie ("name", "value1", "/path", "localhost"));
 882                         container.Add (new Cookie ("name", "value2", "/path/sub", "localhost"));
 883
 884                         CookieCollection cookies = container.GetCookies (
 885                                 new Uri ("http://localhost/path/sub"));
 886                         Assert.IsNotNull (cookies, "#A1");
 887                         Assert.AreEqual (2, cookies.Count, "#A2");
 888
 889                         Cookie cookie = cookies [0];
 890                         Assert.AreEqual ("name", cookie.Name, "#B1");
 891                         Assert.AreEqual ("value2", cookie.Value, "#B2");
 892                         Assert.AreEqual ("/path/sub", cookie.Path, "#B3");
 893                         Assert.AreEqual ("localhost", cookie.Domain, "#B4");
 894
 895                         cookie = cookies [1];
 896                         Assert.AreEqual ("name", cookie.Name, "#C1");
 897                         Assert.AreEqual ("value1", cookie.Value, "#C2");
 898                         Assert.AreEqual ("/path", cookie.Path, "#C3");
 899                         Assert.AreEqual ("localhost", cookie.Domain, "#C4");
 900
 901                         cookies = container.GetCookies (new Uri ("http://localhost/path"));
 902                         Assert.IsNotNull (cookies, "#D1");
 903                         Assert.AreEqual (1, cookies.Count, "#D2");
 904
 905                         cookie = cookies [0];
 906                         Assert.AreEqual ("name", cookie.Name, "#E1");
 907                         Assert.AreEqual ("value1", cookie.Value, "#E2");
 908                         Assert.AreEqual ("/path", cookie.Path, "#E3");
 909                         Assert.AreEqual ("localhost", cookie.Domain, "#E4");
 910
 911                         cookies = container.GetCookies (new Uri ("http://localhost/whatever"));
 912                         Assert.IsNotNull (cookies, "#F1");
 913                         Assert.AreEqual (0, cookies.Count, "#F2");
 914                 }
 915
 916                 [Test]
 917                 [Category ("NotWorking")]
 918                 public void GetCookies2 ()
 919                 {
 920                         CookieContainer container;
 921                         CookieCollection cookies;
 922                         Cookie cookie;
 923
 924                         container = new CookieContainer ();
 925                         container.Add (new Cookie ("Country", "Belgium", "/path", "mono.com"));
 926                         container.Add (new Cookie ("Age", "26", "/path", "dev.mono.com"));
 927
 928                         cookies = container.GetCookies (new Uri ("http://dev.mono.com/path/ok"));
 929                         Assert.IsNotNull (cookies, "#G1");
 930                         Assert.AreEqual (1, cookies.Count, "#G2");
 931
 932                         cookie = cookies [0];
 933                         Assert.AreEqual ("Age", cookie.Name, "#H1");
 934                         Assert.AreEqual ("26", cookie.Value, "#H2");
 935                         Assert.AreEqual ("/path", cookie.Path, "#H3");
 936                         Assert.AreEqual ("dev.mono.com", cookie.Domain, "#H4");
 937
 938                         cookies = container.GetCookies (new Uri ("http://mono.com/path"));
 939                         Assert.IsNotNull (cookies, "#I1");
 940                         Assert.AreEqual (1, cookies.Count, "#I2");
 941
 942                         cookie = cookies [0];
 943                         Assert.AreEqual ("Country", cookie.Name, "#J1");
 944                         Assert.AreEqual ("Belgium", cookie.Value, "#J2");
 945                         Assert.AreEqual ("/path", cookie.Path, "#J3");
 946                         Assert.AreEqual ("mono.com", cookie.Domain, "#J4");
 947
 948                         cookies = container.GetCookies (new Uri ("http://test.mono.com/path"));
 949                         Assert.IsNotNull (cookies, "#K1");
 950                         Assert.AreEqual (0, cookies.Count, "#K2");
 951
 952                         cookies = container.GetCookies (new Uri ("http://us.dev.mono.com/path"));
 953                         Assert.IsNotNull (cookies, "#L1");
 954                         Assert.AreEqual (0, cookies.Count, "#L2");
 955
 956                         container = new CookieContainer ();
 957                         container.SetCookies (new Uri ("http://dev.test.mono.com/Whatever/Do"),
 958                                 "Country=Belgium; path=/Whatever; domain=mono.com," +
 959                                 "Age=26; path=/Whatever; domain=test.mono.com," +
 960                                 "Weight=87; path=/Whatever/Do; domain=.mono.com;");
 961
 962                         cookies = container.GetCookies (new Uri ("http://dev.mono.com/Whatever/Do"));
 963                         Assert.IsNotNull (cookies, "#M1");
 964                         Assert.AreEqual (2, cookies.Count, "#M2");
 965
 966                         cookie = cookies [0];
 967                         Assert.AreEqual ("Weight", cookie.Name, "#N1");
 968                         Assert.AreEqual ("87", cookie.Value, "#N2");
 969                         Assert.AreEqual ("/Whatever/Do", cookie.Path, "#N3");
 970                         Assert.AreEqual (".mono.com", cookie.Domain, "#N4");
 971                         cookie = cookies [1];
 972                         Assert.AreEqual ("Country", cookie.Name, "#N5");
 973                         Assert.AreEqual ("Belgium", cookie.Value, "#N6");
 974                         Assert.AreEqual ("/Whatever", cookie.Path, "#N7");
 975                         Assert.AreEqual ("mono.com", cookie.Domain, "#N8");
 976
 977                         cookies = container.GetCookies (new Uri ("http://test.mono.com/Whatever/Do"));
 978                         Assert.IsNotNull (cookies, "#O1");
 979                         Assert.AreEqual (2, cookies.Count, "#O2");
 980
 981                         cookie = cookies [0];
 982                         Assert.AreEqual ("Weight", cookie.Name, "#P1");
 983                         Assert.AreEqual ("87", cookie.Value, "#P2");
 984                         Assert.AreEqual ("/Whatever/Do", cookie.Path, "#P3");
 985                         Assert.AreEqual (".mono.com", cookie.Domain, "#P4");
 986                         cookie = cookies [1];
 987                         Assert.AreEqual ("Country", cookie.Name, "#P5");
 988                         Assert.AreEqual ("Belgium", cookie.Value, "#P6");
 989                         Assert.AreEqual ("/Whatever", cookie.Path, "#P7");
 990                         Assert.AreEqual ("mono.com", cookie.Domain, "#P8");
 991
 992                         cookies = container.GetCookies (new Uri ("http://mono.com/Whatever/Do"));
 993                         Assert.IsNotNull (cookies, "#Q1");
 994                         Assert.AreEqual (0, cookies.Count, "#Q2");
 995
 996                         cookies = container.GetCookies (new Uri ("http://us.test.mono.com/Whatever/Do"));
 997                         Assert.IsNotNull (cookies, "#R1");
 998                         Assert.AreEqual (3, cookies.Count, "#R2");
 999
1000                         cookie = cookies [0];
1001                         Assert.AreEqual ("Age", cookie.Name, "#S1");
1002                         Assert.AreEqual ("26", cookie.Value, "#S2");
1003                         Assert.AreEqual ("/Whatever", cookie.Path, "#S3");
1004                         Assert.AreEqual ("test.mono.com", cookie.Domain, "#S4");
1005                         cookie = cookies [1];
1006                         Assert.AreEqual ("Weight", cookie.Name, "#S5");
1007                         Assert.AreEqual ("87", cookie.Value, "#S6");
1008                         Assert.AreEqual ("/Whatever/Do", cookie.Path, "#S7");
1009                         Assert.AreEqual (".mono.com", cookie.Domain, "#S8");
1010                         cookie = cookies [2];
1011                         Assert.AreEqual ("Country", cookie.Name, "#S9");
1012                         Assert.AreEqual ("Belgium", cookie.Value, "#S10");
1013                         Assert.AreEqual ("/Whatever", cookie.Path, "#S11");
1014                         Assert.AreEqual ("mono.com", cookie.Domain, "#S12");
1015
1016                         container = new CookieContainer ();
1017                         container.Add (new Cookie ("Height", "178", "/Whatever", "mono.com"));
1018                         container.Add (new Cookie ("Town", "Brussels", "/Whatever", ".mono.com"));
1019                         container.Add (new Cookie ("Income", "34445", "/Whatever/", ".test.mono.com"));
1020                         container.Add (new Cookie ("Sex", "Male", "/WhateveR/DO", ".test.mono.com"));
1021                         container.SetCookies (new Uri ("http://dev.test.mono.com/Whatever/Do/You"),
1022                                 "Country=Belgium," +
1023                                 "Age=26; path=/Whatever/Do; domain=test.mono.com," +
1024                                 "Weight=87; path=/");
1025
1026                         cookies = container.GetCookies (new Uri ("http://us.test.mono.com/Whatever/Do/Ok"));
1027                         Assert.IsNotNull (cookies, "#T1");
1028                         Assert.AreEqual (3, cookies.Count, "#T2");
1029
1030                         cookie = cookies [0];
1031                         Assert.AreEqual ("Age", cookie.Name, "#U1");
1032                         Assert.AreEqual ("26", cookie.Value, "#U2");
1033                         Assert.AreEqual ("/Whatever/Do", cookie.Path, "#U3");
1034                         Assert.AreEqual ("test.mono.com", cookie.Domain, "#U4");
1035                         cookie = cookies [1];
1036                         Assert.AreEqual ("Income", cookie.Name, "#U5");
1037                         Assert.AreEqual ("34445", cookie.Value, "#U6");
1038                         Assert.AreEqual ("/Whatever/", cookie.Path, "#U7");
1039                         Assert.AreEqual (".test.mono.com", cookie.Domain, "#U8");
1040                         cookie = cookies [2];
1041                         Assert.AreEqual ("Town", cookie.Name, "#U9");
1042                         Assert.AreEqual ("Brussels", cookie.Value, "#U10");
1043                         Assert.AreEqual ("/Whatever", cookie.Path, "#U11");
1044                         Assert.AreEqual (".mono.com", cookie.Domain, "#U12");
1045                 }
1046
1047                 [Test]
1048                 public void GetCookies_Uri_Null ()
1049                 {
1050                         CookieContainer cc = new CookieContainer ();
1051                         try {
1052                                 cc.GetCookies (null);
1053                                 Assert.Fail ("#1");
1054                         } catch (ArgumentNullException ex) {
1055                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1056                                 Assert.IsNull (ex.InnerException, "#3");
1057                                 Assert.IsNotNull (ex.Message, "#4");
1058                                 Assert.AreEqual ("uri", ex.ParamName, "#5");
1059                         }
1060                 }
1061
1062                 [Test]
1063                 [Category ("NotWorking")]
1064                 public void SetCookies ()
1065                 {
1066                         CookieContainer cc;
1067                         CookieCollection cookies;
1068                         Cookie cookie;
1069
1070                         Uri uri = new Uri ("http://dev.test.mono.com/Whatever/Do/You");
1071
1072                         DateTime now = DateTime.Now;
1073
1074                         cc = new CookieContainer ();
1075                         cc.SetCookies (uri, "Country=Belgium," +
1076                                 "Age=26;   ; path=/Whatever/Do; domain=test.mono.com," +
1077                                 "Weight=87; path=/; ");
1078                         Assert.AreEqual (3, cc.Count, "#A");
1079
1080                         cookies = cc.GetCookies (new Uri ("http://us.test.mono.com/Whatever/Do/Ok"));
1081                         Assert.IsNotNull (cookies, "#B1");
1082                         Assert.AreEqual (1, cookies.Count, "#B2");
1083
1084                         cookie = cookies [0];
1085                         Assert.AreEqual (string.Empty, cookie.Comment, "#C:Comment");
1086                         Assert.IsNull (cookie.CommentUri, "#C:CommentUri");
1087                         Assert.IsFalse (cookie.Discard, "#C:Discard");
1088                         Assert.AreEqual ("test.mono.com", cookie.Domain, "#C:Domain");
1089                         Assert.IsFalse (cookie.Expired, "#C:Expired");
1090                         Assert.AreEqual (DateTime.MinValue, cookie.Expires, "#C:Expires");
1091 #if NET_2_0
1092                         Assert.IsFalse (cookie.HttpOnly, "#C:HttpOnly");
1093 #endif
1094                         Assert.AreEqual ("Age", cookie.Name, "#C:Name");
1095                         Assert.AreEqual ("/Whatever/Do", cookie.Path, "#C:Path");
1096                         Assert.IsFalse (cookie.Secure, "#C:Secure");
1097                         Assert.IsTrue ((cookie.TimeStamp - now).TotalMilliseconds >= 0, "#C:TimeStamp1");
1098                         Assert.IsTrue ((cookie.TimeStamp - now).TotalMilliseconds < 1000, "#C:TimeStamp2");
1099                         Assert.AreEqual ("26", cookie.Value, "#C:Value");
1100                         Assert.AreEqual (0, cookie.Version, "#C:Version");
1101
1102                         cookies = cc.GetCookies (new Uri ("http://dev.test.mono.com/Whatever/Do/Ok"));
1103                         Assert.IsNotNull (cookies, "#D1");
1104                         Assert.AreEqual (2, cookies.Count, "#D2");
1105
1106                         cookie = cookies [0];
1107                         Assert.AreEqual (string.Empty, cookie.Comment, "#E:Comment");
1108                         Assert.IsNull (cookie.CommentUri, "#E:CommentUri");
1109                         Assert.IsFalse (cookie.Discard, "#E:Discard");
1110                         Assert.AreEqual ("dev.test.mono.com", cookie.Domain, "#E:Domain");
1111                         Assert.IsFalse (cookie.Expired, "#E:Expired");
1112                         Assert.AreEqual (DateTime.MinValue, cookie.Expires, "#E:Expires");
1113 #if NET_2_0
1114                         Assert.IsFalse (cookie.HttpOnly, "#E:HttpOnly");
1115 #endif
1116                         Assert.AreEqual ("Weight", cookie.Name, "#E:Name");
1117                         Assert.AreEqual ("/", cookie.Path, "#E:Path");
1118                         Assert.IsFalse (cookie.Secure, "#E:Secure");
1119                         Assert.IsTrue ((cookie.TimeStamp - now).TotalMilliseconds >= 0, "#E:TimeStamp1");
1120                         Assert.IsTrue ((cookie.TimeStamp - now).TotalMilliseconds < 1000, "#E:TimeStamp2");
1121                         Assert.AreEqual ("87", cookie.Value, "#E:Value");
1122                         Assert.AreEqual (0, cookie.Version, "#E:Version");
1123
1124                         cookie = cookies [1];
1125                         Assert.AreEqual (string.Empty, cookie.Comment, "#F:Comment");
1126                         Assert.IsNull (cookie.CommentUri, "#F:CommentUri");
1127                         Assert.IsFalse (cookie.Discard, "#F:Discard");
1128                         Assert.AreEqual ("test.mono.com", cookie.Domain, "#F:Domain");
1129                         Assert.IsFalse (cookie.Expired, "#F:Expired");
1130                         Assert.AreEqual (DateTime.MinValue, cookie.Expires, "#F:Expires");
1131 #if NET_2_0
1132                         Assert.IsFalse (cookie.HttpOnly, "#F:HttpOnly");
1133 #endif
1134                         Assert.AreEqual ("Age", cookie.Name, "#F:Name");
1135                         Assert.AreEqual ("/Whatever/Do", cookie.Path, "#F:Path");
1136                         Assert.IsFalse (cookie.Secure, "#F:Secure");
1137                         Assert.IsTrue ((cookie.TimeStamp - now).TotalMilliseconds >= 0, "#F:TimeStamp1");
1138                         Assert.IsTrue ((cookie.TimeStamp - now).TotalMilliseconds < 1000, "#F:TimeStamp2");
1139                         Assert.AreEqual ("26", cookie.Value, "#F:Value");
1140                         Assert.AreEqual (0, cookie.Version, "#F:Version");
1141
1142                         cookies = cc.GetCookies (uri);
1143                         Assert.IsNotNull (cookies, "#G1");
1144                         Assert.AreEqual (3, cookies.Count, "#G2");
1145
1146                         cookie = cookies [0];
1147                         Assert.AreEqual (string.Empty, cookie.Comment, "#H:Comment");
1148                         Assert.IsNull (cookie.CommentUri, "#H:CommentUri");
1149                         Assert.IsFalse (cookie.Discard, "#H:Discard");
1150                         Assert.AreEqual ("dev.test.mono.com", cookie.Domain, "#H:Domain");
1151                         Assert.IsFalse (cookie.Expired, "#H:Expired");
1152                         Assert.AreEqual (DateTime.MinValue, cookie.Expires, "#H:Expires");
1153 #if NET_2_0
1154                         Assert.IsFalse (cookie.HttpOnly, "#H:HttpOnly");
1155 #endif
1156                         Assert.AreEqual ("Country", cookie.Name, "#H:Name");
1157                         Assert.AreEqual ("/Whatever/Do/You", cookie.Path, "#H:Path");
1158                         Assert.IsFalse (cookie.Secure, "#H:Secure");
1159                         Assert.IsTrue ((cookie.TimeStamp - now).TotalMilliseconds >= 0, "#H:TimeStamp1");
1160                         Assert.IsTrue ((cookie.TimeStamp - now).TotalMilliseconds < 1000, "#H:TimeStamp2");
1161                         Assert.AreEqual ("Belgium", cookie.Value, "#H:Value");
1162                         Assert.AreEqual (0, cookie.Version, "#H:Version");
1163
1164                         cookie = cookies [1];
1165                         Assert.AreEqual (string.Empty, cookie.Comment, "#I:Comment");
1166                         Assert.IsNull (cookie.CommentUri, "#I:CommentUri");
1167                         Assert.IsFalse (cookie.Discard, "#I:Discard");
1168                         Assert.AreEqual ("dev.test.mono.com", cookie.Domain, "#I:Domain");
1169                         Assert.IsFalse (cookie.Expired, "#I:Expired");
1170                         Assert.AreEqual (DateTime.MinValue, cookie.Expires, "#I:Expires");
1171 #if NET_2_0
1172                         Assert.IsFalse (cookie.HttpOnly, "#I:HttpOnly");
1173 #endif
1174                         Assert.AreEqual ("Weight", cookie.Name, "#I:Name");
1175                         Assert.AreEqual ("/", cookie.Path, "#I:Path");
1176                         Assert.IsFalse (cookie.Secure, "#I:Secure");
1177                         Assert.IsTrue ((cookie.TimeStamp - now).TotalMilliseconds >= 0, "#I:TimeStamp1");
1178                         Assert.IsTrue ((cookie.TimeStamp - now).TotalMilliseconds < 1000, "#I:TimeStamp2");
1179                         Assert.AreEqual ("87", cookie.Value, "#I:Value");
1180                         Assert.AreEqual (0, cookie.Version, "#I:Version");
1181
1182                         cookie = cookies [2];
1183                         Assert.AreEqual (string.Empty, cookie.Comment, "#J:Comment");
1184                         Assert.IsNull (cookie.CommentUri, "#J:CommentUri");
1185                         Assert.IsFalse (cookie.Discard, "#J:Discard");
1186                         Assert.AreEqual ("test.mono.com", cookie.Domain, "#J:Domain");
1187                         Assert.IsFalse (cookie.Expired, "#J:Expired");
1188                         Assert.AreEqual (DateTime.MinValue, cookie.Expires, "#J:Expires");
1189 #if NET_2_0
1190                         Assert.IsFalse (cookie.HttpOnly, "#J:HttpOnly");
1191 #endif
1192                         Assert.AreEqual ("Age", cookie.Name, "#J:Name");
1193                         Assert.AreEqual ("/Whatever/Do", cookie.Path, "#J:Path");
1194                         Assert.IsFalse (cookie.Secure, "#J:Secure");
1195                         Assert.IsTrue ((cookie.TimeStamp - now).TotalMilliseconds >= 0, "#J:TimeStamp1");
1196                         Assert.IsTrue ((cookie.TimeStamp - now).TotalMilliseconds < 1000, "#J:TimeStamp2");
1197                         Assert.AreEqual ("26", cookie.Value, "#J:Value");
1198                         Assert.AreEqual (0, cookie.Version, "#J:Version");
1199
1200                         cc.SetCookies (uri, "Country=,A");
1201                         cookies = cc.GetCookies (uri);
1202                         Assert.IsNotNull (cookies, "#K1");
1203                         Assert.AreEqual (4, cookies.Count, "#K2");
1204
1205                         cc = new CookieContainer ();
1206                         cc.SetCookies (uri, "Country=,A");
1207                         cookies = cc.GetCookies (uri);
1208                         Assert.IsNotNull (cookies, "#L1");
1209                         Assert.AreEqual (2, cookies.Count, "#L2");
1210
1211                         cookie = cookies [0];
1212                         Assert.AreEqual (string.Empty, cookie.Comment, "#M:Comment");
1213                         Assert.IsNull (cookie.CommentUri, "#M:CommentUri");
1214                         Assert.IsFalse (cookie.Discard, "#M:Discard");
1215                         Assert.AreEqual ("dev.test.mono.com", cookie.Domain, "#M:Domain");
1216                         Assert.IsFalse (cookie.Expired, "#M:Expired");
1217                         Assert.AreEqual (DateTime.MinValue, cookie.Expires, "#M:Expires");
1218 #if NET_2_0
1219                         Assert.IsFalse (cookie.HttpOnly, "#M:HttpOnly");
1220 #endif
1221                         Assert.AreEqual ("Country", cookie.Name, "#M:Name");
1222                         Assert.AreEqual ("/Whatever/Do/You", cookie.Path, "#M:Path");
1223                         Assert.IsFalse (cookie.Secure, "#M:Secure");
1224                         Assert.IsTrue ((cookie.TimeStamp - now).TotalMilliseconds >= 0, "#M:TimeStamp1");
1225                         Assert.IsTrue ((cookie.TimeStamp - now).TotalMilliseconds < 1000, "#M:TimeStamp2");
1226                         Assert.AreEqual (string.Empty, cookie.Value, "#M:Value");
1227                         Assert.AreEqual (0, cookie.Version, "#M:Version");
1228
1229                         cookie = cookies [1];
1230                         Assert.AreEqual (string.Empty, cookie.Comment, "#N:Comment");
1231                         Assert.IsNull (cookie.CommentUri, "#N:CommentUri");
1232                         Assert.IsFalse (cookie.Discard, "#N:Discard");
1233                         Assert.AreEqual ("dev.test.mono.com", cookie.Domain, "#N:Domain");
1234                         Assert.IsFalse (cookie.Expired, "#N:Expired");
1235                         Assert.AreEqual (DateTime.MinValue, cookie.Expires, "#N:Expires");
1236 #if NET_2_0
1237                         Assert.IsFalse (cookie.HttpOnly, "#N:HttpOnly");
1238 #endif
1239                         Assert.AreEqual ("A", cookie.Name, "#N:Name");
1240                         Assert.AreEqual ("/Whatever/Do/You", cookie.Path, "#N:Path");
1241                         Assert.IsFalse (cookie.Secure, "#N:Secure");
1242                         Assert.IsTrue ((cookie.TimeStamp - now).TotalMilliseconds >= 0, "#N:TimeStamp1");
1243                         Assert.IsTrue ((cookie.TimeStamp - now).TotalMilliseconds < 1000, "#N:TimeStamp2");
1244                         Assert.AreEqual (string.Empty, cookie.Value, "#N:Value");
1245                         Assert.AreEqual (0, cookie.Version, "#N:Version");
1246                 }
1247
1248                 [Test]
1249                 public void SetCookies_CookieHeader_Empty ()
1250                 {
1251                         CookieContainer cc = new CookieContainer ();
1252                         cc.SetCookies (new Uri ("http://www.contoso.com"), string.Empty);
1253                         Assert.AreEqual (0, cc.Count);
1254                 }
1255
1256                 [Test]
1257                 public void SetCookies_CookieHeader_Null ()
1258                 {
1259                         CookieContainer cc = new CookieContainer ();
1260                         try {
1261                                 cc.SetCookies (new Uri ("http://www.contoso.com"), null);
1262                                 Assert.Fail ("#1");
1263                         } catch (ArgumentNullException ex) {
1264                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1265                                 Assert.IsNull (ex.InnerException, "#3");
1266                                 Assert.IsNotNull (ex.Message, "#4");
1267                                 Assert.AreEqual ("cookieHeader", ex.ParamName, "#5");
1268                         }
1269                 }
1270
1271                 [Test]
1272                 [Category ("NotWorking")]
1273                 public void SetCookies_CookieHeader_Invalid ()
1274                 {
1275                         CookieContainer cc;
1276
1277                         // cookie format error
1278                         cc = new CookieContainer ();
1279                         try {
1280                                 cc.SetCookies (new Uri ("http://www.contoso.com"), "=lalala");
1281                                 Assert.Fail ("#A1");
1282                         } catch (CookieException ex) {
1283                                 // An error has occurred when parsing Cookie
1284                                 // header for Uri 'http://www.contoso.com/'
1285                                 Assert.AreEqual (typeof (CookieException), ex.GetType (), "#A2");
1286                                 Assert.IsNotNull (ex.InnerException, "#A3");
1287                                 Assert.IsNotNull (ex.Message, "#A4");
1288                                 Assert.IsTrue (ex.Message.IndexOf ("'http://www.contoso.com/'") != -1, "#A5");
1289
1290                                 // Cookie format error
1291                                 CookieException inner = ex.InnerException as CookieException;
1292                                 Assert.AreEqual (typeof (CookieException), inner.GetType (), "#A6");
1293                                 Assert.IsNull (inner.InnerException, "#A7");
1294                                 Assert.IsNotNull (inner.Message, "#A8");
1295                         }
1296
1297                         // cookie path not part of URI path
1298                         cc = new CookieContainer ();
1299                         try {
1300                                 cc.SetCookies (new Uri ("http://dev.test.mono.com/Whatever"),
1301                                         "Age=26; path=/Whatever/Do; domain=test.mono.com");
1302                                 Assert.Fail ("#B1");
1303                         } catch (CookieException ex) {
1304                                 // An error has occurred when parsing Cookie
1305                                 // header for Uri 'http://dev.test.mono.com/Whatever'
1306                                 Assert.AreEqual (typeof (CookieException), ex.GetType (), "#B2");
1307                                 Assert.IsNotNull (ex.InnerException, "#B3");
1308                                 Assert.IsNotNull (ex.Message, "#B4");
1309                                 Assert.IsTrue (ex.Message.IndexOf ("'http://dev.test.mono.com/Whatever'") != -1, "#B5");
1310
1311                                 // The 'Path'='/Whatever/Do' part of the Cookie
1312                                 // is invalid
1313                                 CookieException inner = ex.InnerException as CookieException;
1314                                 Assert.AreEqual (typeof (CookieException), inner.GetType (), "#B6");
1315                                 Assert.IsNull (inner.InnerException, "#B7");
1316                                 Assert.IsNotNull (inner.Message, "#B8");
1317                                 Assert.IsTrue (inner.Message.IndexOf ("'Path'='/Whatever/Do'") != -1, "#B9");
1318                         }
1319                 }
1320
1321                 [Test]
1322                 public void SetCookies_Uri_Null ()
1323                 {
1324                         CookieContainer cc = new CookieContainer ();
1325                         try {
1326                                 cc.SetCookies (null, "Age=26; path=/Whatever; domain=test.mono.com");
1327                                 Assert.Fail ("#1");
1328                         } catch (ArgumentNullException ex) {
1329                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
1330                                 Assert.IsNull (ex.InnerException, "#3");
1331                                 Assert.IsNotNull (ex.Message, "#4");
1332                                 Assert.AreEqual ("uri", ex.ParamName, "#5");
1333                         }
1334                 }
1335
1336                 [Test]
1337                 [Category ("NotWorking")]
1338                 public void SetCookies_DomainMatchesHost ()
1339                 {
1340                         CookieContainer cc = new CookieContainer ();
1341
1342 #if NET_2_0
1343                         cc.SetCookies (new Uri ("http://test.mono.com/Whatever/Do"),
1344                                 "Age=26; path=/Whatever; domain=test.mono.com");
1345                         CookieCollection cookies = cc.GetCookies (new Uri ("http://test.mono.com/Whatever/Do"));
1346                         Assert.IsNotNull (cookies, "#A1");
1347                         Assert.AreEqual (0, cookies.Count, "#A2");
1348                         cookies = cc.GetCookies (new Uri ("http://us.test.mono.com/Whatever/Do"));
1349                         Assert.IsNotNull (cookies, "#A3");
1350                         Assert.AreEqual (1, cookies.Count, "#A4");
1351 #else
1352                         try {
1353                                 cc.SetCookies (new Uri ("http://test.mono.com/Whatever/Do"),
1354                                         "Age=26; path=/Whatever; domain=test.mono.com");
1355                                 Assert.Fail ("#A1");
1356                         } catch (CookieException ex) {
1357                                 // An error has occurred when parsing Cookie
1358                                 // header for Uri 'http://test.mono.com/Whatever/Do'
1359                                 Assert.AreEqual (typeof (CookieException), ex.GetType (), "#A2");
1360                                 Assert.IsNotNull (ex.InnerException, "#A3");
1361                                 Assert.IsNotNull (ex.Message, "#A4");
1362                                 Assert.IsTrue (ex.Message.IndexOf ("'http://test.mono.com/Whatever/Do'") != -1, "#A5");
1363
1364                                 // The 'Domain'='test.mono.com' part of the
1365                                 // Cookie is invalid
1366                                 CookieException inner = ex.InnerException as CookieException;
1367                                 Assert.AreEqual (typeof (CookieException), inner.GetType (), "#A6");
1368                                 Assert.IsNull (inner.InnerException, "#A7");
1369                                 Assert.IsNotNull (inner.Message, "#A8");
1370                                 Assert.IsTrue (inner.Message.IndexOf ("'Domain'='test.mono.com'") != -1, "#A9");
1371                         }
1372 #endif
1373                 }
1374
1375                 [Test]
1376                 [Category ("NotWorking")]
1377                 public void SetCookies_Domain_Local ()
1378                 {
1379                         CookieContainer cc;
1380                         CookieCollection cookies;
1381
1382                         cc = new CookieContainer ();
1383                         cc.SetCookies (new Uri ("http://localhost/Whatever/Do"),
1384                                 "Age=26; path=/Whatever; domain=.local");
1385                         cookies = cc.GetCookies (new Uri ("http://localhost/Whatever/Do"));
1386                         Assert.IsNotNull (cookies, "#A1");
1387                         Assert.AreEqual (1, cookies.Count, "#A2");
1388                         cookies = cc.GetCookies (new Uri ("http://127.0.0.1/Whatever/Do"));
1389                         Assert.IsNotNull (cookies, "#A3");
1390                         Assert.AreEqual (0, cookies.Count, "#A4");
1391                         cookies = cc.GetCookies (new Uri ("http://" + Dns.GetHostName () + "/Whatever/Do"));
1392                         Assert.IsNotNull (cookies, "#A5");
1393                         Assert.AreEqual (1, cookies.Count, "#A6");
1394
1395                         cc = new CookieContainer ();
1396                         cc.SetCookies (new Uri ("http://127.0.0.1/Whatever/Do"),
1397                                 "Age=26; path=/Whatever; domain=.local");
1398                         cookies = cc.GetCookies (new Uri ("http://localhost/Whatever/Do"));
1399                         Assert.IsNotNull (cookies, "#B1");
1400                         Assert.AreEqual (1, cookies.Count, "#B2");
1401                         cookies = cc.GetCookies (new Uri ("http://127.0.0.1/Whatever/Do"));
1402                         Assert.IsNotNull (cookies, "#B3");
1403                         Assert.AreEqual (0, cookies.Count, "#B4");
1404                         cookies = cc.GetCookies (new Uri ("http://" + Dns.GetHostName () + "/Whatever/Do"));
1405                         Assert.IsNotNull (cookies, "#B5");
1406                         Assert.AreEqual (1, cookies.Count, "#B6");
1407
1408                         cc = new CookieContainer ();
1409                         cc.SetCookies (new Uri ("http://" + Dns.GetHostName () + "/Whatever/Do"),
1410                                 "Age=26; path=/Whatever; domain=.local");
1411                         cookies = cc.GetCookies (new Uri ("http://localhost/Whatever/Do"));
1412                         Assert.IsNotNull (cookies, "#C1");
1413                         Assert.AreEqual (1, cookies.Count, "#C2");
1414                         cookies = cc.GetCookies (new Uri ("http://127.0.0.1/Whatever/Do"));
1415                         Assert.IsNotNull (cookies, "#C3");
1416                         Assert.AreEqual (0, cookies.Count, "#C4");
1417                         cookies = cc.GetCookies (new Uri ("http://" + Dns.GetHostName () + "/Whatever/Do"));
1418                         Assert.IsNotNull (cookies, "#C5");
1419                         Assert.AreEqual (1, cookies.Count, "#C6");
1420                 }
1421
1422                 [Test]
1423                 public void bug421827 ()
1424                 {
1425                         CookieContainer container;
1426                         CookieCollection cookies;
1427                         Cookie cookie;
1428
1429                         container = new CookieContainer ();
1430                         container.SetCookies (new Uri ("http://test.mono.com/Whatever/Do"),
1431                                 "Country=Belgium; path=/Whatever; domain=mono.com");
1432                         cookies = container.GetCookies (new Uri ("http://dev.mono.com/Whatever"));
1433
1434                         Assert.AreEqual (1, cookies.Count, "#A1");
1435                         cookie = cookies [0];
1436                         Assert.AreEqual ("Country", cookie.Name, "#A2");
1437                         Assert.AreEqual ("mono.com", cookie.Domain, "#A3");
1438                         Assert.AreEqual ("/Whatever", cookie.Path, "#A4");
1439                         Assert.AreEqual (0, cookie.Version, "#A5");
1440
1441                         container = new CookieContainer ();
1442                         container.SetCookies (new Uri ("http://sub.mono.com/Whatever/Do"),
1443                                 "Country=Belgium; path=/Whatever; domain=mono.com");
1444                         cookies = container.GetCookies (new Uri ("http://gomono.com/Whatever"));
1445
1446                         Assert.AreEqual (0, cookies.Count, "#B");
1447
1448                         container = new CookieContainer ();
1449                         container.SetCookies (new Uri ("http://sub.mono.com/Whatever/Do"),
1450                                 "Country=Belgium; path=/Whatever; domain=mono.com");
1451                         cookies = container.GetCookies (new Uri ("http://amono.com/Whatever"));
1452
1453                         Assert.AreEqual (0, cookies.Count, "#C");
1454                 }
1455         }
1456 }