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://" + ep.ToString () + "/test/";
  29
  30                         using (SocketResponder responder = new SocketResponder (ep, 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                 }
  53
  54                 [Test]
  55                 public void Close_Disposed ()
  56                 {
  57                         IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000);
  58                         string url = "http://" + ep.ToString () + "/test/";
  59
  60                         using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (FullResponseHandler))) {
  61                                 responder.Start ();
  62
  63                                 HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
  64                                 req.Method = "GET";
  65                                 req.Timeout = 2000;
  66                                 req.ReadWriteTimeout = 2000;
  67                                 req.KeepAlive = false;
  68
  69                                 HttpWebResponse resp = (HttpWebResponse) req.GetResponse ();
  70                                 ((IDisposable) resp).Dispose ();
  71                                 resp.Close ();
  72                         }
  73                 }
  74
  75                 [Test]
  76                 public void ContentEncoding_Disposed ()
  77                 {
  78                         IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000);
  79                         string url = "http://" + ep.ToString () + "/test/";
  80
  81                         using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (FullResponseHandler))) {
  82                                 responder.Start ();
  83
  84                                 HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
  85                                 req.Method = "GET";
  86                                 req.Timeout = 2000;
  87                                 req.ReadWriteTimeout = 2000;
  88                                 req.KeepAlive = false;
  89
  90                                 HttpWebResponse resp = (HttpWebResponse) req.GetResponse ();
  91                                 ((IDisposable) resp).Dispose ();
  92
  93                                 try {
  94                                         string enc = resp.ContentEncoding;
  95                                         Assert.Fail ("#1:" + enc);
  96                                 } catch (ObjectDisposedException ex) {
  97                                         Assert.AreEqual (typeof (ObjectDisposedException), ex.GetType (), "#2");
  98                                         Assert.IsNull (ex.InnerException, "#3");
  99                                         Assert.IsNotNull (ex.Message, "#4");
 100                                         Assert.AreEqual (typeof (HttpWebResponse).FullName, ex.ObjectName, "#5");
 101                                 }
 102                         }
 103                 }
 104
 105                 [Test]
 106                 public void ContentLength_Disposed ()
 107                 {
 108                         IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000);
 109                         string url = "http://" + ep.ToString () + "/test/";
 110
 111                         using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (FullResponseHandler))) {
 112                                 responder.Start ();
 113
 114                                 HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
 115                                 req.Method = "GET";
 116                                 req.Timeout = 2000;
 117                                 req.ReadWriteTimeout = 2000;
 118                                 req.KeepAlive = false;
 119
 120                                 HttpWebResponse resp = (HttpWebResponse) req.GetResponse ();
 121                                 ((IDisposable) resp).Dispose ();
 122
 123                                 Assert.AreEqual (9, resp.ContentLength);
 124                         }
 125                 }
 126
 127                 [Test]
 128                 public void ContentType_Disposed ()
 129                 {
 130                         IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000);
 131                         string url = "http://" + ep.ToString () + "/test/";
 132
 133                         using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (FullResponseHandler))) {
 134                                 responder.Start ();
 135
 136                                 HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
 137                                 req.Method = "GET";
 138                                 req.Timeout = 2000;
 139                                 req.ReadWriteTimeout = 2000;
 140                                 req.KeepAlive = false;
 141
 142                                 HttpWebResponse resp = (HttpWebResponse) req.GetResponse ();
 143                                 ((IDisposable) resp).Dispose ();
 144
 145                                 try {
 146                                         string contentType = resp.ContentType;
 147                                         Assert.Fail ("#1:" + contentType);
 148                                 } catch (ObjectDisposedException ex) {
 149                                         Assert.AreEqual (typeof (ObjectDisposedException), ex.GetType (), "#2");
 150                                         Assert.IsNull (ex.InnerException, "#3");
 151                                         Assert.IsNotNull (ex.Message, "#4");
 152                                         Assert.AreEqual (typeof (HttpWebResponse).FullName, ex.ObjectName, "#5");
 153                                 }
 154                         }
 155                 }
 156
 157                 [Test]
 158                 public void Cookies_Disposed ()
 159                 {
 160                         IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000);
 161                         string url = "http://" + ep.ToString () + "/test/";
 162
 163                         using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (FullResponseHandler))) {
 164                                 responder.Start ();
 165
 166                                 HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
 167                                 req.Method = "GET";
 168                                 req.Timeout = 2000;
 169                                 req.ReadWriteTimeout = 2000;
 170                                 req.KeepAlive = false;
 171
 172                                 HttpWebResponse resp = (HttpWebResponse) req.GetResponse ();
 173                                 ((IDisposable) resp).Dispose ();
 174
 175                                 try {
 176                                         CookieCollection cookies = resp.Cookies;
 177                                         Assert.Fail ("#A1:" + cookies);
 178                                 } catch (ObjectDisposedException ex) {
 179                                         Assert.AreEqual (typeof (ObjectDisposedException), ex.GetType (), "#A2");
 180                                         Assert.IsNull (ex.InnerException, "#A3");
 181                                         Assert.IsNotNull (ex.Message, "#A4");
 182                                         Assert.AreEqual (typeof (HttpWebResponse).FullName, ex.ObjectName, "#A5");
 183                                 }
 184
 185                                 try {
 186                                         resp.Cookies = new CookieCollection ();
 187                                         Assert.Fail ("#B1");
 188                                 } catch (ObjectDisposedException ex) {
 189                                         Assert.AreEqual (typeof (ObjectDisposedException), ex.GetType (), "#B2");
 190                                         Assert.IsNull (ex.InnerException, "#B3");
 191                                         Assert.IsNotNull (ex.Message, "#B4");
 192                                         Assert.AreEqual (typeof (HttpWebResponse).FullName, ex.ObjectName, "#B5");
 193                                 }
 194                         }
 195                 }
 196
 197                 [Test]
 198                 public void GetResponseHeader_Disposed ()
 199                 {
 200                         IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000);
 201                         string url = "http://" + ep.ToString () + "/test/";
 202
 203                         using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (FullResponseHandler))) {
 204                                 responder.Start ();
 205
 206                                 HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
 207                                 req.Method = "GET";
 208                                 req.Timeout = 2000;
 209                                 req.ReadWriteTimeout = 2000;
 210                                 req.KeepAlive = false;
 211
 212                                 HttpWebResponse resp = (HttpWebResponse) req.GetResponse ();
 213                                 ((IDisposable) resp).Dispose ();
 214
 215                                 try {
 216                                         string server = resp.GetResponseHeader ("Server");
 217                                         Assert.Fail ("#1:" + server);
 218                                 } catch (ObjectDisposedException ex) {
 219                                         Assert.AreEqual (typeof (ObjectDisposedException), ex.GetType (), "#2");
 220                                         Assert.IsNull (ex.InnerException, "#3");
 221                                         Assert.IsNotNull (ex.Message, "#4");
 222                                         Assert.AreEqual (typeof (HttpWebResponse).FullName, ex.ObjectName, "#5");
 223                                 }
 224                         }
 225                 }
 226
 227                 [Test]
 228                 public void GetResponseStream_Disposed ()
 229                 {
 230                         IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000);
 231                         string url = "http://" + ep.ToString () + "/test/";
 232
 233                         using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (FullResponseHandler))) {
 234                                 responder.Start ();
 235
 236                                 HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
 237                                 req.Method = "GET";
 238                                 req.Timeout = 2000;
 239                                 req.ReadWriteTimeout = 2000;
 240                                 req.KeepAlive = false;
 241
 242                                 HttpWebResponse resp = (HttpWebResponse) req.GetResponse ();
 243                                 ((IDisposable) resp).Dispose ();
 244
 245                                 try {
 246                                         Stream s = resp.GetResponseStream ();
 247                                         Assert.Fail ("#1:" + s);
 248                                 } catch (ObjectDisposedException ex) {
 249                                         Assert.AreEqual (typeof (ObjectDisposedException), ex.GetType (), "#2");
 250                                         Assert.IsNull (ex.InnerException, "#3");
 251                                         Assert.IsNotNull (ex.Message, "#4");
 252                                         Assert.AreEqual (typeof (HttpWebResponse).FullName, ex.ObjectName, "#5");
 253                                 }
 254                         }
 255                 }
 256
 257                 [Test]
 258                 public void Headers_Disposed ()
 259                 {
 260                         IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000);
 261                         string url = "http://" + ep.ToString () + "/test/";
 262
 263                         using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (FullResponseHandler))) {
 264                                 responder.Start ();
 265
 266                                 HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
 267                                 req.Method = "GET";
 268                                 req.Timeout = 2000;
 269                                 req.ReadWriteTimeout = 2000;
 270                                 req.KeepAlive = false;
 271
 272                                 HttpWebResponse resp = (HttpWebResponse) req.GetResponse ();
 273                                 ((IDisposable) resp).Dispose ();
 274
 275 #if NET_2_0
 276                                 WebHeaderCollection headers = resp.Headers;
 277                                 Assert.AreEqual (6, headers.Count, "#1");
 278                                 Assert.AreEqual ("9", headers ["Content-Length"], "#2");
 279                                 Assert.AreEqual ("utf-8", headers ["Content-Encoding"], "#3");
 280                                 Assert.AreEqual ("text/xml; charset=UTF-8", headers ["Content-Type"], "#4");
 281                                 Assert.AreEqual ("Wed, 08 Jan 2003 23:11:55 GMT", headers ["Last-Modified"], "#5");
 282                                 Assert.AreEqual ("UserID=Miguel,StoreProfile=true", headers ["Set-Cookie"], "#6");
 283                                 Assert.AreEqual ("Mono/Test", headers ["Server"], "#7");
 284 #else
 285                                 try {
 286                                         WebHeaderCollection headers = resp.Headers;
 287                                         Assert.Fail ("#1:" + headers);
 288                                 } catch (ObjectDisposedException ex) {
 289                                         Assert.AreEqual (typeof (ObjectDisposedException), ex.GetType (), "#2");
 290                                         Assert.IsNull (ex.InnerException, "#3");
 291                                         Assert.IsNotNull (ex.Message, "#4");
 292                                         Assert.AreEqual (typeof (HttpWebResponse).FullName, ex.ObjectName, "#5");
 293                                 }
 294 #endif
 295                         }
 296                 }
 297
 298                 [Test]
 299                 public void LastModified_Disposed ()
 300                 {
 301                         IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000);
 302                         string url = "http://" + ep.ToString () + "/test/";
 303
 304                         using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (FullResponseHandler))) {
 305                                 responder.Start ();
 306
 307                                 HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
 308                                 req.Method = "GET";
 309                                 req.Timeout = 2000;
 310                                 req.ReadWriteTimeout = 2000;
 311                                 req.KeepAlive = false;
 312
 313                                 HttpWebResponse resp = (HttpWebResponse) req.GetResponse ();
 314                                 ((IDisposable) resp).Dispose ();
 315
 316                                 try {
 317                                         DateTime lastMod = resp.LastModified;
 318                                         Assert.Fail ("#1:" + lastMod);
 319                                 } catch (ObjectDisposedException ex) {
 320                                         Assert.AreEqual (typeof (ObjectDisposedException), ex.GetType (), "#2");
 321                                         Assert.IsNull (ex.InnerException, "#3");
 322                                         Assert.IsNotNull (ex.Message, "#4");
 323                                         Assert.AreEqual (typeof (HttpWebResponse).FullName, ex.ObjectName, "#5");
 324                                 }
 325                         }
 326                 }
 327
 328                 [Test]
 329                 public void Method_Disposed ()
 330                 {
 331                         IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000);
 332                         string url = "http://" + ep.ToString () + "/test/";
 333
 334                         using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (FullResponseHandler))) {
 335                                 responder.Start ();
 336
 337                                 HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
 338                                 req.Method = "GET";
 339                                 req.Timeout = 2000;
 340                                 req.ReadWriteTimeout = 2000;
 341                                 req.KeepAlive = false;
 342
 343                                 HttpWebResponse resp = (HttpWebResponse) req.GetResponse ();
 344                                 ((IDisposable) resp).Dispose ();
 345
 346                                 try {
 347                                         string method = resp.Method;
 348                                         Assert.Fail ("#1:" + method);
 349                                 } catch (ObjectDisposedException ex) {
 350                                         Assert.AreEqual (typeof (ObjectDisposedException), ex.GetType (), "#2");
 351                                         Assert.IsNull (ex.InnerException, "#3");
 352                                         Assert.IsNotNull (ex.Message, "#4");
 353                                         Assert.AreEqual (typeof (HttpWebResponse).FullName, ex.ObjectName, "#5");
 354                                 }
 355                         }
 356                 }
 357
 358                 [Test]
 359                 public void ProtocolVersion_Disposed ()
 360                 {
 361                         IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000);
 362                         string url = "http://" + ep.ToString () + "/test/";
 363
 364                         using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (FullResponseHandler))) {
 365                                 responder.Start ();
 366
 367                                 HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
 368                                 req.Method = "GET";
 369                                 req.Timeout = 2000;
 370                                 req.ReadWriteTimeout = 2000;
 371                                 req.KeepAlive = false;
 372
 373                                 HttpWebResponse resp = (HttpWebResponse) req.GetResponse ();
 374                                 ((IDisposable) resp).Dispose ();
 375
 376                                 try {
 377                                         Version protocolVersion = resp.ProtocolVersion;
 378                                         Assert.Fail ("#1:" + protocolVersion);
 379                                 } catch (ObjectDisposedException ex) {
 380                                         Assert.AreEqual (typeof (ObjectDisposedException), ex.GetType (), "#2");
 381                                         Assert.IsNull (ex.InnerException, "#3");
 382                                         Assert.IsNotNull (ex.Message, "#4");
 383                                         Assert.AreEqual (typeof (HttpWebResponse).FullName, ex.ObjectName, "#5");
 384                                 }
 385                         }
 386                 }
 387
 388                 [Test]
 389                 public void ResponseUri_Disposed ()
 390                 {
 391                         IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000);
 392                         string url = "http://" + ep.ToString () + "/test/";
 393
 394                         using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (FullResponseHandler))) {
 395                                 responder.Start ();
 396
 397                                 HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
 398                                 req.Method = "GET";
 399                                 req.Timeout = 2000;
 400                                 req.ReadWriteTimeout = 2000;
 401                                 req.KeepAlive = false;
 402
 403                                 HttpWebResponse resp = (HttpWebResponse) req.GetResponse ();
 404                                 ((IDisposable) resp).Dispose ();
 405
 406                                 try {
 407                                         Uri respUri = resp.ResponseUri;
 408                                         Assert.Fail ("#1:" + respUri);
 409                                 } catch (ObjectDisposedException ex) {
 410                                         Assert.AreEqual (typeof (ObjectDisposedException), ex.GetType (), "#2");
 411                                         Assert.IsNull (ex.InnerException, "#3");
 412                                         Assert.IsNotNull (ex.Message, "#4");
 413                                         Assert.AreEqual (typeof (HttpWebResponse).FullName, ex.ObjectName, "#5");
 414                                 }
 415                         }
 416                 }
 417
 418                 [Test]
 419                 public void Server_Disposed ()
 420                 {
 421                         IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000);
 422                         string url = "http://" + ep.ToString () + "/test/";
 423
 424                         using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (FullResponseHandler))) {
 425                                 responder.Start ();
 426
 427                                 HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
 428                                 req.Method = "GET";
 429                                 req.Timeout = 2000;
 430                                 req.ReadWriteTimeout = 2000;
 431                                 req.KeepAlive = false;
 432
 433                                 HttpWebResponse resp = (HttpWebResponse) req.GetResponse ();
 434                                 ((IDisposable) resp).Dispose ();
 435
 436                                 try {
 437                                         string server = resp.Server;
 438                                         Assert.Fail ("#1:" + server);
 439                                 } catch (ObjectDisposedException ex) {
 440                                         Assert.AreEqual (typeof (ObjectDisposedException), ex.GetType (), "#2");
 441                                         Assert.IsNull (ex.InnerException, "#3");
 442                                         Assert.IsNotNull (ex.Message, "#4");
 443                                         Assert.AreEqual (typeof (HttpWebResponse).FullName, ex.ObjectName, "#5");
 444                                 }
 445                         }
 446                 }
 447
 448                 [Test]
 449                 public void StatusCode_Disposed ()
 450                 {
 451                         IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000);
 452                         string url = "http://" + ep.ToString () + "/test/";
 453
 454                         using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (FullResponseHandler))) {
 455                                 responder.Start ();
 456
 457                                 HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
 458                                 req.Method = "GET";
 459                                 req.Timeout = 2000;
 460                                 req.ReadWriteTimeout = 2000;
 461                                 req.KeepAlive = false;
 462
 463                                 HttpWebResponse resp = (HttpWebResponse) req.GetResponse ();
 464                                 ((IDisposable) resp).Dispose ();
 465
 466                                 Assert.AreEqual (HttpStatusCode.OK, resp.StatusCode);
 467                         }
 468                 }
 469
 470                 [Test]
 471                 public void StatusDescription_Disposed ()
 472                 {
 473                         IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000);
 474                         string url = "http://" + ep.ToString () + "/test/";
 475
 476                         using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (FullResponseHandler))) {
 477                                 responder.Start ();
 478
 479                                 HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
 480                                 req.Method = "GET";
 481                                 req.Timeout = 2000;
 482                                 req.ReadWriteTimeout = 2000;
 483                                 req.KeepAlive = false;
 484
 485                                 HttpWebResponse resp = (HttpWebResponse) req.GetResponse ();
 486                                 ((IDisposable) resp).Dispose ();
 487
 488                                 try {
 489                                         string statusDesc = resp.StatusDescription;
 490                                         Assert.Fail ("#1:" + statusDesc);
 491                                 } catch (ObjectDisposedException ex) {
 492                                         Assert.AreEqual (typeof (ObjectDisposedException), ex.GetType (), "#2");
 493                                         Assert.IsNull (ex.InnerException, "#3");
 494                                         Assert.IsNotNull (ex.Message, "#4");
 495                                         Assert.AreEqual (typeof (HttpWebResponse).FullName, ex.ObjectName, "#5");
 496                                 }
 497                         }
 498                 }
 499
 500                 internal static byte [] FullResponseHandler (Socket socket)
 501                 {
 502                         StringWriter sw = new StringWriter ();
 503                         sw.NewLine = "\r\n";
 504                         sw.WriteLine ("HTTP/1.0 200 OK");
 505                         sw.WriteLine ("Server: Mono/Test");
 506                         sw.WriteLine ("Last-Modified: Wed, 08 Jan 2003 23:11:55 GMT");
 507                         sw.WriteLine ("Content-Encoding: " + Encoding.UTF8.WebName);
 508                         sw.WriteLine ("Content-Type: text/xml; charset=UTF-8");
 509                         sw.WriteLine ("Content-Length: 9");
 510                         sw.WriteLine ("Set-Cookie: UserID=Miguel");
 511                         sw.WriteLine ("Set-Cookie: StoreProfile=true");
 512                         sw.WriteLine ();
 513                         sw.Write ("<dummy />");
 514                         sw.Flush ();
 515
 516                         return Encoding.UTF8.GetBytes (sw.ToString ());
 517                 }
 518         }
 519
 520         [TestFixture]
 521         public class HttpResponseStreamTest
 522         {
 523                 [Test]
 524                 public void BeginRead_Buffer_Null ()
 525                 {
 526                         IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000);
 527                         string url = "http://" + ep.ToString () + "/test/";
 528
 529                         using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (HttpWebResponseTest.FullResponseHandler))) {
 530                                 responder.Start ();
 531
 532                                 HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
 533                                 req.Method = "GET";
 534                                 req.Timeout = 2000;
 535                                 req.ReadWriteTimeout = 2000;
 536                                 req.KeepAlive = false;
 537
 538                                 using (HttpWebResponse resp = (HttpWebResponse) req.GetResponse ()) {
 539                                         Stream rs = resp.GetResponseStream ();
 540                                         byte [] buffer = null;
 541                                         try {
 542                                                 try {
 543                                                         rs.BeginRead (buffer, 0, 0, null, null);
 544                                                         Assert.Fail ("#A1");
 545                                                 } catch (ArgumentNullException ex) {
 546                                                         Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
 547                                                         Assert.IsNull (ex.InnerException, "#A3");
 548                                                         Assert.IsNotNull (ex.Message, "#A4");
 549                                                         Assert.AreEqual ("buffer", ex.ParamName, "#A5");
 550                                                 }
 551
 552                                                 // read full response
 553                                                 buffer = new byte [24];
 554                                                 Assert.AreEqual (9, rs.Read (buffer, 0, buffer.Length));
 555
 556                                                 buffer = null;
 557                                                 try {
 558                                                         rs.BeginRead (buffer, 0, 0, null, null);
 559                                                         Assert.Fail ("#B1");
 560                                                 } catch (ArgumentNullException ex) {
 561                                                         Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#B2");
 562                                                         Assert.IsNull (ex.InnerException, "#B3");
 563                                                         Assert.IsNotNull (ex.Message, "#B4");
 564                                                         Assert.AreEqual ("buffer", ex.ParamName, "#B5");
 565                                                 }
 566                                         } finally {
 567                                                 rs.Close ();
 568                                                 req.Abort ();
 569                                         }
 570                                 }
 571                         }
 572                 }
 573
 574                 [Test]
 575                 public void BeginWrite ()
 576                 {
 577                         IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000);
 578                         string url = "http://" + ep.ToString () + "/test/";
 579
 580                         using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (HttpWebResponseTest.FullResponseHandler))) {
 581                                 responder.Start ();
 582
 583                                 HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
 584                                 req.Method = "GET";
 585                                 req.Timeout = 2000;
 586                                 req.ReadWriteTimeout = 2000;
 587                                 req.KeepAlive = false;
 588
 589                                 using (HttpWebResponse resp = (HttpWebResponse) req.GetResponse ()) {
 590                                         Stream rs = resp.GetResponseStream ();
 591                                         byte [] buffer = new byte [5];
 592                                         try {
 593                                                 rs.BeginWrite (buffer, 0, buffer.Length, null, null);
 594                                                 Assert.Fail ("#1");
 595                                         } catch (NotSupportedException ex) {
 596                                                 // The stream does not support writing
 597                                                 Assert.AreEqual (typeof (NotSupportedException), ex.GetType (), "#2");
 598                                                 Assert.IsNull (ex.InnerException, "#3");
 599                                                 Assert.IsNotNull (ex.Message, "#4");
 600                                         } finally {
 601                                                 rs.Close ();
 602                                                 req.Abort ();
 603                                         }
 604                                 }
 605                         }
 606                 }
 607
 608                 [Test]
 609                 [Category ("NotWorking")]
 610                 public void CanRead ()
 611                 {
 612                         IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000);
 613                         string url = "http://" + ep.ToString () + "/test/";
 614
 615                         using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (HttpWebResponseTest.FullResponseHandler))) {
 616                                 responder.Start ();
 617
 618                                 HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
 619                                 req.Method = "GET";
 620                                 req.Timeout = 2000;
 621                                 req.ReadWriteTimeout = 2000;
 622                                 req.KeepAlive = false;
 623
 624                                 using (HttpWebResponse resp = (HttpWebResponse) req.GetResponse ()) {
 625                                         Stream rs = resp.GetResponseStream ();
 626                                         try {
 627                                                 Assert.IsTrue (rs.CanRead, "#1");
 628                                                 rs.Close ();
 629                                                 Assert.IsFalse (rs.CanRead, "#2");
 630                                         } finally {
 631                                                 rs.Close ();
 632                                                 req.Abort ();
 633                                         }
 634                                 }
 635                         }
 636                 }
 637
 638                 [Test]
 639                 public void CanSeek ()
 640                 {
 641                         IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000);
 642                         string url = "http://" + ep.ToString () + "/test/";
 643
 644                         using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (HttpWebResponseTest.FullResponseHandler))) {
 645                                 responder.Start ();
 646
 647                                 HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
 648                                 req.Method = "GET";
 649                                 req.Timeout = 2000;
 650                                 req.ReadWriteTimeout = 2000;
 651                                 req.KeepAlive = false;
 652
 653                                 using (HttpWebResponse resp = (HttpWebResponse) req.GetResponse ()) {
 654                                         Stream rs = resp.GetResponseStream ();
 655                                         try {
 656                                                 Assert.IsFalse (rs.CanSeek, "#1");
 657                                                 rs.Close ();
 658                                                 Assert.IsFalse (rs.CanSeek, "#2");
 659                                         } finally {
 660                                                 rs.Close ();
 661                                                 req.Abort ();
 662                                         }
 663                                 }
 664                         }
 665                 }
 666
 667 #if NET_2_0
 668                 [Test] // bug #324182
 669                 public void CanTimeout ()
 670                 {
 671                         IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000);
 672                         string url = "http://" + ep.ToString () + "/test/";
 673
 674                         using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (HttpWebResponseTest.FullResponseHandler))) {
 675                                 responder.Start ();
 676
 677                                 HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
 678                                 req.Method = "GET";
 679                                 req.Timeout = 2000;
 680                                 req.ReadWriteTimeout = 2000;
 681                                 req.KeepAlive = false;
 682
 683                                 using (HttpWebResponse resp = (HttpWebResponse) req.GetResponse ()) {
 684                                         Stream rs = resp.GetResponseStream ();
 685                                         try {
 686                                                 Assert.IsTrue (rs.CanTimeout, "#1");
 687                                                 rs.Close ();
 688                                                 Assert.IsTrue (rs.CanTimeout, "#2");
 689                                         } finally {
 690                                                 rs.Close ();
 691                                                 req.Abort ();
 692                                         }
 693                                 }
 694                         }
 695                 }
 696 #endif
 697
 698                 [Test]
 699                 public void CanWrite ()
 700                 {
 701                         IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000);
 702                         string url = "http://" + ep.ToString () + "/test/";
 703
 704                         using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (HttpWebResponseTest.FullResponseHandler))) {
 705                                 responder.Start ();
 706
 707                                 HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
 708                                 req.Method = "GET";
 709                                 req.Timeout = 2000;
 710                                 req.ReadWriteTimeout = 2000;
 711                                 req.KeepAlive = false;
 712
 713                                 using (HttpWebResponse resp = (HttpWebResponse) req.GetResponse ()) {
 714                                         Stream rs = resp.GetResponseStream ();
 715                                         try {
 716                                                 Assert.IsFalse (rs.CanWrite, "#1");
 717                                                 rs.Close ();
 718                                                 Assert.IsFalse (rs.CanWrite, "#2");
 719                                         } finally {
 720                                                 rs.Close ();
 721                                                 req.Abort ();
 722                                         }
 723                                 }
 724                         }
 725                 }
 726
 727                 [Test]
 728                 public void Read ()
 729                 {
 730                         IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000);
 731                         string url = "http://" + ep.ToString () + "/test/";
 732
 733                         using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (HttpWebResponseTest.FullResponseHandler))) {
 734                                 responder.Start ();
 735
 736                                 HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
 737                                 req.Method = "GET";
 738                                 req.Timeout = 2000;
 739                                 req.ReadWriteTimeout = 2000;
 740                                 req.KeepAlive = false;
 741
 742                                 using (HttpWebResponse resp = (HttpWebResponse) req.GetResponse ()) {
 743                                         Stream rs = resp.GetResponseStream ();
 744                                         byte [] buffer = new byte [5];
 745                                         try {
 746                                                 Assert.AreEqual (1, rs.Read (buffer, 4, 1), "#A1");
 747                                                 Assert.AreEqual (new byte [] { 0x00, 0x00, 0x00, 0x00, 0x3c }, buffer, "#A2");
 748                                                 Assert.AreEqual (2, rs.Read (buffer, 0, 2), "#B1");
 749                                                 Assert.AreEqual (new byte [] { 0x64, 0x75, 0x00, 0x00, 0x3c }, buffer, "#B2");
 750                                                 Assert.AreEqual (4, rs.Read (buffer, 1, 4), "#C1");
 751                                                 Assert.AreEqual (new byte [] { 0x64, 0x6d, 0x6d, 0x79, 0x20 }, buffer, "#C2");
 752                                                 Assert.AreEqual (2, rs.Read (buffer, 0, 3), "#D1");
 753                                                 Assert.AreEqual (new byte [] { 0x2f, 0x3e, 0x6d, 0x79, 0x20 }, buffer, "#D2");
 754                                                 Assert.AreEqual (0, rs.Read (buffer, 1, 3), "#E1");
 755                                                 Assert.AreEqual (new byte [] { 0x2f, 0x3e, 0x6d, 0x79, 0x20 }, buffer, "#E2");
 756                                                 Assert.AreEqual (0, rs.Read (buffer, buffer.Length, 0), "#G1");
 757                                                 Assert.AreEqual (new byte [] { 0x2f, 0x3e, 0x6d, 0x79, 0x20 }, buffer, "#G2");
 758                                         } finally {
 759                                                 rs.Close ();
 760                                                 req.Abort ();
 761                                         }
 762                                 }
 763                         }
 764                 }
 765
 766                 [Test]
 767                 public void Read_Buffer_Null ()
 768                 {
 769                         IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000);
 770                         string url = "http://" + ep.ToString () + "/test/";
 771
 772                         using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (HttpWebResponseTest.FullResponseHandler))) {
 773                                 responder.Start ();
 774
 775                                 HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
 776                                 req.Method = "GET";
 777                                 req.Timeout = 2000;
 778                                 req.ReadWriteTimeout = 2000;
 779                                 req.KeepAlive = false;
 780
 781                                 using (HttpWebResponse resp = (HttpWebResponse) req.GetResponse ()) {
 782                                         Stream rs = resp.GetResponseStream ();
 783                                         byte [] buffer = null;
 784                                         try {
 785                                                 try {
 786                                                         rs.Read (buffer, 0, 0);
 787                                                         Assert.Fail ("#A1");
 788                                                 } catch (ArgumentNullException ex) {
 789                                                         Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
 790                                                         Assert.IsNull (ex.InnerException, "#A3");
 791                                                         Assert.IsNotNull (ex.Message, "#A4");
 792                                                         Assert.AreEqual ("buffer", ex.ParamName, "#A5");
 793                                                 }
 794
 795                                                 // read full response
 796                                                 buffer = new byte [24];
 797                                                 Assert.AreEqual (9, rs.Read (buffer, 0, buffer.Length));
 798
 799                                                 buffer = null;
 800                                                 try {
 801                                                         rs.Read (buffer, 0, 0);
 802                                                         Assert.Fail ("#B1");
 803                                                 } catch (ArgumentNullException ex) {
 804                                                         Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#B2");
 805                                                         Assert.IsNull (ex.InnerException, "#B3");
 806                                                         Assert.IsNotNull (ex.Message, "#B4");
 807                                                         Assert.AreEqual ("buffer", ex.ParamName, "#B5");
 808                                                 }
 809                                         } finally {
 810                                                 rs.Close ();
 811                                                 req.Abort ();
 812                                         }
 813                                 }
 814                         }
 815                 }
 816
 817                 [Test]
 818                 public void Read_Count_Negative ()
 819                 {
 820                         IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000);
 821                         string url = "http://" + ep.ToString () + "/test/";
 822
 823                         using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (HttpWebResponseTest.FullResponseHandler))) {
 824                                 responder.Start ();
 825
 826                                 HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
 827                                 req.Method = "GET";
 828                                 req.Timeout = 2000;
 829                                 req.ReadWriteTimeout = 2000;
 830                                 req.KeepAlive = false;
 831
 832                                 using (HttpWebResponse resp = (HttpWebResponse) req.GetResponse ()) {
 833                                         Stream rs = resp.GetResponseStream ();
 834                                         byte [] buffer = new byte [5];
 835                                         try {
 836                                                 try {
 837                                                         rs.Read (buffer, 1, -1);
 838                                                         Assert.Fail ("#A1");
 839                                                 } catch (ArgumentOutOfRangeException ex) {
 840                                                         // Specified argument was out of the range of valid values
 841                                                         Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#A2");
 842                                                         Assert.IsNull (ex.InnerException, "#A3");
 843                                                         Assert.IsNotNull (ex.Message, "#A4");
 844                                                         Assert.AreEqual ("size", ex.ParamName, "#A5");
 845                                                 }
 846
 847                                                 // read full response
 848                                                 buffer = new byte [24];
 849                                                 Assert.AreEqual (9, rs.Read (buffer, 0, buffer.Length));
 850
 851                                                 try {
 852                                                         rs.Read (buffer, 1, -1);
 853                                                         Assert.Fail ("#B1");
 854                                                 } catch (ArgumentOutOfRangeException ex) {
 855                                                         // Specified argument was out of the range of valid values
 856                                                         Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#B2");
 857                                                         Assert.IsNull (ex.InnerException, "#B3");
 858                                                         Assert.IsNotNull (ex.Message, "#B4");
 859                                                         Assert.AreEqual ("size", ex.ParamName, "#B5");
 860                                                 }
 861                                         } finally {
 862                                                 rs.Close ();
 863                                                 req.Abort ();
 864                                         }
 865                                 }
 866                         }
 867                 }
 868
 869                 [Test]
 870                 public void Read_Count_Overflow ()
 871                 {
 872                         IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000);
 873                         string url = "http://" + ep.ToString () + "/test/";
 874
 875                         using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (HttpWebResponseTest.FullResponseHandler))) {
 876                                 responder.Start ();
 877
 878                                 HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
 879                                 req.Method = "GET";
 880                                 req.Timeout = 2000;
 881                                 req.ReadWriteTimeout = 2000;
 882                                 req.KeepAlive = false;
 883
 884                                 using (HttpWebResponse resp = (HttpWebResponse) req.GetResponse ()) {
 885                                         Stream rs = resp.GetResponseStream ();
 886                                         byte [] buffer = new byte [5];
 887                                         try {
 888                                                 try {
 889                                                         rs.Read (buffer, buffer.Length - 2, 3);
 890                                                         Assert.Fail ("#A1");
 891                                                 } catch (ArgumentOutOfRangeException ex) {
 892                                                         // Specified argument was out of the range of valid values
 893                                                         Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#A2");
 894                                                         Assert.IsNull (ex.InnerException, "#A3");
 895                                                         Assert.IsNotNull (ex.Message, "#A4");
 896                                                         Assert.AreEqual ("size", ex.ParamName, "#A5");
 897                                                 }
 898
 899                                                 // read full response
 900                                                 buffer = new byte [24];
 901                                                 Assert.AreEqual (9, rs.Read (buffer, 0, buffer.Length));
 902
 903                                                 try {
 904                                                         rs.Read (buffer, buffer.Length - 2, 3);
 905                                                         Assert.Fail ("#B1");
 906                                                 } catch (ArgumentOutOfRangeException ex) {
 907                                                         // Specified argument was out of the range of valid values
 908                                                         Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#B2");
 909                                                         Assert.IsNull (ex.InnerException, "#B3");
 910                                                         Assert.IsNotNull (ex.Message, "#B4");
 911                                                         Assert.AreEqual ("size", ex.ParamName, "#B5");
 912                                                 }
 913                                         } finally {
 914                                                 rs.Close ();
 915                                                 req.Abort ();
 916                                         }
 917                                 }
 918                         }
 919                 }
 920
 921                 [Test]
 922                 public void Read_Offset_Negative ()
 923                 {
 924                         IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000);
 925                         string url = "http://" + ep.ToString () + "/test/";
 926
 927                         using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (HttpWebResponseTest.FullResponseHandler))) {
 928                                 responder.Start ();
 929
 930                                 HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
 931                                 req.Method = "GET";
 932                                 req.Timeout = 2000;
 933                                 req.ReadWriteTimeout = 2000;
 934                                 req.KeepAlive = false;
 935
 936                                 using (HttpWebResponse resp = (HttpWebResponse) req.GetResponse ()) {
 937                                         Stream rs = resp.GetResponseStream ();
 938                                         byte [] buffer = new byte [5];
 939                                         try {
 940                                                 try {
 941                                                         rs.Read (buffer, -1, 0);
 942                                                         Assert.Fail ("#A1");
 943                                                 } catch (ArgumentOutOfRangeException ex) {
 944                                                         // Specified argument was out of the range of valid values
 945                                                         Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#A2");
 946                                                         Assert.IsNull (ex.InnerException, "#A3");
 947                                                         Assert.IsNotNull (ex.Message, "#A4");
 948                                                         Assert.AreEqual ("offset", ex.ParamName, "#A5");
 949                                                 }
 950
 951                                                 // read full response
 952                                                 buffer = new byte [24];
 953                                                 Assert.AreEqual (9, rs.Read (buffer, 0, buffer.Length));
 954
 955                                                 try {
 956                                                         rs.Read (buffer, -1, 0);
 957                                                         Assert.Fail ("#B1");
 958                                                 } catch (ArgumentOutOfRangeException ex) {
 959                                                         // Specified argument was out of the range of valid values
 960                                                         Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#B2");
 961                                                         Assert.IsNull (ex.InnerException, "#B3");
 962                                                         Assert.IsNotNull (ex.Message, "#B4");
 963                                                         Assert.AreEqual ("offset", ex.ParamName, "#B5");
 964                                                 }
 965                                         } finally {
 966                                                 rs.Close ();
 967                                                 req.Abort ();
 968                                         }
 969                                 }
 970                         }
 971                 }
 972
 973                 [Test]
 974                 public void Read_Offset_Overflow ()
 975                 {
 976                         IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000);
 977                         string url = "http://" + ep.ToString () + "/test/";
 978
 979                         using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (HttpWebResponseTest.FullResponseHandler))) {
 980                                 responder.Start ();
 981
 982                                 HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
 983                                 req.Method = "GET";
 984                                 req.Timeout = 2000;
 985                                 req.ReadWriteTimeout = 2000;
 986                                 req.KeepAlive = false;
 987
 988                                 using (HttpWebResponse resp = (HttpWebResponse) req.GetResponse ()) {
 989                                         Stream rs = resp.GetResponseStream ();
 990                                         byte [] buffer = new byte [5];
 991                                         try {
 992                                                 try {
 993                                                         rs.Read (buffer, buffer.Length + 1, 0);
 994                                                         Assert.Fail ("#A1");
 995                                                 } catch (ArgumentOutOfRangeException ex) {
 996                                                         // Specified argument was out of the range of valid values
 997                                                         Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#A2");
 998                                                         Assert.IsNull (ex.InnerException, "#A3");
 999                                                         Assert.IsNotNull (ex.Message, "#A4");
1000                                                         Assert.AreEqual ("offset", ex.ParamName, "#A5");
1001                                                 }
1002
1003                                                 // read full response
1004                                                 buffer = new byte [24];
1005                                                 Assert.AreEqual (9, rs.Read (buffer, 0, buffer.Length));
1006
1007                                                 try {
1008                                                         rs.Read (buffer, buffer.Length + 1, 0);
1009                                                         Assert.Fail ("#B1");
1010                                                 } catch (ArgumentOutOfRangeException ex) {
1011                                                         // Specified argument was out of the range of valid values
1012                                                         Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#B2");
1013                                                         Assert.IsNull (ex.InnerException, "#B3");
1014                                                         Assert.IsNotNull (ex.Message, "#B4");
1015                                                         Assert.AreEqual ("offset", ex.ParamName, "#B5");
1016                                                 }
1017                                         } finally {
1018                                                 rs.Close ();
1019                                                 req.Abort ();
1020                                         }
1021                                 }
1022                         }
1023                 }
1024
1025                 [Test]
1026                 [Category ("NotWorking")]
1027                 public void Read_Stream_Closed ()
1028                 {
1029                         IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000);
1030                         string url = "http://" + ep.ToString () + "/test/";
1031
1032                         using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (HttpWebResponseTest.FullResponseHandler))) {
1033                                 responder.Start ();
1034
1035                                 HttpWebRequest req;
1036
1037                                 req = (HttpWebRequest) WebRequest.Create (url);
1038                                 req.Method = "GET";
1039                                 req.Timeout = 2000;
1040                                 req.ReadWriteTimeout = 2000;
1041                                 req.KeepAlive = false;
1042
1043                                 using (HttpWebResponse resp = (HttpWebResponse) req.GetResponse ()) {
1044                                         Stream rs = resp.GetResponseStream ();
1045                                         rs.Close ();
1046                                         try {
1047                                                 rs.Read (new byte [0], 0, 0);
1048                                                 Assert.Fail ("#A1");
1049                                         } catch (WebException ex) {
1050                                                 // The request was aborted: The connection was closed unexpectedly
1051                                                 Assert.AreEqual (typeof (WebException), ex.GetType (), "#A2");
1052                                                 Assert.IsNull (ex.InnerException, "#A3");
1053                                                 Assert.IsNotNull (ex.Message, "#A4");
1054                                                 Assert.IsNull (ex.Response, "#A5");
1055                                                 Assert.AreEqual (WebExceptionStatus.ConnectionClosed, ex.Status, "#A6");
1056                                         } finally {
1057                                                 rs.Close ();
1058                                                 req.Abort ();
1059                                         }
1060                                 }
1061
1062                                 req = (HttpWebRequest) WebRequest.Create (url);
1063                                 req.Method = "GET";
1064                                 req.Timeout = 2000;
1065                                 req.ReadWriteTimeout = 2000;
1066                                 req.KeepAlive = false;
1067
1068                                 using (HttpWebResponse resp = (HttpWebResponse) req.GetResponse ()) {
1069                                         Stream rs = resp.GetResponseStream ();
1070                                         byte [] buffer = new byte [24];
1071                                         Assert.AreEqual (9, rs.Read (buffer, 0, buffer.Length));
1072                                         rs.Close ();
1073                                         try {
1074                                                 rs.Read (new byte [0], 0, 0);
1075                                                 Assert.Fail ("#B1");
1076                                         } catch (WebException ex) {
1077                                                 // The request was aborted: The connection was closed unexpectedly
1078                                                 Assert.AreEqual (typeof (WebException), ex.GetType (), "#B2");
1079                                                 Assert.IsNull (ex.InnerException, "#B3");
1080                                                 Assert.IsNotNull (ex.Message, "#B4");
1081                                                 Assert.IsNull (ex.Response, "#B5");
1082                                                 Assert.AreEqual (WebExceptionStatus.ConnectionClosed, ex.Status, "#B6");
1083                                         } finally {
1084                                                 rs.Close ();
1085                                                 req.Abort ();
1086                                         }
1087                                 }
1088                         }
1089                 }
1090
1091 #if NET_2_0
1092                 [Test]
1093                 public void ReadTimeout ()
1094                 {
1095                         IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000);
1096                         string url = "http://" + ep.ToString () + "/test/";
1097
1098                         using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (HttpWebResponseTest.FullResponseHandler))) {
1099                                 responder.Start ();
1100
1101                                 HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
1102                                 req.Method = "GET";
1103                                 req.Timeout = 2000;
1104                                 req.ReadWriteTimeout = 2000;
1105                                 req.KeepAlive = false;
1106
1107                                 using (HttpWebResponse resp = (HttpWebResponse) req.GetResponse ()) {
1108                                         Stream rs = resp.GetResponseStream ();
1109                                         try {
1110                                                 Assert.AreEqual (2000, rs.ReadTimeout, "#1");
1111                                                 rs.Close ();
1112                                                 Assert.AreEqual (2000, rs.ReadTimeout, "#2");
1113                                         } finally {
1114                                                 rs.Close ();
1115                                                 req.Abort ();
1116                                         }
1117                                 }
1118                         }
1119                 }
1120 #endif
1121
1122                 [Test]
1123                 public void Write ()
1124                 {
1125                         IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000);
1126                         string url = "http://" + ep.ToString () + "/test/";
1127
1128                         using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (HttpWebResponseTest.FullResponseHandler))) {
1129                                 responder.Start ();
1130
1131                                 HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
1132                                 req.Method = "GET";
1133                                 req.Timeout = 2000;
1134                                 req.ReadWriteTimeout = 2000;
1135                                 req.KeepAlive = false;
1136
1137                                 using (HttpWebResponse resp = (HttpWebResponse) req.GetResponse ()) {
1138                                         Stream rs = resp.GetResponseStream ();
1139                                         byte [] buffer = new byte [5];
1140                                         try {
1141                                                 rs.Write (buffer, 0, buffer.Length);
1142                                                 Assert.Fail ("#1");
1143                                         } catch (NotSupportedException ex) {
1144                                                 // The stream does not support writing
1145                                                 Assert.AreEqual (typeof (NotSupportedException), ex.GetType (), "#2");
1146                                                 Assert.IsNull (ex.InnerException, "#3");
1147                                                 Assert.IsNotNull (ex.Message, "#4");
1148                                         } finally {
1149                                                 rs.Close ();
1150                                                 req.Abort ();
1151                                         }
1152                                 }
1153                         }
1154                 }
1155
1156 #if NET_2_0
1157                 [Test]
1158                 public void WriteTimeout ()
1159                 {
1160                         IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000);
1161                         string url = "http://" + ep.ToString () + "/test/";
1162
1163                         using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (HttpWebResponseTest.FullResponseHandler))) {
1164                                 responder.Start ();
1165
1166                                 HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
1167                                 req.Method = "GET";
1168                                 req.Timeout = 2000;
1169                                 req.ReadWriteTimeout = 2000;
1170                                 req.KeepAlive = false;
1171
1172                                 using (HttpWebResponse resp = (HttpWebResponse) req.GetResponse ()) {
1173                                         Stream rs = resp.GetResponseStream ();
1174                                         try {
1175                                                 Assert.AreEqual (2000, rs.WriteTimeout, "#1");
1176                                                 rs.Close ();
1177                                                 Assert.AreEqual (2000, rs.WriteTimeout, "#2");
1178                                         } finally {
1179                                                 rs.Close ();
1180                                                 req.Abort ();
1181                                         }
1182                                 }
1183                         }
1184                 }
1185 #endif
1186         }
1187 }