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

   1 //
   2 // HttpClientTest.cs
   3 //
   4 // Authors:
   5 //      Marek Safar  <marek.safar@gmail.com>
   6 //
   7 // Copyright (C) 2011 Xamarin Inc (http://www.xamarin.com)
   8 //
   9 // Permission is hereby granted, free of charge, to any person obtaining
  10 // a copy of this software and associated documentation files (the
  11 // "Software"), to deal in the Software without restriction, including
  12 // without limitation the rights to use, copy, modify, merge, publish,
  13 // distribute, sublicense, and/or sell copies of the Software, and to
  14 // permit persons to whom the Software is furnished to do so, subject to
  15 // the following conditions:
  16 //
  17 // The above copyright notice and this permission notice shall be
  18 // included in all copies or substantial portions of the Software.
  19 //
  20 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  21 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  22 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  23 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  24 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  25 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  26 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  27 //
  28
  29 using System;
  30 using System.Collections;
  31 using System.Collections.Generic;
  32 using NUnit.Framework;
  33 using System.Net.Http;
  34 using System.Net.Http.Headers;
  35 using System.Threading;
  36 using System.Threading.Tasks;
  37 using System.Net;
  38 using System.Linq;
  39 using System.IO;
  40
  41 using MonoTests.Helpers;
  42
  43 namespace MonoTests.System.Net.Http
  44 {
  45         [TestFixture]
  46         public class HttpClientTest
  47         {
  48                 class HttpMessageHandlerMock : HttpMessageHandler
  49                 {
  50                         public Func<HttpRequestMessage, Task<HttpResponseMessage>> OnSend;
  51                         public Func<HttpRequestMessage, CancellationToken, Task<HttpResponseMessage>> OnSendFull;
  52
  53                         public HttpMessageHandlerMock ()
  54                         {
  55                         }
  56
  57                         protected override Task<HttpResponseMessage> SendAsync (HttpRequestMessage request, CancellationToken cancellationToken)
  58                         {
  59                                 if (OnSend != null)
  60                                         return OnSend (request);
  61
  62                                 if (OnSendFull != null)
  63                                         return OnSendFull (request, cancellationToken);
  64
  65                                 Assert.Fail ("Send");
  66                                 return null;
  67                         }
  68                 }
  69
  70                 class HttpClientHandlerMock : HttpClientHandler
  71                 {
  72                         public Func<HttpRequestMessage, Task<HttpResponseMessage>> OnSend;
  73                         public Func<HttpRequestMessage, CancellationToken, Task<HttpResponseMessage>> OnSendFull;
  74
  75                         protected override Task<HttpResponseMessage> SendAsync (HttpRequestMessage request, CancellationToken cancellationToken)
  76                         {
  77                                 if (OnSend != null)
  78                                         return OnSend (request);
  79
  80                                 if (OnSendFull != null)
  81                                         return OnSendFull (request, cancellationToken);
  82
  83                                 Assert.Fail ("Send");
  84                                 return null;
  85                         }
  86                 }
  87
  88                 class CustomStream : Stream
  89                 {
  90                         public override void Flush ()
  91                         {
  92                                 throw new NotImplementedException ();
  93                         }
  94
  95                         int pos;
  96
  97                         public override int Read (byte[] buffer, int offset, int count)
  98                         {
  99                                 ++pos;
 100                                 if (pos > 4)
 101                                         return 0;
 102
 103                                 return 11;
 104                         }
 105
 106                         public override long Seek (long offset, SeekOrigin origin)
 107                         {
 108                                 throw new NotImplementedException ();
 109                         }
 110
 111                         public override void SetLength (long value)
 112                         {
 113                                 throw new NotImplementedException ();
 114                         }
 115
 116                         public override void Write (byte[] buffer, int offset, int count)
 117                         {
 118                                 throw new NotImplementedException ();
 119                         }
 120
 121                         public override bool CanRead {
 122                                 get {
 123                                         return true;
 124                                 }
 125                         }
 126
 127                         public override bool CanSeek {
 128                                 get {
 129                                         return false;
 130                                 }
 131                         }
 132
 133                         public override bool CanWrite {
 134                                 get {
 135                                         throw new NotImplementedException ();
 136                                 }
 137                         }
 138
 139                         public override long Length {
 140                                 get {
 141                                         throw new NotImplementedException ();
 142                                 }
 143                         }
 144
 145                         public override long Position {
 146                                 get {
 147                                         throw new NotImplementedException ();
 148                                 }
 149                                 set {
 150                                         throw new NotImplementedException ();
 151                                 }
 152                         }
 153                 }
 154
 155                 class ThrowOnlyProxy : IWebProxy
 156                 {
 157                         public ICredentials Credentials {
 158                                 get {
 159                                         throw new NotImplementedException ();
 160                                 }
 161
 162                                 set {
 163                                         throw new NotImplementedException ();
 164                                 }
 165                         }
 166
 167                         public Uri GetProxy (Uri destination)
 168                         {
 169                                 throw new NotImplementedException ();
 170                         }
 171
 172                         public bool IsBypassed (Uri host)
 173                         {
 174                                 throw new NotImplementedException ();
 175                         }
 176                 }
 177
 178                 const int WaitTimeout = 10000;
 179
 180                 [Test]
 181                 public void Ctor ()
 182                 {
 183                         var client = new HttpClient ();
 184                         Assert.IsNull (client.BaseAddress, "#1");
 185                         Assert.IsNotNull (client.DefaultRequestHeaders, "#2");  // TODO: full check
 186                         Assert.AreEqual (int.MaxValue, client.MaxResponseContentBufferSize, "#3");
 187                         Assert.AreEqual (TimeSpan.FromSeconds (100), client.Timeout, "#4");
 188                 }
 189
 190                 [Test]
 191 #if FEATURE_NO_BSD_SOCKETS
 192 #if !MONOTOUCH_WATCH
 193                 [ExpectedException (typeof (PlatformNotSupportedException))]
 194 #endif
 195 #endif
 196                 public void Ctor_HttpClientHandler ()
 197                 {
 198                         var client = HttpClientTestHelpers.CreateHttpClientWithHttpClientHandler ();
 199                         Assert.IsNull (client.BaseAddress, "#1");
 200                         Assert.IsNotNull (client.DefaultRequestHeaders, "#2");  // TODO: full check
 201                         Assert.AreEqual (int.MaxValue, client.MaxResponseContentBufferSize, "#3");
 202                         Assert.AreEqual (TimeSpan.FromSeconds (100), client.Timeout, "#4");
 203                 }
 204
 205                 [Test]
 206                 public void CancelPendingRequests ()
 207                 {
 208                         var mh = new HttpMessageHandlerMock ();
 209
 210                         var client = new HttpClient (mh);
 211                         var request = new HttpRequestMessage (HttpMethod.Get, "http://xamarin.com");
 212                         var mre = new ManualResetEvent (false);
 213
 214                         mh.OnSendFull = (l, c) => {
 215                                 mre.Set ();
 216                                 Assert.IsTrue (c.WaitHandle.WaitOne (1000), "#20");
 217                                 Assert.IsTrue (c.IsCancellationRequested, "#21");
 218                                 mre.Set ();
 219                                 return Task.FromResult (new HttpResponseMessage ());
 220                         };
 221
 222                         var t = Task.Factory.StartNew (() => {
 223                                 client.SendAsync (request).Wait (WaitTimeout);
 224                         });
 225
 226                         Assert.IsTrue (mre.WaitOne (500), "#1");
 227                         mre.Reset ();
 228                         client.CancelPendingRequests ();
 229                         Assert.IsTrue (t.Wait (500), "#2");
 230
 231                         request = new HttpRequestMessage (HttpMethod.Get, "http://xamarin.com");
 232                         mh.OnSendFull = (l, c) => {
 233                                 Assert.IsFalse (c.IsCancellationRequested, "#30");
 234                                 return Task.FromResult (new HttpResponseMessage ());
 235                         };
 236
 237                         client.SendAsync (request).Wait (WaitTimeout);
 238                 }
 239
 240                 [Test]
 241                 public void CancelPendingRequests_BeforeSend ()
 242                 {
 243                         var ct = new CancellationTokenSource ();
 244                         ct.Cancel ();
 245                         var rr = CancellationTokenSource.CreateLinkedTokenSource (new CancellationToken (), ct.Token);
 246
 247
 248                         var mh = new HttpMessageHandlerMock ();
 249
 250                         var client = new HttpClient (mh);
 251                         var request = new HttpRequestMessage (HttpMethod.Get, "http://xamarin.com");
 252                         client.CancelPendingRequests ();
 253
 254                         mh.OnSendFull = (l, c) => {
 255                                 Assert.IsFalse (c.IsCancellationRequested, "#30");
 256                                 return Task.FromResult (new HttpResponseMessage ());
 257                         };
 258
 259                         client.SendAsync (request).Wait (WaitTimeout);
 260
 261                         request = new HttpRequestMessage (HttpMethod.Get, "http://xamarin.com");
 262                         client.SendAsync (request).Wait (WaitTimeout);
 263                 }
 264
 265
 266                 [Test]
 267                 [Ignore]
 268 #if FEATURE_NO_BSD_SOCKETS
 269                 // Using HttpClientHandler, which indirectly requires BSD sockets.
 270                 [ExpectedException (typeof (PlatformNotSupportedException))]
 271 #endif
 272                 public void CancelRequestViaProxy ()
 273                 {
 274                         var handler = HttpClientTestHelpers.CreateHttpClientHandler ();
 275                         handler.Proxy = new WebProxy ("192.168.10.25:8888/"); // proxy that doesn't exist
 276                         handler.UseProxy = true;
 277                         handler.AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate;
 278
 279                         var httpClient = new HttpClient (handler) {
 280                                 BaseAddress = new Uri ("https://www.example.com"),
 281                                 Timeout = TimeSpan.FromMilliseconds (1)
 282                         };
 283
 284                         try {
 285                                 var restRequest = new HttpRequestMessage {
 286                                         Method = HttpMethod.Post,
 287                                         RequestUri = new Uri("foo", UriKind.Relative),
 288                                         Content = new StringContent("", null, "application/json")
 289                                 };
 290
 291                                 httpClient.PostAsync (restRequest.RequestUri, restRequest.Content).Wait (WaitTimeout);
 292                                 Assert.Fail ("#1");
 293                         } catch (AggregateException e) {
 294                                 Assert.That (e.InnerException, Is.InstanceOf<TaskCanceledException> (), $"#2: {e}");
 295                         }
 296                 }
 297
 298                 [Test]
 299                 public void Properties ()
 300                 {
 301                         var client = new HttpClient ();
 302                         client.BaseAddress = null;
 303                         client.MaxResponseContentBufferSize = int.MaxValue;
 304                         client.Timeout = Timeout.InfiniteTimeSpan;
 305
 306                         Assert.IsNull (client.BaseAddress, "#1");
 307                         Assert.AreEqual (int.MaxValue, client.MaxResponseContentBufferSize, "#2");
 308                         Assert.AreEqual (Timeout.InfiniteTimeSpan, client.Timeout, "#3");
 309                 }
 310
 311                 [Test]
 312                 public void Properties_Invalid ()
 313                 {
 314                         var client = new HttpClient ();
 315                         try {
 316                                 client.MaxResponseContentBufferSize = 0;
 317                                 Assert.Fail ("#1");
 318                         } catch (ArgumentOutOfRangeException) {
 319                         }
 320
 321                         try {
 322                                 client.Timeout = TimeSpan.MinValue;
 323                                 Assert.Fail ("#2");
 324                         } catch (ArgumentOutOfRangeException) {
 325                         }
 326
 327                         try {
 328                                 client.Timeout = TimeSpan.Zero;
 329                                 Assert.Fail ("#3");
 330                         } catch (ArgumentOutOfRangeException) {
 331                         }
 332
 333                         try {
 334                                 client.Timeout = TimeSpan.FromMilliseconds (int.MaxValue + 1L);
 335                                 Assert.Fail ("#3");
 336                         } catch (ArgumentOutOfRangeException) {
 337                         }
 338                 }
 339
 340                 [Test]
 341 #if FEATURE_NO_BSD_SOCKETS
 342                 [ExpectedException (typeof (PlatformNotSupportedException))]
 343 #endif
 344                 [Category ("InetAccess")]
 345                 public void Proxy_Disabled ()
 346                 {
 347                         var pp = WebRequest.DefaultWebProxy;
 348
 349                         try {
 350                                 WebRequest.DefaultWebProxy = new ThrowOnlyProxy ();
 351
 352                                 var request = HttpClientTestHelpers.CreateHttpClientHandler ();
 353                                 request.UseProxy = false;
 354
 355                                 var client = new HttpClient (request);
 356                                 Assert.IsTrue (client.GetAsync ("http://www.example.com").Wait (5000), "needs internet access");
 357                         } finally {
 358                                 WebRequest.DefaultWebProxy = pp;
 359                         }
 360                 }
 361
 362                 [Test]
 363                 public void Send ()
 364                 {
 365                         var mh = new HttpMessageHandlerMock ();
 366
 367                         var client = new HttpClient (mh);
 368                         client.BaseAddress = new Uri ("http://www.example.com");
 369                         var request = new HttpRequestMessage ();
 370                         var response = new HttpResponseMessage ();
 371
 372                         mh.OnSend = l => {
 373                                 Assert.AreEqual (l, request, "#2");
 374                                 Assert.AreEqual (client.BaseAddress, l.RequestUri, "#2");
 375                                 return Task.FromResult (response);
 376                         };
 377
 378                         Assert.AreEqual (response, client.SendAsync (request).Result, "#1");
 379                 }
 380
 381                 [Test]
 382                 public void Send_BaseAddress ()
 383                 {
 384                         var mh = new HttpMessageHandlerMock ();
 385
 386                         var client = new HttpClient (mh);
 387                         client.BaseAddress = new Uri ("http://localhost/");
 388                         var response = new HttpResponseMessage ();
 389
 390                         mh.OnSend = l => {
 391                                 Assert.AreEqual ("http://localhost/relative", l.RequestUri.ToString (), "#2");
 392                                 return Task.FromResult (response);
 393                         };
 394
 395                         Assert.AreEqual (response, client.GetAsync ("relative").Result, "#1");
 396                         Assert.AreEqual (response, client.GetAsync ("/relative").Result, "#2");
 397                 }
 398
 399                 [Test]
 400                 public void Send_DefaultRequestHeaders ()
 401                 {
 402                         var mh = new HttpMessageHandlerMock ();
 403
 404                         var client = new HttpClient (mh);
 405                         client.DefaultRequestHeaders.Referrer = new Uri ("http://www.example.com");
 406
 407                         var request = new HttpRequestMessage (HttpMethod.Get, "http://www.example.org");
 408                         var response = new HttpResponseMessage ();
 409
 410                         mh.OnSend = l => {
 411                                 Assert.AreEqual (client.DefaultRequestHeaders.Referrer, l.Headers.Referrer, "#2");
 412                                 Assert.IsNotNull (l.Headers.Referrer, "#3");
 413                                 return Task.FromResult (response);
 414                         };
 415
 416                         Assert.AreEqual (response, client.SendAsync (request).Result, "#1");
 417                 }
 418
 419                 [Test]
 420 #if FEATURE_NO_BSD_SOCKETS
 421                 [ExpectedException (typeof (PlatformNotSupportedException))]
 422 #endif
 423                 public void Send_Complete_Default ()
 424                 {
 425                         bool? failed = null;
 426                         var listener = NetworkHelpers.CreateAndStartHttpListener("http://*:", out int port, "/Send_Complete_Default/");
 427                         AddListenerContext (listener, l => {
 428                                 try {
 429                                         var request = l.Request;
 430
 431                                         Assert.IsNull (request.AcceptTypes, "#1");
 432                                         Assert.AreEqual (0, request.ContentLength64, "#2");
 433                                         Assert.IsNull (request.ContentType, "#3");
 434                                         Assert.AreEqual (0, request.Cookies.Count, "#4");
 435                                         Assert.IsFalse (request.HasEntityBody, "#5");
 436                                         Assert.AreEqual ($"localhost:{port}", request.Headers["Host"], "#6b");
 437                                         Assert.AreEqual ("GET", request.HttpMethod, "#7");
 438                                         Assert.IsFalse (request.IsAuthenticated, "#8");
 439                                         Assert.IsTrue (request.IsLocal, "#9");
 440                                         Assert.IsFalse (request.IsSecureConnection, "#10");
 441                                         Assert.IsFalse (request.IsWebSocketRequest, "#11");
 442                                         Assert.IsTrue (request.KeepAlive, "#12");
 443                                         Assert.AreEqual (HttpVersion.Version11, request.ProtocolVersion, "#13");
 444                                         Assert.IsNull (request.ServiceName, "#14");
 445                                         Assert.IsNull (request.UrlReferrer, "#15");
 446                                         Assert.IsNull (request.UserAgent, "#16");
 447                                         Assert.IsNull (request.UserLanguages, "#17");
 448                                         failed = false;
 449                                 } catch {
 450                                         failed = true;
 451                                 }
 452                         });
 453
 454                         try {
 455                                 var client = HttpClientTestHelpers.CreateHttpClientWithHttpClientHandler ();
 456                                 var request = new HttpRequestMessage (HttpMethod.Get, $"http://localhost:{port}/Send_Complete_Default/");
 457                                 var response = client.SendAsync (request, HttpCompletionOption.ResponseHeadersRead).Result;
 458
 459                                 Assert.AreEqual ("", response.Content.ReadAsStringAsync ().Result, "#100");
 460                                 Assert.AreEqual (HttpStatusCode.OK, response.StatusCode, "#101");
 461                                 Assert.AreEqual (false, failed, "#102");
 462                         } finally {
 463                                 listener.Close ();
 464                         }
 465                 }
 466
 467                 [Test]
 468 #if FEATURE_NO_BSD_SOCKETS
 469                 [ExpectedException (typeof (PlatformNotSupportedException))]
 470 #endif
 471                 public void Send_Complete_Version_1_0 ()
 472                 {
 473                         bool? failed = null;
 474
 475                         var listener = NetworkHelpers.CreateAndStartHttpListener("http://*:", out int port, "/Send_Complete_Version_1_0/");
 476                         AddListenerContext (listener, l => {
 477                                 try {
 478                                         var request = l.Request;
 479
 480                                         Assert.IsNull (request.AcceptTypes, "#1");
 481                                         Assert.AreEqual (0, request.ContentLength64, "#2");
 482                                         Assert.IsNull (request.ContentType, "#3");
 483                                         Assert.AreEqual (0, request.Cookies.Count, "#4");
 484                                         Assert.IsFalse (request.HasEntityBody, "#5");
 485                                         Assert.AreEqual (1, request.Headers.Count, "#6");
 486                                         Assert.AreEqual ($"localhost:{port}", request.Headers["Host"], "#6a");
 487                                         Assert.AreEqual ("GET", request.HttpMethod, "#7");
 488                                         Assert.IsFalse (request.IsAuthenticated, "#8");
 489                                         Assert.IsTrue (request.IsLocal, "#9");
 490                                         Assert.IsFalse (request.IsSecureConnection, "#10");
 491                                         Assert.IsFalse (request.IsWebSocketRequest, "#11");
 492                                         Assert.IsFalse (request.KeepAlive, "#12");
 493                                         Assert.AreEqual (HttpVersion.Version10, request.ProtocolVersion, "#13");
 494                                         Assert.IsNull (request.ServiceName, "#14");
 495                                         Assert.IsNull (request.UrlReferrer, "#15");
 496                                         Assert.IsNull (request.UserAgent, "#16");
 497                                         Assert.IsNull (request.UserLanguages, "#17");
 498                                         failed = false;
 499                                 } catch {
 500                                         failed = true;
 501                                 }
 502                         });
 503
 504                         try {
 505                                 var client = HttpClientTestHelpers.CreateHttpClientWithHttpClientHandler ();
 506                                 var request = new HttpRequestMessage (HttpMethod.Get, $"http://localhost:{port}/Send_Complete_Version_1_0/");
 507                                 request.Version = HttpVersion.Version10;
 508                                 var response = client.SendAsync (request, HttpCompletionOption.ResponseHeadersRead).Result;
 509
 510                                 Assert.AreEqual ("", response.Content.ReadAsStringAsync ().Result, "#100");
 511                                 Assert.AreEqual (HttpStatusCode.OK, response.StatusCode, "#101");
 512                                 Assert.AreEqual (false, failed, "#102");
 513                         } finally {
 514                                 listener.Close ();
 515                         }
 516                 }
 517
 518                 [Test]
 519 #if FEATURE_NO_BSD_SOCKETS
 520                 [ExpectedException (typeof (PlatformNotSupportedException))]
 521 #endif
 522                 public void Send_Complete_ClientHandlerSettings ()
 523                 {
 524                         bool? failed = null;
 525
 526                         var listener = NetworkHelpers.CreateAndStartHttpListener("http://*:", out int port, "/Send_Complete_ClientHandlerSettings/");
 527                         AddListenerContext (listener, l => {
 528                                 var request = l.Request;
 529
 530                                 try {
 531                                         Assert.IsNull (request.AcceptTypes, "#1");
 532                                         Assert.AreEqual (0, request.ContentLength64, "#2");
 533                                         Assert.IsNull (request.ContentType, "#3");
 534                                         Assert.AreEqual (1, request.Cookies.Count, "#4");
 535                                         Assert.AreEqual (new Cookie ("mycookie", "vv"), request.Cookies[0], "#4a");
 536                                         Assert.IsFalse (request.HasEntityBody, "#5");
 537                                         Assert.AreEqual (4, request.Headers.Count, "#6");
 538                                         Assert.AreEqual ($"localhost:{port}", request.Headers["Host"], "#6a");
 539                                         Assert.AreEqual ("gzip", request.Headers["Accept-Encoding"], "#6b");
 540                                         Assert.AreEqual ("mycookie=vv", request.Headers["Cookie"], "#6c");
 541                                         Assert.AreEqual ("GET", request.HttpMethod, "#7");
 542                                         Assert.IsFalse (request.IsAuthenticated, "#8");
 543                                         Assert.IsTrue (request.IsLocal, "#9");
 544                                         Assert.IsFalse (request.IsSecureConnection, "#10");
 545                                         Assert.IsFalse (request.IsWebSocketRequest, "#11");
 546                                         Assert.IsTrue (request.KeepAlive, "#12");
 547                                         Assert.AreEqual (HttpVersion.Version10, request.ProtocolVersion, "#13");
 548                                         Assert.IsNull (request.ServiceName, "#14");
 549                                         Assert.IsNull (request.UrlReferrer, "#15");
 550                                         Assert.IsNull (request.UserAgent, "#16");
 551                                         Assert.IsNull (request.UserLanguages, "#17");
 552                                         failed = false;
 553                                 } catch {
 554                                         failed = true;
 555                                 }
 556                         });
 557
 558                         try {
 559                                 var chandler = HttpClientTestHelpers.CreateHttpClientHandler ();
 560                                 chandler.AllowAutoRedirect = true;
 561                                 chandler.AutomaticDecompression = DecompressionMethods.GZip;
 562                                 chandler.MaxAutomaticRedirections = 33;
 563                                 chandler.MaxRequestContentBufferSize = 5555;
 564                                 chandler.PreAuthenticate = true;
 565                                 chandler.CookieContainer.Add (new Uri ($"http://localhost:{port}/Send_Complete_ClientHandlerSettings/"), new Cookie ( "mycookie", "vv"));
 566                                 chandler.UseCookies = true;
 567                                 chandler.UseDefaultCredentials = true;
 568                                 chandler.Proxy = new WebProxy ("ee");
 569                                 chandler.UseProxy = true;
 570
 571                                 var client = new HttpClient (chandler);
 572                                 var request = new HttpRequestMessage (HttpMethod.Get, $"http://localhost:{port}/Send_Complete_ClientHandlerSettings/");
 573                                 request.Version = HttpVersion.Version10;
 574                                 request.Headers.Add ("Keep-Alive", "false");
 575                                 var response = client.SendAsync (request, HttpCompletionOption.ResponseHeadersRead).Result;
 576
 577                                 Assert.AreEqual ("", response.Content.ReadAsStringAsync ().Result, "#100");
 578                                 Assert.AreEqual (HttpStatusCode.OK, response.StatusCode, "#101");
 579                                 Assert.AreEqual (false, failed, "#102");
 580                         } finally {
 581                                 listener.Abort ();
 582                                 listener.Close ();
 583                         }
 584                 }
 585
 586                 [Test]
 587 #if FEATURE_NO_BSD_SOCKETS
 588                 [ExpectedException (typeof (PlatformNotSupportedException))]
 589 #endif
 590                 public void Send_Complete_CustomHeaders ()
 591                 {
 592                         bool? failed = null;
 593
 594                         var listener = NetworkHelpers.CreateAndStartHttpListener("http://*:", out int port, "/Send_Complete_CustomHeaders/");
 595                         AddListenerContext (listener, l => {
 596                                 var request = l.Request;
 597                                 try {
 598                                         Assert.AreEqual ("vv", request.Headers["aa"], "#1");
 599
 600                                         var response = l.Response;
 601                                         response.Headers.Add ("rsp", "rrr");
 602                                         response.Headers.Add ("upgrade", "vvvvaa");
 603                                         response.Headers.Add ("Date", "aa");
 604                                         response.Headers.Add ("cache-control", "audio");
 605
 606                                         response.StatusDescription = "test description";
 607                                         response.ProtocolVersion = HttpVersion.Version10;
 608                                         response.SendChunked = true;
 609                                         response.RedirectLocation = "w3.org";
 610
 611                                         failed = false;
 612                                 } catch {
 613                                         failed = true;
 614                                 }
 615                         });
 616
 617                         try {
 618                                 var handler = HttpClientTestHelpers.CreateHttpClientHandler ();
 619                                 var client = new HttpClient (handler);
 620                                 var request = new HttpRequestMessage (HttpMethod.Get, $"http://localhost:{port}/Send_Complete_CustomHeaders/");
 621                                 Assert.IsTrue (request.Headers.TryAddWithoutValidation ("aa", "vv"), "#0");
 622                                 var response = client.SendAsync (request, HttpCompletionOption.ResponseHeadersRead).Result;
 623
 624                                 Assert.AreEqual ("", response.Content.ReadAsStringAsync ().Result, "#100");
 625                                 Assert.AreEqual (HttpStatusCode.OK, response.StatusCode, "#101");
 626
 627                                 IEnumerable<string> values;
 628                                 Assert.IsTrue (response.Headers.TryGetValues ("rsp", out values), "#102");
 629                                 Assert.AreEqual ("rrr", values.First (), "#102a");
 630
 631                                 Assert.IsTrue (response.Headers.TryGetValues ("Transfer-Encoding", out values), "#103");
 632                                 Assert.AreEqual ("chunked", values.First (), "#103a");
 633                                 Assert.AreEqual (true, response.Headers.TransferEncodingChunked, "#103b");
 634
 635                                 Assert.IsTrue (response.Headers.TryGetValues ("Date", out values), "#104");
 636                                 Assert.AreEqual (1, values.Count (), "#104b");
 637                                 // .NET overwrites Date, Mono does not
 638                                 // Assert.IsNotNull (response.Headers.Date, "#104c");
 639
 640                                 Assert.AreEqual (new ProductHeaderValue ("vvvvaa"), response.Headers.Upgrade.First (), "#105");
 641
 642                                 Assert.AreEqual ("audio", response.Headers.CacheControl.Extensions.First ().Name, "#106");
 643
 644                                 Assert.AreEqual ("w3.org", response.Headers.Location.OriginalString, "#107");
 645
 646                                 Assert.AreEqual ("test description", response.ReasonPhrase, "#110");
 647                                 if (HttpClientTestHelpers.IsSocketsHandler (handler))
 648                                         Assert.AreEqual (HttpVersion.Version10, response.Version, "#111");
 649                                 else
 650                                         Assert.AreEqual (HttpVersion.Version11, response.Version, "#111");
 651
 652                                 Assert.AreEqual (false, failed, "#112");
 653                         } finally {
 654                                 listener.Close ();
 655                         }
 656                 }
 657
 658                 [Test]
 659 #if FEATURE_NO_BSD_SOCKETS
 660                 [ExpectedException (typeof (PlatformNotSupportedException))]
 661 #endif
 662                 public void Send_Complete_CustomHeaders_SpecialSeparators ()
 663                 {
 664                         bool? failed = null;
 665
 666                         var listener = NetworkHelpers.CreateAndStartHttpListener("http://*:", out int port, "/Send_Complete_CustomHeaders_SpecialSeparators/");
 667                         AddListenerContext (listener, l => {
 668                                 var request = l.Request;
 669
 670                                 try {
 671                                         Assert.AreEqual ("MLK Android Phone 1.1.9", request.UserAgent, "#1");
 672                                         failed = false;
 673                                 } catch {
 674                                         failed = true;
 675                                 }
 676                         });
 677
 678                         try {
 679                                 var client = HttpClientTestHelpers.CreateHttpClientWithHttpClientHandler ();
 680
 681                                 client.DefaultRequestHeaders.Add("User-Agent", "MLK Android Phone 1.1.9");
 682
 683                                 var request = new HttpRequestMessage (HttpMethod.Get, $"http://localhost:{port}/Send_Complete_CustomHeaders_SpecialSeparators/");
 684
 685                                 var response = client.SendAsync (request, HttpCompletionOption.ResponseHeadersRead).Result;
 686
 687                                 Assert.AreEqual ("", response.Content.ReadAsStringAsync ().Result, "#100");
 688                                 Assert.AreEqual (HttpStatusCode.OK, response.StatusCode, "#101");
 689                                 Assert.AreEqual (false, failed, "#102");
 690                         } finally {
 691                                 listener.Abort ();
 692                                 listener.Close ();
 693                         }
 694                 }
 695
 696                 [Test]
 697 #if FEATURE_NO_BSD_SOCKETS
 698                 [ExpectedException (typeof (PlatformNotSupportedException))]
 699 #endif
 700                 public void Send_Complete_CustomHeaders_Host ()
 701                 {
 702                         Exception error = null;
 703                         var listener = NetworkHelpers.CreateAndStartHttpListener("http://*:", out int port, "/Send_Complete_CustomHeaders_Host/");
 704                         AddListenerContext (listener, l => {
 705                                 var request = l.Request;
 706
 707                                 try {
 708                                         Assert.AreEqual ("customhost", request.Headers["Host"], "#1");
 709                                 } catch (Exception ex) {
 710                                         error = ex;
 711                                 }
 712                         });
 713
 714                         try {
 715                                 var client = HttpClientTestHelpers.CreateHttpClientWithHttpClientHandler ();
 716
 717                                 client.DefaultRequestHeaders.Add("Host", "customhost");
 718
 719                                 var request = new HttpRequestMessage (HttpMethod.Get, $"http://localhost:{port}/Send_Complete_CustomHeaders_Host/");
 720
 721                                 var response = client.SendAsync (request, HttpCompletionOption.ResponseHeadersRead).Result;
 722
 723                                 Assert.AreEqual ("", response.Content.ReadAsStringAsync ().Result, "#100");
 724                                 Assert.AreEqual (HttpStatusCode.OK, response.StatusCode, "#101");
 725                                 Assert.IsNull (error, "#102");
 726                         } finally {
 727                                 listener.Abort ();
 728                                 listener.Close ();
 729                         }
 730                 }
 731
 732                 [Test]
 733 #if FEATURE_NO_BSD_SOCKETS
 734                 [ExpectedException (typeof (PlatformNotSupportedException))]
 735 #endif
 736                 public void Send_Transfer_Encoding_Chunked_Needs_Content ()
 737                 {
 738                         if (!HttpClientTestHelpers.UsingSocketsHandler)
 739                                 Assert.Ignore ("Requires SocketsHttpHandler");
 740
 741                         bool? failed = null;
 742
 743                         var listener = NetworkHelpers.CreateAndStartHttpListener("http://*:", out int port, "/Send_Transfer_Encoding_Chunked_Needs_Content/");
 744                         AddListenerContext (listener, l => {
 745                                 failed = true;
 746                         });
 747
 748                         try {
 749                                 try {
 750                                         var client = HttpClientTestHelpers.CreateHttpClientWithHttpClientHandler ();
 751                                         client.DefaultRequestHeaders.TransferEncodingChunked = true;
 752                                         client.GetAsync ($"http://localhost:{port}/Send_Transfer_Encoding_Chunked_Needs_Content/").Wait ();
 753                                         // fails with
 754                                         // 'Transfer-Encoding: chunked' header can not be used when content object is not specified.
 755                                 } catch (AggregateException e) {
 756                                         Assert.AreEqual (typeof (HttpRequestException), e.InnerException.GetType (), "#2");
 757                                 }
 758                                 Assert.IsNull (failed, "#102");
 759                         } finally {
 760                                 listener.Abort ();
 761                                 listener.Close ();
 762                         }
 763                 }
 764
 765                 [Test]
 766 #if FEATURE_NO_BSD_SOCKETS
 767                 [ExpectedException (typeof (PlatformNotSupportedException))]
 768 #endif
 769                 public void Send_Transfer_Encoding_Chunked ()
 770                 {
 771                         if (HttpClientTestHelpers.UsingSocketsHandler)
 772                                 Assert.Ignore ("Requires LegacyHttpClient");
 773
 774                         bool? failed = null;
 775
 776                         var listener = NetworkHelpers.CreateAndStartHttpListener("http://*:", out int port, "/Send_Transfer_Encoding_Chunked/");
 777                         AddListenerContext (listener, l => {
 778                                 var request = l.Request;
 779
 780                                 try {
 781                                         Assert.AreEqual (2, request.Headers.Count, "#1");
 782                                         Assert.AreEqual ("keep-alive", request.Headers ["Connection"], "#2");
 783                                         failed = false;
 784                                 } catch (Exception ex){
 785                                         Console.WriteLine (ex);
 786                                         Console.WriteLine (String.Join ("#", l.Request.Headers.AllKeys));
 787                                         failed = true;
 788                                 }
 789                         });
 790
 791                         try {
 792                                 var client = HttpClientTestHelpers.CreateHttpClientWithHttpClientHandler ();
 793                                 client.DefaultRequestHeaders.TransferEncodingChunked = true;
 794
 795                                 client.GetAsync ($"http://localhost:{port}/Send_Transfer_Encoding_Chunked/").Wait ();
 796
 797                                 Assert.AreEqual (false, failed, "#102");
 798                         } finally {
 799                                 listener.Abort ();
 800                                 listener.Close ();
 801                         }
 802                 }
 803
 804                 [Test]
 805 #if FEATURE_NO_BSD_SOCKETS
 806                 [ExpectedException (typeof (PlatformNotSupportedException))]
 807 #endif
 808                 public void Send_Complete_Content ()
 809                 {
 810                         var listener = NetworkHelpers.CreateAndStartHttpListener("http://*:", out int port, "/Send_Complete_Content/");
 811                         AddListenerContext (listener, l => {
 812                                 var request = l.Request;
 813                                 l.Response.OutputStream.WriteByte (55);
 814                                 l.Response.OutputStream.WriteByte (75);
 815                         });
 816
 817                         try {
 818                                 var client = HttpClientTestHelpers.CreateHttpClientWithHttpClientHandler ();
 819                                 var request = new HttpRequestMessage (HttpMethod.Get, $"http://localhost:{port}/Send_Complete_Content/");
 820                                 Assert.IsTrue (request.Headers.TryAddWithoutValidation ("aa", "vv"), "#0");
 821                                 var response = client.SendAsync (request, HttpCompletionOption.ResponseHeadersRead).Result;
 822
 823                                 Assert.AreEqual ("7K", response.Content.ReadAsStringAsync ().Result, "#100");
 824                                 Assert.AreEqual (HttpStatusCode.OK, response.StatusCode, "#101");
 825
 826                                 IEnumerable<string> values;
 827                                 Assert.IsTrue (response.Headers.TryGetValues ("Transfer-Encoding", out values), "#102");
 828                                 Assert.AreEqual ("chunked", values.First (), "#102a");
 829                                 Assert.AreEqual (true, response.Headers.TransferEncodingChunked, "#102b");
 830                         } finally {
 831                                 listener.Close ();
 832                         }
 833                 }
 834
 835                 [Test]
 836 #if FEATURE_NO_BSD_SOCKETS
 837                 [ExpectedException (typeof (PlatformNotSupportedException))]
 838 #endif
 839                 public void Send_Complete_Content_MaxResponseContentBufferSize ()
 840                 {
 841                         var listener = NetworkHelpers.CreateAndStartHttpListener("http://*:", out int port, "/Send_Complete_Content_MaxResponseContentBufferSize/");
 842                         AddListenerContext (listener, l => {
 843                                 var request = l.Request;
 844                                 var b = new byte[4000];
 845                                 l.Response.OutputStream.Write (b, 0, b.Length);
 846                         });
 847
 848                         try {
 849                                 var client = HttpClientTestHelpers.CreateHttpClientWithHttpClientHandler ();
 850                                 client.MaxResponseContentBufferSize = 1000;
 851                                 var request = new HttpRequestMessage (HttpMethod.Get, $"http://localhost:{port}/Send_Complete_Content_MaxResponseContentBufferSize/");
 852                                 var response = client.SendAsync (request, HttpCompletionOption.ResponseHeadersRead).Result;
 853
 854                                 Assert.AreEqual (4000, response.Content.ReadAsStringAsync ().Result.Length, "#100");
 855                                 Assert.AreEqual (HttpStatusCode.OK, response.StatusCode, "#101");
 856                         } finally {
 857                                 listener.Close ();
 858                         }
 859                 }
 860
 861                 [Test]
 862 #if FEATURE_NO_BSD_SOCKETS
 863                 [ExpectedException (typeof (PlatformNotSupportedException))]
 864 #endif
 865                 public void Send_Complete_Content_MaxResponseContentBufferSize_Error ()
 866                 {
 867                         var listener = NetworkHelpers.CreateAndStartHttpListener("http://*:", out int port, "/Send_Complete_Content_MaxResponseContentBufferSize_Error/");
 868                         AddListenerContext (listener, l => {
 869                                 var request = l.Request;
 870                                 var b = new byte[4000];
 871                                 l.Response.OutputStream.Write (b, 0, b.Length);
 872                         });
 873
 874                         try {
 875                                 var client = HttpClientTestHelpers.CreateHttpClientWithHttpClientHandler ();
 876                                 client.MaxResponseContentBufferSize = 1000;
 877                                 var request = new HttpRequestMessage (HttpMethod.Get, $"http://localhost:{port}/Send_Complete_Content_MaxResponseContentBufferSize_Error/");
 878
 879                                 try {
 880                                         client.SendAsync (request, HttpCompletionOption.ResponseContentRead).Wait (WaitTimeout);
 881                                         Assert.Fail ("#2");
 882                                 } catch (AggregateException e) {
 883                                         Assert.That (e.InnerException, Is.InstanceOf<HttpRequestException> (), $"#3: {e}");
 884                                 }
 885
 886                         } finally {
 887                                 listener.Close ();
 888                         }
 889                 }
 890
 891                 [Test]
 892 #if FEATURE_NO_BSD_SOCKETS
 893                 [ExpectedException (typeof (PlatformNotSupportedException))]
 894 #endif
 895                 public void Send_Complete_NoContent_Post ()
 896                 {
 897                         Send_Complete_NoContent (HttpMethod.Post);
 898                 }
 899
 900                 [Test]
 901 #if FEATURE_NO_BSD_SOCKETS
 902                 [ExpectedException (typeof (PlatformNotSupportedException))]
 903 #endif
 904                 public void Send_Complete_NoContent_Put ()
 905                 {
 906                         Send_Complete_NoContent (HttpMethod.Put);
 907                 }
 908
 909                 [Test]
 910 #if FEATURE_NO_BSD_SOCKETS
 911                 [ExpectedException (typeof (PlatformNotSupportedException))]
 912 #endif
 913                 public void Send_Complete_NoContent_Delete ()
 914                 {
 915                         Send_Complete_NoContent (HttpMethod.Delete);
 916                 }
 917
 918                 void Send_Complete_NoContent (HttpMethod method)
 919                 {
 920                         bool? failed = null;
 921                         var handler = HttpClientTestHelpers.CreateHttpClientHandler ();
 922                         var listener = NetworkHelpers.CreateAndStartHttpListener("http://*:", out int port, "/Send_Complete_NoContent/");
 923                         AddListenerContext (listener, l => {
 924                                 try {
 925                                         var request = l.Request;
 926
 927                                         if (HttpClientTestHelpers.IsSocketsHandler (handler)) {
 928                                                 Assert.AreEqual (2, request.Headers.Count, "#1");
 929                                                 Assert.IsNull (request.Headers["Connection"], "#1c");
 930                                         } else {
 931                                                 Assert.AreEqual (3, request.Headers.Count, "#1");
 932                                                 Assert.AreEqual ("keep-alive", request.Headers["Connection"], "#1c");
 933                                         }
 934                                         Assert.AreEqual ("0", request.Headers ["Content-Length"], "#1b");
 935                                         Assert.AreEqual (method.Method, request.HttpMethod, "#2");
 936                                         failed = false;
 937                                 } catch (Exception ex){
 938                                         Console.WriteLine (ex);
 939                                         Console.WriteLine (String.Join ("#", l.Request.Headers.AllKeys));
 940
 941                                         failed = true;
 942                                 }
 943                         });
 944
 945                         try {
 946                                 var client = new HttpClient (handler);
 947                                 var request = new HttpRequestMessage (method, $"http://localhost:{port}/Send_Complete_NoContent/");
 948                                 var response = client.SendAsync (request, HttpCompletionOption.ResponseHeadersRead).Result;
 949
 950                                 Assert.AreEqual ("", response.Content.ReadAsStringAsync ().Result, "#100");
 951                                 Assert.AreEqual (HttpStatusCode.OK, response.StatusCode, "#101");
 952                                 Assert.AreEqual (false, failed, "#102");
 953                         } finally {
 954                                 listener.Close ();
 955                         }
 956                 }
 957
 958                 [Test]
 959 #if FEATURE_NO_BSD_SOCKETS
 960                 [ExpectedException (typeof (PlatformNotSupportedException))]
 961 #endif
 962                 public void Send_Complete_Error ()
 963                 {
 964                         var listener = NetworkHelpers.CreateAndStartHttpListener("http://*:", out int port, "/Send_Complete_Error/");
 965                         AddListenerContext (listener, l => {
 966                                 var response = l.Response;
 967                                 response.StatusCode = 500;
 968                         });
 969
 970                         try {
 971                                 var client = HttpClientTestHelpers.CreateHttpClientWithHttpClientHandler ();
 972                                 var request = new HttpRequestMessage (HttpMethod.Get, $"http://localhost:{port}/Send_Complete_Error/");
 973                                 var response = client.SendAsync (request, HttpCompletionOption.ResponseHeadersRead).Result;
 974
 975                                 Assert.AreEqual ("", response.Content.ReadAsStringAsync ().Result, "#100");
 976                                 Assert.AreEqual (HttpStatusCode.InternalServerError, response.StatusCode, "#101");
 977                         } finally {
 978                                 listener.Close ();
 979                         }
 980                 }
 981
 982                 [Test]
 983 #if FEATURE_NO_BSD_SOCKETS
 984                 [ExpectedException (typeof (PlatformNotSupportedException))]
 985 #endif
 986                 public void Send_Content_Get ()
 987                 {
 988                         var listener = NetworkHelpers.CreateAndStartHttpListener("http://*:", out int port, "/Send_Content_Get/");
 989                         AddListenerContext (listener, l => {
 990                                 var request = l.Request;
 991                                 l.Response.OutputStream.WriteByte (72);
 992                         });
 993
 994                         try {
 995                                 var client = HttpClientTestHelpers.CreateHttpClientWithHttpClientHandler ();
 996                                 var r = new HttpRequestMessage (HttpMethod.Get, $"http://localhost:{port}/Send_Content_Get/");
 997                                 var response = client.SendAsync (r).Result;
 998
 999                                 Assert.AreEqual ("H", response.Content.ReadAsStringAsync ().Result);
1000                         } finally {
1001                                 listener.Close ();
1002                         }
1003                 }
1004
1005                 [Test]
1006 #if FEATURE_NO_BSD_SOCKETS
1007                 [ExpectedException (typeof (PlatformNotSupportedException))]
1008 #endif
1009                 public void Send_Content_BomEncoding ()
1010                 {
1011                         var listener = NetworkHelpers.CreateAndStartHttpListener("http://*:", out int port, "/Send_Content_BomEncoding/");
1012                         AddListenerContext (listener, l => {
1013                                 var request = l.Request;
1014
1015                                 var str = l.Response.OutputStream;
1016                                 str.WriteByte (0xEF);
1017                                 str.WriteByte (0xBB);
1018                                 str.WriteByte (0xBF);
1019                                 str.WriteByte (71);
1020                         });
1021
1022                         try {
1023                                 var client = HttpClientTestHelpers.CreateHttpClientWithHttpClientHandler ();
1024                                 var r = new HttpRequestMessage (HttpMethod.Get, $"http://localhost:{port}/Send_Content_BomEncoding/");
1025                                 var response = client.SendAsync (r).Result;
1026
1027                                 Assert.AreEqual ("G", response.Content.ReadAsStringAsync ().Result);
1028                         } finally {
1029                                 listener.Close ();
1030                         }
1031                 }
1032
1033                 [Test]
1034 #if FEATURE_NO_BSD_SOCKETS
1035                 [ExpectedException (typeof (PlatformNotSupportedException))]
1036 #endif
1037                 public void Send_Content_Put ()
1038                 {
1039                         bool passed = false;
1040                         var listener = NetworkHelpers.CreateAndStartHttpListener("http://*:", out int port, "/Send_Content_Put/");
1041                         AddListenerContext (listener, l => {
1042                                 var request = l.Request;
1043                                 passed = 7 == request.ContentLength64;
1044                                 passed &= request.ContentType == "text/plain; charset=utf-8";
1045                                 passed &= request.InputStream.ReadByte () == 'm';
1046                         });
1047
1048                         try {
1049                                 var client = HttpClientTestHelpers.CreateHttpClientWithHttpClientHandler ();
1050                                 var r = new HttpRequestMessage (HttpMethod.Put, $"http://localhost:{port}/Send_Content_Put/");
1051                                 r.Content = new StringContent ("my text");
1052                                 var response = client.SendAsync (r).Result;
1053
1054                                 Assert.AreEqual (HttpStatusCode.OK, response.StatusCode, "#1");
1055                                 Assert.IsTrue (passed, "#2");
1056                         } finally {
1057                                 listener.Abort ();
1058                                 listener.Close ();
1059                         }
1060                 }
1061
1062                 [Test]
1063 #if FEATURE_NO_BSD_SOCKETS
1064                 [ExpectedException (typeof (PlatformNotSupportedException))]
1065 #endif
1066                 public void Send_Content_Put_CustomStream ()
1067                 {
1068                         bool passed = false;
1069                         var handler = HttpClientTestHelpers.CreateHttpClientHandler ();
1070                         var listener = NetworkHelpers.CreateAndStartHttpListener("http://*:", out int port, "/Send_Content_Put_CustomStream/");
1071                         AddListenerContext (listener, l => {
1072                                 var request = l.Request;
1073                                 if (HttpClientTestHelpers.IsSocketsHandler (handler))
1074                                         passed = -1 == request.ContentLength64;
1075                                 else
1076                                         passed = 44 == request.ContentLength64;
1077                                 passed &= request.ContentType == null;
1078                         });
1079
1080                         try {
1081                                 var client = new HttpClient (handler);
1082                                 var r = new HttpRequestMessage (HttpMethod.Put, $"http://localhost:{port}/Send_Content_Put_CustomStream/");
1083                                 r.Content = new StreamContent (new CustomStream ());
1084                                 var response = client.SendAsync (r).Result;
1085
1086                                 Assert.AreEqual (HttpStatusCode.OK, response.StatusCode, "#1");
1087                                 Assert.IsTrue (passed, "#2");
1088                         } finally {
1089                                 listener.Abort ();
1090
1091                                 listener.Close ();
1092                         }
1093                 }
1094
1095                 [Test]
1096                 public void Send_Timeout ()
1097                 {
1098                         var mh = new HttpMessageHandlerMock ();
1099
1100                         var client = new HttpClient (mh);
1101                         client.Timeout = TimeSpan.FromMilliseconds (100);
1102                         var request = new HttpRequestMessage (HttpMethod.Get, "http://xamarin.com");
1103                         var response = new HttpResponseMessage ();
1104
1105                         mh.OnSendFull = (l, c) => {
1106                                 Assert.IsTrue (c.WaitHandle.WaitOne (500), "#2");
1107                                 return Task.FromResult (response);
1108                         };
1109
1110                         Assert.AreEqual (response, client.SendAsync (request).Result, "#1");
1111                 }
1112
1113                 [Test]
1114 #if FEATURE_NO_BSD_SOCKETS
1115 #if !MONOTOUCH_WATCH
1116                 [ExpectedException (typeof (PlatformNotSupportedException))]
1117 #endif
1118 #endif
1119                 public void Send_Invalid ()
1120                 {
1121                         var client = HttpClientTestHelpers.CreateHttpClientWithHttpClientHandler ();
1122                         try {
1123                                 client.SendAsync (null).Wait (WaitTimeout);
1124                                 Assert.Fail ("#1");
1125                         } catch (ArgumentNullException) {
1126                         }
1127
1128                         try {
1129                                 var request = new HttpRequestMessage ();
1130                                 client.SendAsync (request).Wait (WaitTimeout);
1131                                 Assert.Fail ("#2");
1132                         } catch (InvalidOperationException) {
1133                         }
1134                 }
1135
1136                 [Test]
1137                 public void Send_InvalidHandler ()
1138                 {
1139                         var mh = new HttpMessageHandlerMock ();
1140
1141                         var client = new HttpClient (mh);
1142                         client.BaseAddress = new Uri ("http://xamarin.com");
1143                         var request = new HttpRequestMessage ();
1144
1145                         mh.OnSend = l => {
1146                                 Assert.AreEqual (l, request, "#1");
1147                                 return null;
1148                         };
1149
1150                         try {
1151                                 // Broken by design
1152                                 client.SendAsync (request).Wait (WaitTimeout);
1153                                 Assert.Fail ("#2");
1154                         } catch (Exception) {
1155                         }
1156                 }
1157
1158                 [Test]
1159                 public void Send_SameMessage ()
1160                 {
1161                         var mh = new HttpMessageHandlerMock ();
1162
1163                         var client = new HttpClient (mh);
1164                         var request = new HttpRequestMessage (HttpMethod.Get, "http://xamarin.com");
1165
1166                         mh.OnSend = l => Task.FromResult (new HttpResponseMessage ());
1167
1168                         client.SendAsync (request).Wait (WaitTimeout);
1169                         try {
1170                                 client.SendAsync (request).Wait (WaitTimeout);
1171                                 Assert.Fail ("#1");
1172                         } catch (InvalidOperationException) {
1173                         }
1174                 }
1175
1176                 [Test]
1177 #if FEATURE_NO_BSD_SOCKETS
1178                 [ExpectedException (typeof (PlatformNotSupportedException))]
1179 #endif
1180                 public void Post_TransferEncodingChunked ()
1181                 {
1182                         bool? failed = null;
1183                         var listener = NetworkHelpers.CreateAndStartHttpListener("http://*:", out int port, "/Post_TransferEncodingChunked/");
1184                         AddListenerContext (listener, l => {
1185                                 try {
1186                                         var request = l.Request;
1187
1188                                         Assert.IsNull (request.AcceptTypes, "#1");
1189                                         Assert.AreEqual (-1, request.ContentLength64, "#2");
1190                                         Assert.IsNull (request.ContentType, "#3");
1191                                         Assert.AreEqual (0, request.Cookies.Count, "#4");
1192                                         Assert.IsTrue (request.HasEntityBody, "#5");
1193                                         Assert.AreEqual ($"localhost:{port}", request.Headers ["Host"], "#6b");
1194                                         Assert.AreEqual ("POST", request.HttpMethod, "#7");
1195                                         Assert.IsFalse (request.IsAuthenticated, "#8");
1196                                         Assert.IsTrue (request.IsLocal, "#9");
1197                                         Assert.IsFalse (request.IsSecureConnection, "#10");
1198                                         Assert.IsFalse (request.IsWebSocketRequest, "#11");
1199                                         Assert.IsTrue (request.KeepAlive, "#12");
1200                                         Assert.AreEqual (HttpVersion.Version11, request.ProtocolVersion, "#13");
1201                                         Assert.IsNull (request.ServiceName, "#14");
1202                                         Assert.IsNull (request.UrlReferrer, "#15");
1203                                         Assert.IsNull (request.UserAgent, "#16");
1204                                         Assert.IsNull (request.UserLanguages, "#17");
1205                                         Assert.AreEqual ("chunked", request.Headers ["Transfer-Encoding"], "#18");
1206                                         Assert.IsNull (request.Headers ["Content-Length"], "#19");
1207                                         failed = false;
1208                                 } catch (Exception e) {
1209                                         failed = true;
1210                                         Console.WriteLine (e);
1211                                 }
1212                         });
1213
1214                         try {
1215                                 var client = HttpClientTestHelpers.CreateHttpClientWithHttpClientHandler ();
1216
1217                                 client.DefaultRequestHeaders.TransferEncodingChunked = true;
1218
1219                                 var imageContent = new StreamContent (new MemoryStream ());
1220
1221                                 var response = client.PostAsync ($"http://localhost:{port}/Post_TransferEncodingChunked/", imageContent).Result;
1222
1223                                 Assert.AreEqual(HttpStatusCode.OK, response.StatusCode, "#101");
1224                                 Assert.AreEqual(false, failed, "#102");
1225                         } finally {
1226                                 listener.Close ();
1227                         }
1228                 }
1229
1230                 [Test]
1231 #if FEATURE_NO_BSD_SOCKETS
1232                 [ExpectedException (typeof (PlatformNotSupportedException))]
1233 #endif
1234                 public void Post_StreamCaching ()
1235                 {
1236                         bool? failed = null;
1237                         var listener = NetworkHelpers.CreateAndStartHttpListener("http://*:", out int port, "/Post_StreamCaching/");
1238                         AddListenerContext (listener, l => {
1239                                 try {
1240                                         var request = l.Request;
1241
1242                                         Assert.IsNull (request.AcceptTypes, "#1");
1243                                         Assert.AreEqual (0, request.ContentLength64, "#2");
1244                                         Assert.IsNull (request.ContentType, "#3");
1245                                         Assert.AreEqual (0, request.Cookies.Count, "#4");
1246                                         Assert.IsFalse (request.HasEntityBody, "#5");
1247                                         Assert.AreEqual ($"localhost:{port}", request.Headers ["Host"], "#6b");
1248                                         Assert.AreEqual ("POST", request.HttpMethod, "#7");
1249                                         Assert.IsFalse (request.IsAuthenticated, "#8");
1250                                         Assert.IsTrue (request.IsLocal, "#9");
1251                                         Assert.IsFalse (request.IsSecureConnection, "#10");
1252                                         Assert.IsFalse (request.IsWebSocketRequest, "#11");
1253                                         Assert.IsTrue (request.KeepAlive, "#12");
1254                                         Assert.AreEqual (HttpVersion.Version11, request.ProtocolVersion, "#13");
1255                                         Assert.IsNull (request.ServiceName, "#14");
1256                                         Assert.IsNull (request.UrlReferrer, "#15");
1257                                         Assert.IsNull (request.UserAgent, "#16");
1258                                         Assert.IsNull (request.UserLanguages, "#17");
1259                                         Assert.IsNull (request.Headers ["Transfer-Encoding"], "#18");
1260                                         Assert.AreEqual ("0", request.Headers ["Content-Length"], "#19");
1261                                         failed = false;
1262                                 } catch (Exception e) {
1263                                         failed = true;
1264                                         Console.WriteLine (e);
1265                                 }
1266                         });
1267
1268                         try {
1269                                 var client = HttpClientTestHelpers.CreateHttpClientWithHttpClientHandler ();
1270
1271                                 var imageContent = new StreamContent (new MemoryStream ());
1272
1273                                 var response = client.PostAsync ($"http://localhost:{port}/Post_StreamCaching/", imageContent).Result;
1274
1275                                 Assert.AreEqual(HttpStatusCode.OK, response.StatusCode, "#101");
1276                                 Assert.AreEqual(false, failed, "#102");
1277                         } finally {
1278                                 listener.Close ();
1279                         }
1280                 }
1281
1282                 [Test]
1283                 [Category ("MobileNotWorking")] // Missing encoding
1284 #if FEATURE_NO_BSD_SOCKETS
1285                 [ExpectedException (typeof (PlatformNotSupportedException))]
1286 #endif
1287                 public void GetString_Many ()
1288                 {
1289                         Action<HttpListenerContext> context = (HttpListenerContext l) => {
1290                                 var response = l.Response;
1291                                 response.StatusCode = 200;
1292                                 response.OutputStream.WriteByte (0x68);
1293                                 response.OutputStream.WriteByte (0x65);
1294                                 response.OutputStream.WriteByte (0x6c);
1295                                 response.OutputStream.WriteByte (0x6c);
1296                                 response.OutputStream.WriteByte (0x6f);
1297                         };
1298
1299                         var listener = NetworkHelpers.CreateAndStartHttpListener("http://*:", out int port, "/GetString_Many/");
1300                         AddListenerContext (listener, context);  // creates a default request handler
1301                         AddListenerContext (listener, context);  // add another request handler for the second request
1302
1303                         try {
1304                                 var client = HttpClientTestHelpers.CreateHttpClientWithHttpClientHandler ();
1305                                 var t1 = client.GetStringAsync ($"http://localhost:{port}/GetString_Many/");
1306                                 var t2 = client.GetStringAsync ($"http://localhost:{port}/GetString_Many/");
1307                                 Assert.IsTrue (Task.WaitAll (new [] { t1, t2 }, WaitTimeout));
1308                                 Assert.AreEqual ("hello", t1.Result, "#1");
1309                                 Assert.AreEqual ("hello", t2.Result, "#2");
1310                         } finally {
1311                                 listener.Abort ();
1312                                 listener.Close ();
1313                         }
1314                 }
1315
1316                 [Test]
1317 #if FEATURE_NO_BSD_SOCKETS
1318                 [ExpectedException (typeof (PlatformNotSupportedException))]
1319 #endif
1320                 public void GetByteArray_ServerError ()
1321                 {
1322                         var listener = NetworkHelpers.CreateAndStartHttpListener("http://*:", out int port, "/GetByteArray_ServerError/");
1323                         AddListenerContext (listener, l => {
1324                                 var response = l.Response;
1325                                 response.StatusCode = 500;
1326                                 l.Response.OutputStream.WriteByte (72);
1327                         });
1328
1329                         try {
1330                                 var client = HttpClientTestHelpers.CreateHttpClientWithHttpClientHandler ();
1331                                 try {
1332                                         client.GetByteArrayAsync ($"http://localhost:{port}/GetByteArray_ServerError/").Wait (WaitTimeout);
1333                                         Assert.Fail ("#1");
1334                                 } catch (AggregateException e) {
1335                                         Assert.That (e.InnerException, Is.InstanceOf<HttpRequestException> (), $"#2: {e}");
1336                                 }
1337                         } finally {
1338                                 listener.Close ();
1339                         }
1340                 }
1341
1342                 [Test]
1343 #if FEATURE_NO_BSD_SOCKETS
1344                 [ExpectedException (typeof (PlatformNotSupportedException))]
1345 #endif
1346                 public void DisallowAutoRedirect ()
1347                 {
1348                         var listener = NetworkHelpers.CreateAndStartHttpListener("http://*:", out int port, "/DisallowAutoRedirect/");
1349                         AddListenerContext (listener, l => {
1350                                 var request = l.Request;
1351                                 var response = l.Response;
1352
1353                                 response.StatusCode = (int)HttpStatusCode.Moved;
1354                                 response.RedirectLocation = "http://xamarin.com/";
1355                         });
1356
1357                         try {
1358                                 var chandler = HttpClientTestHelpers.CreateHttpClientHandler ();
1359                                 chandler.AllowAutoRedirect = false;
1360                                 var client = new HttpClient (chandler);
1361
1362                                 try {
1363                                         client.GetStringAsync ($"http://localhost:{port}/DisallowAutoRedirect/").Wait (WaitTimeout);
1364                                         Assert.Fail ("#1");
1365                                 } catch (AggregateException e) {
1366                                         Assert.That (e.InnerException, Is.InstanceOf<HttpRequestException> (), $"#2: {e}");
1367                                 }
1368                         } finally {
1369                                 listener.Abort ();
1370                                 listener.Close ();
1371                         }
1372                 }
1373
1374                 [Test]
1375 #if FEATURE_NO_BSD_SOCKETS
1376                 [ExpectedException (typeof (PlatformNotSupportedException))]
1377 #endif
1378                 public void RequestUriAfterRedirect ()
1379                 {
1380                         var listener = NetworkHelpers.CreateAndStartHttpListener("http://*:", out int port, "/RequestUriAfterRedirect/");
1381                         var listener2 = NetworkHelpers.CreateAndStartHttpListener("http://*:", out int redirectPort, "/RequestUriAfterRedirect/");
1382
1383                         AddListenerContext (listener, l => {
1384                                 var request = l.Request;
1385                                 var response = l.Response;
1386
1387                                 response.StatusCode = (int)HttpStatusCode.Moved;
1388                                 response.RedirectLocation = $"http://localhost:{redirectPort}/RequestUriAfterRedirect/";
1389                         });
1390
1391                         AddListenerContext (listener2, l => {
1392                                 var response = l.Response;
1393
1394                                 response.StatusCode = (int)HttpStatusCode.OK;
1395                                 response.OutputStream.WriteByte (0x68);
1396                                 response.OutputStream.WriteByte (0x65);
1397                                 response.OutputStream.WriteByte (0x6c);
1398                                 response.OutputStream.WriteByte (0x6c);
1399                                 response.OutputStream.WriteByte (0x6f);
1400                         });
1401
1402                         try {
1403                                 var chandler = HttpClientTestHelpers.CreateHttpClientHandler ();
1404                                 chandler.AllowAutoRedirect = true;
1405                                 var client = new HttpClient (chandler);
1406
1407                                 var r = client.GetAsync ($"http://localhost:{port}/RequestUriAfterRedirect/");
1408                                 Assert.IsTrue (r.Wait (WaitTimeout), "#1");
1409                                 var resp = r.Result;
1410                                 Assert.AreEqual ($"http://localhost:{redirectPort}/RequestUriAfterRedirect/", resp.RequestMessage.RequestUri.AbsoluteUri, "#2");
1411                                 Assert.AreEqual ("hello", resp.Content.ReadAsStringAsync ().Result, "#3");
1412                         } finally {
1413                                 listener.Abort ();
1414                                 listener.Close ();
1415                                 listener2.Abort ();
1416                                 listener2.Close ();
1417                         }
1418                 }
1419
1420                 [Test]
1421 #if FEATURE_NO_BSD_SOCKETS
1422                 [ExpectedException (typeof (PlatformNotSupportedException))]
1423 #endif
1424                 /*
1425                  * Properties may only be modified before sending the first request.
1426                  */
1427                 public void ModifyHandlerAfterFirstRequest ()
1428                 {
1429                         var chandler = HttpClientTestHelpers.CreateHttpClientHandler ();
1430                         chandler.AllowAutoRedirect = true;
1431                         var client = new HttpClient (chandler, true);
1432
1433                         var listener = NetworkHelpers.CreateAndStartHttpListener("http://*:", out int port, "/ModifyHandlerAfterFirstRequest/");
1434                         AddListenerContext (listener, l => {
1435                                 var response = l.Response;
1436                                 response.StatusCode = 200;
1437                                 response.OutputStream.WriteByte (55);
1438                         });
1439
1440                         try {
1441                                 client.GetStringAsync ($"http://localhost:{port}/ModifyHandlerAfterFirstRequest/").Wait (WaitTimeout);
1442                                 try {
1443                                         chandler.AllowAutoRedirect = false;
1444                                         Assert.Fail ("#1");
1445                                 } catch (InvalidOperationException) {
1446                                         ;
1447                                 }
1448                         } finally {
1449                                 listener.Abort ();
1450                                 listener.Close ();
1451                         }
1452                 }
1453
1454                 [Test]
1455 #if FEATURE_NO_BSD_SOCKETS
1456                 // Using HttpClientHandler, which indirectly requires BSD sockets.
1457                 [ExpectedException (typeof (PlatformNotSupportedException))]
1458 #endif
1459                 /*
1460                  * However, this policy is not enforced for custom handlers and there
1461                  * is also no way a derived class could tell its HttpClientHandler parent
1462                  * that it just sent a request.
1463                  *
1464                  */
1465                 public void ModifyHandlerAfterFirstRequest_Mock ()
1466                 {
1467                         var ch = new HttpClientHandlerMock ();
1468                         ch.AllowAutoRedirect = true;
1469
1470                         var client = new HttpClient (ch);
1471
1472                         ch.OnSend = (l) => {
1473                                 return Task.FromResult (new HttpResponseMessage ());
1474                         };
1475
1476                         client.GetAsync ("http://xamarin.com").Wait (WaitTimeout);
1477                         ch.AllowAutoRedirect = false;
1478                 }
1479
1480 #if !FEATURE_NO_BSD_SOCKETS
1481                 [Test]
1482                 // https://github.com/mono/mono/issues/7355
1483                 public void WildcardConnect ()
1484                 {
1485                         if (HttpClientTestHelpers.UsingSocketsHandler)
1486                                 Assert.Ignore ("Throws System.NullReferenceException");
1487
1488                         try {
1489                                 using (var client = HttpClientTestHelpers.CreateHttpClientWithHttpClientHandler ()) {
1490                                         client.GetAsync ("http://255.255.255.255").Wait (WaitTimeout);
1491                                 }
1492                         } catch (AggregateException e) {
1493                                 Assert.That (e.InnerException, Is.InstanceOf<HttpRequestException> (), "#1");
1494                                 var rex = (HttpRequestException)e.InnerException;
1495                                 Assert.That (rex.InnerException, Is.InstanceOf<WebException> (), "#2");
1496                                 var wex = (WebException)rex.InnerException;
1497                                 Assert.That (wex.Status, Is.EqualTo (WebExceptionStatus.ConnectFailure), "#3");
1498                         }
1499                 }
1500 #endif
1501
1502                 void AddListenerContext (HttpListener l, Action<HttpListenerContext> contextAssert)
1503                 {
1504                         l.BeginGetContext (ar => {
1505                                 var ctx = l.EndGetContext (ar);
1506
1507                                 try {
1508                                         if (contextAssert != null)
1509                                                 contextAssert (ctx);
1510                                 } finally {
1511                                         ctx.Response.Close ();
1512                                 }
1513                         }, null);
1514                 }
1515         }
1516 }