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 #if TARGET_JVM
 670                 [Category ("NotWorking")]
 671 #endif
 672                 public void CanTimeout ()
 673                 {
 674                         IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000);
 675                         string url = "http://" + ep.ToString () + "/test/";
 676
 677                         using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (HttpWebResponseTest.FullResponseHandler))) {
 678                                 responder.Start ();
 679
 680                                 HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
 681                                 req.Method = "GET";
 682                                 req.Timeout = 2000;
 683                                 req.ReadWriteTimeout = 2000;
 684                                 req.KeepAlive = false;
 685
 686                                 using (HttpWebResponse resp = (HttpWebResponse) req.GetResponse ()) {
 687                                         Stream rs = resp.GetResponseStream ();
 688                                         try {
 689                                                 Assert.IsTrue (rs.CanTimeout, "#1");
 690                                                 rs.Close ();
 691                                                 Assert.IsTrue (rs.CanTimeout, "#2");
 692                                         } finally {
 693                                                 rs.Close ();
 694                                                 req.Abort ();
 695                                         }
 696                                 }
 697                         }
 698                 }
 699 #endif
 700
 701                 [Test]
 702                 public void CanWrite ()
 703                 {
 704                         IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000);
 705                         string url = "http://" + ep.ToString () + "/test/";
 706
 707                         using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (HttpWebResponseTest.FullResponseHandler))) {
 708                                 responder.Start ();
 709
 710                                 HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
 711                                 req.Method = "GET";
 712                                 req.Timeout = 2000;
 713                                 req.ReadWriteTimeout = 2000;
 714                                 req.KeepAlive = false;
 715
 716                                 using (HttpWebResponse resp = (HttpWebResponse) req.GetResponse ()) {
 717                                         Stream rs = resp.GetResponseStream ();
 718                                         try {
 719                                                 Assert.IsFalse (rs.CanWrite, "#1");
 720                                                 rs.Close ();
 721                                                 Assert.IsFalse (rs.CanWrite, "#2");
 722                                         } finally {
 723                                                 rs.Close ();
 724                                                 req.Abort ();
 725                                         }
 726                                 }
 727                         }
 728                 }
 729
 730                 [Test]
 731                 public void Read ()
 732                 {
 733                         IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000);
 734                         string url = "http://" + ep.ToString () + "/test/";
 735
 736                         using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (HttpWebResponseTest.FullResponseHandler))) {
 737                                 responder.Start ();
 738
 739                                 HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
 740                                 req.Method = "GET";
 741                                 req.Timeout = 2000;
 742                                 req.ReadWriteTimeout = 2000;
 743                                 req.KeepAlive = false;
 744
 745                                 using (HttpWebResponse resp = (HttpWebResponse) req.GetResponse ()) {
 746                                         Stream rs = resp.GetResponseStream ();
 747                                         byte [] buffer = new byte [5];
 748                                         try {
 749                                                 Assert.AreEqual (1, rs.Read (buffer, 4, 1), "#A1");
 750                                                 Assert.AreEqual (new byte [] { 0x00, 0x00, 0x00, 0x00, 0x3c }, buffer, "#A2");
 751                                                 Assert.AreEqual (2, rs.Read (buffer, 0, 2), "#B1");
 752                                                 Assert.AreEqual (new byte [] { 0x64, 0x75, 0x00, 0x00, 0x3c }, buffer, "#B2");
 753                                                 Assert.AreEqual (4, rs.Read (buffer, 1, 4), "#C1");
 754                                                 Assert.AreEqual (new byte [] { 0x64, 0x6d, 0x6d, 0x79, 0x20 }, buffer, "#C2");
 755                                                 Assert.AreEqual (2, rs.Read (buffer, 0, 3), "#D1");
 756                                                 Assert.AreEqual (new byte [] { 0x2f, 0x3e, 0x6d, 0x79, 0x20 }, buffer, "#D2");
 757                                                 Assert.AreEqual (0, rs.Read (buffer, 1, 3), "#E1");
 758                                                 Assert.AreEqual (new byte [] { 0x2f, 0x3e, 0x6d, 0x79, 0x20 }, buffer, "#E2");
 759                                                 Assert.AreEqual (0, rs.Read (buffer, buffer.Length, 0), "#G1");
 760                                                 Assert.AreEqual (new byte [] { 0x2f, 0x3e, 0x6d, 0x79, 0x20 }, buffer, "#G2");
 761                                         } finally {
 762                                                 rs.Close ();
 763                                                 req.Abort ();
 764                                         }
 765                                 }
 766                         }
 767                 }
 768
 769                 [Test]
 770                 public void Read_Buffer_Null ()
 771                 {
 772                         IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000);
 773                         string url = "http://" + ep.ToString () + "/test/";
 774
 775                         using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (HttpWebResponseTest.FullResponseHandler))) {
 776                                 responder.Start ();
 777
 778                                 HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
 779                                 req.Method = "GET";
 780                                 req.Timeout = 2000;
 781                                 req.ReadWriteTimeout = 2000;
 782                                 req.KeepAlive = false;
 783
 784                                 using (HttpWebResponse resp = (HttpWebResponse) req.GetResponse ()) {
 785                                         Stream rs = resp.GetResponseStream ();
 786                                         byte [] buffer = null;
 787                                         try {
 788                                                 try {
 789                                                         rs.Read (buffer, 0, 0);
 790                                                         Assert.Fail ("#A1");
 791                                                 } catch (ArgumentNullException ex) {
 792                                                         Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
 793                                                         Assert.IsNull (ex.InnerException, "#A3");
 794                                                         Assert.IsNotNull (ex.Message, "#A4");
 795                                                         Assert.AreEqual ("buffer", ex.ParamName, "#A5");
 796                                                 }
 797
 798                                                 // read full response
 799                                                 buffer = new byte [24];
 800                                                 Assert.AreEqual (9, rs.Read (buffer, 0, buffer.Length));
 801
 802                                                 buffer = null;
 803                                                 try {
 804                                                         rs.Read (buffer, 0, 0);
 805                                                         Assert.Fail ("#B1");
 806                                                 } catch (ArgumentNullException ex) {
 807                                                         Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#B2");
 808                                                         Assert.IsNull (ex.InnerException, "#B3");
 809                                                         Assert.IsNotNull (ex.Message, "#B4");
 810                                                         Assert.AreEqual ("buffer", ex.ParamName, "#B5");
 811                                                 }
 812                                         } finally {
 813                                                 rs.Close ();
 814                                                 req.Abort ();
 815                                         }
 816                                 }
 817                         }
 818                 }
 819
 820                 [Test]
 821                 public void Read_Count_Negative ()
 822                 {
 823                         IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000);
 824                         string url = "http://" + ep.ToString () + "/test/";
 825
 826                         using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (HttpWebResponseTest.FullResponseHandler))) {
 827                                 responder.Start ();
 828
 829                                 HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
 830                                 req.Method = "GET";
 831                                 req.Timeout = 2000;
 832                                 req.ReadWriteTimeout = 2000;
 833                                 req.KeepAlive = false;
 834
 835                                 using (HttpWebResponse resp = (HttpWebResponse) req.GetResponse ()) {
 836                                         Stream rs = resp.GetResponseStream ();
 837                                         byte [] buffer = new byte [5];
 838                                         try {
 839                                                 try {
 840                                                         rs.Read (buffer, 1, -1);
 841                                                         Assert.Fail ("#A1");
 842                                                 } catch (ArgumentOutOfRangeException ex) {
 843                                                         // Specified argument was out of the range of valid values
 844                                                         Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#A2");
 845                                                         Assert.IsNull (ex.InnerException, "#A3");
 846                                                         Assert.IsNotNull (ex.Message, "#A4");
 847                                                         Assert.AreEqual ("size", ex.ParamName, "#A5");
 848                                                 }
 849
 850                                                 // read full response
 851                                                 buffer = new byte [24];
 852                                                 Assert.AreEqual (9, rs.Read (buffer, 0, buffer.Length));
 853
 854                                                 try {
 855                                                         rs.Read (buffer, 1, -1);
 856                                                         Assert.Fail ("#B1");
 857                                                 } catch (ArgumentOutOfRangeException ex) {
 858                                                         // Specified argument was out of the range of valid values
 859                                                         Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#B2");
 860                                                         Assert.IsNull (ex.InnerException, "#B3");
 861                                                         Assert.IsNotNull (ex.Message, "#B4");
 862                                                         Assert.AreEqual ("size", ex.ParamName, "#B5");
 863                                                 }
 864                                         } finally {
 865                                                 rs.Close ();
 866                                                 req.Abort ();
 867                                         }
 868                                 }
 869                         }
 870                 }
 871
 872                 [Test]
 873                 public void Read_Count_Overflow ()
 874                 {
 875                         IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000);
 876                         string url = "http://" + ep.ToString () + "/test/";
 877
 878                         using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (HttpWebResponseTest.FullResponseHandler))) {
 879                                 responder.Start ();
 880
 881                                 HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
 882                                 req.Method = "GET";
 883                                 req.Timeout = 2000;
 884                                 req.ReadWriteTimeout = 2000;
 885                                 req.KeepAlive = false;
 886
 887                                 using (HttpWebResponse resp = (HttpWebResponse) req.GetResponse ()) {
 888                                         Stream rs = resp.GetResponseStream ();
 889                                         byte [] buffer = new byte [5];
 890                                         try {
 891                                                 try {
 892                                                         rs.Read (buffer, buffer.Length - 2, 3);
 893                                                         Assert.Fail ("#A1");
 894                                                 } catch (ArgumentOutOfRangeException ex) {
 895                                                         // Specified argument was out of the range of valid values
 896                                                         Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#A2");
 897                                                         Assert.IsNull (ex.InnerException, "#A3");
 898                                                         Assert.IsNotNull (ex.Message, "#A4");
 899                                                         Assert.AreEqual ("size", ex.ParamName, "#A5");
 900                                                 }
 901
 902                                                 // read full response
 903                                                 buffer = new byte [24];
 904                                                 Assert.AreEqual (9, rs.Read (buffer, 0, buffer.Length));
 905
 906                                                 try {
 907                                                         rs.Read (buffer, buffer.Length - 2, 3);
 908                                                         Assert.Fail ("#B1");
 909                                                 } catch (ArgumentOutOfRangeException ex) {
 910                                                         // Specified argument was out of the range of valid values
 911                                                         Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#B2");
 912                                                         Assert.IsNull (ex.InnerException, "#B3");
 913                                                         Assert.IsNotNull (ex.Message, "#B4");
 914                                                         Assert.AreEqual ("size", ex.ParamName, "#B5");
 915                                                 }
 916                                         } finally {
 917                                                 rs.Close ();
 918                                                 req.Abort ();
 919                                         }
 920                                 }
 921                         }
 922                 }
 923
 924                 [Test]
 925                 public void Read_Offset_Negative ()
 926                 {
 927                         IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000);
 928                         string url = "http://" + ep.ToString () + "/test/";
 929
 930                         using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (HttpWebResponseTest.FullResponseHandler))) {
 931                                 responder.Start ();
 932
 933                                 HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
 934                                 req.Method = "GET";
 935                                 req.Timeout = 2000;
 936                                 req.ReadWriteTimeout = 2000;
 937                                 req.KeepAlive = false;
 938
 939                                 using (HttpWebResponse resp = (HttpWebResponse) req.GetResponse ()) {
 940                                         Stream rs = resp.GetResponseStream ();
 941                                         byte [] buffer = new byte [5];
 942                                         try {
 943                                                 try {
 944                                                         rs.Read (buffer, -1, 0);
 945                                                         Assert.Fail ("#A1");
 946                                                 } catch (ArgumentOutOfRangeException ex) {
 947                                                         // Specified argument was out of the range of valid values
 948                                                         Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#A2");
 949                                                         Assert.IsNull (ex.InnerException, "#A3");
 950                                                         Assert.IsNotNull (ex.Message, "#A4");
 951                                                         Assert.AreEqual ("offset", ex.ParamName, "#A5");
 952                                                 }
 953
 954                                                 // read full response
 955                                                 buffer = new byte [24];
 956                                                 Assert.AreEqual (9, rs.Read (buffer, 0, buffer.Length));
 957
 958                                                 try {
 959                                                         rs.Read (buffer, -1, 0);
 960                                                         Assert.Fail ("#B1");
 961                                                 } catch (ArgumentOutOfRangeException ex) {
 962                                                         // Specified argument was out of the range of valid values
 963                                                         Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#B2");
 964                                                         Assert.IsNull (ex.InnerException, "#B3");
 965                                                         Assert.IsNotNull (ex.Message, "#B4");
 966                                                         Assert.AreEqual ("offset", ex.ParamName, "#B5");
 967                                                 }
 968                                         } finally {
 969                                                 rs.Close ();
 970                                                 req.Abort ();
 971                                         }
 972                                 }
 973                         }
 974                 }
 975
 976                 [Test]
 977                 public void Read_Offset_Overflow ()
 978                 {
 979                         IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000);
 980                         string url = "http://" + ep.ToString () + "/test/";
 981
 982                         using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (HttpWebResponseTest.FullResponseHandler))) {
 983                                 responder.Start ();
 984
 985                                 HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
 986                                 req.Method = "GET";
 987                                 req.Timeout = 2000;
 988                                 req.ReadWriteTimeout = 2000;
 989                                 req.KeepAlive = false;
 990
 991                                 using (HttpWebResponse resp = (HttpWebResponse) req.GetResponse ()) {
 992                                         Stream rs = resp.GetResponseStream ();
 993                                         byte [] buffer = new byte [5];
 994                                         try {
 995                                                 try {
 996                                                         rs.Read (buffer, buffer.Length + 1, 0);
 997                                                         Assert.Fail ("#A1");
 998                                                 } catch (ArgumentOutOfRangeException ex) {
 999                                                         // Specified argument was out of the range of valid values
1000                                                         Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#A2");
1001                                                         Assert.IsNull (ex.InnerException, "#A3");
1002                                                         Assert.IsNotNull (ex.Message, "#A4");
1003                                                         Assert.AreEqual ("offset", ex.ParamName, "#A5");
1004                                                 }
1005
1006                                                 // read full response
1007                                                 buffer = new byte [24];
1008                                                 Assert.AreEqual (9, rs.Read (buffer, 0, buffer.Length));
1009
1010                                                 try {
1011                                                         rs.Read (buffer, buffer.Length + 1, 0);
1012                                                         Assert.Fail ("#B1");
1013                                                 } catch (ArgumentOutOfRangeException ex) {
1014                                                         // Specified argument was out of the range of valid values
1015                                                         Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#B2");
1016                                                         Assert.IsNull (ex.InnerException, "#B3");
1017                                                         Assert.IsNotNull (ex.Message, "#B4");
1018                                                         Assert.AreEqual ("offset", ex.ParamName, "#B5");
1019                                                 }
1020                                         } finally {
1021                                                 rs.Close ();
1022                                                 req.Abort ();
1023                                         }
1024                                 }
1025                         }
1026                 }
1027
1028                 [Test]
1029                 [Category ("NotWorking")]
1030                 public void Read_Stream_Closed ()
1031                 {
1032                         IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000);
1033                         string url = "http://" + ep.ToString () + "/test/";
1034
1035                         using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (HttpWebResponseTest.FullResponseHandler))) {
1036                                 responder.Start ();
1037
1038                                 HttpWebRequest req;
1039
1040                                 req = (HttpWebRequest) WebRequest.Create (url);
1041                                 req.Method = "GET";
1042                                 req.Timeout = 2000;
1043                                 req.ReadWriteTimeout = 2000;
1044                                 req.KeepAlive = false;
1045
1046                                 using (HttpWebResponse resp = (HttpWebResponse) req.GetResponse ()) {
1047                                         Stream rs = resp.GetResponseStream ();
1048                                         rs.Close ();
1049                                         try {
1050                                                 rs.Read (new byte [0], 0, 0);
1051                                                 Assert.Fail ("#A1");
1052                                         } catch (WebException ex) {
1053                                                 // The request was aborted: The connection was closed unexpectedly
1054                                                 Assert.AreEqual (typeof (WebException), ex.GetType (), "#A2");
1055                                                 Assert.IsNull (ex.InnerException, "#A3");
1056                                                 Assert.IsNotNull (ex.Message, "#A4");
1057                                                 Assert.IsNull (ex.Response, "#A5");
1058                                                 Assert.AreEqual (WebExceptionStatus.ConnectionClosed, ex.Status, "#A6");
1059                                         } finally {
1060                                                 rs.Close ();
1061                                                 req.Abort ();
1062                                         }
1063                                 }
1064
1065                                 req = (HttpWebRequest) WebRequest.Create (url);
1066                                 req.Method = "GET";
1067                                 req.Timeout = 2000;
1068                                 req.ReadWriteTimeout = 2000;
1069                                 req.KeepAlive = false;
1070
1071                                 using (HttpWebResponse resp = (HttpWebResponse) req.GetResponse ()) {
1072                                         Stream rs = resp.GetResponseStream ();
1073                                         byte [] buffer = new byte [24];
1074                                         Assert.AreEqual (9, rs.Read (buffer, 0, buffer.Length));
1075                                         rs.Close ();
1076                                         try {
1077                                                 rs.Read (new byte [0], 0, 0);
1078                                                 Assert.Fail ("#B1");
1079                                         } catch (WebException ex) {
1080                                                 // The request was aborted: The connection was closed unexpectedly
1081                                                 Assert.AreEqual (typeof (WebException), ex.GetType (), "#B2");
1082                                                 Assert.IsNull (ex.InnerException, "#B3");
1083                                                 Assert.IsNotNull (ex.Message, "#B4");
1084                                                 Assert.IsNull (ex.Response, "#B5");
1085                                                 Assert.AreEqual (WebExceptionStatus.ConnectionClosed, ex.Status, "#B6");
1086                                         } finally {
1087                                                 rs.Close ();
1088                                                 req.Abort ();
1089                                         }
1090                                 }
1091                         }
1092                 }
1093
1094 #if NET_2_0
1095                 [Test]
1096                 public void ReadTimeout ()
1097                 {
1098                         IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000);
1099                         string url = "http://" + ep.ToString () + "/test/";
1100
1101                         using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (HttpWebResponseTest.FullResponseHandler))) {
1102                                 responder.Start ();
1103
1104                                 HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
1105                                 req.Method = "GET";
1106                                 req.Timeout = 2000;
1107                                 req.ReadWriteTimeout = 2000;
1108                                 req.KeepAlive = false;
1109
1110                                 using (HttpWebResponse resp = (HttpWebResponse) req.GetResponse ()) {
1111                                         Stream rs = resp.GetResponseStream ();
1112                                         try {
1113                                                 Assert.AreEqual (2000, rs.ReadTimeout, "#1");
1114                                                 rs.Close ();
1115                                                 Assert.AreEqual (2000, rs.ReadTimeout, "#2");
1116                                         } finally {
1117                                                 rs.Close ();
1118                                                 req.Abort ();
1119                                         }
1120                                 }
1121                         }
1122                 }
1123 #endif
1124
1125                 [Test]
1126                 public void Write ()
1127                 {
1128                         IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000);
1129                         string url = "http://" + ep.ToString () + "/test/";
1130
1131                         using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (HttpWebResponseTest.FullResponseHandler))) {
1132                                 responder.Start ();
1133
1134                                 HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
1135                                 req.Method = "GET";
1136                                 req.Timeout = 2000;
1137                                 req.ReadWriteTimeout = 2000;
1138                                 req.KeepAlive = false;
1139
1140                                 using (HttpWebResponse resp = (HttpWebResponse) req.GetResponse ()) {
1141                                         Stream rs = resp.GetResponseStream ();
1142                                         byte [] buffer = new byte [5];
1143                                         try {
1144                                                 rs.Write (buffer, 0, buffer.Length);
1145                                                 Assert.Fail ("#1");
1146                                         } catch (NotSupportedException ex) {
1147                                                 // The stream does not support writing
1148                                                 Assert.AreEqual (typeof (NotSupportedException), ex.GetType (), "#2");
1149                                                 Assert.IsNull (ex.InnerException, "#3");
1150                                                 Assert.IsNotNull (ex.Message, "#4");
1151                                         } finally {
1152                                                 rs.Close ();
1153                                                 req.Abort ();
1154                                         }
1155                                 }
1156                         }
1157                 }
1158
1159 #if NET_2_0
1160                 [Test]
1161                 public void WriteTimeout ()
1162                 {
1163                         IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000);
1164                         string url = "http://" + ep.ToString () + "/test/";
1165
1166                         using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (HttpWebResponseTest.FullResponseHandler))) {
1167                                 responder.Start ();
1168
1169                                 HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
1170                                 req.Method = "GET";
1171                                 req.Timeout = 2000;
1172                                 req.ReadWriteTimeout = 2000;
1173                                 req.KeepAlive = false;
1174
1175                                 using (HttpWebResponse resp = (HttpWebResponse) req.GetResponse ()) {
1176                                         Stream rs = resp.GetResponseStream ();
1177                                         try {
1178                                                 Assert.AreEqual (2000, rs.WriteTimeout, "#1");
1179                                                 rs.Close ();
1180                                                 Assert.AreEqual (2000, rs.WriteTimeout, "#2");
1181                                         } finally {
1182                                                 rs.Close ();
1183                                                 req.Abort ();
1184                                         }
1185                                 }
1186                         }
1187                 }
1188 #endif
1189         }
1190 }