[TestFixture]
public class HttpWebRequestTest
{
+ private Random rand = new Random ();
+ private byte [] data64KB = new byte [64 * 1024];
+
+ [TestFixtureSetUp]
+ public void Setup ()
+ {
+ ServicePointManager.Expect100Continue = false;
+ rand.NextBytes (data64KB);
+ }
+
[Test]
#if TARGET_JVM
[Ignore ("Ignore failures in Sys.Net")]
{
HttpWebRequest req = (HttpWebRequest) WebRequest.Create ("http://www.google.com");
Assert.IsNotNull (req.Proxy, "#1");
-#if NET_2_0
req.Proxy = null;
Assert.IsNull (req.Proxy, "#2");
-#else
- try {
- req.Proxy = null;
- Assert.Fail ("#2");
- } catch (ArgumentNullException ex) {
- Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#3");
- Assert.IsNull (ex.InnerException, "#4");
- Assert.IsNotNull (ex.Message, "#5");
- Assert.IsNotNull (ex.ParamName, "#6");
- Assert.AreEqual ("value", ex.ParamName, "#7");
- }
-#endif
}
[Test]
public void Sync ()
{
HttpWebRequest req = (HttpWebRequest) WebRequest.Create ("http://www.google.com");
- Assertion.AssertNotNull ("req:If Modified Since: ", req.IfModifiedSince);
+ Assert.IsNotNull (req.IfModifiedSince, "req:If Modified Since: ");
req.UserAgent = "MonoClient v1.0";
Assert.AreEqual ("User-Agent", req.Headers.GetKey (0), "#A1");
req.AddRange (50, 90);
req.AddRange ("bytes", 100);
req.AddRange ("bytes", 100, 120);
- Assertion.AssertEquals ("#1", "bytes=10-,50-90,100-,100-120", req.Headers ["Range"]);
+ Assert.AreEqual ("bytes=10-,50-90,100-,100-120", req.Headers ["Range"], "#1");
try {
req.AddRange ("bits", 2000);
- Assertion.Fail ("#2");
+ Assert.Fail ("#2");
} catch (InvalidOperationException) {}
}
[Test] // bug #471782
public void CloseRequestStreamAfterReadingResponse ()
{
- IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000);
- string url = "http://" + IPAddress.Loopback.ToString () + ":8000/test/";
+ IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 9152);
+ string url = "http://" + ep.ToString () + "/test/";
using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (EchoRequestHandler))) {
responder.Start ();
req.KeepAlive = false;
req.UserAgent = "Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US; rv; 1.7.6) Gecko/20050317 Firefox/1.0.2";
req.CookieContainer = cookies;
- Assertion.AssertEquals ("#01", 0, cookies.Count);
+ Assert.AreEqual (0, cookies.Count, "#01");
using (HttpWebResponse res = (HttpWebResponse) req.GetResponse()) {
CookieCollection coll = req.CookieContainer.GetCookies (new Uri (url));
- Assertion.AssertEquals ("#02", 1, coll.Count);
- Assertion.AssertEquals ("#03", 1, res.Cookies.Count);
+ Assert.AreEqual (1, coll.Count, "#02");
+ Assert.AreEqual (1, res.Cookies.Count, "#03");
Cookie one = coll [0];
Cookie two = res.Cookies [0];
- Assertion.AssertEquals ("#04", true, object.ReferenceEquals (one, two));
+ Assert.AreEqual (true, object.ReferenceEquals (one, two), "#04");
}
}
#if !TARGET_JVM //NotWorking
[Test]
+ [Ignore ("Fails on MS.NET")]
public void SslClientBlock ()
{
// This tests that the write request/initread/write body sequence does not hang
stream.Write (bytes, 0, bytes.Length);
stream.Close ();
HttpWebResponse resp = (HttpWebResponse) request.GetResponse ();
- Assertion.AssertEquals ("StatusCode", 200, (int) resp.StatusCode);
+ Assert.AreEqual (200, (int) resp.StatusCode, "StatusCode");
StreamReader sr = new StreamReader (resp.GetResponseStream (), Encoding.UTF8);
- string x = sr.ReadToEnd ();
+ sr.ReadToEnd ();
sr.Close ();
resp.Close ();
server.Stop ();
// Using StreamReader+UTF8Encoding here fails on MS runtime
Stream stream = resp.GetResponseStream ();
int nread = stream.Read (bytes, 0, 32);
- Assertion.AssertEquals ("#01", 16, nread);
+ Assert.AreEqual (16, nread, "#01");
x = Encoding.ASCII.GetString (bytes, 0, 16);
} finally {
resp.Close ();
if (server.Error != null)
throw server.Error;
- Assertion.AssertEquals ("1234567890123456", x);
+ Assert.AreEqual ("1234567890123456", x);
}
[Test]
public void MethodCase ()
{
ListDictionary methods = new ListDictionary ();
-#if NET_2_0
methods.Add ("post", "POST");
methods.Add ("puT", "PUT");
-#else
- methods.Add ("post", "post");
- methods.Add ("puT", "puT");
-#endif
methods.Add ("POST", "POST");
methods.Add ("whatever", "whatever");
methods.Add ("PUT", "PUT");
- IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000);
- string url = "http://" + IPAddress.Loopback.ToString () + ":8000/test/";
+ IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 9153);
+ string url = "http://" + ep.ToString () + "/test/";
foreach (DictionaryEntry de in methods) {
- SocketResponder responder = new SocketResponder (new IPEndPoint (IPAddress.Loopback, 8000),
- new SocketRequestHandler (EchoRequestHandler));
+ SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (EchoRequestHandler));
responder.Start ();
HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
[Test]
public void BeginGetRequestStream_Body_NotAllowed ()
{
- IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000);
- string url = "http://" + IPAddress.Loopback.ToString () + ":8000/test/";
+ IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 9154);
+ string url = "http://" + ep.ToString () + "/test/";
using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (EchoRequestHandler))) {
responder.Start ();
[Test] // bug #465613
public void BeginGetRequestStream_NoBuffering ()
{
- IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8002);
- string url = "http://" + IPAddress.Loopback.ToString () + ":8002/test/";
+ IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 11001);
+ string url = "http://" + ep.ToString () + "/test/";
using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (EchoRequestHandler))) {
responder.Start ();
}
[Test] // bug #508027
- [Category ("NotWorking")]
+ [Category ("NotWorking")] // #5842
public void BeginGetResponse ()
{
- IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8003);
- string url = "http://" + IPAddress.Loopback.ToString () + ":8003/test/";
+ IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8001);
+ string url = "http://" + ep.ToString () + "/test/";
using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (EchoRequestHandler))) {
responder.Start ();
HttpWebRequest req;
req = (HttpWebRequest) WebRequest.Create (url);
+ req.Timeout = 5000;
req.Method = "POST";
req.SendChunked = false;
req.KeepAlive = false;
req.Abort ();
req = (HttpWebRequest) WebRequest.Create (url);
+ req.Timeout = 5000;
req.Method = "POST";
req.SendChunked = true;
req.KeepAlive = false;
req.AllowWriteStreamBuffering = false;
+ req.GetRequestStream ().WriteByte (1);
req.BeginGetResponse (null, null);
req.Abort ();
req = (HttpWebRequest) WebRequest.Create (url);
+ req.Timeout = 5000;
req.Method = "POST";
req.ContentLength = 5;
req.SendChunked = false;
req.KeepAlive = false;
req.AllowWriteStreamBuffering = false;
+ req.GetRequestStream ().WriteByte (5);
req.BeginGetResponse (null, null);
req.Abort ();
req = (HttpWebRequest) WebRequest.Create (url);
+ req.Timeout = 5000;
req.Method = "POST";
req.SendChunked = false;
req.KeepAlive = true;
req.AllowWriteStreamBuffering = false;
-#if NET_2_0
+
req.BeginGetResponse (null, null);
req.Abort ();
-#else
- try {
- req.BeginGetResponse (null, null);
- } catch (ProtocolViolationException ex) {
- // Either ContentLength must be set to a non-negative
- // number, or SendChunked set to true in order to perform
- // the write operation when AllowWriteStreamBuffering
- // is disabled
- Assert.IsNull (ex.InnerException, "#A2");
- Assert.IsNotNull (ex.Message, "#A3");
- } finally {
- req.Abort ();
- }
-#endif
req = (HttpWebRequest) WebRequest.Create (url);
+ req.Timeout = 5000;
req.Method = "POST";
req.SendChunked = false;
req.KeepAlive = false;
req.Abort ();
req = (HttpWebRequest) WebRequest.Create (url);
+ req.Timeout = 5000;
req.Method = "POST";
req.SendChunked = false;
req.KeepAlive = true;
req.Abort ();
req = (HttpWebRequest) WebRequest.Create (url);
+ req.Timeout = 5000;
req.Method = "GET";
req.SendChunked = true;
-#if NET_2_0
+
req.BeginGetResponse (null, null);
req.Abort ();
-#else
- try {
- req.BeginGetResponse (null, null);
- Assert.Fail ("#B1");
- } catch (ProtocolViolationException ex) {
- // Content-Length cannot be set for a
- // non-write operation
- Assert.IsNull (ex.InnerException, "#B2");
- Assert.IsNotNull (ex.Message, "#B3");
- } finally {
- req.Abort ();
- }
-#endif
req = (HttpWebRequest) WebRequest.Create (url);
+ req.Timeout = 5000;
req.Method = "GET";
req.ContentLength = 5;
-#if NET_2_0
+
req.BeginGetResponse (null, null);
req.Abort ();
-#else
- try {
- req.BeginGetResponse (null, null);
- Assert.Fail ("#C1");
- } catch (ProtocolViolationException ex) {
- // Content-Length cannot be set for a
- // non-write operation
- Assert.IsNull (ex.InnerException, "#C2");
- Assert.IsNotNull (ex.Message, "#C3");
- } finally {
- req.Abort ();
- }
-#endif
req = (HttpWebRequest) WebRequest.Create (url);
+ req.Timeout = 5000;
req.Method = "GET";
req.ContentLength = 0;
-#if NET_2_0
+
req.BeginGetResponse (null, null);
req.Abort ();
-#else
+ }
+ }
+
+ [Test] // bug #511851
+ public void BeginGetRequestStream_Request_Aborted ()
+ {
+ IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8002);
+ string url = "http://" + ep.ToString () + "/test/";
+
+ using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (EchoRequestHandler))) {
+ responder.Start ();
+
+ HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
+ req.Method = "POST";
+ req.Abort ();
+
+ try {
+ req.BeginGetRequestStream (null, null);
+ Assert.Fail ("#1");
+ } catch (WebException ex) {
+ // The request was aborted: The request was canceled
+ Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
+ Assert.IsNull (ex.InnerException, "#3");
+ Assert.IsNotNull (ex.Message, "#4");
+ Assert.IsNull (ex.Response, "#5");
+ Assert.AreEqual (WebExceptionStatus.RequestCanceled, ex.Status, "#6");
+ }
+ }
+ }
+
+ [Test] // bug #511851
+ public void BeginGetResponse_Request_Aborted ()
+ {
+ IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 9155);
+ string url = "http://" + ep.ToString () + "/test/";
+
+ using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (EchoRequestHandler))) {
+ responder.Start ();
+
+ HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
+ req.Method = "POST";
+ req.Abort ();
+
try {
req.BeginGetResponse (null, null);
- Assert.Fail ("#D1");
- } catch (ProtocolViolationException ex) {
- // Content-Length cannot be set for a
- // non-write operation
- Assert.IsNull (ex.InnerException, "#D2");
- Assert.IsNotNull (ex.Message, "#D3");
+ Assert.Fail ("#1");
+ } catch (WebException ex) {
+ // The request was aborted: The request was canceled
+ Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
+ Assert.IsNull (ex.InnerException, "#3");
+ Assert.IsNotNull (ex.Message, "#4");
+ Assert.IsNull (ex.Response, "#5");
+ Assert.AreEqual (WebExceptionStatus.RequestCanceled, ex.Status, "#6");
+ }
+ }
+ }
+
+ [Test]
+ public void EndGetRequestStream_AsyncResult_Null ()
+ {
+ IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 9156);
+ string url = "http://" + ep.ToString () + "/test/";
+
+ using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (EchoRequestHandler))) {
+ responder.Start ();
+
+ HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
+ req.Method = "POST";
+ req.BeginGetRequestStream (null, null);
+
+ try {
+ req.EndGetRequestStream (null);
+ Assert.Fail ("#1");
+ } catch (ArgumentNullException ex) {
+ Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
+ Assert.IsNull (ex.InnerException, "#3");
+ Assert.IsNotNull (ex.Message, "#4");
+ Assert.AreEqual ("asyncResult", ex.ParamName, "#5");
} finally {
req.Abort ();
}
-#endif
+ }
+ }
+
+ [Test]
+ [Category ("NotWorking")] // do not get consistent result on MS
+ public void EndGetRequestStream_Request_Aborted ()
+ {
+ IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8003);
+ string url = "http://" + ep.ToString () + "/test/";
+
+ using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (EchoRequestHandler))) {
+ responder.Start ();
+
+ HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
+ req.Method = "POST";
+ IAsyncResult ar = req.BeginGetRequestStream (null, null);
+ req.Abort ();
+ Thread.Sleep (500);
+
+ try {
+ req.EndGetRequestStream (ar);
+ Assert.Fail ("#1");
+ } catch (WebException ex) {
+ // The request was aborted: The request was canceled
+ Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
+ Assert.IsNull (ex.InnerException, "#3");
+ Assert.IsNotNull (ex.Message, "#4");
+ Assert.IsNull (ex.Response, "#5");
+ Assert.AreEqual (WebExceptionStatus.RequestCanceled, ex.Status, "#6");
+ }
+ }
+ }
+
+ [Test] // https://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=471522
+ [Category ("NotWorking")]
+ public void EndGetResponse_AsyncResult_Invalid ()
+ {
+ IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 9157);
+ string url = "http://" + ep.ToString () + "/test/";
+
+ using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (EchoRequestHandler))) {
+ responder.Start ();
+
+ HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
+ req.Method = "POST";
+ req.Timeout = 2000;
+ req.ReadWriteTimeout = 2000;
+ IAsyncResult ar = req.BeginGetRequestStream (null, null);
+
+ // AsyncResult was not returned from call to BeginGetResponse
+ try {
+ req.EndGetResponse (ar);
+ Assert.Fail ();
+ } catch (InvalidCastException) {
+ } finally {
+ req.Abort ();
+ }
+ }
+ }
+
+ [Test]
+ public void EndGetResponse_AsyncResult_Null ()
+ {
+ IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 9158);
+ string url = "http://" + ep.ToString () + "/test/";
+
+ using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (EchoRequestHandler))) {
+ responder.Start ();
+
+ HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
+ req.Timeout = 2000;
+ req.ReadWriteTimeout = 2000;
+ req.Method = "POST";
+ IAsyncResult ar = req.BeginGetResponse (null, null);
+
+ try {
+ req.EndGetResponse (null);
+ Assert.Fail ("#1");
+ } catch (ArgumentNullException ex) {
+ Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
+ Assert.IsNull (ex.InnerException, "#3");
+ Assert.IsNotNull (ex.Message, "#4");
+ Assert.AreEqual ("asyncResult", ex.ParamName, "#5");
+ } finally {
+ req.Abort ();
+ /*
+ using (HttpWebResponse resp = (HttpWebResponse) req.EndGetResponse (ar)) {
+ resp.Close ();
+ }*/
+ }
}
}
[Test] // bug #429200
public void GetRequestStream ()
{
- IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000);
- string url = "http://" + IPAddress.Loopback.ToString () + ":8000/test/";
+ IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 10000);
+ string url = "http://" + ep.ToString () + "/test/";
using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (EchoRequestHandler))) {
responder.Start ();
}
}
+ [Test] // bug #511851
+ public void GetRequestStream_Request_Aborted ()
+ {
+ IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 10001);
+ string url = "http://" + ep.ToString () + "/test/";
+
+ using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (EchoRequestHandler))) {
+ responder.Start ();
+
+ HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
+ req.Method = "POST";
+ req.Abort ();
+
+ try {
+ req.GetRequestStream ();
+ Assert.Fail ("#1");
+ } catch (WebException ex) {
+ // The request was aborted: The request was canceled
+ Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
+ Assert.IsNull (ex.InnerException, "#3");
+ Assert.IsNotNull (ex.Message, "#4");
+ Assert.IsNull (ex.Response, "#5");
+ Assert.AreEqual (WebExceptionStatus.RequestCanceled, ex.Status, "#6");
+ }
+ }
+ }
+
[Test] // bug #510661
- [Category ("NotWorking")]
+ [Category ("NotWorking")] // #5842
public void GetRequestStream_Close_NotAllBytesWritten ()
{
- IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000);
- string url = "http://" + IPAddress.Loopback.ToString () + ":8000/test/";
+ IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 10002);
+ string url = "http://" + ep.ToString () + "/test/";
using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (EchoRequestHandler))) {
responder.Start ();
}
[Test] // bug #510642
- [Category ("NotWorking")]
+ [Category ("NotWorking")] // #5842
public void GetRequestStream_Write_Overflow ()
{
- IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8001);
- string url = "http://" + IPAddress.Loopback.ToString () + ":8001/test/";
+ IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8010);
+ string url = "http://" + ep.ToString () + "/test/";
+ // buffered, non-chunked
using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (EchoRequestHandler))) {
responder.Start ();
- HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
- req.ProtocolVersion = HttpVersion.Version11;
+ HttpWebRequest req;
+ Stream rs;
+ byte [] buffer;
+
+ req = (HttpWebRequest) WebRequest.Create (url);
req.Method = "POST";
- req.Timeout = 200;
- req.ReadWriteTimeout = 100;
+ req.Timeout = 1000;
+ req.ReadWriteTimeout = 2000;
req.ContentLength = 2;
- Stream rs = req.GetRequestStream ();
+ rs = req.GetRequestStream ();
+ rs.WriteByte (0x2c);
- byte [] buffer = new byte [] { 0x2a, 0x2c, 0x1d };
+ buffer = new byte [] { 0x2a, 0x1d };
try {
- rs.Write (buffer, 0, 3);
- Assert.Fail ("#1");
+ rs.Write (buffer, 0, buffer.Length);
+ Assert.Fail ("#A1");
} catch (ProtocolViolationException ex) {
// Bytes to be written to the stream exceed
// Content-Length bytes size specified
- Assert.IsNull (ex.InnerException, "#2");
- Assert.IsNotNull (ex.Message, "#3");
+ Assert.IsNull (ex.InnerException, "#A2");
+ Assert.IsNotNull (ex.Message, "#A3");
} finally {
req.Abort ();
}
- }
- }
- [Test]
- [Ignore ("This test asserts that our code violates RFC 2616")]
- public void GetRequestStream_Body_NotAllowed ()
- {
- string [] methods = new string [] { "GET", "HEAD", "CONNECT",
- "get", "HeAd", "ConNect" };
+ req = (HttpWebRequest) WebRequest.Create (url);
+ req.Method = "POST";
+ req.Timeout = 1000;
+ req.ReadWriteTimeout = 2000;
+ req.ContentLength = 2;
- foreach (string method in methods) {
- HttpWebRequest req = (HttpWebRequest) WebRequest.Create (
- "http://localhost:8000");
- req.Method = method;
+ rs = req.GetRequestStream ();
+
+ buffer = new byte [] { 0x2a, 0x2c, 0x1d };
try {
- req.GetRequestStream ();
- Assert.Fail ("#1:" + method);
+ rs.Write (buffer, 0, buffer.Length);
+ Assert.Fail ("#B1");
} catch (ProtocolViolationException ex) {
- Assert.AreEqual (typeof (ProtocolViolationException), ex.GetType (), "#2:" + method);
- Assert.IsNull (ex.InnerException, "#3:" + method);
- Assert.IsNotNull (ex.Message, "#4:" + method);
+ // Bytes to be written to the stream exceed
+ // Content-Length bytes size specified
+ Assert.IsNull (ex.InnerException, "#B2");
+ Assert.IsNotNull (ex.Message, "#B3");
+ } finally {
+ req.Abort ();
}
}
- }
- [Test]
-#if TARGET_JVM
- [Category("NotWorking")]
-#endif
- [Ignore ("This does not timeout any more. That's how MS works when reading small responses")]
- public void ReadTimeout ()
- {
- IPEndPoint localEP = new IPEndPoint (IPAddress.Loopback, 8764);
- string url = "http://" + localEP.ToString () + "/original/";
-
- using (SocketResponder responder = new SocketResponder (localEP, new SocketRequestHandler (RedirectRequestHandler))) {
+ // buffered, chunked
+ using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (EchoRequestHandler))) {
responder.Start ();
- HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
+ HttpWebRequest req;
+ Stream rs;
+ byte [] buffer;
+
+ /*
+ req = (HttpWebRequest) WebRequest.Create (url);
req.Method = "POST";
- req.AllowAutoRedirect = false;
- req.Timeout = 200;
- req.ReadWriteTimeout = 100;
- req.KeepAlive = false;
- Stream rs = req.GetRequestStream ();
- rs.Close ();
- using (HttpWebResponse resp = (HttpWebResponse) req.GetResponse ()) {
- try {
- Stream s = resp.GetResponseStream ();
- s.ReadByte ();
- Assert.Fail ("#1");
- } catch (WebException ex) {
- Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
- Assert.IsNull (ex.InnerException, "#3");
- Assert.IsNull (ex.Response, "#4");
- Assert.AreEqual (WebExceptionStatus.Timeout, ex.Status, "#5");
+ req.SendChunked = true;
+ req.Timeout = 1000;
+ req.ReadWriteTimeout = 2000;
+ req.ContentLength = 2;
+
+ rs = req.GetRequestStream ();
+ rs.WriteByte (0x2c);
+
+ buffer = new byte [] { 0x2a, 0x1d };
+ rs.Write (buffer, 0, buffer.Length);
+ req.Abort ();
+ */
+
+ req = (HttpWebRequest) WebRequest.Create (url);
+ req.Method = "POST";
+ req.SendChunked = true;
+ req.Timeout = 1000;
+ req.ReadWriteTimeout = 2000;
+ req.ContentLength = 2;
+
+ rs = req.GetRequestStream ();
+
+ buffer = new byte [] { 0x2a, 0x2c, 0x1d };
+ rs.Write (buffer, 0, buffer.Length);
+ req.Abort ();
+ }
+
+ // non-buffered, non-chunked
+ using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (EchoRequestHandler))) {
+ responder.Start ();
+
+ HttpWebRequest req;
+ Stream rs;
+ byte [] buffer;
+
+ req = (HttpWebRequest) WebRequest.Create (url);
+ req.AllowWriteStreamBuffering = false;
+ req.Method = "POST";
+ req.Timeout = 1000;
+ req.ReadWriteTimeout = 2000;
+ req.ContentLength = 2;
+
+ rs = req.GetRequestStream ();
+ rs.WriteByte (0x2c);
+
+ buffer = new byte [] { 0x2a, 0x1d };
+ try {
+ rs.Write (buffer, 0, buffer.Length);
+ Assert.Fail ("#C1");
+ } catch (ProtocolViolationException ex) {
+ // Bytes to be written to the stream exceed
+ // Content-Length bytes size specified
+ Assert.IsNull (ex.InnerException, "#C2");
+ Assert.IsNotNull (ex.Message, "#3");
+ } finally {
+ req.Abort ();
+ }
+
+ req = (HttpWebRequest) WebRequest.Create (url);
+ req.AllowWriteStreamBuffering = false;
+ req.Method = "POST";
+ req.Timeout = 1000;
+ req.ReadWriteTimeout = 2000;
+ req.ContentLength = 2;
+
+ rs = req.GetRequestStream ();
+
+ buffer = new byte [] { 0x2a, 0x2c, 0x1d };
+ try {
+ rs.Write (buffer, 0, buffer.Length);
+ Assert.Fail ("#D1");
+ } catch (ProtocolViolationException ex) {
+ // Bytes to be written to the stream exceed
+ // Content-Length bytes size specified
+ Assert.IsNull (ex.InnerException, "#D2");
+ Assert.IsNotNull (ex.Message, "#D3");
+ } finally {
+ req.Abort ();
+ }
+ }
+
+ // non-buffered, chunked
+ using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (EchoRequestHandler))) {
+ responder.Start ();
+
+ HttpWebRequest req;
+ Stream rs;
+ byte [] buffer;
+
+ req = (HttpWebRequest) WebRequest.Create (url);
+ req.AllowWriteStreamBuffering = false;
+ req.Method = "POST";
+ req.SendChunked = true;
+ req.Timeout = 1000;
+ req.ReadWriteTimeout = 2000;
+ req.ContentLength = 2;
+
+ rs = req.GetRequestStream ();
+ rs.WriteByte (0x2c);
+
+ buffer = new byte [] { 0x2a, 0x1d };
+ rs.Write (buffer, 0, buffer.Length);
+ req.Abort ();
+
+ req = (HttpWebRequest) WebRequest.Create (url);
+ req.AllowWriteStreamBuffering = false;
+ req.Method = "POST";
+ req.SendChunked = true;
+ req.Timeout = 1000;
+ req.ReadWriteTimeout = 2000;
+ req.ContentLength = 2;
+
+ rs = req.GetRequestStream ();
+
+ buffer = new byte [] { 0x2a, 0x2c, 0x1d };
+ rs.Write (buffer, 0, buffer.Length);
+ req.Abort ();
+ }
+ }
+
+ [Test]
+ [Ignore ("This test asserts that our code violates RFC 2616")]
+ public void GetRequestStream_Body_NotAllowed ()
+ {
+ string [] methods = new string [] { "GET", "HEAD", "CONNECT",
+ "get", "HeAd", "ConNect" };
+
+ foreach (string method in methods) {
+ HttpWebRequest req = (HttpWebRequest) WebRequest.Create (
+ "http://localhost:8000");
+ req.Method = method;
+ try {
+ req.GetRequestStream ();
+ Assert.Fail ("#1:" + method);
+ } catch (ProtocolViolationException ex) {
+ Assert.AreEqual (typeof (ProtocolViolationException), ex.GetType (), "#2:" + method);
+ Assert.IsNull (ex.InnerException, "#3:" + method);
+ Assert.IsNotNull (ex.Message, "#4:" + method);
+ }
+ }
+ }
+
+ [Test] // bug #511851
+ public void GetResponse_Request_Aborted ()
+ {
+ IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 10100);
+ string url = "http://" + ep.ToString () + "/test/";
+
+ using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (EchoRequestHandler))) {
+ responder.Start ();
+
+ HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
+ req.Method = "POST";
+ req.Abort ();
+
+ try {
+ req.GetResponse ();
+ Assert.Fail ("#1");
+ } catch (WebException ex) {
+ // The request was aborted: The request was canceled
+ Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
+ Assert.IsNull (ex.InnerException, "#3");
+ Assert.IsNotNull (ex.Message, "#4");
+ Assert.IsNull (ex.Response, "#5");
+ Assert.AreEqual (WebExceptionStatus.RequestCanceled, ex.Status, "#6");
+ }
+ }
+ }
+
+ [Test]
+#if TARGET_JVM
+ [Category("NotWorking")]
+#endif
+ [Ignore ("This does not timeout any more. That's how MS works when reading small responses")]
+ public void ReadTimeout ()
+ {
+ IPEndPoint localEP = new IPEndPoint (IPAddress.Loopback, 8764);
+ string url = "http://" + localEP.ToString () + "/original/";
+
+ using (SocketResponder responder = new SocketResponder (localEP, new SocketRequestHandler (RedirectRequestHandler))) {
+ responder.Start ();
+
+ HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
+ req.Method = "POST";
+ req.AllowAutoRedirect = false;
+ req.Timeout = 200;
+ req.ReadWriteTimeout = 2000;
+ req.KeepAlive = false;
+ Stream rs = req.GetRequestStream ();
+ rs.Close ();
+ using (HttpWebResponse resp = (HttpWebResponse) req.GetResponse ()) {
+ try {
+ Stream s = resp.GetResponseStream ();
+ s.ReadByte ();
+ Assert.Fail ("#1");
+ } catch (WebException ex) {
+ Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
+ Assert.IsNull (ex.InnerException, "#3");
+ Assert.IsNull (ex.Response, "#4");
+ Assert.AreEqual (WebExceptionStatus.Timeout, ex.Status, "#5");
}
}
responder.Stop ();
#endif
public void AllowAutoRedirect ()
{
- IPEndPoint localEP = new IPEndPoint (IPAddress.Loopback, 8764);
+ IPEndPoint localEP = new IPEndPoint (IPAddress.Loopback, 8765);
string url = "http://" + localEP.ToString () + "/original/";
// allow autoredirect
}
}
+ [Test]
+ public void PostAndRedirect_NoCL ()
+ {
+ IPEndPoint localEP = new IPEndPoint (IPAddress.Loopback, 8769);
+ string url = "http://" + localEP.ToString () + "/original/";
+
+ using (SocketResponder responder = new SocketResponder (localEP, new SocketRequestHandler (RedirectRequestHandler))) {
+ responder.Start ();
+
+ HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
+ req.Method = "POST";
+ req.Timeout = 2000;
+ req.ReadWriteTimeout = 2000;
+ Stream rs = req.GetRequestStream ();
+ rs.WriteByte (10);
+ rs.Close ();
+ using (HttpWebResponse resp = (HttpWebResponse) req.GetResponse ()) {
+ StreamReader sr = new StreamReader (resp.GetResponseStream (),
+ Encoding.UTF8);
+ string body = sr.ReadToEnd ();
+
+ Assert.AreEqual (resp.StatusCode, HttpStatusCode.OK, "#A1");
+ Assert.AreEqual (resp.ResponseUri.ToString (), "http://" +
+ localEP.ToString () + "/moved/", "#A2");
+ Assert.AreEqual ("GET", resp.Method, "#A3");
+ Assert.AreEqual ("LOOKS OK", body, "#A4");
+ }
+ responder.Stop ();
+ }
+ }
+
+ [Test]
+ public void PostAndRedirect_CL ()
+ {
+ IPEndPoint localEP = new IPEndPoint (IPAddress.Loopback, 8770);
+ string url = "http://" + localEP.ToString () + "/original/";
+
+ using (SocketResponder responder = new SocketResponder (localEP, new SocketRequestHandler (RedirectRequestHandler))) {
+ responder.Start ();
+
+ HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
+ req.Method = "POST";
+ req.Timeout = 2000;
+ req.ReadWriteTimeout = 2000;
+ req.ContentLength = 1;
+ Stream rs = req.GetRequestStream ();
+ rs.WriteByte (10);
+ using (HttpWebResponse resp = (HttpWebResponse) req.GetResponse ()) {
+ StreamReader sr = new StreamReader (resp.GetResponseStream (),
+ Encoding.UTF8);
+ string body = sr.ReadToEnd ();
+
+ Assert.AreEqual (resp.StatusCode, HttpStatusCode.OK, "#A1");
+ Assert.AreEqual (resp.ResponseUri.ToString (), "http://" +
+ localEP.ToString () + "/moved/", "#A2");
+ Assert.AreEqual ("GET", resp.Method, "#A3");
+ Assert.AreEqual ("LOOKS OK", body, "#A4");
+ }
+ responder.Stop ();
+ }
+ }
+
+ [Test]
+ public void PostAnd401 ()
+ {
+ IPEndPoint localEP = new IPEndPoint (IPAddress.Loopback, 8771);
+ string url = "http://" + localEP.ToString () + "/original/";
+
+ using (SocketResponder responder = new SocketResponder (localEP, new SocketRequestHandler (RedirectRequestHandler))) {
+ responder.Start ();
+
+ HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
+ req.Method = "POST";
+ req.Timeout = 2000;
+ req.ReadWriteTimeout = 2000;
+ req.ContentLength = 1;
+ Stream rs = req.GetRequestStream ();
+ rs.WriteByte (10);
+ using (HttpWebResponse resp = (HttpWebResponse) req.GetResponse ()) {
+ StreamReader sr = new StreamReader (resp.GetResponseStream (),
+ Encoding.UTF8);
+ string body = sr.ReadToEnd ();
+
+ Assert.AreEqual (resp.StatusCode, HttpStatusCode.OK, "#A1");
+ Assert.AreEqual (resp.ResponseUri.ToString (), "http://" +
+ localEP.ToString () + "/moved/", "#A2");
+ Assert.AreEqual ("GET", resp.Method, "#A3");
+ Assert.AreEqual ("LOOKS OK", body, "#A4");
+ }
+ responder.Stop ();
+ }
+ }
+
[Test] // bug #324347
[Category ("NotWorking")]
public void InternalServerError ()
{
- IPEndPoint localEP = new IPEndPoint (IPAddress.Loopback, 8764);
+ IPEndPoint localEP = new IPEndPoint (IPAddress.Loopback, 8766);
string url = "http://" + localEP.ToString () + "/original/";
// POST
[Category ("NotWorking")] // #B3 fails; we get a SocketException: An existing connection was forcibly closed by the remote host
public void NoContentLength ()
{
- IPEndPoint localEP = new IPEndPoint (IPAddress.Loopback, 8764);
+ IPEndPoint localEP = new IPEndPoint (IPAddress.Loopback, 8767);
string url = "http://" + localEP.ToString () + "/original/";
// POST
req.GetResponse ();
Assert.Fail ("#A1");
} catch (WebException ex) {
-#if NET_2_0
// The underlying connection was closed:
// An unexpected error occurred on a
// receive
HttpWebResponse webResponse = ex.Response as HttpWebResponse;
Assert.IsNull (webResponse, "#A11");
-#else
- // The remote server returned an error:
- // (500) Internal Server Error
- Assert.AreEqual (typeof (WebException), ex.GetType (), "#A2");
- Assert.IsNull (ex.InnerException, "#A3");
- Assert.AreEqual (WebExceptionStatus.ProtocolError, ex.Status, "#A4");
-
- HttpWebResponse webResponse = ex.Response as HttpWebResponse;
- Assert.IsNotNull (webResponse, "#A5");
- Assert.AreEqual ("POST", webResponse.Method, "#A6");
- webResponse.Close ();
-#endif
}
responder.Stop ();
}
}
+ [Test] // bug #513087
+ public void NonStandardVerb ()
+ {
+ IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8123);
+ string url = "http://" + ep.ToString () + "/moved/";
+
+ using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (VerbEchoHandler))) {
+ responder.Start ();
+
+ HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
+ req.Method = "WhatEver";
+ req.KeepAlive = false;
+ req.Timeout = 20000;
+ req.ReadWriteTimeout = 20000;
+
+ Stream rs = req.GetRequestStream ();
+ rs.Close ();
+
+ using (HttpWebResponse resp = (HttpWebResponse) req.GetResponse ()) {
+ StreamReader sr = new StreamReader (resp.GetResponseStream (),
+ Encoding.UTF8);
+ string body = sr.ReadToEnd ();
+
+ Assert.AreEqual (resp.StatusCode, HttpStatusCode.OK, "#1");
+ Assert.AreEqual (resp.ResponseUri.ToString (), "http://" +
+ ep.ToString () + "/moved/", "#2");
+ Assert.AreEqual ("WhatEver", resp.Method, "#3");
+ Assert.AreEqual ("WhatEver", body, "#4");
+ }
+
+ responder.Stop ();
+ }
+ }
+
[Test]
[Category ("NotWorking")] // Assert #2 fails
- public void NotModiedSince ()
+ public void NotModifiedSince ()
{
- IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000);
- string url = "http://" + IPAddress.Loopback.ToString () + ":8000/test/";
+ IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 9123);
+ string url = "http://" + ep.ToString () + "/test/";
using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (NotModifiedSinceHandler))) {
responder.Start ();
req.KeepAlive = false;
req.Timeout = 20000;
req.ReadWriteTimeout = 20000;
-#if NET_2_0
req.Headers.Add (HttpRequestHeader.IfNoneMatch, "898bbr2347056cc2e096afc66e104653");
-#else
- req.Headers.Add ("If-None-Match", "898bbr2347056cc2e096afc66e104653");
-#endif
req.IfModifiedSince = new DateTime (2010, 01, 04);
DateTime start = DateTime.Now;
}
}
-#if NET_2_0
- [Test] // bug #324182
-#if TARGET_JVM
- [Category ("NotWorking")]
-#endif
- public void Stream_CanTimeout ()
- {
- IPEndPoint localEP = new IPEndPoint (IPAddress.Loopback, 8764);
- string url = "http://" + localEP.ToString () + "/original/";
-
- // allow autoredirect
- using (SocketResponder responder = new SocketResponder (localEP, new SocketRequestHandler (RedirectRequestHandler))) {
- responder.Start ();
-
- HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
- req.Method = "POST";
- req.Timeout = 2000;
- req.ReadWriteTimeout = 2000;
- req.KeepAlive = false;
- Stream rs = req.GetRequestStream ();
- Assert.IsTrue (rs.CanTimeout, "#1");
- rs.Close ();
- using (HttpWebResponse resp = (HttpWebResponse) req.GetResponse ()) {
- Stream os = resp.GetResponseStream ();
- Assert.IsTrue (os.CanTimeout, "#2");
- os.Close ();
- }
- responder.Stop ();
- }
- }
-#endif
-
[Test] // bug #353495
[Category ("NotWorking")]
public void LastModifiedKind ()
HttpWebRequest req = (HttpWebRequest) WebRequest.Create (reqURL);
HttpWebResponse resp = (HttpWebResponse) req.GetResponse ();
DateTime lastMod = resp.LastModified;
- string rawLastMod = resp.Headers ["Last-Modified"];
+ //string rawLastMod = resp.Headers ["Last-Modified"];
resp.Close ();
//Assert.AreEqual ("Tue, 15 Jan 2008 08:59:59 GMT", rawLastMod, "#1");
-#if NET_2_0
Assert.AreEqual (DateTimeKind.Local, lastMod.Kind, "#2");
-#endif
req = (HttpWebRequest) WebRequest.Create (reqURL);
req.IfModifiedSince = lastMod;
try {
}
}
- static byte [] EchoRequestHandler (Socket socket)
+ internal static byte [] EchoRequestHandler (Socket socket)
{
MemoryStream ms = new MemoryStream ();
byte [] buffer = new byte [4096];
int bytesReceived = socket.Receive (buffer);
while (bytesReceived > 0) {
ms.Write (buffer, 0, bytesReceived);
+ // We don't check for Content-Length or anything else here, so we give the client a little time to write
+ // after sending the headers
+ Thread.Sleep (200);
if (socket.Available > 0) {
bytesReceived = socket.Receive (buffer);
} else {
int bytesReceived = socket.Receive (buffer);
while (bytesReceived > 0) {
ms.Write (buffer, 0, bytesReceived);
+ // We don't check for Content-Length or anything else here, so we give the client a little time to write
+ // after sending the headers
+ Thread.Sleep (200);
if (socket.Available > 0) {
bytesReceived = socket.Receive (buffer);
} else {
StringWriter sw = new StringWriter ();
if (statusLine.StartsWith ("POST /original/")) {
sw.WriteLine ("HTTP/1.0 302 Found");
- sw.WriteLine ("Location: " + "http://" + IPAddress.Loopback.ToString () + ":8764/moved/");
+ EndPoint ep = socket.LocalEndPoint;
+ sw.WriteLine ("Location: " + "http://" + ep.ToString () + "/moved/");
sw.WriteLine ();
sw.Flush ();
} else if (statusLine.StartsWith ("GET /moved/")) {
static byte [] InternalErrorHandler (Socket socket)
{
+ byte [] buffer = new byte [4096];
+ int bytesReceived = socket.Receive (buffer);
+ while (bytesReceived > 0) {
+ // We don't check for Content-Length or anything else here, so we give the client a little time to write
+ // after sending the headers
+ Thread.Sleep (200);
+ if (socket.Available > 0) {
+ bytesReceived = socket.Receive (buffer);
+ } else {
+ bytesReceived = 0;
+ }
+ }
StringWriter sw = new StringWriter ();
sw.WriteLine ("HTTP/1.1 500 Too Lazy");
sw.WriteLine ("Content-Length: 0");
return Encoding.UTF8.GetBytes (sw.ToString ());
}
+ static byte [] VerbEchoHandler (Socket socket)
+ {
+ MemoryStream ms = new MemoryStream ();
+ byte [] buffer = new byte [4096];
+ int bytesReceived = socket.Receive (buffer);
+ while (bytesReceived > 0) {
+ ms.Write (buffer, 0, bytesReceived);
+ // We don't check for Content-Length or anything else here, so we give the client a little time to write
+ // after sending the headers
+ Thread.Sleep (200);
+ if (socket.Available > 0) {
+ bytesReceived = socket.Receive (buffer);
+ } else {
+ bytesReceived = 0;
+ }
+ }
+ ms.Flush ();
+ ms.Position = 0;
+ string statusLine = null;
+ using (StreamReader sr = new StreamReader (ms, Encoding.UTF8)) {
+ statusLine = sr.ReadLine ();
+ }
+
+ string verb = "DEFAULT";
+ if (statusLine != null) {
+ string [] parts = statusLine.Split (' ');
+ if (parts.Length > 0)
+ verb = parts [0];
+ }
+
+ StringWriter sw = new StringWriter ();
+ sw.WriteLine ("HTTP/1.1 200 OK");
+ sw.WriteLine ("Content-Type: text/plain");
+ sw.WriteLine ("Content-Length: " + verb.Length);
+ sw.WriteLine ();
+ sw.Write (verb);
+ sw.Flush ();
+
+ return Encoding.UTF8.GetBytes (sw.ToString ());
+ }
+
+ static byte [] PostAnd401Handler (Socket socket)
+ {
+ MemoryStream ms = new MemoryStream ();
+ byte [] buffer = new byte [4096];
+ int bytesReceived = socket.Receive (buffer);
+ while (bytesReceived > 0) {
+ ms.Write (buffer, 0, bytesReceived);
+ // We don't check for Content-Length or anything else here, so we give the client a little time to write
+ // after sending the headers
+ Thread.Sleep (200);
+ if (socket.Available > 0) {
+ bytesReceived = socket.Receive (buffer);
+ } else {
+ bytesReceived = 0;
+ }
+ }
+ ms.Flush ();
+ ms.Position = 0;
+ string statusLine = null;
+ bool have_auth = false;
+ int cl = -1;
+ using (StreamReader sr = new StreamReader (ms, Encoding.UTF8)) {
+ string l;
+ while ((l = sr.ReadLine ()) != null) {
+ if (statusLine == null) {
+ statusLine = l;
+ } else if (l.StartsWith ("Authorization:")) {
+ have_auth = true;
+ } else if (l.StartsWith ("Content-Length:")) {
+ cl = Int32.Parse (l.Substring ("content-length: ".Length));
+ }
+ }
+ }
+
+ StringWriter sw = new StringWriter ();
+ if (!have_auth) {
+ sw.WriteLine ("HTTP/1.0 401 Invalid Credentials");
+ sw.WriteLine ("WWW-Authenticate: basic Yeah");
+ sw.WriteLine ();
+ sw.Flush ();
+ } else if (cl > 0 && statusLine.StartsWith ("POST ")) {
+ sw.WriteLine ("HTTP/1.0 200 OK");
+ sw.WriteLine ("Content-Type: text/plain");
+ sw.WriteLine ("Content-Length: 8");
+ sw.WriteLine ();
+ sw.Write ("LOOKS OK");
+ sw.Flush ();
+ } else {
+ sw.WriteLine ("HTTP/1.0 500 test failed");
+ sw.WriteLine ("Content-Length: 0");
+ sw.WriteLine ();
+ sw.Flush ();
+ }
+
+ return Encoding.UTF8.GetBytes (sw.ToString ());
+ }
[Test]
public void NtlmAuthentication ()
{
HttpWebResponse resp = (HttpWebResponse) request.GetResponse ();
string res = null;
using (StreamReader reader = new StreamReader (resp.GetResponseStream ())) {
- res = reader.ReadToEnd ();
+ res = reader.ReadToEnd ();
}
resp.Close ();
server.Stop ();
protected abstract void Run ();
}
-#if !TARGET_JVM
- class SslHttpServer : HttpServer {
- X509Certificate _certificate;
+ [Test]
+ public void BeginGetRequestStream ()
+ {
+ this.DoRequest (
+ (r, c) =>
+ {
+ r.Method = "POST";
+ r.ContentLength = 0;
+ r.BeginGetRequestStream ((a) =>
+ {
+ using (Stream s = r.EndGetRequestStream (a)) { };
+ c.Set();
+ },
+ null);
+ },
+ (c) => { });
+ }
- protected override void Run ()
+ [Test]
+ public void BeginGetRequestStreamNoClose ()
+ {
+ this.DoRequest (
+ (r, c) => {
+ r.Method = "POST";
+ r.ContentLength = 1;
+ r.BeginGetRequestStream ((a) =>
+ {
+ r.EndGetRequestStream (a);
+ c.Set ();
+ },
+ null);
+ },
+ (c) => {});
+ }
+
+ [Test]
+ public void BeginGetRequestStreamCancelIfNotAllBytesWritten ()
+ {
+ this.DoRequest (
+ (r, c) =>
{
- try {
- Socket client = sock.Accept ();
- NetworkStream ns = new NetworkStream (client, true);
- SslServerStream s = new SslServerStream (ns, Certificate, false, false);
- s.PrivateKeyCertSelectionDelegate += new PrivateKeySelectionCallback (GetPrivateKey);
+ r.Method = "POST";
+ r.ContentLength = 10;
+ r.BeginGetRequestStream ((a) =>
+ {
+ WebException ex = ExceptionAssert.Throws<WebException> (() =>
+ {
+ using (Stream s = r.EndGetRequestStream (a)) {
+ }
+ }
+ );
+ Assert.AreEqual (ex.Status, WebExceptionStatus.RequestCanceled);
+ c.Set();
+ },
+ null);
+ },
+ (c) => { });
+ }
- StreamReader reader = new StreamReader (s);
- StreamWriter writer = new StreamWriter (s, Encoding.ASCII);
+ [Test]
+ public void GetRequestStream2 ()
+ {
+ this.DoRequest (
+ (r, c) =>
+ {
+ r.Method = "POST";
+ r.ContentLength = data64KB.Length;
+ using (Stream s = r.GetRequestStream ()) {
+ s.Write (data64KB, 0, data64KB.Length);
+ }
+ c.Set ();
+ },
+ (c) => { });
+ }
- string line;
- string hello = "<html><body><h1>Hello World!</h1></body></html>";
- string answer = "HTTP/1.0 200\r\n" +
- "Connection: close\r\n" +
- "Content-Type: text/html\r\n" +
- "Content-Encoding: " + Encoding.ASCII.WebName + "\r\n" +
- "Content-Length: " + hello.Length + "\r\n" +
- "\r\n" + hello;
+ [Test]
+ public void GetRequestStreamNotAllBytesWritten ()
+ {
+ this.DoRequest (
+ (r, c) =>
+ {
+ r.Method = "POST";
+ r.ContentLength = data64KB.Length;
+ WebException ex = ExceptionAssert.Throws<WebException> (() => r.GetRequestStream ().Close ());
+ Assert.AreEqual (ex.Status, WebExceptionStatus.RequestCanceled);
+ c.Set ();
+ },
+ (c) => {});
+ }
- // Read the headers
- do {
- line = reader.ReadLine ();
- } while (line != "" && line != null && line.Length > 0);
+ [Test]
+ public void GetRequestStreamTimeout ()
+ {
+ this.DoRequest (
+ (r, c) =>
+ {
+ r.Method = "POST";
+ r.ContentLength = data64KB.Length;
+ r.Timeout = 100;
+ WebException ex = ExceptionAssert.Throws<WebException> (() => r.GetRequestStream ());
+ Assert.IsTrue (ex.Status == WebExceptionStatus.Timeout || ex.Status == WebExceptionStatus.ConnectFailure);
+ c.Set();
+ });
+ }
- // Now the content. We know it's 100 bytes.
- // This makes BeginRead in sslclientstream block.
- char [] cs = new char [100];
- reader.Read (cs, 0, 100);
+ [Test]
+ public void BeginWrite ()
+ {
+ byte[] received = new byte[data64KB.Length];
- writer.Write (answer);
- writer.Flush ();
- evt.WaitOne (50000, false);
- } catch (Exception e) {
- error = e;
+ this.DoRequest (
+ (r, c) =>
+ {
+ r.Method = "POST";
+ r.ContentLength = data64KB.Length;
+
+ Stream s = r.GetRequestStream ();
+ s.BeginWrite (data64KB, 0, data64KB.Length,
+ (a) =>
+ {
+ s.EndWrite (a);
+ s.Close ();
+ r.GetResponse ().Close ();
+ c.Set();
+ },
+ null);
+ },
+ (c) =>
+ {
+ c.Request.InputStream.ReadAll (received, 0, received.Length);
+ c.Response.StatusCode = 204;
+ c.Response.Close ();
+ });
+
+ Assert.AreEqual (data64KB, received);
+ }
+
+ [Test]
+ public void BeginWriteAfterAbort ()
+ {
+ byte [] received = new byte [data64KB.Length];
+
+ this.DoRequest (
+ (r, c) =>
+ {
+ r.Method = "POST";
+ r.ContentLength = data64KB.Length;
+
+ Stream s = r.GetRequestStream ();
+ r.Abort();
+
+ WebException ex = ExceptionAssert.Throws<WebException> (() => s.BeginWrite (data64KB, 0, data64KB.Length, null, null));
+ Assert.AreEqual (ex.Status, WebExceptionStatus.RequestCanceled);
+
+ c.Set();
+ },
+ (c) =>
+ {
+ c.Request.InputStream.ReadAll (received, 0, received.Length);
+ c.Response.StatusCode = 204;
+ c.Response.Close();
+ });
+ }
+
+ [Test]
+ public void PrematureStreamCloseAborts ()
+ {
+ byte [] received = new byte [data64KB.Length];
+
+ this.DoRequest (
+ (r, c) =>
+ {
+ r.Method = "POST";
+ r.ContentLength = data64KB.Length * 2;
+
+ Stream s = r.GetRequestStream ();
+ s.Write (data64KB, 0, data64KB.Length);
+
+ WebException ex = ExceptionAssert.Throws<WebException>(() => s.Close());
+ Assert.AreEqual(ex.Status, WebExceptionStatus.RequestCanceled);
+
+ c.Set();
+ },
+ (c) =>
+ {
+ c.Request.InputStream.ReadAll (received, 0, received.Length);
+ c.Response.StatusCode = 204;
+ c.Response.Close ();
+ });
+ }
+
+ [Test]
+ public void Write ()
+ {
+ byte [] received = new byte [data64KB.Length];
+
+ this.DoRequest (
+ (r, c) =>
+ {
+ r.Method = "POST";
+ r.ContentLength = data64KB.Length;
+
+ using (Stream s = r.GetRequestStream ()) {
+ s.Write (data64KB, 0, data64KB.Length);
}
- }
- X509Certificate Certificate {
- get {
- if (_certificate == null)
- _certificate = new X509Certificate (CertData.Certificate);
+ r.GetResponse ().Close ();
+ c.Set ();
+ },
+ (c) =>
+ {
+ c.Request.InputStream.ReadAll (received, 0, received.Length);
+ c.Response.StatusCode = 204;
+ c.Response.Close ();
+ });
- return _certificate;
+ Assert.AreEqual(data64KB, received);
+ }
+
+ /*
+ Invalid test: it does not work on linux.
+ [pid 30973] send(9, "POST / HTTP/1.1\r\nContent-Length:"..., 89, 0) = 89
+ Abort set
+ [pid 30970] send(16, "HTTP/1.1 200 OK\r\nServer: Mono-HT"..., 133, 0) = 133
+ Calling abort
+ [pid 30970] close(16) = 0
+ Closing!!!
+ [pid 30980] send(9, "\213t\326\350\312u\36n\234\351\225L\r\243a\200\226\371\350F\271~oZ\32\270\24\226z4\211\345"..., 65536, 0) = 65536
+ Writing...
+ [pid 30966] close(4) = 0
+ OK
+ *
+ The server sideis closed (FD 16) and the send on the client side (FD 9) succeeds.
+ [Test]
+ [Category("NotWorking")]
+ public void WriteServerAborts ()
+ {
+ ManualResetEvent abort = new ManualResetEvent (false);
+ byte [] received = new byte [data64KB.Length];
+
+ this.DoRequest (
+ (r, c) =>
+ {
+ r.Method = "POST";
+ r.ContentLength = data64KB.Length;
+
+ using (Stream s = r.GetRequestStream()) {
+ abort.Set();
+ Thread.Sleep(100);
+ IOException ex = ExceptionAssert.Throws<IOException> (() => s.Write(data64KB, 0, data64KB.Length));
}
- }
- AsymmetricAlgorithm GetPrivateKey (X509Certificate certificate, string targetHost)
+ c.Set();
+ },
+ (c) =>
{
- PrivateKey key = new PrivateKey (CertData.PrivateKey, null);
- return key.RSA;
- }
+ abort.WaitOne();
+ c.Response.Abort();
+ });
}
+ **/
- class CertData {
- public readonly static byte [] Certificate = {
- 48, 130, 1, 191, 48, 130, 1, 40, 160, 3, 2, 1, 2, 2, 16, 36,
- 14, 97, 190, 146, 132, 208, 71, 175, 6, 87, 168, 185, 175, 55, 43, 48,
- 13, 6, 9, 42, 134, 72, 134, 247, 13, 1, 1, 4, 5, 0, 48, 18,
- 49, 16, 48, 14, 6, 3, 85, 4, 3, 19, 7, 103, 111, 110, 122, 97,
- 108, 111, 48, 30, 23, 13, 48, 53, 48, 54, 50, 50, 49, 57, 51, 48,
- 52, 54, 90, 23, 13, 51, 57, 49, 50, 51, 49, 50, 51, 53, 57, 53,
- 57, 90, 48, 18, 49, 16, 48, 14, 6, 3, 85, 4, 3, 19, 7, 103,
- 111, 110, 122, 97, 108, 111, 48, 129, 158, 48, 13, 6, 9, 42, 134, 72,
- 134, 247, 13, 1, 1, 1, 5, 0, 3, 129, 140, 0, 48, 129, 136, 2,
- 129, 129, 0, 138, 9, 38, 25, 166, 252, 59, 26, 39, 184, 128, 216, 38,
- 73, 41, 86, 30, 228, 160, 205, 41, 135, 115, 223, 44, 62, 42, 198, 178,
- 190, 81, 11, 25, 21, 216, 49, 179, 130, 246, 52, 97, 175, 212, 94, 157,
+ [Test]
+ public void Read ()
+ {
+ byte [] received = new byte [data64KB.Length];
+
+ this.DoRequest (
+ (r, c) =>
+ {
+ using (HttpWebResponse x = (HttpWebResponse) r.GetResponse ())
+ using (Stream s = x.GetResponseStream()) {
+ s.ReadAll (received, 0, received.Length);
+ }
+
+ c.Set ();
+ },
+ (c) =>
+ {
+ c.Response.StatusCode = 200;
+ c.Response.ContentLength64 = data64KB.Length;
+ c.Response.OutputStream.Write (data64KB, 0, data64KB.Length);
+ c.Response.OutputStream.Close ();
+ c.Response.Close ();
+ });
+
+ Assert.AreEqual (data64KB, received);
+ }
+
+ [Test]
+ public void ReadTimeout2 ()
+ {
+ byte [] received = new byte [data64KB.Length];
+
+ this.DoRequest (
+ (r, c) =>
+ {
+ r.ReadWriteTimeout = 10;
+ using (HttpWebResponse x = (HttpWebResponse) r.GetResponse ())
+ using (Stream s = x.GetResponseStream ()) {
+ WebException ex = ExceptionAssert.Throws<WebException> (() => s.ReadAll (received, 0, received.Length));
+ Assert.AreEqual (ex.Status, WebExceptionStatus.Timeout);
+ }
+
+ c.Set();
+ },
+ (c) =>
+ {
+ c.Response.StatusCode = 200;
+ c.Response.ContentLength64 = data64KB.Length;
+ c.Response.OutputStream.Write (data64KB, 0, data64KB.Length / 2);
+ Thread.Sleep (1000);
+ c.Response.OutputStream.Write (data64KB, data64KB.Length / 2, data64KB.Length / 2);
+ c.Response.OutputStream.Close ();
+ c.Response.Close ();
+ });
+ }
+
+ [Test]
+ public void ReadServerAborted ()
+ {
+ byte [] received = new byte [data64KB.Length];
+
+ this.DoRequest (
+ (r, c) =>
+ {
+ using (HttpWebResponse x = (HttpWebResponse) r.GetResponse ())
+ using (Stream s = x.GetResponseStream ()) {
+ Assert.AreEqual (1, s.ReadAll (received, 0, received.Length));
+ }
+
+ c.Set();
+ },
+ (c) =>
+ {
+ c.Response.StatusCode = 200;
+ c.Response.ContentLength64 = data64KB.Length;
+ c.Response.OutputStream.Write (data64KB, 0, 1);
+ c.Response.Abort ();
+ });
+ }
+
+ [Test]
+ public void BeginGetResponse2 ()
+ {
+ byte [] received = new byte [data64KB.Length];
+
+ this.DoRequest (
+ (r, c) =>
+ {
+ r.BeginGetResponse ((a) =>
+ {
+ using (HttpWebResponse x = (HttpWebResponse) r.EndGetResponse (a))
+ using (Stream s = x.GetResponseStream ()) {
+ s.ReadAll (received, 0, received.Length);
+ }
+
+ c.Set();
+ }, null);
+ },
+ (c) =>
+ {
+ c.Response.StatusCode = 200;
+ c.Response.ContentLength64 = data64KB.Length;
+ c.Response.OutputStream.Write (data64KB, 0, data64KB.Length);
+ c.Response.OutputStream.Close ();
+ c.Response.Close ();
+ });
+
+ Assert.AreEqual (data64KB, received);
+ }
+
+ [Test]
+ public void BeginGetResponseAborts ()
+ {
+ ManualResetEvent aborted = new ManualResetEvent(false);
+
+ this.DoRequest (
+ (r, c) =>
+ {
+ r.BeginGetResponse((a) =>
+ {
+ WebException ex = ExceptionAssert.Throws<WebException> (() => r.EndGetResponse (a));
+ Assert.AreEqual (ex.Status, WebExceptionStatus.RequestCanceled);
+ c.Set ();
+ }, null);
+
+ aborted.WaitOne ();
+ r.Abort ();
+ },
+ (c) =>
+ {
+ aborted.Set ();
+ Thread.Sleep (100);
+ c.Response.StatusCode = 200;
+ c.Response.ContentLength64 = 0;
+ c.Response.Close ();
+ });
+ }
+
+ void DoRequest (Action<HttpWebRequest, EventWaitHandle> request)
+ {
+ int port = rand.Next (20000, 65535);
+
+ ManualResetEvent completed = new ManualResetEvent (false);
+ Uri address = new Uri (string.Format ("http://localhost:{0}", port));
+ HttpWebRequest client = (HttpWebRequest) WebRequest.Create (address);
+
+ request (client, completed);
+
+ if (!completed.WaitOne (10000))
+ Assert.Fail ("Test hung");
+ }
+
+ void DoRequest (Action<HttpWebRequest, EventWaitHandle> request, Action<HttpListenerContext> processor)
+ {
+ int port = rand.Next (20000, 65535);
+
+ ManualResetEvent [] completed = new ManualResetEvent [2];
+ completed [0] = new ManualResetEvent (false);
+ completed [1] = new ManualResetEvent (false);
+
+ using (ListenerScope scope = new ListenerScope (processor, port, completed [0])) {
+ ManualResetEvent clientCompleted = new ManualResetEvent (false);
+ Uri address = new Uri (string.Format ("http://localhost:{0}", port));
+ HttpWebRequest client = (HttpWebRequest) WebRequest.Create (address);
+
+ ThreadPool.QueueUserWorkItem ((o) => request (client, completed [1]));
+
+ if (!WaitHandle.WaitAll (completed, 10000))
+ Assert.Fail ("Test hung.");
+ }
+ }
+
+#if NET_4_0
+ [Test]
+ [ExpectedException (typeof (ArgumentNullException))]
+ public void NullHost ()
+ {
+ HttpWebRequest req = (HttpWebRequest) WebRequest.Create ("http://go-mono.com");
+ req.Host = null;
+ }
+
+ [Test]
+ public void NoHost ()
+ {
+ HttpWebRequest req = (HttpWebRequest) WebRequest.Create ("http://go-mono.com");
+ Assert.AreEqual (req.Host, "go-mono.com");
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentException))]
+ public void EmptyHost ()
+ {
+ HttpWebRequest req = (HttpWebRequest) WebRequest.Create ("http://go-mono.com");
+ req.Host = "";
+ }
+
+ [Test]
+ public void HostAndPort ()
+ {
+ HttpWebRequest req = (HttpWebRequest) WebRequest.Create ("http://go-mono.com:80");
+ Assert.AreEqual ("go-mono.com", req.Host, "#01");
+ req = (HttpWebRequest) WebRequest.Create ("http://go-mono.com:9000");
+ Assert.AreEqual ("go-mono.com:9000", req.Host, "#02");
+ }
+
+ [Test]
+ public void PortRange ()
+ {
+ for (int i = 0; i < 65536; i++) {
+ if (i == 80)
+ continue;
+ string s = i.ToString ();
+ HttpWebRequest req = (HttpWebRequest) WebRequest.Create ("http://go-mono.com:" + s);
+ Assert.AreEqual ("go-mono.com:" + s, req.Host, "#" + s);
+ }
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentException))]
+ public void PortBelow ()
+ {
+ HttpWebRequest req = (HttpWebRequest) WebRequest.Create ("http://go-mono.com");
+ req.Host = "go-mono.com:-1";
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentException))]
+ public void PortAbove ()
+ {
+ HttpWebRequest req = (HttpWebRequest) WebRequest.Create ("http://go-mono.com");
+ req.Host = "go-mono.com:65536";
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentException))]
+ public void HostTooLong ()
+ {
+ HttpWebRequest req = (HttpWebRequest) WebRequest.Create ("http://go-mono.com");
+ string s = new string ('a', 100);
+ req.Host = s + "." + s + "." + s + "." + s + "." + s + "." + s; // Over 255 bytes
+ }
+
+ [Test]
+ [Category ("NotWorking")] // #5490
+ public void InvalidNamesThatWork ()
+ {
+ HttpWebRequest req = (HttpWebRequest) WebRequest.Create ("http://go-mono.com");
+ req.Host = "-";
+ req.Host = "-.-";
+ req.Host = "á";
+ req.Host = new string ('a', 64); // Should fail. Max. is 63.
+ }
+
+ [Test]
+ public void NoDate ()
+ {
+ HttpWebRequest req = (HttpWebRequest) WebRequest.Create ("http://go-mono.com");
+ Assert.AreEqual (DateTime.MinValue, req.Date);
+ }
+
+ [Test]
+ public void UtcDate ()
+ {
+ HttpWebRequest req = (HttpWebRequest) WebRequest.Create ("http://go-mono.com");
+ req.Date = DateTime.UtcNow;
+ DateTime date = req.Date;
+ Assert.AreEqual (DateTimeKind.Local, date.Kind);
+ }
+
+ [Test]
+ public void AddAndRemoveDate ()
+ {
+ // Neil Armstrong set his foot on Moon
+ var landing = new DateTime (1969, 7, 21, 2, 56, 0, DateTimeKind.Utc);
+ Assert.AreEqual (621214377600000000, landing.Ticks);
+ var unspecified = new DateTime (1969, 7, 21, 2, 56, 0);
+ var local = landing.ToLocalTime ();
+
+ var req = (HttpWebRequest)WebRequest.Create ("http://www.mono-project.com/");
+ req.Date = landing;
+ Assert.AreEqual (DateTimeKind.Local, req.Date.Kind);
+ Assert.AreEqual (local.Ticks, req.Date.Ticks);
+ Assert.AreEqual (local, req.Date);
+
+ req.Date = unspecified;
+ Assert.AreEqual (DateTimeKind.Local, req.Date.Kind);
+ Assert.AreEqual (unspecified.Ticks, req.Date.Ticks);
+ Assert.AreEqual (unspecified, req.Date);
+
+ req.Date = local;
+ Assert.AreEqual (DateTimeKind.Local, req.Date.Kind);
+ Assert.AreEqual (local.Ticks, req.Date.Ticks);
+ Assert.AreEqual (local, req.Date);
+
+ req.Date = DateTime.MinValue;
+ Assert.AreEqual (DateTimeKind.Unspecified, DateTime.MinValue.Kind);
+ Assert.AreEqual (DateTimeKind.Unspecified, req.Date.Kind);
+ Assert.AreEqual (0, req.Date.Ticks);
+ }
+#endif
+ class ListenerScope : IDisposable {
+ EventWaitHandle completed;
+ public HttpListener listener;
+ Action<HttpListenerContext> processor;
+
+ public ListenerScope (Action<HttpListenerContext> processor, int port, EventWaitHandle completed)
+ {
+ this.processor = processor;
+ this.completed = completed;
+
+ this.listener = new HttpListener ();
+ this.listener.Prefixes.Add (string.Format ("http://localhost:{0}/", port));
+ this.listener.AuthenticationSchemes = AuthenticationSchemes.Anonymous;
+ this.listener.Start ();
+
+ this.listener.BeginGetContext (this.RequestHandler, null);
+ }
+
+ void RequestHandler (IAsyncResult result)
+ {
+ HttpListenerContext context = null;
+
+ try {
+ context = this.listener.EndGetContext (result);
+ } catch (HttpListenerException ex) {
+ // check if the thread has been aborted as in the case when we are shutting down.
+ if (ex.ErrorCode == 995)
+ return;
+ } catch (ObjectDisposedException) {
+ return;
+ }
+
+ ThreadPool.QueueUserWorkItem ((o) =>
+ {
+ try {
+ this.processor (context);
+ } catch (HttpListenerException) {
+ }
+ });
+
+ this.completed.Set ();
+ }
+
+ public void Dispose ()
+ {
+ this.listener.Stop ();
+ }
+ }
+
+#if !TARGET_JVM
+ class SslHttpServer : HttpServer {
+ X509Certificate _certificate;
+
+ protected override void Run ()
+ {
+ try {
+ Socket client = sock.Accept ();
+ NetworkStream ns = new NetworkStream (client, true);
+ SslServerStream s = new SslServerStream (ns, Certificate, false, false);
+ s.PrivateKeyCertSelectionDelegate += new PrivateKeySelectionCallback (GetPrivateKey);
+
+ StreamReader reader = new StreamReader (s);
+ StreamWriter writer = new StreamWriter (s, Encoding.ASCII);
+
+ string line;
+ string hello = "<html><body><h1>Hello World!</h1></body></html>";
+ string answer = "HTTP/1.0 200\r\n" +
+ "Connection: close\r\n" +
+ "Content-Type: text/html\r\n" +
+ "Content-Encoding: " + Encoding.ASCII.WebName + "\r\n" +
+ "Content-Length: " + hello.Length + "\r\n" +
+ "\r\n" + hello;
+
+ // Read the headers
+ do {
+ line = reader.ReadLine ();
+ } while (line != "" && line != null && line.Length > 0);
+
+ // Now the content. We know it's 100 bytes.
+ // This makes BeginRead in sslclientstream block.
+ char [] cs = new char [100];
+ reader.Read (cs, 0, 100);
+
+ writer.Write (answer);
+ writer.Flush ();
+ if (evt.WaitOne (5000, false))
+ error = new Exception ("Timeout when stopping the server");
+ } catch (Exception e) {
+ error = e;
+ }
+ }
+
+ X509Certificate Certificate {
+ get {
+ if (_certificate == null)
+ _certificate = new X509Certificate (CertData.Certificate);
+
+ return _certificate;
+ }
+ }
+
+ AsymmetricAlgorithm GetPrivateKey (X509Certificate certificate, string targetHost)
+ {
+ PrivateKey key = new PrivateKey (CertData.PrivateKey, null);
+ return key.RSA;
+ }
+ }
+
+ class CertData {
+ public readonly static byte [] Certificate = {
+ 48, 130, 1, 191, 48, 130, 1, 40, 160, 3, 2, 1, 2, 2, 16, 36,
+ 14, 97, 190, 146, 132, 208, 71, 175, 6, 87, 168, 185, 175, 55, 43, 48,
+ 13, 6, 9, 42, 134, 72, 134, 247, 13, 1, 1, 4, 5, 0, 48, 18,
+ 49, 16, 48, 14, 6, 3, 85, 4, 3, 19, 7, 103, 111, 110, 122, 97,
+ 108, 111, 48, 30, 23, 13, 48, 53, 48, 54, 50, 50, 49, 57, 51, 48,
+ 52, 54, 90, 23, 13, 51, 57, 49, 50, 51, 49, 50, 51, 53, 57, 53,
+ 57, 90, 48, 18, 49, 16, 48, 14, 6, 3, 85, 4, 3, 19, 7, 103,
+ 111, 110, 122, 97, 108, 111, 48, 129, 158, 48, 13, 6, 9, 42, 134, 72,
+ 134, 247, 13, 1, 1, 1, 5, 0, 3, 129, 140, 0, 48, 129, 136, 2,
+ 129, 129, 0, 138, 9, 38, 25, 166, 252, 59, 26, 39, 184, 128, 216, 38,
+ 73, 41, 86, 30, 228, 160, 205, 41, 135, 115, 223, 44, 62, 42, 198, 178,
+ 190, 81, 11, 25, 21, 216, 49, 179, 130, 246, 52, 97, 175, 212, 94, 157,
231, 162, 66, 161, 103, 63, 204, 83, 141, 172, 119, 97, 225, 206, 98, 101,
210, 106, 2, 206, 81, 90, 173, 47, 41, 199, 209, 241, 177, 177, 96, 207,
254, 220, 190, 66, 180, 153, 0, 209, 14, 178, 69, 194, 3, 37, 116, 239,
}
#endif
}
+
+ [TestFixture]
+ public class HttpRequestStreamTest
+ {
+ [Test]
+ public void BeginRead ()
+ {
+ IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 9124);
+ string url = "http://" + ep.ToString () + "/test/";
+
+ using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (HttpWebRequestTest.EchoRequestHandler))) {
+ responder.Start ();
+
+ HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
+ req.Method = "POST";
+
+ using (Stream rs = req.GetRequestStream ()) {
+ byte [] buffer = new byte [10];
+ try {
+ rs.BeginRead (buffer, 0, buffer.Length, null, null);
+ Assert.Fail ("#1");
+ } catch (NotSupportedException ex) {
+ // The stream does not support reading
+ Assert.AreEqual (typeof (NotSupportedException), ex.GetType (), "#2");
+ Assert.IsNull (ex.InnerException, "#3");
+ Assert.IsNotNull (ex.Message, "#4");
+ } finally {
+ req.Abort ();
+ }
+ }
+ }
+ }
+
+ [Test]
+ public void BeginWrite_Request_Aborted ()
+ {
+ IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 9125);
+ string url = "http://" + ep.ToString () + "/test/";
+
+ using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (HttpWebRequestTest.EchoRequestHandler))) {
+ responder.Start ();
+
+ HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
+ req.Method = "POST";
+
+ using (Stream rs = req.GetRequestStream ()) {
+ req.Abort ();
+ try {
+ rs.BeginWrite (new byte [] { 0x2a, 0x2f }, 0, 2, null, null);
+ Assert.Fail ("#1");
+ } catch (WebException ex) {
+ // The request was aborted: The request was canceled
+ Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
+ Assert.IsNull (ex.InnerException, "#3");
+ Assert.IsNotNull (ex.Message, "#4");
+ Assert.IsNull (ex.Response, "#5");
+ Assert.AreEqual (WebExceptionStatus.RequestCanceled, ex.Status, "#6");
+ }
+ }
+ }
+ }
+
+ [Test]
+ public void CanRead ()
+ {
+ IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 9126);
+ string url = "http://" + ep.ToString () + "/test/";
+
+ using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (HttpWebRequestTest.EchoRequestHandler))) {
+ responder.Start ();
+
+ HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
+ req.Method = "POST";
+
+ Stream rs = req.GetRequestStream ();
+ try {
+ Assert.IsFalse (rs.CanRead, "#1");
+ rs.Close ();
+ Assert.IsFalse (rs.CanRead, "#2");
+ } finally {
+ rs.Close ();
+ req.Abort ();
+ }
+ }
+ }
+
+ [Test]
+ public void CanSeek ()
+ {
+ IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 9127);
+ string url = "http://" + ep.ToString () + "/test/";
+
+ using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (HttpWebRequestTest.EchoRequestHandler))) {
+ responder.Start ();
+
+ HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
+ req.Method = "POST";
+
+ Stream rs = req.GetRequestStream ();
+ try {
+ Assert.IsFalse (rs.CanSeek, "#1");
+ rs.Close ();
+ Assert.IsFalse (rs.CanSeek, "#2");
+ } finally {
+ rs.Close ();
+ req.Abort ();
+ }
+ }
+ }
+
+ [Test] // bug #324182
+#if TARGET_JVM
+ [Category ("NotWorking")]
+#endif
+ public void CanTimeout ()
+ {
+ IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 9128);
+ string url = "http://" + ep.ToString () + "/test/";
+
+ using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (HttpWebRequestTest.EchoRequestHandler))) {
+ responder.Start ();
+
+ HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
+ req.Method = "POST";
+
+ Stream rs = req.GetRequestStream ();
+ try {
+ Assert.IsTrue (rs.CanTimeout, "#1");
+ rs.Close ();
+ Assert.IsTrue (rs.CanTimeout, "#2");
+ } finally {
+ rs.Close ();
+ req.Abort ();
+ }
+ }
+ }
+
+ [Test]
+ public void CanWrite ()
+ {
+ IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 9129);
+ string url = "http://" + ep.ToString () + "/test/";
+
+ using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (HttpWebRequestTest.EchoRequestHandler))) {
+ responder.Start ();
+
+ HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
+ req.Method = "POST";
+
+ Stream rs = req.GetRequestStream ();
+ try {
+ Assert.IsTrue (rs.CanWrite, "#1");
+ rs.Close ();
+ Assert.IsFalse (rs.CanWrite, "#2");
+ } finally {
+ rs.Close ();
+ req.Abort ();
+ }
+ }
+ }
+
+ [Test]
+ public void Read ()
+ {
+ IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 9130);
+ string url = "http://" + ep.ToString () + "/test/";
+
+ using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (HttpWebRequestTest.EchoRequestHandler))) {
+ responder.Start ();
+
+ HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
+ req.Method = "POST";
+
+ using (Stream rs = req.GetRequestStream ()) {
+ byte [] buffer = new byte [10];
+ try {
+ rs.Read (buffer, 0, buffer.Length);
+ Assert.Fail ("#1");
+ } catch (NotSupportedException ex) {
+ // The stream does not support reading
+ Assert.AreEqual (typeof (NotSupportedException), ex.GetType (), "#2");
+ Assert.IsNull (ex.InnerException, "#3");
+ Assert.IsNotNull (ex.Message, "#4");
+ } finally {
+ req.Abort ();
+ }
+ }
+ }
+ }
+
+ [Test]
+ public void ReadByte ()
+ {
+ IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 9140);
+ string url = "http://" + ep.ToString () + "/test/";
+
+ using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (HttpWebRequestTest.EchoRequestHandler))) {
+ responder.Start ();
+
+ HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
+ req.Method = "POST";
+
+ using (Stream rs = req.GetRequestStream ()) {
+ try {
+ rs.ReadByte ();
+ Assert.Fail ("#1");
+ } catch (NotSupportedException ex) {
+ // The stream does not support reading
+ Assert.AreEqual (typeof (NotSupportedException), ex.GetType (), "#2");
+ Assert.IsNull (ex.InnerException, "#3");
+ Assert.IsNotNull (ex.Message, "#4");
+ } finally {
+ req.Abort ();
+ }
+ }
+ }
+ }
+
+ [Test]
+ public void ReadTimeout ()
+ {
+ IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 9141);
+ string url = "http://" + ep.ToString () + "/test/";
+
+ using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (HttpWebRequestTest.EchoRequestHandler))) {
+ responder.Start ();
+
+ HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
+ req.Method = "POST";
+
+ Stream rs = req.GetRequestStream ();
+ try {
+ Assert.AreEqual (300000, rs.ReadTimeout, "#1");
+ rs.Close ();
+ Assert.AreEqual (300000, rs.ReadTimeout, "#2");
+ } finally {
+ rs.Close ();
+ req.Abort ();
+ }
+ }
+ }
+
+ [Test]
+ public void Seek ()
+ {
+ IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 9142);
+ string url = "http://" + ep.ToString () + "/test/";
+
+ using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (HttpWebRequestTest.EchoRequestHandler))) {
+ responder.Start ();
+
+ HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
+ req.Method = "POST";
+
+ using (Stream rs = req.GetRequestStream ()) {
+ try {
+ rs.Seek (0, SeekOrigin.Current);
+ Assert.Fail ("#1");
+ } catch (NotSupportedException ex) {
+ // This stream does not support seek operations
+ Assert.AreEqual (typeof (NotSupportedException), ex.GetType (), "#2");
+ Assert.IsNull (ex.InnerException, "#3");
+ Assert.IsNotNull (ex.Message, "#4");
+ } finally {
+ req.Abort ();
+ }
+ }
+ }
+ }
+
+ [Test]
+ public void Write_Buffer_Null ()
+ {
+ IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 9143);
+ string url = "http://" + ep.ToString () + "/test/";
+
+ using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (HttpWebRequestTest.EchoRequestHandler))) {
+ responder.Start ();
+
+ HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
+ req.Method = "POST";
+
+ using (Stream rs = req.GetRequestStream ()) {
+ try {
+ rs.Write ((byte []) null, -1, -1);
+ Assert.Fail ("#1");
+ } catch (ArgumentNullException ex) {
+ Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
+ Assert.IsNull (ex.InnerException, "#3");
+ Assert.IsNotNull (ex.Message, "#4");
+ Assert.AreEqual ("buffer", ex.ParamName, "#5");
+ }
+ }
+
+ req.Abort ();
+ }
+ }
+
+ [Test]
+ public void Write_Count_Negative ()
+ {
+ IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 9144);
+ string url = "http://" + ep.ToString () + "/test/";
+
+ using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (HttpWebRequestTest.EchoRequestHandler))) {
+ responder.Start ();
+
+ HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
+ req.Method = "POST";
+
+ using (Stream rs = req.GetRequestStream ()) {
+ byte [] buffer = new byte [] { 0x2a, 0x2c, 0x1d, 0x00, 0x0f };
+ try {
+ rs.Write (buffer, 1, -1);
+ Assert.Fail ("#1");
+ } catch (ArgumentOutOfRangeException ex) {
+ // Specified argument was out of the range of valid values
+ Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#A2");
+ Assert.IsNull (ex.InnerException, "#A3");
+ Assert.IsNotNull (ex.Message, "#A4");
+ Assert.AreEqual ("size", ex.ParamName, "#A5");
+ }
+ }
+
+ req.Abort ();
+ }
+ }
+
+ [Test]
+ public void Write_Count_Overflow ()
+ {
+ IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 9145);
+ string url = "http://" + ep.ToString () + "/test/";
+
+ using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (HttpWebRequestTest.EchoRequestHandler))) {
+ responder.Start ();
+
+ HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
+ req.Method = "POST";
+
+ using (Stream rs = req.GetRequestStream ()) {
+ byte [] buffer = new byte [] { 0x2a, 0x2c, 0x1d, 0x00, 0x0f };
+ try {
+ rs.Write (buffer, buffer.Length - 2, 3);
+ Assert.Fail ("#1");
+ } catch (ArgumentOutOfRangeException ex) {
+ // Specified argument was out of the range of valid values
+ Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
+ Assert.IsNull (ex.InnerException, "#3");
+ Assert.IsNotNull (ex.Message, "#4");
+ Assert.AreEqual ("size", ex.ParamName, "#5");
+ }
+ }
+
+ req.Abort ();
+ }
+ }
+
+ [Test]
+ public void Write_Offset_Negative ()
+ {
+ IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 9146);
+ string url = "http://" + ep.ToString () + "/test/";
+
+ using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (HttpWebRequestTest.EchoRequestHandler))) {
+ responder.Start ();
+
+ HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
+ req.Method = "POST";
+
+ using (Stream rs = req.GetRequestStream ()) {
+ byte [] buffer = new byte [] { 0x2a, 0x2c, 0x1d, 0x00, 0x0f };
+ try {
+ rs.Write (buffer, -1, 0);
+ Assert.Fail ("#1");
+ } catch (ArgumentOutOfRangeException ex) {
+ // Specified argument was out of the range of valid values
+ Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
+ Assert.IsNull (ex.InnerException, "#3");
+ Assert.IsNotNull (ex.Message, "#4");
+ Assert.AreEqual ("offset", ex.ParamName, "#5");
+ }
+ }
+
+ req.Abort ();
+ }
+ }
+
+ [Test]
+ public void Write_Offset_Overflow ()
+ {
+ IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 9147);
+ string url = "http://" + ep.ToString () + "/test/";
+
+ using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (HttpWebRequestTest.EchoRequestHandler))) {
+ responder.Start ();
+
+ HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
+ req.Method = "POST";
+
+ using (Stream rs = req.GetRequestStream ()) {
+ byte [] buffer = new byte [] { 0x2a, 0x2c, 0x1d, 0x00, 0x0f };
+ try {
+ rs.Write (buffer, buffer.Length + 1, 0);
+ Assert.Fail ("#1");
+ } catch (ArgumentOutOfRangeException ex) {
+ // Specified argument was out of the range of valid values
+ Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
+ Assert.IsNull (ex.InnerException, "#3");
+ Assert.IsNotNull (ex.Message, "#4");
+ Assert.AreEqual ("offset", ex.ParamName, "#5");
+ }
+ }
+
+ req.Abort ();
+ }
+ }
+
+ [Test]
+ public void Write_Request_Aborted ()
+ {
+ IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 9148);
+ string url = "http://" + ep.ToString () + "/test/";
+
+ using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (HttpWebRequestTest.EchoRequestHandler))) {
+ responder.Start ();
+
+ HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
+ req.Method = "POST";
+
+ using (Stream rs = req.GetRequestStream ()) {
+ req.Abort ();
+ try {
+ rs.Write (new byte [0], 0, 0);
+ Assert.Fail ("#1");
+ } catch (WebException ex) {
+ // The request was aborted: The request was canceled
+ Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
+ Assert.IsNull (ex.InnerException, "#3");
+ Assert.IsNotNull (ex.Message, "#4");
+ Assert.IsNull (ex.Response, "#5");
+ Assert.AreEqual (WebExceptionStatus.RequestCanceled, ex.Status, "#6");
+ }
+ }
+ }
+ }
+
+ [Test]
+ [Category ("NotWorking")]
+ public void Write_Stream_Closed ()
+ {
+ IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 9149);
+ string url = "http://" + ep.ToString () + "/test/";
+
+ using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (HttpWebRequestTest.EchoRequestHandler))) {
+ responder.Start ();
+
+ HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
+ req.Method = "POST";
+
+ using (Stream rs = req.GetRequestStream ()) {
+ rs.Close ();
+ try {
+ rs.Write (new byte [0], 0, 0);
+ Assert.Fail ("#1");
+ } catch (WebException ex) {
+ // The request was aborted: The connection was closed unexpectedly
+ Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
+ Assert.IsNull (ex.InnerException, "#3");
+ Assert.IsNotNull (ex.Message, "#4");
+ Assert.IsNull (ex.Response, "#5");
+ Assert.AreEqual (WebExceptionStatus.ConnectionClosed, ex.Status, "#6");
+ }
+ }
+ }
+ }
+
+ [Test]
+ public void WriteByte_Request_Aborted ()
+ {
+ IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 9150);
+ string url = "http://" + ep.ToString () + "/test/";
+
+ using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (HttpWebRequestTest.EchoRequestHandler))) {
+ responder.Start ();
+
+ HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
+ req.Method = "POST";
+
+ using (Stream rs = req.GetRequestStream ()) {
+ req.Abort ();
+ try {
+ rs.WriteByte (0x2a);
+ Assert.Fail ("#1");
+ } catch (WebException ex) {
+ // The request was aborted: The request was canceled
+ Assert.AreEqual (typeof (WebException), ex.GetType (), "#2");
+ Assert.IsNull (ex.InnerException, "#3");
+ Assert.IsNotNull (ex.Message, "#4");
+ Assert.IsNull (ex.Response, "#5");
+ Assert.AreEqual (WebExceptionStatus.RequestCanceled, ex.Status, "#6");
+ }
+ }
+ }
+ }
+
+ [Test]
+ public void WriteTimeout ()
+ {
+ IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 9151);
+ string url = "http://" + ep.ToString () + "/test/";
+
+ using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (HttpWebRequestTest.EchoRequestHandler))) {
+ responder.Start ();
+
+ HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url);
+ req.Method = "POST";
+
+ Stream rs = req.GetRequestStream ();
+ try {
+ Assert.AreEqual (300000, rs.WriteTimeout, "#1");
+ rs.Close ();
+ Assert.AreEqual (300000, rs.WriteTimeout, "#2");
+ } finally {
+ rs.Close ();
+ req.Abort ();
+ }
+ }
+ }
+ }
+
+ static class StreamExtensions {
+ public static int ReadAll(this Stream stream, byte[] buffer, int offset, int count)
+ {
+ int totalRead = 0;
+
+ while (totalRead < count) {
+ int bytesRead = stream.Read (buffer, offset + totalRead, count - totalRead);
+ if (bytesRead == 0)
+ break;
+
+ totalRead += bytesRead;
+ }
+
+ return totalRead;
+ }
+ }
+
+ static class ExceptionAssert {
+ /// <summary>
+ /// Asserts that the function throws an exception.
+ /// </summary>
+ /// <param name="f">A function execute that is expected to raise an exception.</param>
+ /// <typeparam name="T">The type of exception that is expected.</typeparam>
+ /// <returns>The exception thrown.</returns>
+ /// <exception cref="AssertFailedException">If the function does not throw an exception
+ /// or throws a different exception.</exception>
+ /// <example><![CDATA[
+ /// ExceptionAssert.Throws(typeof(ArgumentNullException), delegate {
+ /// myObject.myFunction(null); });
+ /// ]]></example>
+ public static T Throws<T> (Action f) where T : Exception {
+ Exception actualException = null;
+
+ try {
+ f ();
+ } catch (Exception ex) {
+ actualException = ex;
+ }
+
+ if (actualException == null)
+ throw new AssertionException (string.Format (
+ "No exception thrown. Expected '{0}'",
+ typeof (T).FullName));
+ else if (typeof(T) != actualException.GetType())
+ throw new AssertionException (string.Format (
+ "Caught exception of type '{0}'. Expected '{1}':{2}",
+ actualException.GetType().FullName,
+ typeof (T).FullName,
+ Environment.NewLine + actualException));
+
+ return (T) actualException;
+ }
+ }
}
projects / mono.git / blobdiff