Imported Upstream version 4.0.0~alpha1

Former-commit-id: 806294f5ded97629b74c85c09952f2a74fe182d9

mcs/class/System.Net.Http/Test/System.Net.Http.Headers/ContentDispositionHeaderValueTest.cs

@@ -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]

mcs/class/System.Net.Http/Test/System.Net.Http.Headers/ContentRangeHeaderValueTest.cs

@@ -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");

mcs/class/System.Net.Http/Test/System.Net.Http.Headers/NameValueHeaderValueTest.cs

@@ -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]

mcs/class/System.Net.Http/Test/System.Net.Http.Headers/RangeHeaderValueTest.cs

@@ -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]

mcs/class/System.Net.Http/Test/System.Net.Http.Headers/ViaHeaderValueTest.cs

@@ -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]

mcs/class/System.Net.Http/Test/System.Net.Http/HttpClientTest.cs

@@ -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 ();

mcs/class/System.Net.Http/Test/System.Net.Http/HttpRequestMessageTest.cs

@@ -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]