mcs/class/System/Test/System.Net/HttpWebResponseTest.cs

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