* HttpListener2Test.cs: Added test for multiple responses.

* HttpWebResponseTest.cs: Added tests for disposed checks.

svn path=/trunk/mcs/; revision=107135

diff --git a/mcs/class/System/Test/System.Net/ChangeLog b/mcs/class/System/Test/System.Net/ChangeLog
index 85c52c7245a6cfc394228a0f7c89d8234e8c686d..bb5143c44db77490d7e4b0f6b16c0a228c009fd4 100644 (file)
--- a/mcs/class/System/Test/System.Net/ChangeLog
+++ b/mcs/class/System/Test/System.Net/ChangeLog
@@ -1,3 +1,8 @@
+2008-07-03  Gert Driesen  <drieseng@users.sourceforge.net>
+
+       * HttpListener2Test.cs: Added test for multiple responses.
+       * HttpWebResponseTest.cs: Added tests for disposed checks.
+
 2008-04-18  Gert Driesen  <drieseng@users.sourceforge.net>
 
        * FileWebRequestTest.cs: Now that we have proper locking for file

diff --git a/mcs/class/System/Test/System.Net/HttpListener2Test.cs b/mcs/class/System/Test/System.Net/HttpListener2Test.cs
index af16069f42da996d9732bf32c58c113ae918633b..952546c8aa7d085530e9b3e6b76d0397c90770bb 100644 (file)
--- a/mcs/class/System/Test/System.Net/HttpListener2Test.cs
+++ b/mcs/class/System/Test/System.Net/HttpListener2Test.cs
@@ -29,6 +29,7 @@
 #if NET_2_0
 using System;
 using System.Collections.Generic;
+using System.Globalization;
 using System.IO;
 using System.Net;
 using System.Net.Sockets;
@@ -536,6 +537,68 @@ namespace MonoTests.System.Net {
 
                        listener.Close ();
                }
+
+               [Test]
+               public void MultiResponses ()
+               {
+                       Thread srv = new Thread (new ThreadStart (EchoServer));
+                       srv.Start ();
+                       Thread.Sleep (200);
+
+                       for (int i = 0; i < 10; i++) {
+                               string payload = string.Format (CultureInfo.InvariantCulture,
+                                       "Client{0}", i);
+
+                               HttpWebRequest req = (HttpWebRequest) WebRequest.Create (
+                                       "http://localhost:8888/foobar/");
+                               req.ServicePoint.Expect100Continue = false;
+                               req.ServicePoint.UseNagleAlgorithm = false;
+                               req.Method = "POST";
+                               StreamWriter w = new StreamWriter (req.GetRequestStream ());
+                               w.WriteLine (payload);
+                               w.Close ();
+
+                               HttpWebResponse resp = (HttpWebResponse) req.GetResponse ();
+                               StreamReader r = new StreamReader (resp.GetResponseStream ());
+                               Assert.AreEqual ("Hello, " + payload + "!", r.ReadToEnd ().Trim ());
+                               r.Close ();
+                       }
+
+                       manualReset.Set ();
+                       srv.Join ();
+               }
+
+               void EchoServer ()
+               {
+                       HttpListener listener = new HttpListener ();
+                       listener.Prefixes.Add ("http://*:8888/foobar/");
+                       listener.Start ();
+
+                       manualReset = new ManualResetEvent (false);
+
+                       IAsyncResult result = listener.BeginGetContext (
+                               new AsyncCallback (EchoCallback), listener);
+                       manualReset.WaitOne ();
+               }
+
+               void EchoCallback (IAsyncResult result)
+               {
+                       HttpListener listener = (HttpListener) result.AsyncState;
+                       HttpListenerContext context = listener.EndGetContext (result);
+                       HttpListenerRequest req = context.Request;
+                       StreamReader r = new StreamReader (req.InputStream);
+                       string reqBody = r.ReadToEnd ().Trim ();
+
+                       HttpListenerResponse resp = context.Response;
+                       StreamWriter o = new StreamWriter (resp.OutputStream);
+                       o.WriteLine ("Hello, " + reqBody + "!");
+                       o.Close ();
+
+                       listener.BeginGetContext (new AsyncCallback (EchoCallback), listener);
+               }
+
+               private ManualResetEvent manualReset;
+
        }
 
        [TestFixture]

diff --git a/mcs/class/System/Test/System.Net/HttpWebResponseTest.cs b/mcs/class/System/Test/System.Net/HttpWebResponseTest.cs
new file mode 100644 (file)
index 0000000..bcfe233
--- /dev/null
+++ b/mcs/class/System/Test/System.Net/HttpWebResponseTest.cs
@@ -0,0 +1,552 @@
+//
+// HttpWebResponseTest.cs - NUnit Test Cases for System.Net.HttpWebResponse
+//
+// Authors:
+//     Gert Driesen (drieseng@users.sourceforge.net)
+//
+// Copyright (c) 2008 Gert Driesen
+//
+
+using System;
+using System.Globalization;
+using System.IO;
+using System.Net;
+using System.Net.Sockets;
+using System.Text;
+
+using NUnit.Framework;
+
+namespace MonoTests.System.Net
+{
+       [TestFixture]
+       [Ignore ("Awaits approval of fixes"]
+       public class HttpWebResponseTest
+       {
+               [Test]
+               public void CharacterSet_Disposed ()
+               {
+                       IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000);
+                       string url = "http://" + IPAddress.Loopback.ToString () + ":8000/test/";
+
+                       using (SocketResponder responder = new SocketResponder (new IPEndPoint (IPAddress.Loopback, 8000), new SocketRequestHandler (FullResponseHandler))) {
+                               responder.Start ();
+
+                               HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
+                               req.Method = "GET";
+                               req.Timeout = 2000;
+                               req.ReadWriteTimeout = 2000;
+                               req.KeepAlive = false;
+
+                               HttpWebResponse resp = (HttpWebResponse) req.GetResponse ();
+                               ((IDisposable) resp).Dispose ();
+
+                               try {
+                                       string charset = resp.CharacterSet;
+                                       Assert.Fail ("#1:" + charset);
+                               } catch (ObjectDisposedException ex) {
+                                       Assert.AreEqual (typeof (ObjectDisposedException), ex.GetType (), "#2");
+                                       Assert.IsNull (ex.InnerException, "#3");
+                                       Assert.IsNotNull (ex.Message, "#4");
+                                       Assert.AreEqual (typeof (HttpWebResponse).FullName, ex.ObjectName, "#5");
+                               }
+
+                               responder.Stop ();
+                       }
+               }
+
+               [Test]
+               public void Close_Disposed ()
+               {
+                       IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000);
+                       string url = "http://" + IPAddress.Loopback.ToString () + ":8000/test/";
+
+                       using (SocketResponder responder = new SocketResponder (new IPEndPoint (IPAddress.Loopback, 8000), new SocketRequestHandler (FullResponseHandler))) {
+                               responder.Start ();
+
+                               HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
+                               req.Method = "GET";
+                               req.Timeout = 2000;
+                               req.ReadWriteTimeout = 2000;
+                               req.KeepAlive = false;
+
+                               HttpWebResponse resp = (HttpWebResponse) req.GetResponse ();
+                               ((IDisposable) resp).Dispose ();
+                               resp.Close ();
+
+                               responder.Stop ();
+                       }
+               }
+
+               [Test]
+               public void ContentEncoding_Disposed ()
+               {
+                       IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000);
+                       string url = "http://" + IPAddress.Loopback.ToString () + ":8000/test/";
+
+                       using (SocketResponder responder = new SocketResponder (new IPEndPoint (IPAddress.Loopback, 8000), new SocketRequestHandler (FullResponseHandler))) {
+                               responder.Start ();
+
+                               HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
+                               req.Method = "GET";
+                               req.Timeout = 2000;
+                               req.ReadWriteTimeout = 2000;
+                               req.KeepAlive = false;
+
+                               HttpWebResponse resp = (HttpWebResponse) req.GetResponse ();
+                               ((IDisposable) resp).Dispose ();
+
+                               try {
+                                       string enc = resp.ContentEncoding;
+                                       Assert.Fail ("#1:" + enc);
+                               } catch (ObjectDisposedException ex) {
+                                       Assert.AreEqual (typeof (ObjectDisposedException), ex.GetType (), "#2");
+                                       Assert.IsNull (ex.InnerException, "#3");
+                                       Assert.IsNotNull (ex.Message, "#4");
+                                       Assert.AreEqual (typeof (HttpWebResponse).FullName, ex.ObjectName, "#5");
+                               }
+
+                               responder.Stop ();
+                       }
+               }
+
+               [Test]
+               public void ContentLength_Disposed ()
+               {
+                       IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000);
+                       string url = "http://" + IPAddress.Loopback.ToString () + ":8000/test/";
+
+                       using (SocketResponder responder = new SocketResponder (new IPEndPoint (IPAddress.Loopback, 8000), new SocketRequestHandler (FullResponseHandler))) {
+                               responder.Start ();
+
+                               HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
+                               req.Method = "GET";
+                               req.Timeout = 2000;
+                               req.ReadWriteTimeout = 2000;
+                               req.KeepAlive = false;
+
+                               HttpWebResponse resp = (HttpWebResponse) req.GetResponse ();
+                               ((IDisposable) resp).Dispose ();
+
+                               Assert.AreEqual (9, resp.ContentLength);
+
+                               responder.Stop ();
+                       }
+               }
+
+               [Test]
+               public void ContentType_Disposed ()
+               {
+                       IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000);
+                       string url = "http://" + IPAddress.Loopback.ToString () + ":8000/test/";
+
+                       using (SocketResponder responder = new SocketResponder (new IPEndPoint (IPAddress.Loopback, 8000), new SocketRequestHandler (FullResponseHandler))) {
+                               responder.Start ();
+
+                               HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
+                               req.Method = "GET";
+                               req.Timeout = 2000;
+                               req.ReadWriteTimeout = 2000;
+                               req.KeepAlive = false;
+
+                               HttpWebResponse resp = (HttpWebResponse) req.GetResponse ();
+                               ((IDisposable) resp).Dispose ();
+
+                               try {
+                                       string contentType = resp.ContentType;
+                                       Assert.Fail ("#1:" + contentType);
+                               } catch (ObjectDisposedException ex) {
+                                       Assert.AreEqual (typeof (ObjectDisposedException), ex.GetType (), "#2");
+                                       Assert.IsNull (ex.InnerException, "#3");
+                                       Assert.IsNotNull (ex.Message, "#4");
+                                       Assert.AreEqual (typeof (HttpWebResponse).FullName, ex.ObjectName, "#5");
+                               }
+
+                               responder.Stop ();
+                       }
+               }
+
+               [Test]
+               public void Cookies_Disposed ()
+               {
+                       IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000);
+                       string url = "http://" + IPAddress.Loopback.ToString () + ":8000/test/";
+
+                       using (SocketResponder responder = new SocketResponder (new IPEndPoint (IPAddress.Loopback, 8000), new SocketRequestHandler (FullResponseHandler))) {
+                               responder.Start ();
+
+                               HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
+                               req.Method = "GET";
+                               req.Timeout = 2000;
+                               req.ReadWriteTimeout = 2000;
+                               req.KeepAlive = false;
+
+                               HttpWebResponse resp = (HttpWebResponse) req.GetResponse ();
+                               ((IDisposable) resp).Dispose ();
+
+                               try {
+                                       CookieCollection cookies = resp.Cookies;
+                                       Assert.Fail ("#A1:" + cookies);
+                               } catch (ObjectDisposedException ex) {
+                                       Assert.AreEqual (typeof (ObjectDisposedException), ex.GetType (), "#A2");
+                                       Assert.IsNull (ex.InnerException, "#A3");
+                                       Assert.IsNotNull (ex.Message, "#A4");
+                                       Assert.AreEqual (typeof (HttpWebResponse).FullName, ex.ObjectName, "#A5");
+                               }
+
+                               try {
+                                       resp.Cookies = new CookieCollection ();
+                                       Assert.Fail ("#B1");
+                               } catch (ObjectDisposedException ex) {
+                                       Assert.AreEqual (typeof (ObjectDisposedException), ex.GetType (), "#B2");
+                                       Assert.IsNull (ex.InnerException, "#B3");
+                                       Assert.IsNotNull (ex.Message, "#B4");
+                                       Assert.AreEqual (typeof (HttpWebResponse).FullName, ex.ObjectName, "#B5");
+                               }
+
+                               responder.Stop ();
+                       }
+               }
+
+               [Test]
+               public void GetResponseHeader_Disposed ()
+               {
+                       IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000);
+                       string url = "http://" + IPAddress.Loopback.ToString () + ":8000/test/";
+
+                       using (SocketResponder responder = new SocketResponder (new IPEndPoint (IPAddress.Loopback, 8000), new SocketRequestHandler (FullResponseHandler))) {
+                               responder.Start ();
+
+                               HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
+                               req.Method = "GET";
+                               req.Timeout = 2000;
+                               req.ReadWriteTimeout = 2000;
+                               req.KeepAlive = false;
+
+                               HttpWebResponse resp = (HttpWebResponse) req.GetResponse ();
+                               ((IDisposable) resp).Dispose ();
+
+                               try {
+                                       string server = resp.GetResponseHeader ("Server");
+                                       Assert.Fail ("#1:" + server);
+                               } catch (ObjectDisposedException ex) {
+                                       Assert.AreEqual (typeof (ObjectDisposedException), ex.GetType (), "#2");
+                                       Assert.IsNull (ex.InnerException, "#3");
+                                       Assert.IsNotNull (ex.Message, "#4");
+                                       Assert.AreEqual (typeof (HttpWebResponse).FullName, ex.ObjectName, "#5");
+                               }
+
+                               responder.Stop ();
+                       }
+               }
+
+               [Test]
+               public void GetResponseStream_Disposed ()
+               {
+                       IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000);
+                       string url = "http://" + IPAddress.Loopback.ToString () + ":8000/test/";
+
+                       using (SocketResponder responder = new SocketResponder (new IPEndPoint (IPAddress.Loopback, 8000), new SocketRequestHandler (FullResponseHandler))) {
+                               responder.Start ();
+
+                               HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
+                               req.Method = "GET";
+                               req.Timeout = 2000;
+                               req.ReadWriteTimeout = 2000;
+                               req.KeepAlive = false;
+
+                               HttpWebResponse resp = (HttpWebResponse) req.GetResponse ();
+                               ((IDisposable) resp).Dispose ();
+
+                               try {
+                                       Stream s = resp.GetResponseStream ();
+                                       Assert.Fail ("#1:" + s);
+                               } catch (ObjectDisposedException ex) {
+                                       Assert.AreEqual (typeof (ObjectDisposedException), ex.GetType (), "#2");
+                                       Assert.IsNull (ex.InnerException, "#3");
+                                       Assert.IsNotNull (ex.Message, "#4");
+                                       Assert.AreEqual (typeof (HttpWebResponse).FullName, ex.ObjectName, "#5");
+                               }
+
+                               responder.Stop ();
+                       }
+               }
+
+               [Test]
+               public void Headers_Disposed ()
+               {
+                       IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000);
+                       string url = "http://" + IPAddress.Loopback.ToString () + ":8000/test/";
+
+                       using (SocketResponder responder = new SocketResponder (new IPEndPoint (IPAddress.Loopback, 8000), new SocketRequestHandler (FullResponseHandler))) {
+                               responder.Start ();
+
+                               HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
+                               req.Method = "GET";
+                               req.Timeout = 2000;
+                               req.ReadWriteTimeout = 2000;
+                               req.KeepAlive = false;
+
+                               HttpWebResponse resp = (HttpWebResponse) req.GetResponse ();
+                               ((IDisposable) resp).Dispose ();
+
+#if NET_2_0
+                               WebHeaderCollection headers = resp.Headers;
+                               Assert.AreEqual (6, headers.Count, "#1");
+                               Assert.AreEqual ("9", headers ["Content-Length"], "#2");
+                               Assert.AreEqual ("utf-8", headers ["Content-Encoding"], "#3");
+                               Assert.AreEqual ("text/xml; charset=UTF-8", headers ["Content-Type"], "#4");
+                               Assert.AreEqual ("Wed, 08 Jan 2003 23:11:55 GMT", headers ["Last-Modified"], "#5");
+                               Assert.AreEqual ("UserID=Miguel,StoreProfile=true", headers ["Set-Cookie"], "#6");
+                               Assert.AreEqual ("Mono/Test", headers ["Server"], "#7");
+#else
+                               try {
+                                       WebHeaderCollection headers = resp.Headers;
+                                       Assert.Fail ("#1:" + headers);
+                               } catch (ObjectDisposedException ex) {
+                                       Assert.AreEqual (typeof (ObjectDisposedException), ex.GetType (), "#2");
+                                       Assert.IsNull (ex.InnerException, "#3");
+                                       Assert.IsNotNull (ex.Message, "#4");
+                                       Assert.AreEqual (typeof (HttpWebResponse).FullName, ex.ObjectName, "#5");
+                               }
+#endif
+
+                               responder.Stop ();
+                       }
+               }
+
+               [Test]
+               public void LastModified_Disposed ()
+               {
+                       IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000);
+                       string url = "http://" + IPAddress.Loopback.ToString () + ":8000/test/";
+
+                       using (SocketResponder responder = new SocketResponder (new IPEndPoint (IPAddress.Loopback, 8000), new SocketRequestHandler (FullResponseHandler))) {
+                               responder.Start ();
+
+                               HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
+                               req.Method = "GET";
+                               req.Timeout = 2000;
+                               req.ReadWriteTimeout = 2000;
+                               req.KeepAlive = false;
+
+                               HttpWebResponse resp = (HttpWebResponse) req.GetResponse ();
+                               ((IDisposable) resp).Dispose ();
+
+                               try {
+                                       DateTime lastMod = resp.LastModified;
+                                       Assert.Fail ("#1:" + lastMod);
+                               } catch (ObjectDisposedException ex) {
+                                       Assert.AreEqual (typeof (ObjectDisposedException), ex.GetType (), "#2");
+                                       Assert.IsNull (ex.InnerException, "#3");
+                                       Assert.IsNotNull (ex.Message, "#4");
+                                       Assert.AreEqual (typeof (HttpWebResponse).FullName, ex.ObjectName, "#5");
+                               }
+
+                               responder.Stop ();
+                       }
+               }
+
+               [Test]
+               public void Method_Disposed ()
+               {
+                       IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000);
+                       string url = "http://" + IPAddress.Loopback.ToString () + ":8000/test/";
+
+                       using (SocketResponder responder = new SocketResponder (new IPEndPoint (IPAddress.Loopback, 8000), new SocketRequestHandler (FullResponseHandler))) {
+                               responder.Start ();
+
+                               HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
+                               req.Method = "GET";
+                               req.Timeout = 2000;
+                               req.ReadWriteTimeout = 2000;
+                               req.KeepAlive = false;
+
+                               HttpWebResponse resp = (HttpWebResponse) req.GetResponse ();
+                               ((IDisposable) resp).Dispose ();
+
+                               try {
+                                       string method = resp.Method;
+                                       Assert.Fail ("#1:" + method);
+                               } catch (ObjectDisposedException ex) {
+                                       Assert.AreEqual (typeof (ObjectDisposedException), ex.GetType (), "#2");
+                                       Assert.IsNull (ex.InnerException, "#3");
+                                       Assert.IsNotNull (ex.Message, "#4");
+                                       Assert.AreEqual (typeof (HttpWebResponse).FullName, ex.ObjectName, "#5");
+                               }
+
+                               responder.Stop ();
+                       }
+               }
+
+               [Test]
+               public void ProtocolVersion_Disposed ()
+               {
+                       IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000);
+                       string url = "http://" + IPAddress.Loopback.ToString () + ":8000/test/";
+
+                       using (SocketResponder responder = new SocketResponder (new IPEndPoint (IPAddress.Loopback, 8000), new SocketRequestHandler (FullResponseHandler))) {
+                               responder.Start ();
+
+                               HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
+                               req.Method = "GET";
+                               req.Timeout = 2000;
+                               req.ReadWriteTimeout = 2000;
+                               req.KeepAlive = false;
+
+                               HttpWebResponse resp = (HttpWebResponse) req.GetResponse ();
+                               ((IDisposable) resp).Dispose ();
+
+                               try {
+                                       Version protocolVersion = resp.ProtocolVersion;
+                                       Assert.Fail ("#1:" + protocolVersion);
+                               } catch (ObjectDisposedException ex) {
+                                       Assert.AreEqual (typeof (ObjectDisposedException), ex.GetType (), "#2");
+                                       Assert.IsNull (ex.InnerException, "#3");
+                                       Assert.IsNotNull (ex.Message, "#4");
+                                       Assert.AreEqual (typeof (HttpWebResponse).FullName, ex.ObjectName, "#5");
+                               }
+
+                               responder.Stop ();
+                       }
+               }
+
+               [Test]
+               public void ResponseUri_Disposed ()
+               {
+                       IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000);
+                       string url = "http://" + IPAddress.Loopback.ToString () + ":8000/test/";
+
+                       using (SocketResponder responder = new SocketResponder (new IPEndPoint (IPAddress.Loopback, 8000), new SocketRequestHandler (FullResponseHandler))) {
+                               responder.Start ();
+
+                               HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
+                               req.Method = "GET";
+                               req.Timeout = 2000;
+                               req.ReadWriteTimeout = 2000;
+                               req.KeepAlive = false;
+
+                               HttpWebResponse resp = (HttpWebResponse) req.GetResponse ();
+                               ((IDisposable) resp).Dispose ();
+
+                               try {
+                                       Uri respUri = resp.ResponseUri;
+                                       Assert.Fail ("#1:" + respUri);
+                               } catch (ObjectDisposedException ex) {
+                                       Assert.AreEqual (typeof (ObjectDisposedException), ex.GetType (), "#2");
+                                       Assert.IsNull (ex.InnerException, "#3");
+                                       Assert.IsNotNull (ex.Message, "#4");
+                                       Assert.AreEqual (typeof (HttpWebResponse).FullName, ex.ObjectName, "#5");
+                               }
+
+                               responder.Stop ();
+                       }
+               }
+
+               [Test]
+               public void Server_Disposed ()
+               {
+                       IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000);
+                       string url = "http://" + IPAddress.Loopback.ToString () + ":8000/test/";
+
+                       using (SocketResponder responder = new SocketResponder (new IPEndPoint (IPAddress.Loopback, 8000), new SocketRequestHandler (FullResponseHandler))) {
+                               responder.Start ();
+
+                               HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
+                               req.Method = "GET";
+                               req.Timeout = 2000;
+                               req.ReadWriteTimeout = 2000;
+                               req.KeepAlive = false;
+
+                               HttpWebResponse resp = (HttpWebResponse) req.GetResponse ();
+                               ((IDisposable) resp).Dispose ();
+
+                               try {
+                                       string server = resp.Server;
+                                       Assert.Fail ("#1:" + server);
+                               } catch (ObjectDisposedException ex) {
+                                       Assert.AreEqual (typeof (ObjectDisposedException), ex.GetType (), "#2");
+                                       Assert.IsNull (ex.InnerException, "#3");
+                                       Assert.IsNotNull (ex.Message, "#4");
+                                       Assert.AreEqual (typeof (HttpWebResponse).FullName, ex.ObjectName, "#5");
+                               }
+
+                               responder.Stop ();
+                       }
+               }
+
+               [Test]
+               public void StatusCode_Disposed ()
+               {
+                       IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000);
+                       string url = "http://" + IPAddress.Loopback.ToString () + ":8000/test/";
+
+                       using (SocketResponder responder = new SocketResponder (new IPEndPoint (IPAddress.Loopback, 8000), new SocketRequestHandler (FullResponseHandler))) {
+                               responder.Start ();
+
+                               HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
+                               req.Method = "GET";
+                               req.Timeout = 2000;
+                               req.ReadWriteTimeout = 2000;
+                               req.KeepAlive = false;
+
+                               HttpWebResponse resp = (HttpWebResponse) req.GetResponse ();
+                               ((IDisposable) resp).Dispose ();
+
+                               Assert.AreEqual (HttpStatusCode.OK, resp.StatusCode);
+
+                               responder.Stop ();
+                       }
+               }
+
+               [Test]
+               public void StatusDescription_Disposed ()
+               {
+                       IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000);
+                       string url = "http://" + IPAddress.Loopback.ToString () + ":8000/test/";
+
+                       using (SocketResponder responder = new SocketResponder (new IPEndPoint (IPAddress.Loopback, 8000), new SocketRequestHandler (FullResponseHandler))) {
+                               responder.Start ();
+
+                               HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
+                               req.Method = "GET";
+                               req.Timeout = 2000;
+                               req.ReadWriteTimeout = 2000;
+                               req.KeepAlive = false;
+
+                               HttpWebResponse resp = (HttpWebResponse) req.GetResponse ();
+                               ((IDisposable) resp).Dispose ();
+
+                               try {
+                                       string statusDesc = resp.StatusDescription;
+                                       Assert.Fail ("#1:" + statusDesc);
+                               } catch (ObjectDisposedException ex) {
+                                       Assert.AreEqual (typeof (ObjectDisposedException), ex.GetType (), "#2");
+                                       Assert.IsNull (ex.InnerException, "#3");
+                                       Assert.IsNotNull (ex.Message, "#4");
+                                       Assert.AreEqual (typeof (HttpWebResponse).FullName, ex.ObjectName, "#5");
+                               }
+
+                               responder.Stop ();
+                       }
+               }
+
+               static byte [] FullResponseHandler (Socket socket)
+               {
+                       StringWriter sw = new StringWriter ();
+                       sw.NewLine = "\r\n";
+                       sw.WriteLine ("HTTP/1.1 200 OK");
+                       sw.WriteLine ("Server: Mono/Test");
+                       sw.WriteLine ("Last-Modified: Wed, 08 Jan 2003 23:11:55 GMT");
+                       sw.WriteLine ("Content-Encoding: " + Encoding.UTF8.WebName);
+                       sw.WriteLine ("Content-Type: text/xml; charset=UTF-8");
+                       sw.WriteLine ("Content-Length: 9");
+                       sw.WriteLine ("Set-Cookie: UserID=Miguel");
+                       sw.WriteLine ("Set-Cookie: StoreProfile=true");
+                       sw.WriteLine ();
+                       sw.Write ("<dummy />");
+                       sw.Flush ();
+
+                       return Encoding.UTF8.GetBytes (sw.ToString ());
+               }
+       }
+}