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