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