net_4_5_dirs := \
System.Threading.Tasks.Dataflow \
- System.ComponentModel.Composition.4.5
+ System.ComponentModel.Composition.4.5 \
+ System.Net.Http
net_2_0_SUBDIRS := $(common_dirs) $(net_2_0_dirs) $(net_2_0_only_dirs) aot-compiler
moonlight_raw_SUBDIRS := $(moonlight_raw_dirs)
this.count = count;
}
- protected override Stream CreateContentReadStream ()
- {
- return new MemoryStream (content, offset, count);
- }
-
protected override void SerializeToStream (Stream stream, TransportContext context)
{
stream.Write (content, offset, count);
using System.Threading;
using System.Net.Http.Headers;
+using System.Threading.Tasks;
namespace System.Net.Http
{
}
}
- public HttpResponseMessage Delete (string requestUri)
+ public Task<HttpResponseMessage> DeleteAsync (string requestUri)
{
- return Send (new HttpRequestMessage (HttpMethod.Delete, requestUri));
+ return SendAsync (new HttpRequestMessage (HttpMethod.Delete, requestUri));
}
- public HttpResponseMessage Delete (Uri requestUri)
+ public Task<HttpResponseMessage> DeleteAsync (string requestUri, CancellationToken cancellationToken)
{
- return Send (new HttpRequestMessage (HttpMethod.Delete, requestUri));
+ return SendAsync (new HttpRequestMessage (HttpMethod.Delete, requestUri), cancellationToken);
}
- public HttpResponseMessage Get (string requestUri)
+ public Task<HttpResponseMessage> DeleteAsync (Uri requestUri)
{
- return Send (new HttpRequestMessage (HttpMethod.Get, requestUri));
+ return SendAsync (new HttpRequestMessage (HttpMethod.Delete, requestUri));
}
- public HttpResponseMessage Get (Uri requestUri)
+ public Task<HttpResponseMessage> DeleteAsync (Uri requestUri, CancellationToken cancellationToken)
{
- return Send (new HttpRequestMessage (HttpMethod.Get, requestUri));
+ return SendAsync (new HttpRequestMessage (HttpMethod.Delete, requestUri), cancellationToken);
}
- public HttpResponseMessage Post (string requestUri, HttpContent content)
+ public Task<HttpResponseMessage> GetAsync (string requestUri)
{
- return Send (new HttpRequestMessage (HttpMethod.Post, requestUri) { Content = content });
+ return SendAsync (new HttpRequestMessage (HttpMethod.Get, requestUri));
}
- public HttpResponseMessage Put (Uri requestUri, HttpContent content)
+ public Task<HttpResponseMessage> GetAsync (string requestUri, CancellationToken cancellationToken)
{
- return Send (new HttpRequestMessage (HttpMethod.Put, requestUri) { Content = content });
+ return SendAsync (new HttpRequestMessage (HttpMethod.Get, requestUri));
}
- public HttpResponseMessage Put (string requestUri, HttpContent content)
+ public Task<HttpResponseMessage> GetAsync (string requestUri, HttpCompletionOption completionOption)
{
- return Send (new HttpRequestMessage (HttpMethod.Put, requestUri) { Content = content });
+ return SendAsync (new HttpRequestMessage (HttpMethod.Get, requestUri), completionOption);
}
- public HttpResponseMessage Post (Uri requestUri, HttpContent content)
+ public Task<HttpResponseMessage> GetAsync (string requestUri, HttpCompletionOption completionOption, CancellationToken cancellationToken)
{
- return Send (new HttpRequestMessage (HttpMethod.Post, requestUri) { Content = content });
+ return SendAsync (new HttpRequestMessage (HttpMethod.Get, requestUri), completionOption, cancellationToken);
}
- public HttpResponseMessage Send (HttpRequestMessage request)
+ public Task<HttpResponseMessage> GetAsync (Uri requestUri)
{
- return Send (request, HttpCompletionOption.ResponseContentRead, CancellationToken.None);
+ return SendAsync (new HttpRequestMessage (HttpMethod.Get, requestUri));
}
- public HttpResponseMessage Send (HttpRequestMessage request, HttpCompletionOption completionOption)
+ public Task<HttpResponseMessage> GetAsync (Uri requestUri, CancellationToken cancellationToken)
{
- return Send (request, completionOption, CancellationToken.None);
+ return SendAsync (new HttpRequestMessage (HttpMethod.Get, requestUri), cancellationToken);
}
- public HttpResponseMessage Send (HttpRequestMessage request, CancellationToken cancellationToken)
+ public Task<HttpResponseMessage> GetAsync (Uri requestUri, HttpCompletionOption completionOption)
{
- return Send (request, HttpCompletionOption.ResponseContentRead, cancellationToken);
+ return SendAsync (new HttpRequestMessage (HttpMethod.Get, requestUri), completionOption);
}
- public HttpResponseMessage Send (HttpRequestMessage request, HttpCompletionOption completionOption, CancellationToken cancellationToken)
+ public Task<HttpResponseMessage> GetAsync (Uri requestUri, HttpCompletionOption completionOption, CancellationToken cancellationToken)
+ {
+ return SendAsync (new HttpRequestMessage (HttpMethod.Get, requestUri), completionOption, cancellationToken);
+ }
+
+ public Task<HttpResponseMessage> PostAsync (string requestUri, HttpContent content)
+ {
+ return SendAsync (new HttpRequestMessage (HttpMethod.Post, requestUri) { Content = content });
+ }
+
+ public Task<HttpResponseMessage> PostAsync (string requestUri, HttpContent content, CancellationToken cancellationToken)
+ {
+ return SendAsync (new HttpRequestMessage (HttpMethod.Post, requestUri) { Content = content }, cancellationToken);
+ }
+
+ public Task<HttpResponseMessage> PostAsync (Uri requestUri, HttpContent content)
+ {
+ return SendAsync (new HttpRequestMessage (HttpMethod.Post, requestUri) { Content = content });
+ }
+
+ public Task<HttpResponseMessage> PostAsync (Uri requestUri, HttpContent content, CancellationToken cancellationToken)
+ {
+ return SendAsync (new HttpRequestMessage (HttpMethod.Post, requestUri) { Content = content }, cancellationToken);
+ }
+
+ public Task<HttpResponseMessage> PutAsync (Uri requestUri, HttpContent content)
+ {
+ return SendAsync (new HttpRequestMessage (HttpMethod.Put, requestUri) { Content = content });
+ }
+
+ public Task<HttpResponseMessage> PutAsync (Uri requestUri, HttpContent content, CancellationToken cancellationToken)
+ {
+ return SendAsync (new HttpRequestMessage (HttpMethod.Put, requestUri) { Content = content }, cancellationToken);
+ }
+
+ public Task<HttpResponseMessage> PutAsync (string requestUri, HttpContent content)
+ {
+ return SendAsync (new HttpRequestMessage (HttpMethod.Put, requestUri) { Content = content });
+ }
+
+ public Task<HttpResponseMessage> PutAsync (string requestUri, HttpContent content, CancellationToken cancellationToken)
+ {
+ return SendAsync (new HttpRequestMessage (HttpMethod.Put, requestUri) { Content = content }, cancellationToken);
+ }
+
+ public Task<HttpResponseMessage> SendAsync (HttpRequestMessage request)
+ {
+ return SendAsync (request, HttpCompletionOption.ResponseContentRead, CancellationToken.None);
+ }
+
+ public Task<HttpResponseMessage> SendAsync (HttpRequestMessage request, HttpCompletionOption completionOption)
+ {
+ return SendAsync (request, completionOption, CancellationToken.None);
+ }
+
+ public Task<HttpResponseMessage> SendAsync (HttpRequestMessage request, CancellationToken cancellationToken)
+ {
+ return SendAsync (request, HttpCompletionOption.ResponseContentRead, cancellationToken);
+ }
+
+ public Task<HttpResponseMessage> SendAsync (HttpRequestMessage request, HttpCompletionOption completionOption, CancellationToken cancellationToken)
{
if (request == null)
throw new ArgumentNullException ("request");
using (var cts = CancellationTokenSource.CreateLinkedTokenSource (cancellation_token.Token, cancellationToken)) {
cts.CancelAfter (timeout);
- var response = handler.Send (request, cts.Token);
- if (response == null)
- throw new InvalidOperationException ("Handler failed to return a response");
+ var response = handler.SendAsync (request, cts.Token);
+ //if (response == null)
+ // throw new InvalidOperationException ("Handler failed to return a response");
return response;
}
return response;
}
-
+ /*
protected internal override HttpResponseMessage Send (HttpRequestMessage request, CancellationToken cancellationToken)
{
var wrequest = CreateWebRequest (request);
return CreateResponseMessage (wresponse, request);
}
-
+ */
protected internal override Task<HttpResponseMessage> SendAsync (HttpRequestMessage request, CancellationToken cancellationToken)
{
throw new NotImplementedException ();
public abstract class HttpContent : IDisposable
{
MemoryStream buffer;
- Stream content_stream;
bool disposed;
HttpContentHeaders headers;
- public Stream ContentReadStream {
- get {
- if (content_stream == null)
- content_stream = CreateContentReadStream ();
-
- return content_stream;
- }
- }
-
public HttpContentHeaders Headers {
get {
return headers ?? (headers = new HttpContentHeaders (this));
return SerializeToStreamAsync (stream, context);
}
- protected virtual Stream CreateContentReadStream ()
- {
- LoadIntoBuffer ();
- return buffer;
- }
-
public void Dispose ()
{
Dispose (true);
if (buffer != null)
buffer.Dispose ();
-
- if (content_stream != null)
- content_stream.Dispose ();
}
}
throw new NotImplementedException ();
}
- public byte[] ReadAsByteArray ()
+ public Task<byte[]> ReadAsByteArrayAsync ()
{
LoadIntoBuffer ();
- return buffer.ToArray ();
+ throw new NotImplementedException ();
+// return buffer.ToArray ();
}
- public string ReadAsString ()
+ public Task<string> ReadAsStringAsync ()
{
LoadIntoBuffer ();
if (buffer.Length == 0)
- return string.Empty;
+ return Task.FromResult (string.Empty);
Encoding encoding;
if (headers != null && headers.ContentType != null && headers.ContentType.CharSet != null) {
encoding = Encoding.UTF8;
}
- return encoding.GetString (buffer.GetBuffer (), 0, (int) buffer.Length);
+ throw new NotImplementedException ();
+ //return encoding.GetString (buffer.GetBuffer (), 0, (int) buffer.Length);
}
protected abstract void SerializeToStream (Stream stream, TransportContext context);
{
}
- protected internal abstract HttpResponseMessage Send (HttpRequestMessage request, CancellationToken cancellationToken);
protected internal abstract Task<HttpResponseMessage> SendAsync (HttpRequestMessage request, CancellationToken cancellationToken);
}
}
this.bufferSize = bufferSize;
}
- protected override Stream CreateContentReadStream ()
- {
- return content;
- }
-
protected override void Dispose (bool disposing)
{
if (disposing) {
}
}
- [Test]
- public void ContentReadStream ()
- {
- byte[] b = { 4, 2 };
-
- var sc = new ByteArrayContent (b);
- var s = sc.ContentReadStream;
- Assert.AreEqual (4, s.ReadByte (), "#1");
- Assert.AreEqual (2, s.ReadByte (), "#2");
- }
-
[Test]
public void CopyTo_Invalid ()
{
var m = new MemoryStream ();
- var sc = new ByteArrayContent (new byte[0]);
- try {
- sc.CopyTo (null);
- Assert.Fail ("#1");
- } catch (ArgumentNullException) {
- }
- }
-
- [Test]
- public void CopyTo ()
- {
- byte[] b = { 4, 2 };
-
- var sc = new ByteArrayContent (b);
-
- var dest = new MemoryStream ();
- sc.CopyTo (dest);
- Assert.AreEqual (2, dest.Length, "#1");
-
- sc.CopyTo (dest, null);
- }
-
- [Test]
- public void CopyToAsync_Invalid ()
- {
var sc = new ByteArrayContent (new byte[0]);
try {
sc.CopyToAsync (null);
}
[Test]
- public void LoadIntoBuffer ()
+ public void LoadIntoBufferAsync ()
{
byte[] b = { 4 };
var sc = new ByteArrayContent (b);
- sc.LoadIntoBuffer (400);
+ sc.LoadIntoBufferAsync (400).Wait ();
}
[Test]
- public void ReadAsByteArray ()
+ public void ReadAsByteArrayAsync ()
{
byte[] b = { 4, 55 };
var sc = new ByteArrayContent (b, 1, 1);
- var res = sc.ReadAsByteArray ();
+ var res = sc.ReadAsByteArrayAsync ().Result;
Assert.AreEqual (1, res.Length, "#1");
Assert.AreEqual (55, res[0], "#2");
sc = new ByteArrayContent (b);
- res = sc.ReadAsByteArray ();
+ res = sc.ReadAsByteArrayAsync ().Result;
Assert.AreEqual (2, res.Length, "#10");
Assert.AreEqual (55, res[1], "#11");
}
[Test]
- public void ReadAsString ()
+ public void ReadAsStringAsync ()
{
byte[] b = { 77, 55 };
var sc = new ByteArrayContent (b);
- var res = sc.ReadAsString ();
+ var res = sc.ReadAsStringAsync ().Result;
Assert.AreEqual ("M7", res, "#1");
}
}
{
class HttpMessageHandlerMock : HttpMessageHandler
{
- public Func<HttpRequestMessage, HttpResponseMessage> OnSend;
- public Func<HttpRequestMessage, CancellationToken, HttpResponseMessage> OnSendFull;
- public Func<HttpRequestMessage, Task<HttpResponseMessage>> OnSendAsync;
+ public Func<HttpRequestMessage, Task<HttpResponseMessage>> OnSend;
+ public Func<HttpRequestMessage, CancellationToken, Task<HttpResponseMessage>> OnSendFull;
public HttpMessageHandlerMock ()
{
}
- protected override HttpResponseMessage Send (HttpRequestMessage request, CancellationToken cancellationToken)
+ protected override Task<HttpResponseMessage> SendAsync (HttpRequestMessage request, CancellationToken cancellationToken)
{
if (OnSend != null)
return OnSend (request);
if (OnSendFull != null)
- return OnSendFull (request, cancellationToken);
+ return OnSendFull (request, cancellationToken);
Assert.Fail ("Send");
return null;
}
-
- protected override Task<HttpResponseMessage> SendAsync (HttpRequestMessage request, CancellationToken cancellationToken)
- {
- if (OnSendAsync != null)
- return OnSendAsync (request);
-
- Assert.Fail ("SendAsync");
- return null;
- }
}
string port, TestHost, LocalServer;
Assert.IsTrue (c.WaitHandle.WaitOne (1000), "#20");
Assert.IsTrue (c.IsCancellationRequested, "#21");
mre.Set ();
- return new HttpResponseMessage ();
+ return Task.FromResult (new HttpResponseMessage ());
};
var t = Task.Factory.StartNew (() => {
- client.Send (request);
+ client.SendAsync (request).Wait ();
});
Assert.IsTrue (mre.WaitOne (500), "#1");
request = new HttpRequestMessage (HttpMethod.Get, "http://xamarin.com");
mh.OnSendFull = (l, c) => {
Assert.IsFalse (c.IsCancellationRequested, "#30");
- return new HttpResponseMessage ();
+ return Task.FromResult (new HttpResponseMessage ());
};
- client.Send (request);
+ client.SendAsync (request).Wait ();
}
[Test]
mh.OnSendFull = (l, c) => {
Assert.IsFalse (c.IsCancellationRequested, "#30");
- return new HttpResponseMessage ();
+ return Task.FromResult (new HttpResponseMessage ());
};
- client.Send (request);
+ client.SendAsync (request).Wait ();
request = new HttpRequestMessage (HttpMethod.Get, "http://xamarin.com");
- client.Send (request);
+ client.SendAsync (request).Wait ();
}
[Test]
mh.OnSend = l => {
Assert.AreEqual (l, request, "#2");
Assert.AreEqual (client.BaseAddress, l.RequestUri, "#2");
- return response;
+ return Task.FromResult (response);
};
- Assert.AreEqual (response, client.Send (request), "#1");
+ Assert.AreEqual (response, client.SendAsync (request).Result, "#1");
}
[Test]
mh.OnSend = l => {
Assert.AreEqual (client.DefaultRequestHeaders.Referrer, l.Headers.Referrer, "#2");
Assert.IsNotNull (l.Headers.Referrer, "#3");
- return response;
+ return Task.FromResult (response);
};
- Assert.AreEqual (response, client.Send (request), "#1");
+ Assert.AreEqual (response, client.SendAsync (request).Result, "#1");
}
[Test]
try {
var client = new HttpClient ();
var request = new HttpRequestMessage (HttpMethod.Get, LocalServer);
- var response = client.Send (request, HttpCompletionOption.ResponseHeadersRead);
+ var response = client.SendAsync (request, HttpCompletionOption.ResponseHeadersRead).Result;
- Assert.AreEqual ("", response.Content.ReadAsString (), "#100");
+ Assert.AreEqual ("", response.Content.ReadAsStringAsync ().Result, "#100");
Assert.AreEqual (HttpStatusCode.OK, response.StatusCode, "#101");
} finally {
listener.Close ();
var client = new HttpClient ();
var request = new HttpRequestMessage (HttpMethod.Get, LocalServer);
request.Version = HttpVersion.Version10;
- var response = client.Send (request, HttpCompletionOption.ResponseHeadersRead);
+ var response = client.SendAsync (request, HttpCompletionOption.ResponseHeadersRead).Result;
- Assert.AreEqual ("", response.Content.ReadAsString (), "#100");
+ Assert.AreEqual ("", response.Content.ReadAsStringAsync ().Result, "#100");
Assert.AreEqual (HttpStatusCode.OK, response.StatusCode, "#101");
} finally {
listener.Close ();
var client = new HttpClient (chandler);
var request = new HttpRequestMessage (HttpMethod.Get, LocalServer);
request.Version = HttpVersion.Version10;
- var response = client.Send (request, HttpCompletionOption.ResponseHeadersRead);
+ var response = client.SendAsync (request, HttpCompletionOption.ResponseHeadersRead).Result;
- Assert.AreEqual ("", response.Content.ReadAsString (), "#100");
+ Assert.AreEqual ("", response.Content.ReadAsStringAsync ().Result, "#100");
Assert.AreEqual (HttpStatusCode.OK, response.StatusCode, "#101");
} finally {
listener.Close ();
var request = new HttpRequestMessage (HttpMethod.Get, LocalServer);
request.Headers.AddWithoutValidation ("aa", "vv");
// request.Headers.Range = new RangeHeaderValue (3, 20);
- var response = client.Send (request, HttpCompletionOption.ResponseHeadersRead);
+ var response = client.SendAsync (request, HttpCompletionOption.ResponseHeadersRead).Result;
- Assert.AreEqual ("", response.Content.ReadAsString (), "#100");
+ Assert.AreEqual ("", response.Content.ReadAsStringAsync ().Result, "#100");
Assert.AreEqual (HttpStatusCode.OK, response.StatusCode, "#101");
IEnumerable<string> values;
try {
var client = new HttpClient ();
var request = new HttpRequestMessage (HttpMethod.Get, LocalServer);
- var response = client.Send (request, HttpCompletionOption.ResponseHeadersRead);
+ var response = client.SendAsync (request, HttpCompletionOption.ResponseHeadersRead).Result;
- Assert.AreEqual ("", response.Content.ReadAsString (), "#100");
+ Assert.AreEqual ("", response.Content.ReadAsStringAsync ().Result, "#100");
Assert.AreEqual (HttpStatusCode.InternalServerError, response.StatusCode, "#101");
} finally {
listener.Close ();
try {
var client = new HttpClient ();
var r = new HttpRequestMessage (HttpMethod.Get, LocalServer);
- var response = client.Send (r);
+ var response = client.SendAsync (r).Result;
- Assert.AreEqual ("H", response.Content.ReadAsString ());
+ Assert.AreEqual ("H", response.Content.ReadAsStringAsync ().Result);
} finally {
listener.Close ();
}
var client = new HttpClient ();
var r = new HttpRequestMessage (HttpMethod.Put, LocalServer);
r.Content = new StringContent ("my text");
- var response = client.Send (r);
+ var response = client.SendAsync (r).Result;
Assert.AreEqual (HttpStatusCode.OK, response.StatusCode, "#1");
Assert.IsTrue (passed, "#2");
mh.OnSendFull = (l, c) => {
Assert.IsTrue (c.WaitHandle.WaitOne (500), "#2");
- return response;
+ return Task.FromResult (response);
};
- Assert.AreEqual (response, client.Send (request), "#1");
+ Assert.AreEqual (response, client.SendAsync (request).Result, "#1");
}
[Test]
{
var client = new HttpClient ();
try {
- client.Send (null);
+ client.SendAsync (null).Wait ();
Assert.Fail ("#1");
} catch (ArgumentNullException) {
}
try {
var request = new HttpRequestMessage ();
- client.Send (request);
+ client.SendAsync (request).Wait ();
Assert.Fail ("#2");
} catch (InvalidOperationException) {
}
};
try {
- client.Send (request);
+ // Broken on .net because of return null
+ client.SendAsync (request).Wait ();
Assert.Fail ("#2");
} catch (InvalidOperationException) {
}
var request = new HttpRequestMessage (HttpMethod.Get, "http://xamarin.com");
mh.OnSend = l => {
- return new HttpResponseMessage ();
+ return Task.FromResult (new HttpResponseMessage ());
};
- client.Send (request);
+ client.SendAsync (request).Wait ();
try {
- client.Send (request);
+ client.SendAsync (request).Wait ();
} catch (InvalidOperationException) {
}
}
HttpRequestHeaders headers = message.Headers;
try {
- headers.Add ("Age", "");
+ headers.Add ("Allow", "");
Assert.Fail ("#1");
} catch (InvalidOperationException) {
}
}
try {
- headers.AddWithoutValidation ("Age", "");
+ headers.AddWithoutValidation ("Allow", "");
Assert.Fail ("#3");
} catch (InvalidOperationException) {
}
}
}
+ [Test]
+ public void Headers_Response ()
+ {
+ HttpRequestMessage message = new HttpRequestMessage ();
+ HttpRequestHeaders headers = message.Headers;
+
+ headers.Add ("Age", "vv");
+ Assert.AreEqual ("vv", headers.GetValues ("Age").First (), "#1");
+
+ headers.Clear ();
+ headers.AddWithoutValidation ("Age", "vv");
+ Assert.AreEqual ("vv", headers.GetValues ("Age").First (), "#2");
+ }
+
[Test]
public void Headers_ExpectContinue ()
{
}
try {
- headers.Add ("accept", "audio");
+ headers.Add ("Allow", "audio");
Assert.Fail ("#2c");
} catch (InvalidOperationException) {
}
try {
- headers.AddWithoutValidation ("Max-Forwards", "");
+ headers.AddWithoutValidation ("Allow", "");
Assert.Fail ("#3");
} catch (InvalidOperationException) {
}
}
}
+ [Test]
+ public void Headers_Request ()
+ {
+ HttpResponseMessage message = new HttpResponseMessage ();
+ HttpResponseHeaders headers = message.Headers;
+
+ headers.Add ("accept", "audio");
+ Assert.AreEqual ("audio", headers.GetValues ("Accept").First (), "#1");
+
+ headers.Clear ();
+ headers.AddWithoutValidation ("accept", "audio");
+ Assert.AreEqual ("audio", headers.GetValues ("Accept").First (), "#2");
+ }
+
[Test]
public void Headers_ConnectionClose ()
{
class StreamContentMock : StreamContent
{
public Func<long> OnTryComputeLength;
- public Action OnCreateContentReadStream;
public Action OnSerializeToStreamAsync;
public StreamContentMock (Stream stream)
return base.TryComputeLength (out length);
}
- protected override void SerializeToStream (Stream stream, TransportContext context)
- {
- base.SerializeToStream (stream, context);
- }
-
protected override Task SerializeToStreamAsync (Stream stream, TransportContext context)
{
if (OnSerializeToStreamAsync != null)
return base.SerializeToStreamAsync (stream, context);
}
-
- protected override Stream CreateContentReadStream ()
- {
- if (OnCreateContentReadStream != null)
- OnCreateContentReadStream ();
-
- return base.CreateContentReadStream ();
- }
}
class ExceptionStream : MemoryStream
}
}
- [Test]
- public void ContentReadStream ()
- {
- var ms = new MemoryStream ();
- ms.WriteByte (4);
- ms.WriteByte (2);
- ms.Seek (0, SeekOrigin.Begin);
-
- var sc = new StreamContent (ms);
- var s = sc.ContentReadStream;
- Assert.AreEqual (4, s.ReadByte (), "#1");
- Assert.AreEqual (2, s.ReadByte (), "#2");
-
- bool hit = false;
- var scm = new StreamContentMock (MemoryStream.Null);
- scm.OnCreateContentReadStream = () => { hit = true; };
- s = scm.ContentReadStream;
- Assert.IsTrue (hit, "#10");
- }
-
- [Test]
- public void CopyTo_Invalid ()
- {
- var m = new MemoryStream ();
-
- var sc = new StreamContent (new MemoryStream ());
- try {
- sc.CopyTo (null);
- Assert.Fail ("#1");
- } catch (ArgumentNullException) {
- }
-
- sc = new StreamContent (new ExceptionStream ());
- try {
- sc.CopyTo (m);
- Assert.Fail ("#2");
- } catch (ApplicationException) {
- }
- }
-
- [Test]
- public void CopyTo ()
- {
- var ms = new MemoryStream ();
- ms.WriteByte (4);
- ms.WriteByte (2);
- ms.Seek (0, SeekOrigin.Begin);
-
- var sc = new StreamContent (ms);
-
- var dest = new MemoryStream ();
- sc.CopyTo (dest);
- Assert.AreEqual (2, dest.Length, "#1");
-
- sc.CopyTo (dest, null);
- }
-
[Test]
public void CopyToAsync_Invalid ()
{
//
// For some reason does not work on .net
//
- //sc = new StreamContent (new ExceptionStream ());
- //try {
- // sc.CopyToAsync (m).Wait ();
- // Assert.Fail ("#2");
- //} catch (AggregateException) {
- //}
+ /*
+ sc = new StreamContent (new ExceptionStream ());
+ try {
+ sc.CopyToAsync (m).Wait ();
+ Assert.Fail ("#2");
+ } catch (AggregateException) {
+ }
+ */
}
[Test]
var scm = new StreamContentMock (new ExceptionStream ());
scm.OnSerializeToStreamAsync = () => { hit = true; };
task = scm.CopyToAsync (dest);
+ task.Wait ();
Assert.IsTrue (hit, "#10");
-// Assert.IsTrue (task.IsFaulted, "#11");
+ //Assert.IsTrue (task.IsFaulted, "#11");
}
[Test]
var ms = new MemoryStream ();
ms.WriteByte (4);
ms.WriteByte (2);
+ ms.Seek (0, SeekOrigin.Begin);
var sc = new StreamContent (ms);
var headers = sc.Headers;
ms.Seek (0, SeekOrigin.Begin);
var sc = new StreamContent (ms);
- sc.LoadIntoBuffer (400);
+ sc.LoadIntoBufferAsync (400).Wait ();
}
[Test]
- public void ReadAsByteArray ()
+ public void ReadAsByteArrayAsync ()
{
var ms = new MemoryStream ();
ms.WriteByte (4);
ms.WriteByte (55);
var sc = new StreamContent (ms);
- var res = sc.ReadAsByteArray ();
+ var res = sc.ReadAsByteArrayAsync ().Result;
Assert.AreEqual (0, res.Length, "#1");
ms.Seek (0, SeekOrigin.Begin);
sc = new StreamContent (ms);
- res = sc.ReadAsByteArray ();
+ res = sc.ReadAsByteArrayAsync ().Result;
Assert.AreEqual (2, res.Length, "#10");
Assert.AreEqual (55, res[1], "#11");
}
ms.Seek (0, SeekOrigin.Begin);
var sc = new StreamContent (ms);
- var res = sc.ReadAsString ();
+ var res = sc.ReadAsStringAsync ().Result;
Assert.AreEqual ("M7", res, "#1");
}
}
Assert.AreEqual ("Content-Type: multipart/*; charset=ibm852\r\n", s.Headers.ToString ());
}
- [Test]
- public void ContentReadStream ()
- {
- var sc = new StringContent ("ab\9e");
- var s = sc.ContentReadStream;
- Assert.AreEqual (97, s.ReadByte (), "#1");
- Assert.AreEqual (98, s.ReadByte (), "#2");
- Assert.AreEqual (197, s.ReadByte (), "#3");
- }
-
- [Test]
- public void CopyTo_Invalid ()
- {
- var sc = new StringContent ("");
- try {
- sc.CopyTo (null);
- Assert.Fail ("#1");
- } catch (ArgumentNullException) {
- }
- }
-
- [Test]
- public void CopyTo ()
- {
- var sc = new StringContent ("nm");
-
- var dest = new MemoryStream ();
- sc.CopyTo (dest);
- Assert.AreEqual (2, dest.Length, "#1");
-
- sc.CopyTo (dest, null);
- }
-
[Test]
public void CopyToAsync_Invalid ()
{
public void LoadIntoBuffer ()
{
var sc = new StringContent ("b");
- sc.LoadIntoBuffer (400);
+ sc.LoadIntoBufferAsync (400).Wait ();
}
[Test]
- public void ReadAsByteArray ()
+ public void ReadAsByteArrayAsync ()
{
var sc = new StringContent ("h");
- var res = sc.ReadAsByteArray ();
+ var res = sc.ReadAsByteArrayAsync ().Result;
Assert.AreEqual (1, res.Length, "#1");
Assert.AreEqual (104, res[0], "#2");
}
[Test]
- public void ReadAsString ()
+ public void ReadAsStringAsync ()
{
var sc = new StringContent ("ab\9e");
- var res = sc.ReadAsString ();
+ var res = sc.ReadAsStringAsync ().Result;
Assert.AreEqual ("ab\9e", res, "#1");
}
}
projects / mono.git / commitdiff