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