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

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