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

   1 //
   2 // HttpWebResponseTest.cs - NUnit Test Cases for System.Net.HttpWebResponse
   3 //
   4 // Authors:
   5 //      Gert Driesen (drieseng@users.sourceforge.net)
   6 //
   7 // Copyright (c) 2008 Gert Driesen
   8 //
   9
  10 using System;
  11 using System.Globalization;
  12 using System.IO;
  13 using System.Net;
  14 using System.Net.Sockets;
  15 using System.Text;
  16
  17 using NUnit.Framework;
  18
  19 namespace MonoTests.System.Net
  20 {
  21         [TestFixture]
  22         public class HttpWebResponseTest
  23         {
  24                 [Test]
  25                 public void CharacterSet_Disposed ()
  26                 {
  27                         IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000);
  28                         string url = "http://" + IPAddress.Loopback.ToString () + ":8000/test/";
  29
  30                         using (SocketResponder responder = new SocketResponder (new IPEndPoint (IPAddress.Loopback, 8000), new SocketRequestHandler (FullResponseHandler))) {
  31                                 responder.Start ();
  32
  33                                 HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
  34                                 req.Method = "GET";
  35                                 req.Timeout = 2000;
  36                                 req.ReadWriteTimeout = 2000;
  37                                 req.KeepAlive = false;
  38
  39                                 HttpWebResponse resp = (HttpWebResponse) req.GetResponse ();
  40                                 ((IDisposable) resp).Dispose ();
  41
  42                                 try {
  43                                         string charset = resp.CharacterSet;
  44                                         Assert.Fail ("#1:" + charset);
  45                                 } catch (ObjectDisposedException ex) {
  46                                         Assert.AreEqual (typeof (ObjectDisposedException), ex.GetType (), "#2");
  47                                         Assert.IsNull (ex.InnerException, "#3");
  48                                         Assert.IsNotNull (ex.Message, "#4");
  49                                         Assert.AreEqual (typeof (HttpWebResponse).FullName, ex.ObjectName, "#5");
  50                                 }
  51
  52                                 responder.Stop ();
  53                         }
  54                 }
  55
  56                 [Test]
  57                 public void Close_Disposed ()
  58                 {
  59                         IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000);
  60                         string url = "http://" + IPAddress.Loopback.ToString () + ":8000/test/";
  61
  62                         using (SocketResponder responder = new SocketResponder (new IPEndPoint (IPAddress.Loopback, 8000), new SocketRequestHandler (FullResponseHandler))) {
  63                                 responder.Start ();
  64
  65                                 HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
  66                                 req.Method = "GET";
  67                                 req.Timeout = 2000;
  68                                 req.ReadWriteTimeout = 2000;
  69                                 req.KeepAlive = false;
  70
  71                                 HttpWebResponse resp = (HttpWebResponse) req.GetResponse ();
  72                                 ((IDisposable) resp).Dispose ();
  73                                 resp.Close ();
  74
  75                                 responder.Stop ();
  76                         }
  77                 }
  78
  79                 [Test]
  80                 public void ContentEncoding_Disposed ()
  81                 {
  82                         IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000);
  83                         string url = "http://" + IPAddress.Loopback.ToString () + ":8000/test/";
  84
  85                         using (SocketResponder responder = new SocketResponder (new IPEndPoint (IPAddress.Loopback, 8000), new SocketRequestHandler (FullResponseHandler))) {
  86                                 responder.Start ();
  87
  88                                 HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
  89                                 req.Method = "GET";
  90                                 req.Timeout = 2000;
  91                                 req.ReadWriteTimeout = 2000;
  92                                 req.KeepAlive = false;
  93
  94                                 HttpWebResponse resp = (HttpWebResponse) req.GetResponse ();
  95                                 ((IDisposable) resp).Dispose ();
  96
  97                                 try {
  98                                         string enc = resp.ContentEncoding;
  99                                         Assert.Fail ("#1:" + enc);
 100                                 } catch (ObjectDisposedException ex) {
 101                                         Assert.AreEqual (typeof (ObjectDisposedException), ex.GetType (), "#2");
 102                                         Assert.IsNull (ex.InnerException, "#3");
 103                                         Assert.IsNotNull (ex.Message, "#4");
 104                                         Assert.AreEqual (typeof (HttpWebResponse).FullName, ex.ObjectName, "#5");
 105                                 }
 106
 107                                 responder.Stop ();
 108                         }
 109                 }
 110
 111                 [Test]
 112                 public void ContentLength_Disposed ()
 113                 {
 114                         IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000);
 115                         string url = "http://" + IPAddress.Loopback.ToString () + ":8000/test/";
 116
 117                         using (SocketResponder responder = new SocketResponder (new IPEndPoint (IPAddress.Loopback, 8000), new SocketRequestHandler (FullResponseHandler))) {
 118                                 responder.Start ();
 119
 120                                 HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
 121                                 req.Method = "GET";
 122                                 req.Timeout = 2000;
 123                                 req.ReadWriteTimeout = 2000;
 124                                 req.KeepAlive = false;
 125
 126                                 HttpWebResponse resp = (HttpWebResponse) req.GetResponse ();
 127                                 ((IDisposable) resp).Dispose ();
 128
 129                                 Assert.AreEqual (9, resp.ContentLength);
 130
 131                                 responder.Stop ();
 132                         }
 133                 }
 134
 135                 [Test]
 136                 public void ContentType_Disposed ()
 137                 {
 138                         IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000);
 139                         string url = "http://" + IPAddress.Loopback.ToString () + ":8000/test/";
 140
 141                         using (SocketResponder responder = new SocketResponder (new IPEndPoint (IPAddress.Loopback, 8000), new SocketRequestHandler (FullResponseHandler))) {
 142                                 responder.Start ();
 143
 144                                 HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
 145                                 req.Method = "GET";
 146                                 req.Timeout = 2000;
 147                                 req.ReadWriteTimeout = 2000;
 148                                 req.KeepAlive = false;
 149
 150                                 HttpWebResponse resp = (HttpWebResponse) req.GetResponse ();
 151                                 ((IDisposable) resp).Dispose ();
 152
 153                                 try {
 154                                         string contentType = resp.ContentType;
 155                                         Assert.Fail ("#1:" + contentType);
 156                                 } catch (ObjectDisposedException ex) {
 157                                         Assert.AreEqual (typeof (ObjectDisposedException), ex.GetType (), "#2");
 158                                         Assert.IsNull (ex.InnerException, "#3");
 159                                         Assert.IsNotNull (ex.Message, "#4");
 160                                         Assert.AreEqual (typeof (HttpWebResponse).FullName, ex.ObjectName, "#5");
 161                                 }
 162
 163                                 responder.Stop ();
 164                         }
 165                 }
 166
 167                 [Test]
 168                 public void Cookies_Disposed ()
 169                 {
 170                         IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000);
 171                         string url = "http://" + IPAddress.Loopback.ToString () + ":8000/test/";
 172
 173                         using (SocketResponder responder = new SocketResponder (new IPEndPoint (IPAddress.Loopback, 8000), new SocketRequestHandler (FullResponseHandler))) {
 174                                 responder.Start ();
 175
 176                                 HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
 177                                 req.Method = "GET";
 178                                 req.Timeout = 2000;
 179                                 req.ReadWriteTimeout = 2000;
 180                                 req.KeepAlive = false;
 181
 182                                 HttpWebResponse resp = (HttpWebResponse) req.GetResponse ();
 183                                 ((IDisposable) resp).Dispose ();
 184
 185                                 try {
 186                                         CookieCollection cookies = resp.Cookies;
 187                                         Assert.Fail ("#A1:" + cookies);
 188                                 } catch (ObjectDisposedException ex) {
 189                                         Assert.AreEqual (typeof (ObjectDisposedException), ex.GetType (), "#A2");
 190                                         Assert.IsNull (ex.InnerException, "#A3");
 191                                         Assert.IsNotNull (ex.Message, "#A4");
 192                                         Assert.AreEqual (typeof (HttpWebResponse).FullName, ex.ObjectName, "#A5");
 193                                 }
 194
 195                                 try {
 196                                         resp.Cookies = new CookieCollection ();
 197                                         Assert.Fail ("#B1");
 198                                 } catch (ObjectDisposedException ex) {
 199                                         Assert.AreEqual (typeof (ObjectDisposedException), ex.GetType (), "#B2");
 200                                         Assert.IsNull (ex.InnerException, "#B3");
 201                                         Assert.IsNotNull (ex.Message, "#B4");
 202                                         Assert.AreEqual (typeof (HttpWebResponse).FullName, ex.ObjectName, "#B5");
 203                                 }
 204
 205                                 responder.Stop ();
 206                         }
 207                 }
 208
 209                 [Test]
 210                 public void GetResponseHeader_Disposed ()
 211                 {
 212                         IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000);
 213                         string url = "http://" + IPAddress.Loopback.ToString () + ":8000/test/";
 214
 215                         using (SocketResponder responder = new SocketResponder (new IPEndPoint (IPAddress.Loopback, 8000), new SocketRequestHandler (FullResponseHandler))) {
 216                                 responder.Start ();
 217
 218                                 HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
 219                                 req.Method = "GET";
 220                                 req.Timeout = 2000;
 221                                 req.ReadWriteTimeout = 2000;
 222                                 req.KeepAlive = false;
 223
 224                                 HttpWebResponse resp = (HttpWebResponse) req.GetResponse ();
 225                                 ((IDisposable) resp).Dispose ();
 226
 227                                 try {
 228                                         string server = resp.GetResponseHeader ("Server");
 229                                         Assert.Fail ("#1:" + server);
 230                                 } catch (ObjectDisposedException ex) {
 231                                         Assert.AreEqual (typeof (ObjectDisposedException), ex.GetType (), "#2");
 232                                         Assert.IsNull (ex.InnerException, "#3");
 233                                         Assert.IsNotNull (ex.Message, "#4");
 234                                         Assert.AreEqual (typeof (HttpWebResponse).FullName, ex.ObjectName, "#5");
 235                                 }
 236
 237                                 responder.Stop ();
 238                         }
 239                 }
 240
 241                 [Test]
 242                 public void GetResponseStream_Disposed ()
 243                 {
 244                         IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000);
 245                         string url = "http://" + IPAddress.Loopback.ToString () + ":8000/test/";
 246
 247                         using (SocketResponder responder = new SocketResponder (new IPEndPoint (IPAddress.Loopback, 8000), new SocketRequestHandler (FullResponseHandler))) {
 248                                 responder.Start ();
 249
 250                                 HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
 251                                 req.Method = "GET";
 252                                 req.Timeout = 2000;
 253                                 req.ReadWriteTimeout = 2000;
 254                                 req.KeepAlive = false;
 255
 256                                 HttpWebResponse resp = (HttpWebResponse) req.GetResponse ();
 257                                 ((IDisposable) resp).Dispose ();
 258
 259                                 try {
 260                                         Stream s = resp.GetResponseStream ();
 261                                         Assert.Fail ("#1:" + s);
 262                                 } catch (ObjectDisposedException ex) {
 263                                         Assert.AreEqual (typeof (ObjectDisposedException), ex.GetType (), "#2");
 264                                         Assert.IsNull (ex.InnerException, "#3");
 265                                         Assert.IsNotNull (ex.Message, "#4");
 266                                         Assert.AreEqual (typeof (HttpWebResponse).FullName, ex.ObjectName, "#5");
 267                                 }
 268
 269                                 responder.Stop ();
 270                         }
 271                 }
 272
 273                 [Test]
 274                 public void Headers_Disposed ()
 275                 {
 276                         IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000);
 277                         string url = "http://" + IPAddress.Loopback.ToString () + ":8000/test/";
 278
 279                         using (SocketResponder responder = new SocketResponder (new IPEndPoint (IPAddress.Loopback, 8000), new SocketRequestHandler (FullResponseHandler))) {
 280                                 responder.Start ();
 281
 282                                 HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
 283                                 req.Method = "GET";
 284                                 req.Timeout = 2000;
 285                                 req.ReadWriteTimeout = 2000;
 286                                 req.KeepAlive = false;
 287
 288                                 HttpWebResponse resp = (HttpWebResponse) req.GetResponse ();
 289                                 ((IDisposable) resp).Dispose ();
 290
 291 #if NET_2_0
 292                                 WebHeaderCollection headers = resp.Headers;
 293                                 Assert.AreEqual (6, headers.Count, "#1");
 294                                 Assert.AreEqual ("9", headers ["Content-Length"], "#2");
 295                                 Assert.AreEqual ("utf-8", headers ["Content-Encoding"], "#3");
 296                                 Assert.AreEqual ("text/xml; charset=UTF-8", headers ["Content-Type"], "#4");
 297                                 Assert.AreEqual ("Wed, 08 Jan 2003 23:11:55 GMT", headers ["Last-Modified"], "#5");
 298                                 Assert.AreEqual ("UserID=Miguel,StoreProfile=true", headers ["Set-Cookie"], "#6");
 299                                 Assert.AreEqual ("Mono/Test", headers ["Server"], "#7");
 300 #else
 301                                 try {
 302                                         WebHeaderCollection headers = resp.Headers;
 303                                         Assert.Fail ("#1:" + headers);
 304                                 } catch (ObjectDisposedException ex) {
 305                                         Assert.AreEqual (typeof (ObjectDisposedException), ex.GetType (), "#2");
 306                                         Assert.IsNull (ex.InnerException, "#3");
 307                                         Assert.IsNotNull (ex.Message, "#4");
 308                                         Assert.AreEqual (typeof (HttpWebResponse).FullName, ex.ObjectName, "#5");
 309                                 }
 310 #endif
 311
 312                                 responder.Stop ();
 313                         }
 314                 }
 315
 316                 [Test]
 317                 public void LastModified_Disposed ()
 318                 {
 319                         IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000);
 320                         string url = "http://" + IPAddress.Loopback.ToString () + ":8000/test/";
 321
 322                         using (SocketResponder responder = new SocketResponder (new IPEndPoint (IPAddress.Loopback, 8000), new SocketRequestHandler (FullResponseHandler))) {
 323                                 responder.Start ();
 324
 325                                 HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
 326                                 req.Method = "GET";
 327                                 req.Timeout = 2000;
 328                                 req.ReadWriteTimeout = 2000;
 329                                 req.KeepAlive = false;
 330
 331                                 HttpWebResponse resp = (HttpWebResponse) req.GetResponse ();
 332                                 ((IDisposable) resp).Dispose ();
 333
 334                                 try {
 335                                         DateTime lastMod = resp.LastModified;
 336                                         Assert.Fail ("#1:" + lastMod);
 337                                 } catch (ObjectDisposedException ex) {
 338                                         Assert.AreEqual (typeof (ObjectDisposedException), ex.GetType (), "#2");
 339                                         Assert.IsNull (ex.InnerException, "#3");
 340                                         Assert.IsNotNull (ex.Message, "#4");
 341                                         Assert.AreEqual (typeof (HttpWebResponse).FullName, ex.ObjectName, "#5");
 342                                 }
 343
 344                                 responder.Stop ();
 345                         }
 346                 }
 347
 348                 [Test]
 349                 public void Method_Disposed ()
 350                 {
 351                         IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000);
 352                         string url = "http://" + IPAddress.Loopback.ToString () + ":8000/test/";
 353
 354                         using (SocketResponder responder = new SocketResponder (new IPEndPoint (IPAddress.Loopback, 8000), new SocketRequestHandler (FullResponseHandler))) {
 355                                 responder.Start ();
 356
 357                                 HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
 358                                 req.Method = "GET";
 359                                 req.Timeout = 2000;
 360                                 req.ReadWriteTimeout = 2000;
 361                                 req.KeepAlive = false;
 362
 363                                 HttpWebResponse resp = (HttpWebResponse) req.GetResponse ();
 364                                 ((IDisposable) resp).Dispose ();
 365
 366                                 try {
 367                                         string method = resp.Method;
 368                                         Assert.Fail ("#1:" + method);
 369                                 } catch (ObjectDisposedException ex) {
 370                                         Assert.AreEqual (typeof (ObjectDisposedException), ex.GetType (), "#2");
 371                                         Assert.IsNull (ex.InnerException, "#3");
 372                                         Assert.IsNotNull (ex.Message, "#4");
 373                                         Assert.AreEqual (typeof (HttpWebResponse).FullName, ex.ObjectName, "#5");
 374                                 }
 375
 376                                 responder.Stop ();
 377                         }
 378                 }
 379
 380                 [Test]
 381                 public void ProtocolVersion_Disposed ()
 382                 {
 383                         IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000);
 384                         string url = "http://" + IPAddress.Loopback.ToString () + ":8000/test/";
 385
 386                         using (SocketResponder responder = new SocketResponder (new IPEndPoint (IPAddress.Loopback, 8000), new SocketRequestHandler (FullResponseHandler))) {
 387                                 responder.Start ();
 388
 389                                 HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
 390                                 req.Method = "GET";
 391                                 req.Timeout = 2000;
 392                                 req.ReadWriteTimeout = 2000;
 393                                 req.KeepAlive = false;
 394
 395                                 HttpWebResponse resp = (HttpWebResponse) req.GetResponse ();
 396                                 ((IDisposable) resp).Dispose ();
 397
 398                                 try {
 399                                         Version protocolVersion = resp.ProtocolVersion;
 400                                         Assert.Fail ("#1:" + protocolVersion);
 401                                 } catch (ObjectDisposedException ex) {
 402                                         Assert.AreEqual (typeof (ObjectDisposedException), ex.GetType (), "#2");
 403                                         Assert.IsNull (ex.InnerException, "#3");
 404                                         Assert.IsNotNull (ex.Message, "#4");
 405                                         Assert.AreEqual (typeof (HttpWebResponse).FullName, ex.ObjectName, "#5");
 406                                 }
 407
 408                                 responder.Stop ();
 409                         }
 410                 }
 411
 412                 [Test]
 413                 public void ResponseUri_Disposed ()
 414                 {
 415                         IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000);
 416                         string url = "http://" + IPAddress.Loopback.ToString () + ":8000/test/";
 417
 418                         using (SocketResponder responder = new SocketResponder (new IPEndPoint (IPAddress.Loopback, 8000), new SocketRequestHandler (FullResponseHandler))) {
 419                                 responder.Start ();
 420
 421                                 HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
 422                                 req.Method = "GET";
 423                                 req.Timeout = 2000;
 424                                 req.ReadWriteTimeout = 2000;
 425                                 req.KeepAlive = false;
 426
 427                                 HttpWebResponse resp = (HttpWebResponse) req.GetResponse ();
 428                                 ((IDisposable) resp).Dispose ();
 429
 430                                 try {
 431                                         Uri respUri = resp.ResponseUri;
 432                                         Assert.Fail ("#1:" + respUri);
 433                                 } catch (ObjectDisposedException ex) {
 434                                         Assert.AreEqual (typeof (ObjectDisposedException), ex.GetType (), "#2");
 435                                         Assert.IsNull (ex.InnerException, "#3");
 436                                         Assert.IsNotNull (ex.Message, "#4");
 437                                         Assert.AreEqual (typeof (HttpWebResponse).FullName, ex.ObjectName, "#5");
 438                                 }
 439
 440                                 responder.Stop ();
 441                         }
 442                 }
 443
 444                 [Test]
 445                 public void Server_Disposed ()
 446                 {
 447                         IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000);
 448                         string url = "http://" + IPAddress.Loopback.ToString () + ":8000/test/";
 449
 450                         using (SocketResponder responder = new SocketResponder (new IPEndPoint (IPAddress.Loopback, 8000), new SocketRequestHandler (FullResponseHandler))) {
 451                                 responder.Start ();
 452
 453                                 HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
 454                                 req.Method = "GET";
 455                                 req.Timeout = 2000;
 456                                 req.ReadWriteTimeout = 2000;
 457                                 req.KeepAlive = false;
 458
 459                                 HttpWebResponse resp = (HttpWebResponse) req.GetResponse ();
 460                                 ((IDisposable) resp).Dispose ();
 461
 462                                 try {
 463                                         string server = resp.Server;
 464                                         Assert.Fail ("#1:" + server);
 465                                 } catch (ObjectDisposedException ex) {
 466                                         Assert.AreEqual (typeof (ObjectDisposedException), ex.GetType (), "#2");
 467                                         Assert.IsNull (ex.InnerException, "#3");
 468                                         Assert.IsNotNull (ex.Message, "#4");
 469                                         Assert.AreEqual (typeof (HttpWebResponse).FullName, ex.ObjectName, "#5");
 470                                 }
 471
 472                                 responder.Stop ();
 473                         }
 474                 }
 475
 476                 [Test]
 477                 public void StatusCode_Disposed ()
 478                 {
 479                         IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000);
 480                         string url = "http://" + IPAddress.Loopback.ToString () + ":8000/test/";
 481
 482                         using (SocketResponder responder = new SocketResponder (new IPEndPoint (IPAddress.Loopback, 8000), new SocketRequestHandler (FullResponseHandler))) {
 483                                 responder.Start ();
 484
 485                                 HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
 486                                 req.Method = "GET";
 487                                 req.Timeout = 2000;
 488                                 req.ReadWriteTimeout = 2000;
 489                                 req.KeepAlive = false;
 490
 491                                 HttpWebResponse resp = (HttpWebResponse) req.GetResponse ();
 492                                 ((IDisposable) resp).Dispose ();
 493
 494                                 Assert.AreEqual (HttpStatusCode.OK, resp.StatusCode);
 495
 496                                 responder.Stop ();
 497                         }
 498                 }
 499
 500                 [Test]
 501                 public void StatusDescription_Disposed ()
 502                 {
 503                         IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000);
 504                         string url = "http://" + IPAddress.Loopback.ToString () + ":8000/test/";
 505
 506                         using (SocketResponder responder = new SocketResponder (new IPEndPoint (IPAddress.Loopback, 8000), new SocketRequestHandler (FullResponseHandler))) {
 507                                 responder.Start ();
 508
 509                                 HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
 510                                 req.Method = "GET";
 511                                 req.Timeout = 2000;
 512                                 req.ReadWriteTimeout = 2000;
 513                                 req.KeepAlive = false;
 514
 515                                 HttpWebResponse resp = (HttpWebResponse) req.GetResponse ();
 516                                 ((IDisposable) resp).Dispose ();
 517
 518                                 try {
 519                                         string statusDesc = resp.StatusDescription;
 520                                         Assert.Fail ("#1:" + statusDesc);
 521                                 } catch (ObjectDisposedException ex) {
 522                                         Assert.AreEqual (typeof (ObjectDisposedException), ex.GetType (), "#2");
 523                                         Assert.IsNull (ex.InnerException, "#3");
 524                                         Assert.IsNotNull (ex.Message, "#4");
 525                                         Assert.AreEqual (typeof (HttpWebResponse).FullName, ex.ObjectName, "#5");
 526                                 }
 527
 528                                 responder.Stop ();
 529                         }
 530                 }
 531
 532                 static byte [] FullResponseHandler (Socket socket)
 533                 {
 534                         StringWriter sw = new StringWriter ();
 535                         sw.NewLine = "\r\n";
 536                         sw.WriteLine ("HTTP/1.0 200 OK");
 537                         sw.WriteLine ("Server: Mono/Test");
 538                         sw.WriteLine ("Last-Modified: Wed, 08 Jan 2003 23:11:55 GMT");
 539                         sw.WriteLine ("Content-Encoding: " + Encoding.UTF8.WebName);
 540                         sw.WriteLine ("Content-Type: text/xml; charset=UTF-8");
 541                         sw.WriteLine ("Content-Length: 9");
 542                         sw.WriteLine ("Set-Cookie: UserID=Miguel");
 543                         sw.WriteLine ("Set-Cookie: StoreProfile=true");
 544                         sw.WriteLine ();
 545                         sw.Write ("<dummy />");
 546                         sw.Flush ();
 547
 548                         return Encoding.UTF8.GetBytes (sw.ToString ());
 549                 }
 550         }
 551 }