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 //
   7 // (c) Copyright 2004 Novell, Inc. (http://www.novell.com)
   8 //
   9
  10 using NUnit.Framework;
  11 using System;
  12 using System.Net;
  13 using System.Reflection;
  14
  15 namespace MonoTests.System.Net
  16 {
  17         [TestFixture]
  18         public class CookieContainerTest : Assertion
  19         {
  20                 [Test]
  21                 public void TestCtor1 ()
  22                 {
  23                         CookieContainer c = new CookieContainer (234);
  24                         AssertEquals ("#01", 234, c.Capacity);
  25                         bool passed = false;
  26                         try {
  27                                 new CookieContainer (0);
  28                                 passed = false;
  29                         } catch (ArgumentException) {
  30                                 passed = true;
  31                         }
  32                         AssertEquals ("#02", true, passed);
  33
  34                         try {
  35                                 new CookieContainer (-10);
  36                                 passed = false;
  37                         } catch (ArgumentException) {
  38                                 passed = true;
  39                         }
  40                         AssertEquals ("#03", true, passed);
  41                 }
  42
  43                 [Test]
  44                 public void TestCtor3 ()
  45                 {
  46                         CookieContainer c = new CookieContainer (100, 50, 1000);
  47                         AssertEquals ("#01", 100, c.Capacity);
  48                         AssertEquals ("#02", 50, c.PerDomainCapacity);
  49                         AssertEquals ("#03", 1000, c.MaxCookieSize);
  50                         bool passed = false;
  51                         try {
  52                                 new CookieContainer (100, 0, 1000);
  53                                 passed = false;
  54                         } catch (ArgumentException) {
  55                                 passed = true;
  56                         }
  57                         AssertEquals ("#04", true, passed);
  58
  59                         try {
  60                                 new CookieContainer (100, -1, 1000);
  61                                 passed = false;
  62                         } catch (ArgumentException) {
  63                                 passed = true;
  64                         }
  65                         AssertEquals ("#05", true, passed);
  66
  67                         try {
  68                                 new CookieContainer (100, Int32.MaxValue, 1000);
  69                                 passed = true;
  70                         } catch (ArgumentException) {
  71                                 passed = false;
  72                         }
  73                         AssertEquals ("#06", true, passed);
  74
  75                         try {
  76                                 new CookieContainer (100, 50, 0);
  77                                 passed = false;
  78                         } catch (ArgumentException) {
  79                                 passed = true;
  80                         }
  81                         AssertEquals ("#07", true, passed);
  82
  83                         try {
  84                                 new CookieContainer (100, 500, -4);
  85                                 passed = false;
  86                         } catch (ArgumentException) {
  87                                 passed = true;
  88                         }
  89                         AssertEquals ("#08", true, passed);
  90                 }
  91
  92                 [Test]
  93                 public void TestDefaultLimits ()
  94                 {
  95                         AssertEquals ("#01", CookieContainer.DefaultCookieLengthLimit, 4096);
  96                         AssertEquals ("#02", CookieContainer.DefaultCookieLimit, 300);
  97                         AssertEquals ("#03", CookieContainer.DefaultPerDomainCookieLimit, 20);
  98                 }
  99
 100                 [Test]
 101                 public void TestCapacity ()
 102                 {
 103                         CookieContainer c = new CookieContainer ();
 104                         AssertEquals ("#01", c.Capacity, 300);
 105                         c.Capacity = 200;
 106                         AssertEquals ("#02", c.Capacity, 200);
 107                         bool passed = false;
 108                         try {
 109                                 c.Capacity = -5;
 110                                 passed = false;
 111                         } catch (ArgumentOutOfRangeException) {
 112                                 passed = true;
 113                         }
 114
 115                         AssertEquals ("#03", true, passed);
 116
 117                         try {
 118                                 c.Capacity = 5; // must be >= PerDomainCapacity if PerDomainCapacity != Int32.MaxValue
 119                                 passed = false;
 120                         } catch (ArgumentOutOfRangeException) {
 121                                 passed = true;
 122                         }
 123
 124                         AssertEquals ("#04", true, passed);
 125                         passed = false;
 126                 }
 127
 128                 [Test]
 129                 public void TestMaxCookieSize ()
 130                 {
 131                         CookieContainer c = new CookieContainer ();
 132                         AssertEquals ("#01", c.MaxCookieSize, 4096);
 133                         bool passed = false;
 134                         try {
 135                                 c.MaxCookieSize = -5;
 136                                 passed = false;
 137                         } catch (ArgumentOutOfRangeException) {
 138                                 passed = true;
 139                         }
 140
 141                         AssertEquals ("#02", true, passed);
 142                         try {
 143                                 c.MaxCookieSize = -1;
 144                                 passed = false;
 145                         } catch (ArgumentOutOfRangeException) {
 146                                 passed = true;
 147                         }
 148
 149                         AssertEquals ("#03", true, passed);
 150                         c.MaxCookieSize = 80000;
 151                         AssertEquals ("#04", 80000, c.MaxCookieSize);
 152                         c.MaxCookieSize = Int32.MaxValue;
 153                         AssertEquals ("#04", Int32.MaxValue, c.MaxCookieSize);
 154                 }
 155
 156                 [Test]
 157                 public void TestAdd_Args ()
 158                 {
 159                         CookieContainer cc = new CookieContainer ();
 160                         bool passed = false;
 161                         try {
 162                                 cc.Add ((Cookie) null);
 163                                 passed = false;
 164                         } catch (ArgumentNullException) {
 165                                 passed = true;
 166                         }
 167                         AssertEquals ("#01", true, passed);
 168
 169                         try {
 170                                 cc.Add ((CookieCollection) null);
 171                                 passed = false;
 172                         } catch (ArgumentNullException) {
 173                                 passed = true;
 174                         }
 175                         AssertEquals ("#02", true, passed);
 176
 177                         try {
 178                                 cc.Add (null, (Cookie) null);
 179                                 passed = false;
 180                         } catch (ArgumentNullException) {
 181                                 passed = true;
 182                         }
 183                         AssertEquals ("#03", true, passed);
 184
 185                         try {
 186                                 cc.Add (null, (CookieCollection) null);
 187                                 passed = false;
 188                         } catch (ArgumentNullException) {
 189                                 passed = true;
 190                         }
 191                         AssertEquals ("#04", true, passed);
 192
 193                         try {
 194                                 cc.Add (new Uri ("http://www.contoso.com"), (Cookie) null);
 195                                 passed = false;
 196                         } catch (ArgumentNullException) {
 197                                 passed = true;
 198                         }
 199                         AssertEquals ("#05", true, passed);
 200
 201                         try {
 202                                 cc.Add (new Uri ("http://www.contoso.com"), (CookieCollection) null);
 203                                 passed = false;
 204                         } catch (ArgumentNullException) {
 205                                 passed = true;
 206                         }
 207                         AssertEquals ("#06", true, passed);
 208                 }
 209
 210                 [Test]
 211                 public void TestAdd_Cookie ()
 212                 {
 213                         CookieContainer cc = new CookieContainer ();
 214                         Uri uri = new Uri ("http://www.contoso.com");
 215                         cc.Add (uri, new CookieCollection ());
 216                         DateTime timestamp = DateTime.Now;
 217                         cc.Add (uri, new Cookie ("hola", "Adios"));
 218                         CookieCollection coll = cc.GetCookies (uri);
 219                         Cookie cookie = coll [0];
 220                         AssertEquals ("#07", "", cookie.Comment);
 221                         AssertEquals ("#08", null, cookie.CommentUri);
 222                         AssertEquals ("#09", "www.contoso.com", cookie.Domain);
 223                         AssertEquals ("#10", false, cookie.Expired);
 224                         AssertEquals ("#11", DateTime.MinValue, cookie.Expires);
 225                         AssertEquals ("#12", "hola", cookie.Name);
 226                         AssertEquals ("#13", "/", cookie.Path);
 227                         AssertEquals ("#14", "", cookie.Port);
 228                         AssertEquals ("#15", false, cookie.Secure);
 229                         // FIX the next test
 230                         TimeSpan ts = cookie.TimeStamp - timestamp;
 231                         if (ts.TotalMilliseconds > 500)
 232                                 AssertEquals ("#16 timestamp", true, false);
 233
 234                         AssertEquals ("#17", "Adios", cookie.Value);
 235                         AssertEquals ("#18", 0, cookie.Version);
 236                 }
 237
 238                 [Test]
 239                 public void TestGetCookies_Args ()
 240                 {
 241                         CookieContainer cc = new CookieContainer ();
 242                         try {
 243                                 cc.GetCookies (null);
 244                                 AssertEquals ("#01", true, false);
 245                         } catch (ArgumentNullException) {
 246                         }
 247                 }
 248
 249                 [Test]
 250                 public void TestSetCookies_Args ()
 251                 {
 252                         CookieContainer cc = new CookieContainer ();
 253                         try {
 254                                 cc.SetCookies (null, "");
 255                                 AssertEquals ("#01", true, false);
 256                         } catch (ArgumentNullException) {
 257                         }
 258
 259                         try {
 260                                 cc.SetCookies (new Uri ("http://www.contoso.com"), null);
 261                                 AssertEquals ("#02", true, false);
 262                         } catch (ArgumentNullException) {
 263                         }
 264
 265                         try {
 266                                 cc.SetCookies (new Uri ("http://www.contoso.com"), "=lalala");
 267                                 AssertEquals ("#03", true, false);
 268                         } catch (CookieException) {
 269                         }
 270
 271                         try {
 272                                 cc.SetCookies (new Uri ("http://www.contoso.com"), "");
 273                         } catch (CookieException) {
 274                                 AssertEquals ("#04", true, false);
 275                         }
 276                 }
 277         }
 278 }
 279