using System.Linq;
using System.IO;
+using MonoTests.Helpers;
+
namespace MonoTests.System.Net.Http
{
[TestFixture]
}
}
- const int WaitTimeout = 5000;
+ class ThrowOnlyProxy : IWebProxy
+ {
+ public ICredentials Credentials {
+ get {
+ throw new NotImplementedException ();
+ }
- string TestHost, LocalServer;
- int port;
+ set {
+ throw new NotImplementedException ();
+ }
+ }
- [SetUp]
- public void SetupFixture ()
- {
- if (Environment.OSVersion.Platform == PlatformID.Win32NT) {
- port = 810;
- } else {
- port = 8810;
+ public Uri GetProxy (Uri destination)
+ {
+ throw new NotImplementedException ();
}
- TestHost = "localhost:" + port;
- LocalServer = string.Format ("http://{0}/", TestHost);
+ public bool IsBypassed (Uri host)
+ {
+ throw new NotImplementedException ();
+ }
}
+ const int WaitTimeout = 5000;
+
[Test]
public void Ctor_Default ()
{
[Test]
+#if FEATURE_NO_BSD_SOCKETS
+ // Using HttpClientHandler, which indirectly requires BSD sockets.
+ [ExpectedException (typeof (PlatformNotSupportedException))]
+#endif
public void CancelRequestViaProxy ()
{
var handler = new HttpClientHandler {
Assert.Fail ("#2");
} catch (ArgumentOutOfRangeException) {
}
+
+ try {
+ client.Timeout = TimeSpan.Zero;
+ Assert.Fail ("#3");
+ } catch (ArgumentOutOfRangeException) {
+ }
+
+ try {
+ client.Timeout = TimeSpan.FromMilliseconds (int.MaxValue + 1L);
+ Assert.Fail ("#3");
+ } catch (ArgumentOutOfRangeException) {
+ }
+ }
+
+ [Test]
+#if FEATURE_NO_BSD_SOCKETS
+ [ExpectedException (typeof (PlatformNotSupportedException))]
+#endif
+ public void Proxy_Disabled ()
+ {
+ var pp = WebRequest.DefaultWebProxy;
+
+ try {
+ WebRequest.DefaultWebProxy = new ThrowOnlyProxy ();
+
+ var request = new HttpClientHandler {
+ UseProxy = false
+ };
+
+ var client = new HttpClient (request);
+ Assert.IsTrue (client.GetAsync ("http://google.com").Wait (5000), "needs internet access");
+ } finally {
+ WebRequest.DefaultWebProxy = pp;
+ }
}
[Test]
}
[Test]
+#if FEATURE_NO_BSD_SOCKETS
+ [ExpectedException (typeof (PlatformNotSupportedException))]
+#endif
public void Send_Complete_Default ()
{
bool? failed = null;
+ var port = NetworkHelpers.FindFreePort ();
var listener = CreateListener (l => {
try {
var request = l.Request;
Assert.IsNull (request.ContentType, "#3");
Assert.AreEqual (0, request.Cookies.Count, "#4");
Assert.IsFalse (request.HasEntityBody, "#5");
- Assert.AreEqual (TestHost, request.Headers["Host"], "#6b");
+ Assert.AreEqual ($"localhost:{port}", request.Headers["Host"], "#6b");
Assert.AreEqual ("GET", request.HttpMethod, "#7");
Assert.IsFalse (request.IsAuthenticated, "#8");
Assert.IsTrue (request.IsLocal, "#9");
} catch {
failed = true;
}
- });
+ }, port);
try {
var client = new HttpClient ();
- var request = new HttpRequestMessage (HttpMethod.Get, LocalServer);
+ var request = new HttpRequestMessage (HttpMethod.Get, $"http://localhost:{port}/");
var response = client.SendAsync (request, HttpCompletionOption.ResponseHeadersRead).Result;
Assert.AreEqual ("", response.Content.ReadAsStringAsync ().Result, "#100");
}
[Test]
+#if FEATURE_NO_BSD_SOCKETS
+ [ExpectedException (typeof (PlatformNotSupportedException))]
+#endif
public void Send_Complete_Version_1_0 ()
{
bool? failed = null;
+ var port = NetworkHelpers.FindFreePort ();
var listener = CreateListener (l => {
try {
var request = l.Request;
Assert.AreEqual (0, request.Cookies.Count, "#4");
Assert.IsFalse (request.HasEntityBody, "#5");
Assert.AreEqual (1, request.Headers.Count, "#6");
- Assert.AreEqual (TestHost, request.Headers["Host"], "#6a");
+ Assert.AreEqual ($"localhost:{port}", request.Headers["Host"], "#6a");
Assert.AreEqual ("GET", request.HttpMethod, "#7");
Assert.IsFalse (request.IsAuthenticated, "#8");
Assert.IsTrue (request.IsLocal, "#9");
} catch {
failed = true;
}
- });
+ }, port);
try {
var client = new HttpClient ();
- var request = new HttpRequestMessage (HttpMethod.Get, LocalServer);
+ var request = new HttpRequestMessage (HttpMethod.Get, $"http://localhost:{port}/");
request.Version = HttpVersion.Version10;
var response = client.SendAsync (request, HttpCompletionOption.ResponseHeadersRead).Result;
}
[Test]
+#if FEATURE_NO_BSD_SOCKETS
+ [ExpectedException (typeof (PlatformNotSupportedException))]
+#endif
public void Send_Complete_ClientHandlerSettings ()
{
bool? failed = null;
+ var port = NetworkHelpers.FindFreePort ();
var listener = CreateListener (l => {
var request = l.Request;
Assert.AreEqual (new Cookie ("mycookie", "vv"), request.Cookies[0], "#4a");
Assert.IsFalse (request.HasEntityBody, "#5");
Assert.AreEqual (4, request.Headers.Count, "#6");
- Assert.AreEqual (TestHost, request.Headers["Host"], "#6a");
+ Assert.AreEqual ($"localhost:{port}", request.Headers["Host"], "#6a");
Assert.AreEqual ("gzip", request.Headers["Accept-Encoding"], "#6b");
Assert.AreEqual ("mycookie=vv", request.Headers["Cookie"], "#6c");
Assert.AreEqual ("GET", request.HttpMethod, "#7");
} catch {
failed = true;
}
- });
+ }, port);
try {
var chandler = new HttpClientHandler ();
chandler.MaxAutomaticRedirections = 33;
chandler.MaxRequestContentBufferSize = 5555;
chandler.PreAuthenticate = true;
- chandler.CookieContainer.Add (new Uri (LocalServer), new Cookie ( "mycookie", "vv"));
+ chandler.CookieContainer.Add (new Uri ($"http://localhost:{port}/"), new Cookie ( "mycookie", "vv"));
chandler.UseCookies = true;
chandler.UseDefaultCredentials = true;
chandler.Proxy = new WebProxy ("ee");
chandler.UseProxy = true;
var client = new HttpClient (chandler);
- var request = new HttpRequestMessage (HttpMethod.Get, LocalServer);
+ var request = new HttpRequestMessage (HttpMethod.Get, $"http://localhost:{port}/");
request.Version = HttpVersion.Version10;
request.Headers.Add ("Keep-Alive", "false");
var response = client.SendAsync (request, HttpCompletionOption.ResponseHeadersRead).Result;
}
[Test]
+#if FEATURE_NO_BSD_SOCKETS
+ [ExpectedException (typeof (PlatformNotSupportedException))]
+#endif
public void Send_Complete_CustomHeaders ()
{
bool? failed = null;
+ var port = NetworkHelpers.FindFreePort ();
var listener = CreateListener (l => {
var request = l.Request;
try {
} catch {
failed = true;
}
- });
+ }, port);
try {
var client = new HttpClient ();
- var request = new HttpRequestMessage (HttpMethod.Get, LocalServer);
+ var request = new HttpRequestMessage (HttpMethod.Get, $"http://localhost:{port}/");
Assert.IsTrue (request.Headers.TryAddWithoutValidation ("aa", "vv"), "#0");
var response = client.SendAsync (request, HttpCompletionOption.ResponseHeadersRead).Result;
}
[Test]
+#if FEATURE_NO_BSD_SOCKETS
+ [ExpectedException (typeof (PlatformNotSupportedException))]
+#endif
public void Send_Complete_CustomHeaders_SpecialSeparators ()
{
bool? failed = null;
+ var port = NetworkHelpers.FindFreePort ();
var listener = CreateListener (l => {
var request = l.Request;
} catch {
failed = true;
}
- });
+ }, port);
try {
var client = new HttpClient ();
client.DefaultRequestHeaders.Add("User-Agent", "MLK Android Phone 1.1.9");
- var request = new HttpRequestMessage (HttpMethod.Get, LocalServer);
+ var request = new HttpRequestMessage (HttpMethod.Get, $"http://localhost:{port}/");
var response = client.SendAsync (request, HttpCompletionOption.ResponseHeadersRead).Result;
}
[Test]
+#if FEATURE_NO_BSD_SOCKETS
+ [ExpectedException (typeof (PlatformNotSupportedException))]
+#endif
public void Send_Complete_CustomHeaders_Host ()
{
bool? failed = null;
+ var port = NetworkHelpers.FindFreePort ();
var listener = CreateListener (l => {
var request = l.Request;
} catch {
failed = true;
}
- });
+ }, port);
try {
var client = new HttpClient ();
client.DefaultRequestHeaders.Add("Host", "customhost");
- var request = new HttpRequestMessage (HttpMethod.Get, LocalServer);
+ var request = new HttpRequestMessage (HttpMethod.Get, $"http://localhost:{port}/");
var response = client.SendAsync (request, HttpCompletionOption.ResponseHeadersRead).Result;
}
[Test]
+#if FEATURE_NO_BSD_SOCKETS
+ [ExpectedException (typeof (PlatformNotSupportedException))]
+#endif
public void Send_Transfer_Encoding_Chunked ()
{
bool? failed = null;
+ var port = NetworkHelpers.FindFreePort ();
var listener = CreateListener (l => {
var request = l.Request;
try {
- Assert.AreEqual (1, request.Headers.Count, "#1");
+ Assert.AreEqual (2, request.Headers.Count, "#1");
+ Assert.AreEqual ("keep-alive", request.Headers ["Connection"], "#2");
failed = false;
- } catch {
+ } catch (Exception ex){
+ Console.WriteLine (ex);
+ Console.WriteLine (String.Join ("#", l.Request.Headers.AllKeys));
failed = true;
}
- });
+ }, port);
try {
var client = new HttpClient ();
client.DefaultRequestHeaders.TransferEncodingChunked = true;
- client.GetAsync (LocalServer).Wait ();
+ client.GetAsync ($"http://localhost:{port}/").Wait ();
Assert.AreEqual (false, failed, "#102");
} finally {
}
[Test]
+#if FEATURE_NO_BSD_SOCKETS
+ [ExpectedException (typeof (PlatformNotSupportedException))]
+#endif
public void Send_Transfer_Encoding_Custom ()
{
bool? failed = null;
+ var port = NetworkHelpers.FindFreePort ();
var listener = CreateListener (l => {
failed = true;
- });
+ }, port);
try {
var client = new HttpClient ();
client.DefaultRequestHeaders.TransferEncoding.Add (new TransferCodingHeaderValue ("chunked2"));
- var request = new HttpRequestMessage (HttpMethod.Get, LocalServer);
+ var request = new HttpRequestMessage (HttpMethod.Get, $"http://localhost:{port}/");
try {
client.SendAsync (request, HttpCompletionOption.ResponseHeadersRead).Wait ();
}
[Test]
+#if FEATURE_NO_BSD_SOCKETS
+ [ExpectedException (typeof (PlatformNotSupportedException))]
+#endif
public void Send_Complete_Content ()
{
+ var port = NetworkHelpers.FindFreePort ();
var listener = CreateListener (l => {
var request = l.Request;
l.Response.OutputStream.WriteByte (55);
l.Response.OutputStream.WriteByte (75);
- });
+ }, port);
try {
var client = new HttpClient ();
- var request = new HttpRequestMessage (HttpMethod.Get, LocalServer);
+ var request = new HttpRequestMessage (HttpMethod.Get, $"http://localhost:{port}/");
Assert.IsTrue (request.Headers.TryAddWithoutValidation ("aa", "vv"), "#0");
var response = client.SendAsync (request, HttpCompletionOption.ResponseHeadersRead).Result;
}
[Test]
+#if FEATURE_NO_BSD_SOCKETS
+ [ExpectedException (typeof (PlatformNotSupportedException))]
+#endif
public void Send_Complete_Content_MaxResponseContentBufferSize ()
{
+ var port = NetworkHelpers.FindFreePort ();
var listener = CreateListener (l => {
var request = l.Request;
var b = new byte[4000];
l.Response.OutputStream.Write (b, 0, b.Length);
- });
+ }, port);
try {
var client = new HttpClient ();
client.MaxResponseContentBufferSize = 1000;
- var request = new HttpRequestMessage (HttpMethod.Get, LocalServer);
+ var request = new HttpRequestMessage (HttpMethod.Get, $"http://localhost:{port}/");
var response = client.SendAsync (request, HttpCompletionOption.ResponseHeadersRead).Result;
Assert.AreEqual (4000, response.Content.ReadAsStringAsync ().Result.Length, "#100");
}
[Test]
+#if FEATURE_NO_BSD_SOCKETS
+ [ExpectedException (typeof (PlatformNotSupportedException))]
+#endif
public void Send_Complete_Content_MaxResponseContentBufferSize_Error ()
{
+ var port = NetworkHelpers.FindFreePort ();
var listener = CreateListener (l => {
var request = l.Request;
var b = new byte[4000];
l.Response.OutputStream.Write (b, 0, b.Length);
- });
+ }, port);
try {
var client = new HttpClient ();
client.MaxResponseContentBufferSize = 1000;
- var request = new HttpRequestMessage (HttpMethod.Get, LocalServer);
+ var request = new HttpRequestMessage (HttpMethod.Get, $"http://localhost:{port}/");
try {
client.SendAsync (request, HttpCompletionOption.ResponseContentRead).Wait (WaitTimeout);
}
[Test]
- public void Send_Complete_NoContent ()
+#if FEATURE_NO_BSD_SOCKETS
+ [ExpectedException (typeof (PlatformNotSupportedException))]
+#endif
+ public void Send_Complete_NoContent_Post ()
+ {
+ Send_Complete_NoContent (HttpMethod.Post);
+ }
+
+ [Test]
+#if FEATURE_NO_BSD_SOCKETS
+ [ExpectedException (typeof (PlatformNotSupportedException))]
+#endif
+ public void Send_Complete_NoContent_Put ()
+ {
+ Send_Complete_NoContent (HttpMethod.Put);
+ }
+
+ [Test]
+#if FEATURE_NO_BSD_SOCKETS
+ [ExpectedException (typeof (PlatformNotSupportedException))]
+#endif
+ public void Send_Complete_NoContent_Delete ()
{
- foreach (var method in new HttpMethod[] { HttpMethod.Post, HttpMethod.Put, HttpMethod.Delete }) {
- bool? failed = null;
- var listener = CreateListener (l => {
- try {
- var request = l.Request;
-
- Assert.AreEqual (2, request.Headers.Count, "#1");
- Assert.AreEqual ("0", request.Headers ["Content-Length"], "#1b");
- Assert.AreEqual (method.Method, request.HttpMethod, "#2");
- failed = false;
- } catch {
- failed = true;
- }
- });
+ Send_Complete_NoContent (HttpMethod.Delete);
+ }
+ void Send_Complete_NoContent (HttpMethod method)
+ {
+ bool? failed = null;
+ var port = NetworkHelpers.FindFreePort ();
+ var listener = CreateListener (l => {
try {
- var client = new HttpClient ();
- var request = new HttpRequestMessage (method, LocalServer);
- var response = client.SendAsync (request, HttpCompletionOption.ResponseHeadersRead).Result;
+ var request = l.Request;
- Assert.AreEqual ("", response.Content.ReadAsStringAsync ().Result, "#100");
- Assert.AreEqual (HttpStatusCode.OK, response.StatusCode, "#101");
- Assert.AreEqual (false, failed, "#102");
- } finally {
- listener.Close ();
+ Assert.AreEqual (3, request.Headers.Count, "#1");
+ Assert.AreEqual ("0", request.Headers ["Content-Length"], "#1b");
+ Assert.AreEqual ("keep-alive", request.Headers ["Connection"], "#1c");
+ Assert.AreEqual (method.Method, request.HttpMethod, "#2");
+ failed = false;
+ } catch (Exception ex){
+ Console.WriteLine (ex);
+ Console.WriteLine (String.Join ("#", l.Request.Headers.AllKeys));
+
+ failed = true;
}
+ }, port);
+
+ try {
+ var client = new HttpClient ();
+ var request = new HttpRequestMessage (method, $"http://localhost:{port}/");
+ var response = client.SendAsync (request, HttpCompletionOption.ResponseHeadersRead).Result;
+
+ Assert.AreEqual ("", response.Content.ReadAsStringAsync ().Result, "#100");
+ Assert.AreEqual (HttpStatusCode.OK, response.StatusCode, "#101");
+ Assert.AreEqual (false, failed, "#102");
+ } finally {
+ listener.Close ();
}
}
[Test]
+#if FEATURE_NO_BSD_SOCKETS
+ [ExpectedException (typeof (PlatformNotSupportedException))]
+#endif
public void Send_Complete_Error ()
{
+ var port = NetworkHelpers.FindFreePort ();
var listener = CreateListener (l => {
var response = l.Response;
response.StatusCode = 500;
- });
+ }, port);
try {
var client = new HttpClient ();
- var request = new HttpRequestMessage (HttpMethod.Get, LocalServer);
+ var request = new HttpRequestMessage (HttpMethod.Get, $"http://localhost:{port}/");
var response = client.SendAsync (request, HttpCompletionOption.ResponseHeadersRead).Result;
Assert.AreEqual ("", response.Content.ReadAsStringAsync ().Result, "#100");
}
[Test]
+#if FEATURE_NO_BSD_SOCKETS
+ [ExpectedException (typeof (PlatformNotSupportedException))]
+#endif
public void Send_Content_Get ()
{
+ var port = NetworkHelpers.FindFreePort ();
var listener = CreateListener (l => {
var request = l.Request;
l.Response.OutputStream.WriteByte (72);
- });
+ }, port);
try {
var client = new HttpClient ();
- var r = new HttpRequestMessage (HttpMethod.Get, LocalServer);
+ var r = new HttpRequestMessage (HttpMethod.Get, $"http://localhost:{port}/");
var response = client.SendAsync (r).Result;
Assert.AreEqual ("H", response.Content.ReadAsStringAsync ().Result);
}
[Test]
+#if FEATURE_NO_BSD_SOCKETS
+ [ExpectedException (typeof (PlatformNotSupportedException))]
+#endif
public void Send_Content_BomEncoding ()
{
+ var port = NetworkHelpers.FindFreePort ();
var listener = CreateListener (l => {
var request = l.Request;
str.WriteByte (0xBB);
str.WriteByte (0xBF);
str.WriteByte (71);
- });
+ }, port);
try {
var client = new HttpClient ();
- var r = new HttpRequestMessage (HttpMethod.Get, LocalServer);
+ var r = new HttpRequestMessage (HttpMethod.Get, $"http://localhost:{port}/");
var response = client.SendAsync (r).Result;
Assert.AreEqual ("G", response.Content.ReadAsStringAsync ().Result);
}
[Test]
+#if FEATURE_NO_BSD_SOCKETS
+ [ExpectedException (typeof (PlatformNotSupportedException))]
+#endif
public void Send_Content_Put ()
{
bool passed = false;
+ var port = NetworkHelpers.FindFreePort ();
var listener = CreateListener (l => {
var request = l.Request;
passed = 7 == request.ContentLength64;
passed &= request.ContentType == "text/plain; charset=utf-8";
passed &= request.InputStream.ReadByte () == 'm';
- });
+ }, port);
try {
var client = new HttpClient ();
- var r = new HttpRequestMessage (HttpMethod.Put, LocalServer);
+ var r = new HttpRequestMessage (HttpMethod.Put, $"http://localhost:{port}/");
r.Content = new StringContent ("my text");
var response = client.SendAsync (r).Result;
}
[Test]
+#if FEATURE_NO_BSD_SOCKETS
+ [ExpectedException (typeof (PlatformNotSupportedException))]
+#endif
public void Send_Content_Put_CustomStream ()
{
bool passed = false;
+ var port = NetworkHelpers.FindFreePort ();
var listener = CreateListener (l => {
var request = l.Request;
passed = 44 == request.ContentLength64;
passed &= request.ContentType == null;
- });
+ }, port);
try {
var client = new HttpClient ();
- var r = new HttpRequestMessage (HttpMethod.Put, LocalServer);
+ var r = new HttpRequestMessage (HttpMethod.Put, $"http://localhost:{port}/");
r.Content = new StreamContent (new CustomStream ());
var response = client.SendAsync (r).Result;
}
}
+ [Test]
+#if FEATURE_NO_BSD_SOCKETS
+ [ExpectedException (typeof (PlatformNotSupportedException))]
+#endif
+ public void Post_TransferEncodingChunked ()
+ {
+ bool? failed = null;
+ var port = NetworkHelpers.FindFreePort ();
+ var listener = CreateListener (l => {
+ try {
+ var request = l.Request;
+
+ Assert.IsNull (request.AcceptTypes, "#1");
+ Assert.AreEqual (-1, request.ContentLength64, "#2");
+ Assert.IsNull (request.ContentType, "#3");
+ Assert.AreEqual (0, request.Cookies.Count, "#4");
+ Assert.IsTrue (request.HasEntityBody, "#5");
+ Assert.AreEqual ($"localhost:{port}", request.Headers ["Host"], "#6b");
+ Assert.AreEqual ("POST", request.HttpMethod, "#7");
+ Assert.IsFalse (request.IsAuthenticated, "#8");
+ Assert.IsTrue (request.IsLocal, "#9");
+ Assert.IsFalse (request.IsSecureConnection, "#10");
+ Assert.IsFalse (request.IsWebSocketRequest, "#11");
+ Assert.IsTrue (request.KeepAlive, "#12");
+ Assert.AreEqual (HttpVersion.Version11, request.ProtocolVersion, "#13");
+ Assert.IsNull (request.ServiceName, "#14");
+ Assert.IsNull (request.UrlReferrer, "#15");
+ Assert.IsNull (request.UserAgent, "#16");
+ Assert.IsNull (request.UserLanguages, "#17");
+ Assert.AreEqual ("chunked", request.Headers ["Transfer-Encoding"], "#18");
+ Assert.IsNull (request.Headers ["Content-Length"], "#19");
+ failed = false;
+ } catch (Exception e) {
+ failed = true;
+ Console.WriteLine (e);
+ }
+ }, port);
+
+ try {
+ var client = new HttpClient ();
+
+ client.DefaultRequestHeaders.TransferEncodingChunked = true;
+
+ var imageContent = new StreamContent (new MemoryStream ());
+
+ var response = client.PostAsync ($"http://localhost:{port}/", imageContent).Result;
+
+ Assert.AreEqual(HttpStatusCode.OK, response.StatusCode, "#101");
+ Assert.AreEqual(false, failed, "#102");
+ } finally {
+ listener.Close ();
+ }
+ }
+
+ [Test]
+#if FEATURE_NO_BSD_SOCKETS
+ [ExpectedException (typeof (PlatformNotSupportedException))]
+#endif
+ public void Post_StreamCaching ()
+ {
+ bool? failed = null;
+ var port = NetworkHelpers.FindFreePort ();
+ var listener = CreateListener (l => {
+ try {
+ var request = l.Request;
+
+ Assert.IsNull (request.AcceptTypes, "#1");
+ Assert.AreEqual (0, request.ContentLength64, "#2");
+ Assert.IsNull (request.ContentType, "#3");
+ Assert.AreEqual (0, request.Cookies.Count, "#4");
+ Assert.IsFalse (request.HasEntityBody, "#5");
+ Assert.AreEqual ($"localhost:{port}", request.Headers ["Host"], "#6b");
+ Assert.AreEqual ("POST", request.HttpMethod, "#7");
+ Assert.IsFalse (request.IsAuthenticated, "#8");
+ Assert.IsTrue (request.IsLocal, "#9");
+ Assert.IsFalse (request.IsSecureConnection, "#10");
+ Assert.IsFalse (request.IsWebSocketRequest, "#11");
+ Assert.IsTrue (request.KeepAlive, "#12");
+ Assert.AreEqual (HttpVersion.Version11, request.ProtocolVersion, "#13");
+ Assert.IsNull (request.ServiceName, "#14");
+ Assert.IsNull (request.UrlReferrer, "#15");
+ Assert.IsNull (request.UserAgent, "#16");
+ Assert.IsNull (request.UserLanguages, "#17");
+ Assert.IsNull (request.Headers ["Transfer-Encoding"], "#18");
+ Assert.AreEqual ("0", request.Headers ["Content-Length"], "#19");
+ failed = false;
+ } catch (Exception e) {
+ failed = true;
+ Console.WriteLine (e);
+ }
+ }, port);
+
+ try {
+ var client = new HttpClient ();
+
+ var imageContent = new StreamContent (new MemoryStream ());
+
+ var response = client.PostAsync ($"http://localhost:{port}/", imageContent).Result;
+
+ Assert.AreEqual(HttpStatusCode.OK, response.StatusCode, "#101");
+ Assert.AreEqual(false, failed, "#102");
+ } finally {
+ listener.Close ();
+ }
+ }
+
[Test]
[Category ("MobileNotWorking")] // Missing encoding
+#if FEATURE_NO_BSD_SOCKETS
+ [ExpectedException (typeof (PlatformNotSupportedException))]
+#endif
public void GetString_Many ()
{
Action<HttpListenerContext> context = (HttpListenerContext l) => {
response.OutputStream.WriteByte (0x6f);
};
- var listener = CreateListener (context); // creates a default request handler
+ var port = NetworkHelpers.FindFreePort ();
+ var listener = CreateListener (context, port); // creates a default request handler
AddListenerContext (listener, context); // add another request handler for the second request
try {
var client = new HttpClient ();
- var t1 = client.GetStringAsync (LocalServer);
- var t2 = client.GetStringAsync (LocalServer);
+ var t1 = client.GetStringAsync ($"http://localhost:{port}/");
+ var t2 = client.GetStringAsync ($"http://localhost:{port}/");
Assert.IsTrue (Task.WaitAll (new [] { t1, t2 }, WaitTimeout));
Assert.AreEqual ("hello", t1.Result, "#1");
Assert.AreEqual ("hello", t2.Result, "#2");
}
[Test]
+#if FEATURE_NO_BSD_SOCKETS
+ [ExpectedException (typeof (PlatformNotSupportedException))]
+#endif
public void GetByteArray_ServerError ()
{
+ var port = NetworkHelpers.FindFreePort ();
var listener = CreateListener (l => {
var response = l.Response;
response.StatusCode = 500;
l.Response.OutputStream.WriteByte (72);
- });
+ }, port);
try {
var client = new HttpClient ();
try {
- client.GetByteArrayAsync (LocalServer).Wait (WaitTimeout);
+ client.GetByteArrayAsync ($"http://localhost:{port}/").Wait (WaitTimeout);
Assert.Fail ("#1");
} catch (AggregateException e) {
Assert.IsTrue (e.InnerException is HttpRequestException , "#2");
}
[Test]
+#if FEATURE_NO_BSD_SOCKETS
+ [ExpectedException (typeof (PlatformNotSupportedException))]
+#endif
public void DisallowAutoRedirect ()
{
+ var port = NetworkHelpers.FindFreePort ();
var listener = CreateListener (l => {
var request = l.Request;
var response = l.Response;
response.StatusCode = (int)HttpStatusCode.Moved;
response.RedirectLocation = "http://xamarin.com/";
- });
+ }, port);
try {
var chandler = new HttpClientHandler ();
var client = new HttpClient (chandler);
try {
- client.GetStringAsync (LocalServer).Wait (WaitTimeout);
+ client.GetStringAsync ($"http://localhost:{port}/").Wait (WaitTimeout);
Assert.Fail ("#1");
} catch (AggregateException e) {
Assert.IsTrue (e.InnerException is HttpRequestException, "#2");
}
[Test]
+#if FEATURE_NO_BSD_SOCKETS
+ [ExpectedException (typeof (PlatformNotSupportedException))]
+#endif
public void RequestUriAfterRedirect ()
{
+ var port = NetworkHelpers.FindFreePort ();
+ var redirectPort = NetworkHelpers.FindFreePort ();
+
var listener = CreateListener (l => {
var request = l.Request;
var response = l.Response;
response.StatusCode = (int)HttpStatusCode.Moved;
- response.RedirectLocation = "http://localhost:8811/";
- });
+ response.RedirectLocation = $"http://localhost:{redirectPort}/";
+ }, port);
var listener2 = CreateListener (l => {
var response = l.Response;
response.OutputStream.WriteByte (0x6c);
response.OutputStream.WriteByte (0x6c);
response.OutputStream.WriteByte (0x6f);
- }, 8811);
+ }, redirectPort);
try {
var chandler = new HttpClientHandler ();
chandler.AllowAutoRedirect = true;
var client = new HttpClient (chandler);
- var r = client.GetAsync (LocalServer);
+ var r = client.GetAsync ($"http://localhost:{port}/");
Assert.IsTrue (r.Wait (WaitTimeout), "#1");
var resp = r.Result;
- Assert.AreEqual ("http://localhost:8811/", resp.RequestMessage.RequestUri.AbsoluteUri, "#2");
+ Assert.AreEqual ($"http://localhost:{redirectPort}/", resp.RequestMessage.RequestUri.AbsoluteUri, "#2");
Assert.AreEqual ("hello", resp.Content.ReadAsStringAsync ().Result, "#3");
} finally {
listener.Abort ();
}
[Test]
+#if FEATURE_NO_BSD_SOCKETS
+ [ExpectedException (typeof (PlatformNotSupportedException))]
+#endif
/*
* Properties may only be modified before sending the first request.
*/
chandler.AllowAutoRedirect = true;
var client = new HttpClient (chandler, true);
+ var port = NetworkHelpers.FindFreePort ();
var listener = CreateListener (l => {
var response = l.Response;
response.StatusCode = 200;
response.OutputStream.WriteByte (55);
- });
+ }, port);
try {
- client.GetStringAsync (LocalServer).Wait (WaitTimeout);
+ client.GetStringAsync ($"http://localhost:{port}/").Wait (WaitTimeout);
try {
chandler.AllowAutoRedirect = false;
Assert.Fail ("#1");
}
[Test]
+#if FEATURE_NO_BSD_SOCKETS
+ // Using HttpClientHandler, which indirectly requires BSD sockets.
+ [ExpectedException (typeof (PlatformNotSupportedException))]
+#endif
/*
* However, this policy is not enforced for custom handlers and there
* is also no way a derived class could tell its HttpClientHandler parent
ch.AllowAutoRedirect = false;
}
- HttpListener CreateListener (Action<HttpListenerContext> contextAssert)
- {
- return CreateListener (contextAssert, port);
- }
-
HttpListener CreateListener (Action<HttpListenerContext> contextAssert, int port)
{
var l = new HttpListener ();
projects / mono.git / blobdiff