mono/linux-packaging-mono
0
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Imported Upstream version 4.0.0~alpha1

Browse Source 
Former-commit-id: 806294f5ded97629b74c85c09952f2a74fe182d9
This commit is contained in:
Jo Shields
2015-04-07 09:35:12 +01:00
parent 283343f570
commit 3c1f479b9d
22469 changed files with 2931443 additions and 869343 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
mcs/class/System.Net.Http/System.Net.Http.Headers/ContentRangeHeaderValue.cs
View File

@ -191,10 +191,11 @@ namespace System.Net.Http.Headers
t = lexer.Scan ();
if (!lexer.IsStarStringValue (t)) {
if (!lexer.TryGetNumericValue (t, out nvalue))
long lvalue;
if (!lexer.TryGetNumericValue (t, out lvalue))
return false;
value.Length = nvalue;
value.Length = lvalue;
}
t = lexer.Scan ();

23
mcs/class/System.Net.Http/System.Net.Http.Headers/HeaderInfo.cs
View File

@ -93,14 +93,22 @@ namespace System.Net.Http.Headers
class CollectionHeaderTypeInfo<T, U> : HeaderTypeInfo<T, U> where U : class
{
readonly int minimalCount;
TryParseListDelegate<T> parser;
readonly string separator;
readonly TryParseListDelegate<T> parser;
public CollectionHeaderTypeInfo (string name, TryParseListDelegate<T> parser, HttpHeaderKind headerKind, int minimalCount)
public CollectionHeaderTypeInfo (string name, TryParseListDelegate<T> parser, HttpHeaderKind headerKind, int minimalCount, string separator)
: base (name, null, headerKind)
{
this.parser = parser;
this.minimalCount = minimalCount;
AllowsMany = true;
this.separator = separator;
}
public override string Separator {
get {
return separator;
}
}
public override bool TryParse (string value, out object result)
@ -134,9 +142,9 @@ namespace System.Net.Http.Headers
//
// Headers with #rule for defining lists of elements or *rule for defining occurences of elements
//
public static HeaderInfo CreateMulti<T> (string name, TryParseListDelegate<T> elementParser, HttpHeaderKind headerKind, int minimalCount = 1) where T : class
public static HeaderInfo CreateMulti<T> (string name, TryParseListDelegate<T> elementParser, HttpHeaderKind headerKind, int minimalCount = 1, string separator = ", ") where T : class
{
return new CollectionHeaderTypeInfo<T, T> (name, elementParser, headerKind, minimalCount);
return new CollectionHeaderTypeInfo<T, T> (name, elementParser, headerKind, minimalCount, separator);
}
public object CreateCollection (HttpHeaders headers)
@ -144,6 +152,13 @@ namespace System.Net.Http.Headers
return CreateCollection (headers, this);
}
public virtual string Separator {
get {
// Needed for AllowsMany only
throw new NotSupportedException ();
}
}
public abstract void AddToCollection (object collection, object value);
protected abstract object CreateCollection (HttpHeaders headers, HeaderInfo headerInfo);
public abstract List<string> ToStringCollection (object collection);

2
mcs/class/System.Net.Http/System.Net.Http.Headers/HttpHeaderValueCollection.cs
View File

@ -97,7 +97,7 @@ namespace System.Net.Http.Headers
// what .NET does when one of the values is invalid
// But it better represents what is actually hold by
// the collection
return string.Join (", ", list);
return string.Join (headerInfo.Separator, list);
}
public bool TryParseAdd (string input)

7
mcs/class/System.Net.Http/System.Net.Http.Headers/HttpHeaders.cs
View File

@ -124,12 +124,12 @@ namespace System.Net.Http.Headers
HeaderInfo.CreateSingle<RangeHeaderValue> ("Range", RangeHeaderValue.TryParse, HttpHeaderKind.Request),
HeaderInfo.CreateSingle<Uri> ("Referer", Parser.Uri.TryParse, HttpHeaderKind.Request),
HeaderInfo.CreateSingle<RetryConditionHeaderValue> ("Retry-After", RetryConditionHeaderValue.TryParse, HttpHeaderKind.Response),
HeaderInfo.CreateMulti<ProductInfoHeaderValue> ("Server", ProductInfoHeaderValue.TryParse, HttpHeaderKind.Response),
HeaderInfo.CreateMulti<ProductInfoHeaderValue> ("Server", ProductInfoHeaderValue.TryParse, HttpHeaderKind.Response, separator: " "),
HeaderInfo.CreateMulti<TransferCodingWithQualityHeaderValue> ("TE", TransferCodingWithQualityHeaderValue.TryParse, HttpHeaderKind.Request, 0),
HeaderInfo.CreateMulti<string> ("Trailer", CollectionParser.TryParse, HttpHeaderKind.Request | HttpHeaderKind.Response),
HeaderInfo.CreateMulti<TransferCodingHeaderValue> ("Transfer-Encoding", TransferCodingHeaderValue.TryParse, HttpHeaderKind.Request | HttpHeaderKind.Response),
HeaderInfo.CreateMulti<ProductHeaderValue> ("Upgrade", ProductHeaderValue.TryParse, HttpHeaderKind.Request | HttpHeaderKind.Response),
HeaderInfo.CreateMulti<ProductInfoHeaderValue> ("User-Agent", ProductInfoHeaderValue.TryParse, HttpHeaderKind.Request),
HeaderInfo.CreateMulti<ProductInfoHeaderValue> ("User-Agent", ProductInfoHeaderValue.TryParse, HttpHeaderKind.Request, separator: " "),
HeaderInfo.CreateMulti<string> ("Vary", CollectionParser.TryParse, HttpHeaderKind.Response),
HeaderInfo.CreateMulti<ViaHeaderValue> ("Via", ViaHeaderValue.TryParse, HttpHeaderKind.Request | HttpHeaderKind.Response),
HeaderInfo.CreateMulti<WarningHeaderValue> ("Warning", WarningHeaderValue.TryParse, HttpHeaderKind.Request | HttpHeaderKind.Response),
@ -458,7 +458,8 @@ namespace System.Net.Http.Headers
HeaderBucket value;
if (!headers.TryGetValue (name, out value)) {
value = new HeaderBucket (new HttpHeaderValueCollection<T> (this, known_headers [name]));
var hinfo = known_headers[name];
value = new HeaderBucket (new HttpHeaderValueCollection<T> (this, hinfo));
headers.Add (name, value);
}

32
mcs/class/System.Net.Http/System.Net.Http.Headers/Lexer.cs
View File

@ -94,7 +94,7 @@ namespace System.Net.Http.Headers
/*90*/ true, false, false, false, true, true, true, true, true, true,
/*100*/ true, true, true, true, true, true, true, true, true, true,
/*110*/ true, true, true, true, true, true, true, true, true, true,
/*120*/ true, true, true, false, true, false
/*120*/ true, true, true, false, true, false, true
};
static readonly int last_token_char = token_chars.Length;
@ -153,6 +153,11 @@ namespace System.Net.Http.Headers
return int.TryParse (GetStringValue (token), NumberStyles.None, CultureInfo.InvariantCulture, out value);
}
public bool TryGetNumericValue (Token token, out long value)
{
return long.TryParse (GetStringValue (token), NumberStyles.None, CultureInfo.InvariantCulture, out value);
}
public TimeSpan? TryGetTimeSpanValue (Token token)
{
int seconds;
@ -202,7 +207,7 @@ namespace System.Net.Http.Headers
public static bool IsValidCharacter (char input)
{
return input <= last_token_char && token_chars[input];
return input < last_token_char && token_chars[input];
}
public void EatChar ()
@ -232,10 +237,20 @@ namespace System.Net.Http.Headers
return false;
}
int parens = 1;
while (pos < s.Length) {
var ch = s[pos];
if (ch == '(') {
++parens;
++pos;
continue;
}
if (ch == ')') {
++pos;
if (--parens > 0)
continue;
var start = readToken.StartPosition;
value = s.Substring (start, pos - start);
return true;
@ -297,18 +312,11 @@ namespace System.Net.Http.Headers
// Quoted string
start = pos - 1;
while (pos < s.Length) {
ch = s[pos];
ch = s [pos++];
if (ch == '"') {
++pos;
ttype = Token.Type.QuotedString;
break;
}
// any OCTET except CTLs, but including LWS
if (ch < 32 || ch > 126)
break;
++pos;
}
break;
@ -317,13 +325,13 @@ namespace System.Net.Http.Headers
ttype = Token.Type.OpenParens;
break;
default:
if (ch <= last_token_char && token_chars[ch]) {
if (ch < last_token_char && token_chars[ch]) {
start = pos - 1;
ttype = Token.Type.Token;
while (pos < s.Length) {
ch = s[pos];
if (ch > last_token_char || !token_chars[ch]) {
if (ch >= last_token_char || !token_chars[ch]) {
break;
}

3
mcs/class/System.Net.Http/System.Net.Http.Headers/MediaTypeWithQualityHeaderValue.cs
View File

@ -89,8 +89,9 @@ namespace System.Net.Http.Headers
}
t = token.Value;
if (t == Token.Type.SeparatorSemicolon && (!NameValueHeaderValue.TryParseParameters (lexer, out parameters, out t) || t != Token.Type.End))
if (t == Token.Type.SeparatorSemicolon && !NameValueHeaderValue.TryParseParameters (lexer, out parameters, out t)) {
return false;
}
parsedValue = new MediaTypeWithQualityHeaderValue ();
parsedValue.media_type = media;

17
mcs/class/System.Net.Http/System.Net.Http.Headers/ProductInfoHeaderValue.cs
View File

@ -127,6 +127,23 @@ namespace System.Net.Http.Headers
}
list.Add (element);
// Separator parsing
switch (lexer.PeekChar ()) {
case ' ':
case '\t':
lexer.EatChar ();
continue;
case -1:
if (minimalCount <= list.Count) {
result = list;
return true;
}
break;
}
return false;
}
}

8
mcs/class/System.Net.Http/System.Net.Http.Headers/RangeHeaderValue.cs
View File

@ -123,8 +123,8 @@ namespace System.Net.Http.Headers
bool token_read;
do {
int? from = null, to = null;
int number;
long? from = null, to = null;
long number;
token_read = false;
t = lexer.Scan (recognizeDash: true);
@ -139,7 +139,7 @@ namespace System.Net.Http.Headers
case Token.Type.Token:
string s = lexer.GetStringValue (t);
var values = s.Split (new [] { '-' }, StringSplitOptions.RemoveEmptyEntries);
if (!int.TryParse (values[0], out number))
if (!Parser.Long.TryParse (values[0], out number))
return false;
switch (values.Length) {
@ -178,7 +178,7 @@ namespace System.Net.Http.Headers
case 2:
from = number;
if (!int.TryParse (values[1], out number))
if (!Parser.Long.TryParse (values[1], out number))
return false;
to = number;

11
mcs/class/System.Net.Http/System.Net.Http/HttpClient.cs
View File

@ -242,16 +242,17 @@ namespace System.Net.Http
if (request.SetIsUsed ())
throw new InvalidOperationException ("Cannot send the same request message multiple times");
if (request.RequestUri == null) {
var uri = request.RequestUri;
if (uri == null) {
if (base_address == null)
throw new InvalidOperationException ("The request URI must either be an absolute URI or BaseAddress must be set");
request.RequestUri = base_address;
} else if (!request.RequestUri.IsAbsoluteUri) {
} else if (!uri.IsAbsoluteUri || uri.Scheme == Uri.UriSchemeFile && uri.OriginalString.StartsWith ("/", StringComparison.Ordinal)) {
if (base_address == null)
throw new InvalidOperationException ("The request URI must either be an absolute URI or BaseAddress must be set");
request.RequestUri = new Uri (base_address, request.RequestUri);
request.RequestUri = new Uri (base_address, uri);
}
if (headers != null) {
@ -303,14 +304,14 @@ namespace System.Net.Http
public async Task<Stream> GetStreamAsync (string requestUri)
{
var resp = await GetAsync (requestUri, HttpCompletionOption.ResponseContentRead).ConfigureAwait (false);
var resp = await GetAsync (requestUri, HttpCompletionOption.ResponseHeadersRead).ConfigureAwait (false);
resp.EnsureSuccessStatusCode ();
return await resp.Content.ReadAsStreamAsync ().ConfigureAwait (false);
}
public async Task<Stream> GetStreamAsync (Uri requestUri)
{
var resp = await GetAsync (requestUri, HttpCompletionOption.ResponseContentRead).ConfigureAwait (false);
var resp = await GetAsync (requestUri, HttpCompletionOption.ResponseHeadersRead).ConfigureAwait (false);
resp.EnsureSuccessStatusCode ();
return await resp.Content.ReadAsStreamAsync ().ConfigureAwait (false);
}

68
mcs/class/System.Net.Http/System.Net.Http/HttpClientHandler.cs
View File

@ -232,6 +232,7 @@ namespace System.Net.Http
{
var wr = new HttpWebRequest (request.RequestUri);
wr.ThrowOnError = false;
wr.AllowWriteStreamBuffering = false;
wr.ConnectionGroupName = connectionGroupName;
wr.Method = request.Method.Method;
@ -314,38 +315,51 @@ namespace System.Net.Http
Volatile.Write (ref sentRequest, true);
var wrequest = CreateWebRequest (request);
HttpWebResponse wresponse = null;
if (request.Content != null) {
var headers = wrequest.Headers;
foreach (var header in request.Content.Headers) {
foreach (var value in header.Value) {
headers.AddValue (header.Key, value);
try {
using (cancellationToken.Register (l => ((HttpWebRequest)l).Abort (), wrequest)) {
var content = request.Content;
if (content != null) {
var headers = wrequest.Headers;
foreach (var header in content.Headers) {
foreach (var value in header.Value) {
headers.AddValue (header.Key, value);
}
}
//
// Content length has to be set because HttpWebRequest is running without buffering
//
var contentLength = content.Headers.ContentLength;
if (contentLength != null) {
wrequest.ContentLength = contentLength.Value;
} else {
await content.LoadIntoBufferAsync (MaxRequestContentBufferSize).ConfigureAwait (false);
wrequest.ContentLength = content.Headers.ContentLength.Value;
}
var stream = await wrequest.GetRequestStreamAsync ().ConfigureAwait (false);
await request.Content.CopyToAsync (stream).ConfigureAwait (false);
} else if (HttpMethod.Post.Equals (request.Method) || HttpMethod.Put.Equals (request.Method) || HttpMethod.Delete.Equals (request.Method)) {
// Explicitly set this to make sure we're sending a "Content-Length: 0" header.
// This fixes the issue that's been reported on the forums:
// http://forums.xamarin.com/discussion/17770/length-required-error-in-http-post-since-latest-release
wrequest.ContentLength = 0;
}
}
var stream = await wrequest.GetRequestStreamAsync ().ConfigureAwait (false);
await request.Content.CopyToAsync (stream).ConfigureAwait (false);
} else if (HttpMethod.Post.Equals (request.Method) || HttpMethod.Put.Equals (request.Method) || HttpMethod.Delete.Equals (request.Method)) {
// Explicitly set this to make sure we're sending a "Content-Length: 0" header.
// This fixes the issue that's been reported on the forums:
// http://forums.xamarin.com/discussion/17770/length-required-error-in-http-post-since-latest-release
wrequest.ContentLength = 0;
wresponse = (HttpWebResponse)await wrequest.GetResponseAsync ().ConfigureAwait (false);
}
} catch (WebException we) {
if (we.Status != WebExceptionStatus.RequestCanceled)
throw;
}
HttpWebResponse wresponse = null;
using (cancellationToken.Register (l => ((HttpWebRequest) l).Abort (), wrequest)) {
try {
wresponse = (HttpWebResponse) await wrequest.GetResponseAsync ().ConfigureAwait (false);
} catch (WebException we) {
if (we.Status != WebExceptionStatus.RequestCanceled)
throw;
}
if (cancellationToken.IsCancellationRequested) {
var cancelled = new TaskCompletionSource<HttpResponseMessage> ();
cancelled.SetCanceled ();
return await cancelled.Task;
}
if (cancellationToken.IsCancellationRequested) {
var cancelled = new TaskCompletionSource<HttpResponseMessage> ();
cancelled.SetCanceled ();
return await cancelled.Task;
}
return CreateResponseMessage (wresponse, request, cancellationToken);

13
mcs/class/System.Net.Http/System.Net.Http/HttpContent.cs
View File

@ -176,12 +176,23 @@ namespace System.Net.Http
encoding = Encoding.GetEncoding (headers.ContentType.CharSet);
preambleLength = StartsWith (buf, buf_length, encoding.GetPreamble ());
} else {
encoding = WebClient.GetEncodingFromBuffer (buf, buf_length, ref preambleLength) ?? Encoding.UTF8;
encoding = GetEncodingFromBuffer (buf, buf_length, ref preambleLength) ?? Encoding.UTF8;
}
return encoding.GetString (buf, preambleLength, buf_length - preambleLength);
}
static Encoding GetEncodingFromBuffer (byte[] buffer, int length, ref int preambleLength)
{
var encodings_with_preamble = new [] { Encoding.UTF8, Encoding.UTF32, Encoding.Unicode };
foreach (var enc in encodings_with_preamble) {
if ((preambleLength = StartsWith (buffer, length, enc.GetPreamble ())) != 0)
return enc;
}
return null;
}
static int StartsWith (byte[] array, int length, byte[] value)
{
if (length < value.Length)

14
mcs/class/System.Net.Http/System.Net.Http/HttpRequestMessage.cs
View File

@ -89,13 +89,25 @@ namespace System.Net.Http
return uri;
}
set {
if (value != null && (value.IsAbsoluteUri && value.Scheme != Uri.UriSchemeHttp && value.Scheme != Uri.UriSchemeHttps))
if (value != null && value.IsAbsoluteUri && !IsAllowedAbsoluteUri (value))
throw new ArgumentException ("Only http or https scheme is allowed");
uri = value;
}
}
static bool IsAllowedAbsoluteUri (Uri uri)
{
if (uri.Scheme == Uri.UriSchemeHttp || uri.Scheme == Uri.UriSchemeHttps)
return true;
// Mono URI handling which does not distinguish between file and url absolute paths without scheme
if (uri.Scheme == Uri.UriSchemeFile && uri.OriginalString.StartsWith ("/", StringComparison.Ordinal))
return true;
return false;
}
public Version Version {
get {
return version ?? HttpVersion.Version11;

8
mcs/class/System.Net.Http/Test/System.Net.Http.Headers/ContentDispositionHeaderValueTest.cs
View File

@ -223,6 +223,14 @@ namespace MonoTests.System.Net.Http.Headers
value.FileName = "\"quoted\"";
Assert.AreEqual ("\"quoted\"", value.FileName, "#41");
Assert.AreEqual (new NameValueHeaderValue ("filename", "\"quoted\""), value.Parameters.First (), "#42");
value.FileName = "~";
Assert.AreEqual ("~", value.FileName, "#51");
Assert.AreEqual (new NameValueHeaderValue ("filename", "~"), value.Parameters.First (), "#52");
value.FileName = "\x7f";
Assert.AreEqual ("\"\x7f\"", value.FileName, "#61");
Assert.AreEqual (new NameValueHeaderValue ("filename", "\"\x7f\""), value.Parameters.First (), "#62");
}
[Test]

6
mcs/class/System.Net.Http/Test/System.Net.Http.Headers/ContentRangeHeaderValueTest.cs
View File

@ -84,11 +84,11 @@ namespace MonoTests.System.Net.Http.Headers
[Test]
public void Parse ()
{
var res = ContentRangeHeaderValue.Parse ("bytes 0 - 499/ 1234");
var res = ContentRangeHeaderValue.Parse ("bytes 0 - 499/ 9223372036854775807");
Assert.AreEqual (0, res.From, "#1");
Assert.AreEqual (499, res.To, "#2");
Assert.AreEqual (1234, res.Length, "#3");
Assert.AreEqual ("bytes 0-499/1234", res.ToString (), "#4");
Assert.AreEqual (9223372036854775807, res.Length, "#3");
Assert.AreEqual ("bytes 0-499/9223372036854775807", res.ToString (), "#4");
res = ContentRangeHeaderValue.Parse ("bytes */ 8");
Assert.IsNull (res.From, "#11");

24
mcs/class/System.Net.Http/Test/System.Net.Http.Headers/NameValueHeaderValueTest.cs
View File

@ -51,6 +51,30 @@ namespace MonoTests.System.Net.Http.Headers
Assert.Fail ("#2");
} catch (FormatException) {
}
try {
new NameValueHeaderValue ("\x7f", null);
Assert.Fail ("#3");
} catch (FormatException) {
}
try {
new NameValueHeaderValue ("arg", "\x7f");
Assert.Fail ("#4");
} catch (FormatException) {
}
}
[Test]
public void Ctor_ValidArguments ()
{
NameValueHeaderValue nvh;
nvh = new NameValueHeaderValue ("arg", "~");
Assert.AreEqual ("~", nvh.Value, "#1");
nvh = new NameValueHeaderValue ("arg", "\"\x7f\x80\"");
Assert.AreEqual ("\"\x7f\x80\"", nvh.Value, "#2");
}
[Test]

6
mcs/class/System.Net.Http/Test/System.Net.Http.Headers/RangeHeaderValueTest.cs
View File

@ -116,6 +116,12 @@ namespace MonoTests.System.Net.Http.Headers
Assert.IsNull (res.Ranges.Skip (1).First ().From, "#53");
Assert.AreEqual (9, res.Ranges.Skip (1).First ().To, "#54");
Assert.AreEqual ("bytes=0-, -9", res.ToString (), "#55");
res = RangeHeaderValue.Parse ("bytes=3637717541-9223372036854775807");
Assert.AreEqual ("bytes", res.Unit, "#60");
Assert.AreEqual (3637717541, res.Ranges.First ().From, "#61");
Assert.AreEqual (9223372036854775807, res.Ranges.First ().To, "#62");
Assert.AreEqual ("bytes=3637717541-9223372036854775807", res.ToString (), "#63");
}
[Test]

6
mcs/class/System.Net.Http/Test/System.Net.Http.Headers/ViaHeaderValueTest.cs
View File

@ -101,12 +101,12 @@ namespace MonoTests.System.Net.Http.Headers
Assert.AreEqual ("1.1", res.ProtocolVersion, "#3");
Assert.AreEqual ("1.1 nowhere.com", res.ToString (), "#4");
res = ViaHeaderValue.Parse ("foo / 1.1 nowhere.com:43 ( lalala ) ");
res = ViaHeaderValue.Parse ("foo / 1.1 nowhere.com:43 ( lal ( a ) la ) ");
Assert.AreEqual ("foo", res.ProtocolName, "#10");
Assert.AreEqual ("1.1", res.ProtocolVersion, "#11");
Assert.AreEqual ("nowhere.com:43", res.ReceivedBy, "#12");
Assert.AreEqual ("( lalala )", res.Comment, "#13");
Assert.AreEqual ("foo/1.1 nowhere.com:43 ( lalala )", res.ToString (), "#14");
Assert.AreEqual ("( lal ( a ) la )", res.Comment, "#13");
Assert.AreEqual ("foo/1.1 nowhere.com:43 ( lal ( a ) la )", res.ToString (), "#14");
}
[Test]

156
mcs/class/System.Net.Http/Test/System.Net.Http/HttpClientTest.cs
View File

@ -83,6 +83,73 @@ namespace MonoTests.System.Net.Http
}
}
class CustomStream : Stream
{
public override void Flush ()
{
throw new NotImplementedException ();
}
int pos;
public override int Read (byte[] buffer, int offset, int count)
{
++pos;
if (pos > 4)
return 0;
return 11;
}
public override long Seek (long offset, SeekOrigin origin)
{
throw new NotImplementedException ();
}
public override void SetLength (long value)
{
throw new NotImplementedException ();
}
public override void Write (byte[] buffer, int offset, int count)
{
throw new NotImplementedException ();
}
public override bool CanRead {
get {
return true;
}
}
public override bool CanSeek {
get {
return false;
}
}
public override bool CanWrite {
get {
throw new NotImplementedException ();
}
}
public override long Length {
get {
throw new NotImplementedException ();
}
}
public override long Position {
get {
throw new NotImplementedException ();
}
set {
throw new NotImplementedException ();
}
}
}
const int WaitTimeout = 5000;
string port, TestHost, LocalServer;
@ -170,6 +237,35 @@ namespace MonoTests.System.Net.Http
client.SendAsync (request).Wait (WaitTimeout);
}
[Test]
public void CancelRequestViaProxy ()
{
var handler = new HttpClientHandler {
Proxy = new WebProxy ("192.168.10.25:8888/"), // proxy that doesn't exist
UseProxy = true,
AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate
};
var httpClient = new HttpClient (handler) {
BaseAddress = new Uri ("https://google.com"),
Timeout = TimeSpan.FromMilliseconds (1)
};
try {
var restRequest = new HttpRequestMessage {
Method = HttpMethod.Post,
RequestUri = new Uri("foo", UriKind.Relative),
Content = new StringContent("", null, "application/json")
};
httpClient.PostAsync (restRequest.RequestUri, restRequest.Content).Wait (WaitTimeout);
Assert.Fail ("#1");
} catch (AggregateException e) {
Assert.IsTrue (e.InnerException is TaskCanceledException, "#2");
}
}
[Test]
public void Properties ()
{
@ -219,6 +315,24 @@ namespace MonoTests.System.Net.Http
Assert.AreEqual (response, client.SendAsync (request).Result, "#1");
}
[Test]
public void Send_BaseAddress ()
{
var mh = new HttpMessageHandlerMock ();
var client = new HttpClient (mh);
client.BaseAddress = new Uri ("http://localhost/");
var response = new HttpResponseMessage ();
mh.OnSend = l => {
Assert.AreEqual ("http://localhost/relative", l.RequestUri.ToString (), "#2");
return Task.FromResult (response);
};
Assert.AreEqual (response, client.GetAsync ("relative").Result, "#1");
Assert.AreEqual (response, client.GetAsync ("/relative").Result, "#2");
}
[Test]
public void Send_DefaultRequestHeaders ()
{
@ -653,6 +767,31 @@ namespace MonoTests.System.Net.Http
}
}
[Test]
public void Send_Content_Put_CustomStream ()
{
bool passed = false;
var listener = CreateListener (l => {
var request = l.Request;
passed = 44 == request.ContentLength64;
passed &= request.ContentType == null;
});
try {
var client = new HttpClient ();
var r = new HttpRequestMessage (HttpMethod.Put, LocalServer);
r.Content = new StreamContent (new CustomStream ());
var response = client.SendAsync (r).Result;
Assert.AreEqual (HttpStatusCode.OK, response.StatusCode, "#1");
Assert.IsTrue (passed, "#2");
} finally {
listener.Abort ();
listener.Close ();
}
}
[Test]
public void Send_Timeout ()
{
@ -729,17 +868,6 @@ namespace MonoTests.System.Net.Http
}
}
[Test]
public void GetString_RelativeUri ()
{
var client = new HttpClient ();
client.BaseAddress = new Uri ("http://en.wikipedia.org/wiki/");
var uri = new Uri ("Computer", UriKind.Relative);
Assert.That (client.GetStringAsync (uri).Result != null);
Assert.That (client.GetStringAsync ("Computer").Result != null);
}
[Test]
[Category ("MobileNotWorking")] // Missing encoding
public void GetString_Many ()
@ -816,8 +944,10 @@ namespace MonoTests.System.Net.Http
chandler.AllowAutoRedirect = true;
var client = new HttpClient (chandler);
var resp = client.GetAsync (LocalServer).Result;
Assert.AreEqual ("http://xamarin.com/", resp.RequestMessage.RequestUri.AbsoluteUri, "#1");
var r = client.GetAsync (LocalServer);
Assert.IsTrue (r.Wait (WaitTimeout), "#1");
var resp = r.Result;
Assert.AreEqual ("http://xamarin.com/", resp.RequestMessage.RequestUri.AbsoluteUri, "#2");
} finally {
listener.Abort ();
listener.Close ();

82
mcs/class/System.Net.Http/Test/System.Net.Http/HttpRequestMessageTest.cs
View File

@ -99,6 +99,20 @@ namespace MonoTests.System.Net.Http
Assert.AreEqual (req.RequestUri, uri);
}
[Test]
public void Ctor_RelativeOrAbsoluteUri ()
{
var uri = new Uri ("/", UriKind.RelativeOrAbsolute);
new HttpRequestMessage (HttpMethod.Get, uri);
uri = new Uri ("file://", UriKind.RelativeOrAbsolute);
try {
new HttpRequestMessage (HttpMethod.Get, uri);
Assert.Fail ("#1");
} catch (ArgumentException) {
}
}
[Test]
public void Ctor_RelativeUriString ()
{
@ -109,6 +123,18 @@ namespace MonoTests.System.Net.Http
Assert.IsFalse (req.RequestUri.IsAbsoluteUri);
}
[Test]
public void Ctor_RelativeOrAbsoluteUriString ()
{
new HttpRequestMessage (HttpMethod.Get, "/");
try {
new HttpRequestMessage (HttpMethod.Get, "file://");
Assert.Fail ("#1");
} catch (ArgumentException) {
}
}
[Test]
public void Headers ()
{
@ -437,6 +463,62 @@ namespace MonoTests.System.Net.Http
new ProductInfoHeaderValue ("MonoDevelop", null),
new ProductInfoHeaderValue ("(Unix 3.13.0; amd64; en-US; Octokit 0.3.4)")
});
Assert.IsTrue (se, "#1");
Assert.AreEqual ("MonoDevelop (Unix 3.13.0; amd64; en-US; Octokit 0.3.4)", headers.UserAgent.ToString (), "#2");
}
[Test]
public void Headers_UserAgentExtraWithTabs ()
{
HttpRequestMessage message = new HttpRequestMessage ();
var headers = message.Headers;
headers.Add ("User-Agent", "A \t \t B");
var se = headers.UserAgent.SequenceEqual (
new[] {
new ProductInfoHeaderValue ("A", null),
new ProductInfoHeaderValue ("B", null)
});
Assert.IsTrue (se, "#1");
Assert.AreEqual ("A B", headers.UserAgent.ToString (), "#2");
}
[Test]
public void Headers_UserAgentInvalid ()
{
HttpRequestMessage message = new HttpRequestMessage ();
var headers = message.Headers;
try {
headers.Add ("User-Agent", "A(B)");
Assert.Fail ("#1");
} catch (FormatException) {
}
}
[Test]
public void Headers_AcceptMulti ()
{
var request = new HttpRequestMessage();
var headers = request.Headers;
headers.Add("Accept", "application/vnd.github.moondragon+json; charset=utf-8,application/vnd.github.v3+json; charset=utf-8");
var se = headers.Accept.SequenceEqual (
new[] {
new MediaTypeHeaderValue ("application/vnd.github.moondragon+json") {
CharSet = "utf-8"
},
new MediaTypeHeaderValue ("application/vnd.github.v3+json") {
CharSet = "utf-8"
}
});
Assert.IsTrue (se, "#1");
Assert.AreEqual ("application/vnd.github.moondragon+json; charset=utf-8, application/vnd.github.v3+json; charset=utf-8", headers.Accept.ToString (), "#2");
}
[Test]