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 = 5000;
 179
 180                 [Test]
 181                 public void Ctor_Default ()
 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                 public void CancelPendingRequests ()
 192                 {
 193                         var mh = new HttpMessageHandlerMock ();
 194
 195                         var client = new HttpClient (mh);
 196                         var request = new HttpRequestMessage (HttpMethod.Get, "http://xamarin.com");
 197                         var mre = new ManualResetEvent (false);
 198
 199                         mh.OnSendFull = (l, c) => {
 200                                 mre.Set ();
 201                                 Assert.IsTrue (c.WaitHandle.WaitOne (1000), "#20");
 202                                 Assert.IsTrue (c.IsCancellationRequested, "#21");
 203                                 mre.Set ();
 204                                 return Task.FromResult (new HttpResponseMessage ());
 205                         };
 206
 207                         var t = Task.Factory.StartNew (() => {
 208                                 client.SendAsync (request).Wait (WaitTimeout);
 209                         });
 210
 211                         Assert.IsTrue (mre.WaitOne (500), "#1");
 212                         mre.Reset ();
 213                         client.CancelPendingRequests ();
 214                         Assert.IsTrue (t.Wait (500), "#2");
 215
 216                         request = new HttpRequestMessage (HttpMethod.Get, "http://xamarin.com");
 217                         mh.OnSendFull = (l, c) => {
 218                                 Assert.IsFalse (c.IsCancellationRequested, "#30");
 219                                 return Task.FromResult (new HttpResponseMessage ());
 220                         };
 221
 222                         client.SendAsync (request).Wait (WaitTimeout);
 223                 }
 224
 225                 [Test]
 226                 public void CancelPendingRequests_BeforeSend ()
 227                 {
 228                         var ct = new CancellationTokenSource ();
 229                         ct.Cancel ();
 230                         var rr = CancellationTokenSource.CreateLinkedTokenSource (new CancellationToken (), ct.Token);
 231
 232
 233                         var mh = new HttpMessageHandlerMock ();
 234
 235                         var client = new HttpClient (mh);
 236                         var request = new HttpRequestMessage (HttpMethod.Get, "http://xamarin.com");
 237                         client.CancelPendingRequests ();
 238
 239                         mh.OnSendFull = (l, c) => {
 240                                 Assert.IsFalse (c.IsCancellationRequested, "#30");
 241                                 return Task.FromResult (new HttpResponseMessage ());
 242                         };
 243
 244                         client.SendAsync (request).Wait (WaitTimeout);
 245
 246                         request = new HttpRequestMessage (HttpMethod.Get, "http://xamarin.com");
 247                         client.SendAsync (request).Wait (WaitTimeout);
 248                 }
 249
 250
 251                 [Test]
 252 #if FEATURE_NO_BSD_SOCKETS
 253                 // Using HttpClientHandler, which indirectly requires BSD sockets.
 254                 [ExpectedException (typeof (PlatformNotSupportedException))]
 255 #endif
 256                 public void CancelRequestViaProxy ()
 257                 {
 258                         var handler = new HttpClientHandler {
 259                                 Proxy = new WebProxy ("192.168.10.25:8888/"), // proxy that doesn't exist
 260                                 UseProxy = true,
 261                                 AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate
 262                         };
 263
 264                         var httpClient = new HttpClient (handler) {
 265                                 BaseAddress = new Uri ("https://google.com"),
 266                                 Timeout = TimeSpan.FromMilliseconds (1)
 267                         };
 268
 269                         try {
 270                                 var restRequest = new HttpRequestMessage {
 271                                         Method = HttpMethod.Post,
 272                                         RequestUri = new Uri("foo", UriKind.Relative),
 273                                         Content = new StringContent("", null, "application/json")
 274                                 };
 275
 276                                 httpClient.PostAsync (restRequest.RequestUri, restRequest.Content).Wait (WaitTimeout);
 277                                 Assert.Fail ("#1");
 278                         } catch (AggregateException e) {
 279                                 Assert.IsTrue (e.InnerException is TaskCanceledException, "#2");
 280                         }
 281                 }
 282
 283                 [Test]
 284                 public void Properties ()
 285                 {
 286                         var client = new HttpClient ();
 287                         client.BaseAddress = null;
 288                         client.MaxResponseContentBufferSize = int.MaxValue;
 289                         client.Timeout = Timeout.InfiniteTimeSpan;
 290
 291                         Assert.IsNull (client.BaseAddress, "#1");
 292                         Assert.AreEqual (int.MaxValue, client.MaxResponseContentBufferSize, "#2");
 293                         Assert.AreEqual (Timeout.InfiniteTimeSpan, client.Timeout, "#3");
 294                 }
 295
 296                 [Test]
 297                 public void Properties_Invalid ()
 298                 {
 299                         var client = new HttpClient ();
 300                         try {
 301                                 client.MaxResponseContentBufferSize = 0;
 302                                 Assert.Fail ("#1");
 303                         } catch (ArgumentOutOfRangeException) {
 304                         }
 305
 306                         try {
 307                                 client.Timeout = TimeSpan.MinValue;
 308                                 Assert.Fail ("#2");
 309                         } catch (ArgumentOutOfRangeException) {
 310                         }
 311                 }
 312
 313                 [Test]
 314 #if FEATURE_NO_BSD_SOCKETS
 315                 [ExpectedException (typeof (PlatformNotSupportedException))]
 316 #endif
 317                 public void Proxy_Disabled ()
 318                 {
 319                         var pp = WebRequest.DefaultWebProxy;
 320
 321                         try {
 322                                 WebRequest.DefaultWebProxy = new ThrowOnlyProxy ();
 323
 324                                 var request = new HttpClientHandler {
 325                                         UseProxy = false
 326                                 };
 327
 328                                 var client = new HttpClient (request);
 329                                 Assert.IsTrue (client.GetAsync ("http://google.com").Wait (5000), "needs internet access");
 330                         } finally {
 331                                 WebRequest.DefaultWebProxy = pp;
 332                         }
 333                 }
 334
 335                 [Test]
 336                 public void Send ()
 337                 {
 338                         var mh = new HttpMessageHandlerMock ();
 339
 340                         var client = new HttpClient (mh);
 341                         client.BaseAddress = new Uri ("http://xamarin.com");
 342                         var request = new HttpRequestMessage ();
 343                         var response = new HttpResponseMessage ();
 344
 345                         mh.OnSend = l => {
 346                                 Assert.AreEqual (l, request, "#2");
 347                                 Assert.AreEqual (client.BaseAddress, l.RequestUri, "#2");
 348                                 return Task.FromResult (response);
 349                         };
 350
 351                         Assert.AreEqual (response, client.SendAsync (request).Result, "#1");
 352                 }
 353
 354                 [Test]
 355                 public void Send_BaseAddress ()
 356                 {
 357                         var mh = new HttpMessageHandlerMock ();
 358
 359                         var client = new HttpClient (mh);
 360                         client.BaseAddress = new Uri ("http://localhost/");
 361                         var response = new HttpResponseMessage ();
 362
 363                         mh.OnSend = l => {
 364                                 Assert.AreEqual ("http://localhost/relative", l.RequestUri.ToString (), "#2");
 365                                 return Task.FromResult (response);
 366                         };
 367
 368                         Assert.AreEqual (response, client.GetAsync ("relative").Result, "#1");
 369                         Assert.AreEqual (response, client.GetAsync ("/relative").Result, "#2");
 370                 }
 371
 372                 [Test]
 373                 public void Send_DefaultRequestHeaders ()
 374                 {
 375                         var mh = new HttpMessageHandlerMock ();
 376
 377                         var client = new HttpClient (mh);
 378                         client.DefaultRequestHeaders.Referrer = new Uri ("http://google.com");
 379
 380                         var request = new HttpRequestMessage (HttpMethod.Get, "http://xamarin.com");
 381                         var response = new HttpResponseMessage ();
 382
 383                         mh.OnSend = l => {
 384                                 Assert.AreEqual (client.DefaultRequestHeaders.Referrer, l.Headers.Referrer, "#2");
 385                                 Assert.IsNotNull (l.Headers.Referrer, "#3");
 386                                 return Task.FromResult (response);
 387                         };
 388
 389                         Assert.AreEqual (response, client.SendAsync (request).Result, "#1");
 390                 }
 391
 392                 [Test]
 393 #if FEATURE_NO_BSD_SOCKETS
 394                 [ExpectedException (typeof (PlatformNotSupportedException))]
 395 #endif
 396                 public void Send_Complete_Default ()
 397                 {
 398                         bool? failed = null;
 399                         var port = NetworkHelpers.FindFreePort ();
 400                         var listener = CreateListener (l => {
 401                                 try {
 402                                         var request = l.Request;
 403
 404                                         Assert.IsNull (request.AcceptTypes, "#1");
 405                                         Assert.AreEqual (0, request.ContentLength64, "#2");
 406                                         Assert.IsNull (request.ContentType, "#3");
 407                                         Assert.AreEqual (0, request.Cookies.Count, "#4");
 408                                         Assert.IsFalse (request.HasEntityBody, "#5");
 409                                         Assert.AreEqual ($"localhost:{port}", request.Headers["Host"], "#6b");
 410                                         Assert.AreEqual ("GET", request.HttpMethod, "#7");
 411                                         Assert.IsFalse (request.IsAuthenticated, "#8");
 412                                         Assert.IsTrue (request.IsLocal, "#9");
 413                                         Assert.IsFalse (request.IsSecureConnection, "#10");
 414                                         Assert.IsFalse (request.IsWebSocketRequest, "#11");
 415                                         Assert.IsTrue (request.KeepAlive, "#12");
 416                                         Assert.AreEqual (HttpVersion.Version11, request.ProtocolVersion, "#13");
 417                                         Assert.IsNull (request.ServiceName, "#14");
 418                                         Assert.IsNull (request.UrlReferrer, "#15");
 419                                         Assert.IsNull (request.UserAgent, "#16");
 420                                         Assert.IsNull (request.UserLanguages, "#17");
 421                                         failed = false;
 422                                 } catch {
 423                                         failed = true;
 424                                 }
 425                         }, port);
 426
 427                         try {
 428                                 var client = new HttpClient ();
 429                                 var request = new HttpRequestMessage (HttpMethod.Get, $"http://localhost:{port}/");
 430                                 var response = client.SendAsync (request, HttpCompletionOption.ResponseHeadersRead).Result;
 431
 432                                 Assert.AreEqual ("", response.Content.ReadAsStringAsync ().Result, "#100");
 433                                 Assert.AreEqual (HttpStatusCode.OK, response.StatusCode, "#101");
 434                                 Assert.AreEqual (false, failed, "#102");
 435                         } finally {
 436                                 listener.Close ();
 437                         }
 438                 }
 439
 440                 [Test]
 441 #if FEATURE_NO_BSD_SOCKETS
 442                 [ExpectedException (typeof (PlatformNotSupportedException))]
 443 #endif
 444                 public void Send_Complete_Version_1_0 ()
 445                 {
 446                         bool? failed = null;
 447
 448                         var port = NetworkHelpers.FindFreePort ();
 449                         var listener = CreateListener (l => {
 450                                 try {
 451                                         var request = l.Request;
 452
 453                                         Assert.IsNull (request.AcceptTypes, "#1");
 454                                         Assert.AreEqual (0, request.ContentLength64, "#2");
 455                                         Assert.IsNull (request.ContentType, "#3");
 456                                         Assert.AreEqual (0, request.Cookies.Count, "#4");
 457                                         Assert.IsFalse (request.HasEntityBody, "#5");
 458                                         Assert.AreEqual (1, request.Headers.Count, "#6");
 459                                         Assert.AreEqual ($"localhost:{port}", request.Headers["Host"], "#6a");
 460                                         Assert.AreEqual ("GET", request.HttpMethod, "#7");
 461                                         Assert.IsFalse (request.IsAuthenticated, "#8");
 462                                         Assert.IsTrue (request.IsLocal, "#9");
 463                                         Assert.IsFalse (request.IsSecureConnection, "#10");
 464                                         Assert.IsFalse (request.IsWebSocketRequest, "#11");
 465                                         Assert.IsFalse (request.KeepAlive, "#12");
 466                                         Assert.AreEqual (HttpVersion.Version10, request.ProtocolVersion, "#13");
 467                                         Assert.IsNull (request.ServiceName, "#14");
 468                                         Assert.IsNull (request.UrlReferrer, "#15");
 469                                         Assert.IsNull (request.UserAgent, "#16");
 470                                         Assert.IsNull (request.UserLanguages, "#17");
 471                                         failed = false;
 472                                 } catch {
 473                                         failed = true;
 474                                 }
 475                         }, port);
 476
 477                         try {
 478                                 var client = new HttpClient ();
 479                                 var request = new HttpRequestMessage (HttpMethod.Get, $"http://localhost:{port}/");
 480                                 request.Version = HttpVersion.Version10;
 481                                 var response = client.SendAsync (request, HttpCompletionOption.ResponseHeadersRead).Result;
 482
 483                                 Assert.AreEqual ("", response.Content.ReadAsStringAsync ().Result, "#100");
 484                                 Assert.AreEqual (HttpStatusCode.OK, response.StatusCode, "#101");
 485                                 Assert.AreEqual (false, failed, "#102");
 486                         } finally {
 487                                 listener.Close ();
 488                         }
 489                 }
 490
 491                 [Test]
 492 #if FEATURE_NO_BSD_SOCKETS
 493                 [ExpectedException (typeof (PlatformNotSupportedException))]
 494 #endif
 495                 public void Send_Complete_ClientHandlerSettings ()
 496                 {
 497                         bool? failed = null;
 498
 499                         var port = NetworkHelpers.FindFreePort ();
 500                         var listener = CreateListener (l => {
 501                                 var request = l.Request;
 502
 503                                 try {
 504                                         Assert.IsNull (request.AcceptTypes, "#1");
 505                                         Assert.AreEqual (0, request.ContentLength64, "#2");
 506                                         Assert.IsNull (request.ContentType, "#3");
 507                                         Assert.AreEqual (1, request.Cookies.Count, "#4");
 508                                         Assert.AreEqual (new Cookie ("mycookie", "vv"), request.Cookies[0], "#4a");
 509                                         Assert.IsFalse (request.HasEntityBody, "#5");
 510                                         Assert.AreEqual (4, request.Headers.Count, "#6");
 511                                         Assert.AreEqual ($"localhost:{port}", request.Headers["Host"], "#6a");
 512                                         Assert.AreEqual ("gzip", request.Headers["Accept-Encoding"], "#6b");
 513                                         Assert.AreEqual ("mycookie=vv", request.Headers["Cookie"], "#6c");
 514                                         Assert.AreEqual ("GET", request.HttpMethod, "#7");
 515                                         Assert.IsFalse (request.IsAuthenticated, "#8");
 516                                         Assert.IsTrue (request.IsLocal, "#9");
 517                                         Assert.IsFalse (request.IsSecureConnection, "#10");
 518                                         Assert.IsFalse (request.IsWebSocketRequest, "#11");
 519                                         Assert.IsTrue (request.KeepAlive, "#12");
 520                                         Assert.AreEqual (HttpVersion.Version10, request.ProtocolVersion, "#13");
 521                                         Assert.IsNull (request.ServiceName, "#14");
 522                                         Assert.IsNull (request.UrlReferrer, "#15");
 523                                         Assert.IsNull (request.UserAgent, "#16");
 524                                         Assert.IsNull (request.UserLanguages, "#17");
 525                                         failed = false;
 526                                 } catch {
 527                                         failed = true;
 528                                 }
 529                         }, port);
 530
 531                         try {
 532                                 var chandler = new HttpClientHandler ();
 533                                 chandler.AllowAutoRedirect = true;
 534                                 chandler.AutomaticDecompression = DecompressionMethods.GZip;
 535                                 chandler.MaxAutomaticRedirections = 33;
 536                                 chandler.MaxRequestContentBufferSize = 5555;
 537                                 chandler.PreAuthenticate = true;
 538                                 chandler.CookieContainer.Add (new Uri ($"http://localhost:{port}/"), new Cookie ( "mycookie", "vv"));
 539                                 chandler.UseCookies = true;
 540                                 chandler.UseDefaultCredentials = true;
 541                                 chandler.Proxy = new WebProxy ("ee");
 542                                 chandler.UseProxy = true;
 543
 544                                 var client = new HttpClient (chandler);
 545                                 var request = new HttpRequestMessage (HttpMethod.Get, $"http://localhost:{port}/");
 546                                 request.Version = HttpVersion.Version10;
 547                                 request.Headers.Add ("Keep-Alive", "false");
 548                                 var response = client.SendAsync (request, HttpCompletionOption.ResponseHeadersRead).Result;
 549
 550                                 Assert.AreEqual ("", response.Content.ReadAsStringAsync ().Result, "#100");
 551                                 Assert.AreEqual (HttpStatusCode.OK, response.StatusCode, "#101");
 552                                 Assert.AreEqual (false, failed, "#102");
 553                         } finally {
 554                                 listener.Abort ();
 555                                 listener.Close ();
 556                         }
 557                 }
 558
 559                 [Test]
 560 #if FEATURE_NO_BSD_SOCKETS
 561                 [ExpectedException (typeof (PlatformNotSupportedException))]
 562 #endif
 563                 public void Send_Complete_CustomHeaders ()
 564                 {
 565                         bool? failed = null;
 566
 567                         var port = NetworkHelpers.FindFreePort ();
 568                         var listener = CreateListener (l => {
 569                                 var request = l.Request;
 570                                 try {
 571                                         Assert.AreEqual ("vv", request.Headers["aa"], "#1");
 572
 573                                         var response = l.Response;
 574                                         response.Headers.Add ("rsp", "rrr");
 575                                         response.Headers.Add ("upgrade", "vvvvaa");
 576                                         response.Headers.Add ("Date", "aa");
 577                                         response.Headers.Add ("cache-control", "audio");
 578
 579                                         response.StatusDescription = "test description";
 580                                         response.ProtocolVersion = HttpVersion.Version10;
 581                                         response.SendChunked = true;
 582                                         response.RedirectLocation = "w3.org";
 583
 584                                         failed = false;
 585                                 } catch {
 586                                         failed = true;
 587                                 }
 588                         }, port);
 589
 590                         try {
 591                                 var client = new HttpClient ();
 592                                 var request = new HttpRequestMessage (HttpMethod.Get, $"http://localhost:{port}/");
 593                                 Assert.IsTrue (request.Headers.TryAddWithoutValidation ("aa", "vv"), "#0");
 594                                 var response = client.SendAsync (request, HttpCompletionOption.ResponseHeadersRead).Result;
 595
 596                                 Assert.AreEqual ("", response.Content.ReadAsStringAsync ().Result, "#100");
 597                                 Assert.AreEqual (HttpStatusCode.OK, response.StatusCode, "#101");
 598
 599                                 IEnumerable<string> values;
 600                                 Assert.IsTrue (response.Headers.TryGetValues ("rsp", out values), "#102");
 601                                 Assert.AreEqual ("rrr", values.First (), "#102a");
 602
 603                                 Assert.IsTrue (response.Headers.TryGetValues ("Transfer-Encoding", out values), "#103");
 604                                 Assert.AreEqual ("chunked", values.First (), "#103a");
 605                                 Assert.AreEqual (true, response.Headers.TransferEncodingChunked, "#103b");
 606
 607                                 Assert.IsTrue (response.Headers.TryGetValues ("Date", out values), "#104");
 608                                 Assert.AreEqual (1, values.Count (), "#104b");
 609                                 // .NET overwrites Date, Mono does not
 610                                 // Assert.IsNotNull (response.Headers.Date, "#104c");
 611
 612                                 Assert.AreEqual (new ProductHeaderValue ("vvvvaa"), response.Headers.Upgrade.First (), "#105");
 613
 614                                 Assert.AreEqual ("audio", response.Headers.CacheControl.Extensions.First ().Name, "#106");
 615
 616                                 Assert.AreEqual ("w3.org", response.Headers.Location.OriginalString, "#107");
 617
 618                                 Assert.AreEqual ("test description", response.ReasonPhrase, "#110");
 619                                 Assert.AreEqual (HttpVersion.Version11, response.Version, "#111");
 620
 621                                 Assert.AreEqual (false, failed, "#112");
 622                         } finally {
 623                                 listener.Close ();
 624                         }
 625                 }
 626
 627                 [Test]
 628 #if FEATURE_NO_BSD_SOCKETS
 629                 [ExpectedException (typeof (PlatformNotSupportedException))]
 630 #endif
 631                 public void Send_Complete_CustomHeaders_SpecialSeparators ()
 632                 {
 633                         bool? failed = null;
 634
 635                         var port = NetworkHelpers.FindFreePort ();
 636                         var listener = CreateListener (l => {
 637                                 var request = l.Request;
 638
 639                                 try {
 640                                         Assert.AreEqual ("MLK Android Phone 1.1.9", request.UserAgent, "#1");
 641                                         failed = false;
 642                                 } catch {
 643                                         failed = true;
 644                                 }
 645                         }, port);
 646
 647                         try {
 648                                 var client = new HttpClient ();
 649
 650                                 client.DefaultRequestHeaders.Add("User-Agent", "MLK Android Phone 1.1.9");
 651
 652                                 var request = new HttpRequestMessage (HttpMethod.Get, $"http://localhost:{port}/");
 653
 654                                 var response = client.SendAsync (request, HttpCompletionOption.ResponseHeadersRead).Result;
 655
 656                                 Assert.AreEqual ("", response.Content.ReadAsStringAsync ().Result, "#100");
 657                                 Assert.AreEqual (HttpStatusCode.OK, response.StatusCode, "#101");
 658                                 Assert.AreEqual (false, failed, "#102");
 659                         } finally {
 660                                 listener.Abort ();
 661                                 listener.Close ();
 662                         }
 663                 }
 664
 665                 [Test]
 666 #if FEATURE_NO_BSD_SOCKETS
 667                 [ExpectedException (typeof (PlatformNotSupportedException))]
 668 #endif
 669                 public void Send_Complete_CustomHeaders_Host ()
 670                 {
 671                         bool? failed = null;
 672                         var port = NetworkHelpers.FindFreePort ();
 673                         var listener = CreateListener (l => {
 674                                 var request = l.Request;
 675
 676                                 try {
 677                                         Assert.AreEqual ("customhost", request.Headers["Host"], "#1");
 678                                         failed = false;
 679                                 } catch {
 680                                         failed = true;
 681                                 }
 682                         }, port);
 683
 684                         try {
 685                                 var client = new HttpClient ();
 686
 687                                 client.DefaultRequestHeaders.Add("Host", "customhost");
 688
 689                                 var request = new HttpRequestMessage (HttpMethod.Get, $"http://localhost:{port}/");
 690
 691                                 var response = client.SendAsync (request, HttpCompletionOption.ResponseHeadersRead).Result;
 692
 693                                 Assert.AreEqual ("", response.Content.ReadAsStringAsync ().Result, "#100");
 694                                 Assert.AreEqual (HttpStatusCode.OK, response.StatusCode, "#101");
 695                                 Assert.AreEqual (false, failed, "#102");
 696                         } finally {
 697                                 listener.Abort ();
 698                                 listener.Close ();
 699                         }
 700                 }
 701
 702                 [Test]
 703 #if FEATURE_NO_BSD_SOCKETS
 704                 [ExpectedException (typeof (PlatformNotSupportedException))]
 705 #endif
 706                 public void Send_Transfer_Encoding_Chunked ()
 707                 {
 708                         bool? failed = null;
 709
 710                         var port = NetworkHelpers.FindFreePort ();
 711                         var listener = CreateListener (l => {
 712                                 var request = l.Request;
 713
 714                                 try {
 715                                         Assert.AreEqual (2, request.Headers.Count, "#1");
 716                                         Assert.AreEqual ("keep-alive", request.Headers ["Connection"], "#2");
 717                                         failed = false;
 718                                 } catch (Exception ex){
 719                                         Console.WriteLine (ex);
 720                                         Console.WriteLine (String.Join ("#", l.Request.Headers.AllKeys));
 721                                         failed = true;
 722                                 }
 723                         }, port);
 724
 725                         try {
 726                                 var client = new HttpClient ();
 727                                 client.DefaultRequestHeaders.TransferEncodingChunked = true;
 728
 729                                 client.GetAsync ($"http://localhost:{port}/").Wait ();
 730
 731                                 Assert.AreEqual (false, failed, "#102");
 732                         } finally {
 733                                 listener.Abort ();
 734                                 listener.Close ();
 735                         }
 736                 }
 737
 738                 [Test]
 739 #if FEATURE_NO_BSD_SOCKETS
 740                 [ExpectedException (typeof (PlatformNotSupportedException))]
 741 #endif
 742                 public void Send_Transfer_Encoding_Custom ()
 743                 {
 744                         bool? failed = null;
 745
 746                         var port = NetworkHelpers.FindFreePort ();
 747                         var listener = CreateListener (l => {
 748                                 failed = true;
 749                         }, port);
 750
 751                         try {
 752                                 var client = new HttpClient ();
 753                                 client.DefaultRequestHeaders.TransferEncoding.Add (new TransferCodingHeaderValue ("chunked2"));
 754
 755                                 var request = new HttpRequestMessage (HttpMethod.Get, $"http://localhost:{port}/");
 756
 757                                 try {
 758                                         client.SendAsync (request, HttpCompletionOption.ResponseHeadersRead).Wait ();
 759                                         Assert.Fail ("#1");
 760                                 } catch (AggregateException e) {
 761                                         Assert.AreEqual (typeof (ProtocolViolationException), e.InnerException.GetType (), "#2");
 762                                 }
 763                                 Assert.IsNull (failed, "#102");
 764                         } finally {
 765                                 listener.Abort ();
 766                                 listener.Close ();
 767                         }
 768                 }
 769
 770                 [Test]
 771 #if FEATURE_NO_BSD_SOCKETS
 772                 [ExpectedException (typeof (PlatformNotSupportedException))]
 773 #endif
 774                 public void Send_Complete_Content ()
 775                 {
 776                         var port = NetworkHelpers.FindFreePort ();
 777                         var listener = CreateListener (l => {
 778                                 var request = l.Request;
 779                                 l.Response.OutputStream.WriteByte (55);
 780                                 l.Response.OutputStream.WriteByte (75);
 781                         }, port);
 782
 783                         try {
 784                                 var client = new HttpClient ();
 785                                 var request = new HttpRequestMessage (HttpMethod.Get, $"http://localhost:{port}/");
 786                                 Assert.IsTrue (request.Headers.TryAddWithoutValidation ("aa", "vv"), "#0");
 787                                 var response = client.SendAsync (request, HttpCompletionOption.ResponseHeadersRead).Result;
 788
 789                                 Assert.AreEqual ("7K", response.Content.ReadAsStringAsync ().Result, "#100");
 790                                 Assert.AreEqual (HttpStatusCode.OK, response.StatusCode, "#101");
 791
 792                                 IEnumerable<string> values;
 793                                 Assert.IsTrue (response.Headers.TryGetValues ("Transfer-Encoding", out values), "#102");
 794                                 Assert.AreEqual ("chunked", values.First (), "#102a");
 795                                 Assert.AreEqual (true, response.Headers.TransferEncodingChunked, "#102b");
 796                         } finally {
 797                                 listener.Close ();
 798                         }
 799                 }
 800
 801                 [Test]
 802 #if FEATURE_NO_BSD_SOCKETS
 803                 [ExpectedException (typeof (PlatformNotSupportedException))]
 804 #endif
 805                 public void Send_Complete_Content_MaxResponseContentBufferSize ()
 806                 {
 807                         var port = NetworkHelpers.FindFreePort ();
 808                         var listener = CreateListener (l => {
 809                                 var request = l.Request;
 810                                 var b = new byte[4000];
 811                                 l.Response.OutputStream.Write (b, 0, b.Length);
 812                         }, port);
 813
 814                         try {
 815                                 var client = new HttpClient ();
 816                                 client.MaxResponseContentBufferSize = 1000;
 817                                 var request = new HttpRequestMessage (HttpMethod.Get, $"http://localhost:{port}/");
 818                                 var response = client.SendAsync (request, HttpCompletionOption.ResponseHeadersRead).Result;
 819
 820                                 Assert.AreEqual (4000, response.Content.ReadAsStringAsync ().Result.Length, "#100");
 821                                 Assert.AreEqual (HttpStatusCode.OK, response.StatusCode, "#101");
 822                         } finally {
 823                                 listener.Close ();
 824                         }
 825                 }
 826
 827                 [Test]
 828 #if FEATURE_NO_BSD_SOCKETS
 829                 [ExpectedException (typeof (PlatformNotSupportedException))]
 830 #endif
 831                 public void Send_Complete_Content_MaxResponseContentBufferSize_Error ()
 832                 {
 833                         var port = NetworkHelpers.FindFreePort ();
 834                         var listener = CreateListener (l => {
 835                                 var request = l.Request;
 836                                 var b = new byte[4000];
 837                                 l.Response.OutputStream.Write (b, 0, b.Length);
 838                         }, port);
 839
 840                         try {
 841                                 var client = new HttpClient ();
 842                                 client.MaxResponseContentBufferSize = 1000;
 843                                 var request = new HttpRequestMessage (HttpMethod.Get, $"http://localhost:{port}/");
 844
 845                                 try {
 846                                         client.SendAsync (request, HttpCompletionOption.ResponseContentRead).Wait (WaitTimeout);
 847                                         Assert.Fail ("#2");
 848                                 } catch (AggregateException e) {
 849                                         Assert.IsTrue (e.InnerException is HttpRequestException, "#3");
 850                                 }
 851
 852                         } finally {
 853                                 listener.Close ();
 854                         }
 855                 }
 856
 857                 [Test]
 858 #if FEATURE_NO_BSD_SOCKETS
 859                 [ExpectedException (typeof (PlatformNotSupportedException))]
 860 #endif
 861                 public void Send_Complete_NoContent_Post ()
 862                 {
 863                         Send_Complete_NoContent (HttpMethod.Post);
 864                 }
 865
 866                 [Test]
 867 #if FEATURE_NO_BSD_SOCKETS
 868                 [ExpectedException (typeof (PlatformNotSupportedException))]
 869 #endif
 870                 public void Send_Complete_NoContent_Put ()
 871                 {
 872                         Send_Complete_NoContent (HttpMethod.Put);
 873                 }
 874
 875                 [Test]
 876 #if FEATURE_NO_BSD_SOCKETS
 877                 [ExpectedException (typeof (PlatformNotSupportedException))]
 878 #endif
 879                 public void Send_Complete_NoContent_Delete ()
 880                 {
 881                         Send_Complete_NoContent (HttpMethod.Delete);
 882                 }
 883
 884                 void Send_Complete_NoContent (HttpMethod method)
 885                 {
 886                         bool? failed = null;
 887                         var port = NetworkHelpers.FindFreePort ();
 888                         var listener = CreateListener (l => {
 889                                 try {
 890                                         var request = l.Request;
 891
 892                                         Assert.AreEqual (3, request.Headers.Count, "#1");
 893                                         Assert.AreEqual ("0", request.Headers ["Content-Length"], "#1b");
 894                                         Assert.AreEqual ("keep-alive", request.Headers ["Connection"], "#1c");
 895                                         Assert.AreEqual (method.Method, request.HttpMethod, "#2");
 896                                         failed = false;
 897                                 } catch (Exception ex){
 898                                         Console.WriteLine (ex);
 899                                         Console.WriteLine (String.Join ("#", l.Request.Headers.AllKeys));
 900
 901                                         failed = true;
 902                                 }
 903                         }, port);
 904
 905                         try {
 906                                 var client = new HttpClient ();
 907                                 var request = new HttpRequestMessage (method, $"http://localhost:{port}/");
 908                                 var response = client.SendAsync (request, HttpCompletionOption.ResponseHeadersRead).Result;
 909
 910                                 Assert.AreEqual ("", response.Content.ReadAsStringAsync ().Result, "#100");
 911                                 Assert.AreEqual (HttpStatusCode.OK, response.StatusCode, "#101");
 912                                 Assert.AreEqual (false, failed, "#102");
 913                         } finally {
 914                                 listener.Close ();
 915                         }
 916                 }
 917
 918                 [Test]
 919 #if FEATURE_NO_BSD_SOCKETS
 920                 [ExpectedException (typeof (PlatformNotSupportedException))]
 921 #endif
 922                 public void Send_Complete_Error ()
 923                 {
 924                         var port = NetworkHelpers.FindFreePort ();
 925                         var listener = CreateListener (l => {
 926                                 var response = l.Response;
 927                                 response.StatusCode = 500;
 928                         }, port);
 929
 930                         try {
 931                                 var client = new HttpClient ();
 932                                 var request = new HttpRequestMessage (HttpMethod.Get, $"http://localhost:{port}/");
 933                                 var response = client.SendAsync (request, HttpCompletionOption.ResponseHeadersRead).Result;
 934
 935                                 Assert.AreEqual ("", response.Content.ReadAsStringAsync ().Result, "#100");
 936                                 Assert.AreEqual (HttpStatusCode.InternalServerError, response.StatusCode, "#101");
 937                         } finally {
 938                                 listener.Close ();
 939                         }
 940                 }
 941
 942                 [Test]
 943 #if FEATURE_NO_BSD_SOCKETS
 944                 [ExpectedException (typeof (PlatformNotSupportedException))]
 945 #endif
 946                 public void Send_Content_Get ()
 947                 {
 948                         var port = NetworkHelpers.FindFreePort ();
 949                         var listener = CreateListener (l => {
 950                                 var request = l.Request;
 951                                 l.Response.OutputStream.WriteByte (72);
 952                         }, port);
 953
 954                         try {
 955                                 var client = new HttpClient ();
 956                                 var r = new HttpRequestMessage (HttpMethod.Get, $"http://localhost:{port}/");
 957                                 var response = client.SendAsync (r).Result;
 958
 959                                 Assert.AreEqual ("H", response.Content.ReadAsStringAsync ().Result);
 960                         } finally {
 961                                 listener.Close ();
 962                         }
 963                 }
 964
 965                 [Test]
 966 #if FEATURE_NO_BSD_SOCKETS
 967                 [ExpectedException (typeof (PlatformNotSupportedException))]
 968 #endif
 969                 public void Send_Content_BomEncoding ()
 970                 {
 971                         var port = NetworkHelpers.FindFreePort ();
 972                         var listener = CreateListener (l => {
 973                                 var request = l.Request;
 974
 975                                 var str = l.Response.OutputStream;
 976                                 str.WriteByte (0xEF);
 977                                 str.WriteByte (0xBB);
 978                                 str.WriteByte (0xBF);
 979                                 str.WriteByte (71);
 980                         }, port);
 981
 982                         try {
 983                                 var client = new HttpClient ();
 984                                 var r = new HttpRequestMessage (HttpMethod.Get, $"http://localhost:{port}/");
 985                                 var response = client.SendAsync (r).Result;
 986
 987                                 Assert.AreEqual ("G", response.Content.ReadAsStringAsync ().Result);
 988                         } finally {
 989                                 listener.Close ();
 990                         }
 991                 }
 992
 993                 [Test]
 994 #if FEATURE_NO_BSD_SOCKETS
 995                 [ExpectedException (typeof (PlatformNotSupportedException))]
 996 #endif
 997                 public void Send_Content_Put ()
 998                 {
 999                         bool passed = false;
1000                         var port = NetworkHelpers.FindFreePort ();
1001                         var listener = CreateListener (l => {
1002                                 var request = l.Request;
1003                                 passed = 7 == request.ContentLength64;
1004                                 passed &= request.ContentType == "text/plain; charset=utf-8";
1005                                 passed &= request.InputStream.ReadByte () == 'm';
1006                         }, port);
1007
1008                         try {
1009                                 var client = new HttpClient ();
1010                                 var r = new HttpRequestMessage (HttpMethod.Put, $"http://localhost:{port}/");
1011                                 r.Content = new StringContent ("my text");
1012                                 var response = client.SendAsync (r).Result;
1013
1014                                 Assert.AreEqual (HttpStatusCode.OK, response.StatusCode, "#1");
1015                                 Assert.IsTrue (passed, "#2");
1016                         } finally {
1017                                 listener.Abort ();
1018                                 listener.Close ();
1019                         }
1020                 }
1021
1022                 [Test]
1023 #if FEATURE_NO_BSD_SOCKETS
1024                 [ExpectedException (typeof (PlatformNotSupportedException))]
1025 #endif
1026                 public void Send_Content_Put_CustomStream ()
1027                 {
1028                         bool passed = false;
1029                         var port = NetworkHelpers.FindFreePort ();
1030                         var listener = CreateListener (l => {
1031                                 var request = l.Request;
1032                                 passed = 44 == request.ContentLength64;
1033                                 passed &= request.ContentType == null;
1034                         }, port);
1035
1036                         try {
1037                                 var client = new HttpClient ();
1038                                 var r = new HttpRequestMessage (HttpMethod.Put, $"http://localhost:{port}/");
1039                                 r.Content = new StreamContent (new CustomStream ());
1040                                 var response = client.SendAsync (r).Result;
1041
1042                                 Assert.AreEqual (HttpStatusCode.OK, response.StatusCode, "#1");
1043                                 Assert.IsTrue (passed, "#2");
1044                         } finally {
1045                                 listener.Abort ();
1046
1047                                 listener.Close ();
1048                         }
1049                 }
1050
1051                 [Test]
1052                 public void Send_Timeout ()
1053                 {
1054                         var mh = new HttpMessageHandlerMock ();
1055
1056                         var client = new HttpClient (mh);
1057                         client.Timeout = TimeSpan.FromMilliseconds (100);
1058                         var request = new HttpRequestMessage (HttpMethod.Get, "http://xamarin.com");
1059                         var response = new HttpResponseMessage ();
1060
1061                         mh.OnSendFull = (l, c) => {
1062                                 Assert.IsTrue (c.WaitHandle.WaitOne (500), "#2");
1063                                 return Task.FromResult (response);
1064                         };
1065
1066                         Assert.AreEqual (response, client.SendAsync (request).Result, "#1");
1067                 }
1068
1069                 [Test]
1070                 public void Send_Invalid ()
1071                 {
1072                         var client = new HttpClient ();
1073                         try {
1074                                 client.SendAsync (null).Wait (WaitTimeout);
1075                                 Assert.Fail ("#1");
1076                         } catch (ArgumentNullException) {
1077                         }
1078
1079                         try {
1080                                 var request = new HttpRequestMessage ();
1081                                 client.SendAsync (request).Wait (WaitTimeout);
1082                                 Assert.Fail ("#2");
1083                         } catch (InvalidOperationException) {
1084                         }
1085                 }
1086
1087                 [Test]
1088                 public void Send_InvalidHandler ()
1089                 {
1090                         var mh = new HttpMessageHandlerMock ();
1091
1092                         var client = new HttpClient (mh);
1093                         client.BaseAddress = new Uri ("http://xamarin.com");
1094                         var request = new HttpRequestMessage ();
1095
1096                         mh.OnSend = l => {
1097                                 Assert.AreEqual (l, request, "#1");
1098                                 return null;
1099                         };
1100
1101                         try {
1102                                 // Broken by design
1103                                 client.SendAsync (request).Wait (WaitTimeout);
1104                                 Assert.Fail ("#2");
1105                         } catch (Exception) {
1106                         }
1107                 }
1108
1109                 [Test]
1110                 public void Send_SameMessage ()
1111                 {
1112                         var mh = new HttpMessageHandlerMock ();
1113
1114                         var client = new HttpClient (mh);
1115                         var request = new HttpRequestMessage (HttpMethod.Get, "http://xamarin.com");
1116
1117                         mh.OnSend = l => Task.FromResult (new HttpResponseMessage ());
1118
1119                         client.SendAsync (request).Wait (WaitTimeout);
1120                         try {
1121                                 client.SendAsync (request).Wait (WaitTimeout);
1122                                 Assert.Fail ("#1");
1123                         } catch (InvalidOperationException) {
1124                         }
1125                 }
1126
1127                 [Test]
1128 #if FEATURE_NO_BSD_SOCKETS
1129                 [ExpectedException (typeof (PlatformNotSupportedException))]
1130 #endif
1131                 public void Post_TransferEncodingChunked ()
1132                 {
1133                         bool? failed = null;
1134                         var port = NetworkHelpers.FindFreePort ();
1135                         var listener = CreateListener (l => {
1136                                 try {
1137                                         var request = l.Request;
1138
1139                                         Assert.IsNull (request.AcceptTypes, "#1");
1140                                         Assert.AreEqual (-1, request.ContentLength64, "#2");
1141                                         Assert.IsNull (request.ContentType, "#3");
1142                                         Assert.AreEqual (0, request.Cookies.Count, "#4");
1143                                         Assert.IsTrue (request.HasEntityBody, "#5");
1144                                         Assert.AreEqual ($"localhost:{port}", request.Headers ["Host"], "#6b");
1145                                         Assert.AreEqual ("POST", request.HttpMethod, "#7");
1146                                         Assert.IsFalse (request.IsAuthenticated, "#8");
1147                                         Assert.IsTrue (request.IsLocal, "#9");
1148                                         Assert.IsFalse (request.IsSecureConnection, "#10");
1149                                         Assert.IsFalse (request.IsWebSocketRequest, "#11");
1150                                         Assert.IsTrue (request.KeepAlive, "#12");
1151                                         Assert.AreEqual (HttpVersion.Version11, request.ProtocolVersion, "#13");
1152                                         Assert.IsNull (request.ServiceName, "#14");
1153                                         Assert.IsNull (request.UrlReferrer, "#15");
1154                                         Assert.IsNull (request.UserAgent, "#16");
1155                                         Assert.IsNull (request.UserLanguages, "#17");
1156                                         Assert.AreEqual ("chunked", request.Headers ["Transfer-Encoding"], "#18");
1157                                         Assert.IsNull (request.Headers ["Content-Length"], "#19");
1158                                         failed = false;
1159                                 } catch (Exception e) {
1160                                         failed = true;
1161                                         Console.WriteLine (e);
1162                                 }
1163                         }, port);
1164
1165                         try {
1166                                 var client = new HttpClient ();
1167
1168                                 client.DefaultRequestHeaders.TransferEncodingChunked = true;
1169
1170                                 var imageContent = new StreamContent (new MemoryStream ());
1171
1172                                 var response = client.PostAsync ($"http://localhost:{port}/", imageContent).Result;
1173
1174                                 Assert.AreEqual(HttpStatusCode.OK, response.StatusCode, "#101");
1175                                 Assert.AreEqual(false, failed, "#102");
1176                         } finally {
1177                                 listener.Close ();
1178                         }
1179                 }
1180
1181                 [Test]
1182 #if FEATURE_NO_BSD_SOCKETS
1183                 [ExpectedException (typeof (PlatformNotSupportedException))]
1184 #endif
1185                 public void Post_StreamCaching ()
1186                 {
1187                         bool? failed = null;
1188                         var port = NetworkHelpers.FindFreePort ();
1189                         var listener = CreateListener (l => {
1190                                 try {
1191                                         var request = l.Request;
1192
1193                                         Assert.IsNull (request.AcceptTypes, "#1");
1194                                         Assert.AreEqual (0, request.ContentLength64, "#2");
1195                                         Assert.IsNull (request.ContentType, "#3");
1196                                         Assert.AreEqual (0, request.Cookies.Count, "#4");
1197                                         Assert.IsFalse (request.HasEntityBody, "#5");
1198                                         Assert.AreEqual ($"localhost:{port}", request.Headers ["Host"], "#6b");
1199                                         Assert.AreEqual ("POST", request.HttpMethod, "#7");
1200                                         Assert.IsFalse (request.IsAuthenticated, "#8");
1201                                         Assert.IsTrue (request.IsLocal, "#9");
1202                                         Assert.IsFalse (request.IsSecureConnection, "#10");
1203                                         Assert.IsFalse (request.IsWebSocketRequest, "#11");
1204                                         Assert.IsTrue (request.KeepAlive, "#12");
1205                                         Assert.AreEqual (HttpVersion.Version11, request.ProtocolVersion, "#13");
1206                                         Assert.IsNull (request.ServiceName, "#14");
1207                                         Assert.IsNull (request.UrlReferrer, "#15");
1208                                         Assert.IsNull (request.UserAgent, "#16");
1209                                         Assert.IsNull (request.UserLanguages, "#17");
1210                                         Assert.IsNull (request.Headers ["Transfer-Encoding"], "#18");
1211                                         Assert.AreEqual ("0", request.Headers ["Content-Length"], "#19");
1212                                         failed = false;
1213                                 } catch (Exception e) {
1214                                         failed = true;
1215                                         Console.WriteLine (e);
1216                                 }
1217                         }, port);
1218
1219                         try {
1220                                 var client = new HttpClient ();
1221
1222                                 var imageContent = new StreamContent (new MemoryStream ());
1223
1224                                 var response = client.PostAsync ($"http://localhost:{port}/", imageContent).Result;
1225
1226                                 Assert.AreEqual(HttpStatusCode.OK, response.StatusCode, "#101");
1227                                 Assert.AreEqual(false, failed, "#102");
1228                         } finally {
1229                                 listener.Close ();
1230                         }
1231                 }
1232
1233                 [Test]
1234                 [Category ("MobileNotWorking")] // Missing encoding
1235 #if FEATURE_NO_BSD_SOCKETS
1236                 [ExpectedException (typeof (PlatformNotSupportedException))]
1237 #endif
1238                 public void GetString_Many ()
1239                 {
1240                         Action<HttpListenerContext> context = (HttpListenerContext l) => {
1241                                 var response = l.Response;
1242                                 response.StatusCode = 200;
1243                                 response.OutputStream.WriteByte (0x68);
1244                                 response.OutputStream.WriteByte (0x65);
1245                                 response.OutputStream.WriteByte (0x6c);
1246                                 response.OutputStream.WriteByte (0x6c);
1247                                 response.OutputStream.WriteByte (0x6f);
1248                         };
1249
1250                         var port = NetworkHelpers.FindFreePort ();
1251                         var listener = CreateListener (context, port); // creates a default request handler
1252                         AddListenerContext (listener, context);  // add another request handler for the second request
1253
1254                         try {
1255                                 var client = new HttpClient ();
1256                                 var t1 = client.GetStringAsync ($"http://localhost:{port}/");
1257                                 var t2 = client.GetStringAsync ($"http://localhost:{port}/");
1258                                 Assert.IsTrue (Task.WaitAll (new [] { t1, t2 }, WaitTimeout));
1259                                 Assert.AreEqual ("hello", t1.Result, "#1");
1260                                 Assert.AreEqual ("hello", t2.Result, "#2");
1261                         } finally {
1262                                 listener.Abort ();
1263                                 listener.Close ();
1264                         }
1265                 }
1266
1267                 [Test]
1268 #if FEATURE_NO_BSD_SOCKETS
1269                 [ExpectedException (typeof (PlatformNotSupportedException))]
1270 #endif
1271                 public void GetByteArray_ServerError ()
1272                 {
1273                         var port = NetworkHelpers.FindFreePort ();
1274                         var listener = CreateListener (l => {
1275                                 var response = l.Response;
1276                                 response.StatusCode = 500;
1277                                 l.Response.OutputStream.WriteByte (72);
1278                         }, port);
1279
1280                         try {
1281                                 var client = new HttpClient ();
1282                                 try {
1283                                         client.GetByteArrayAsync ($"http://localhost:{port}/").Wait (WaitTimeout);
1284                                         Assert.Fail ("#1");
1285                                 } catch (AggregateException e) {
1286                                         Assert.IsTrue (e.InnerException is HttpRequestException , "#2");
1287                                 }
1288                         } finally {
1289                                 listener.Close ();
1290                         }
1291                 }
1292
1293                 [Test]
1294 #if FEATURE_NO_BSD_SOCKETS
1295                 [ExpectedException (typeof (PlatformNotSupportedException))]
1296 #endif
1297                 public void DisallowAutoRedirect ()
1298                 {
1299                         var port = NetworkHelpers.FindFreePort ();
1300                         var listener = CreateListener (l => {
1301                                 var request = l.Request;
1302                                 var response = l.Response;
1303
1304                                 response.StatusCode = (int)HttpStatusCode.Moved;
1305                                 response.RedirectLocation = "http://xamarin.com/";
1306                         }, port);
1307
1308                         try {
1309                                 var chandler = new HttpClientHandler ();
1310                                 chandler.AllowAutoRedirect = false;
1311                                 var client = new HttpClient (chandler);
1312
1313                                 try {
1314                                         client.GetStringAsync ($"http://localhost:{port}/").Wait (WaitTimeout);
1315                                         Assert.Fail ("#1");
1316                                 } catch (AggregateException e) {
1317                                         Assert.IsTrue (e.InnerException is HttpRequestException, "#2");
1318                                 }
1319                         } finally {
1320                                 listener.Abort ();
1321                                 listener.Close ();
1322                         }
1323                 }
1324
1325                 [Test]
1326 #if FEATURE_NO_BSD_SOCKETS
1327                 [ExpectedException (typeof (PlatformNotSupportedException))]
1328 #endif
1329                 public void RequestUriAfterRedirect ()
1330                 {
1331                         var port = NetworkHelpers.FindFreePort ();
1332                         var redirectPort = NetworkHelpers.FindFreePort ();
1333
1334                         var listener = CreateListener (l => {
1335                                 var request = l.Request;
1336                                 var response = l.Response;
1337
1338                                 response.StatusCode = (int)HttpStatusCode.Moved;
1339                                 response.RedirectLocation = $"http://localhost:{redirectPort}/";
1340                         }, port);
1341
1342                         var listener2 = CreateListener (l => {
1343                                 var response = l.Response;
1344
1345                                 response.StatusCode = (int)HttpStatusCode.OK;
1346                                 response.OutputStream.WriteByte (0x68);
1347                                 response.OutputStream.WriteByte (0x65);
1348                                 response.OutputStream.WriteByte (0x6c);
1349                                 response.OutputStream.WriteByte (0x6c);
1350                                 response.OutputStream.WriteByte (0x6f);
1351                         }, redirectPort);
1352
1353                         try {
1354                                 var chandler = new HttpClientHandler ();
1355                                 chandler.AllowAutoRedirect = true;
1356                                 var client = new HttpClient (chandler);
1357
1358                                 var r = client.GetAsync ($"http://localhost:{port}/");
1359                                 Assert.IsTrue (r.Wait (WaitTimeout), "#1");
1360                                 var resp = r.Result;
1361                                 Assert.AreEqual ($"http://localhost:{redirectPort}/", resp.RequestMessage.RequestUri.AbsoluteUri, "#2");
1362                                 Assert.AreEqual ("hello", resp.Content.ReadAsStringAsync ().Result, "#3");
1363                         } finally {
1364                                 listener.Abort ();
1365                                 listener.Close ();
1366                                 listener2.Abort ();
1367                                 listener2.Close ();
1368                         }
1369                 }
1370
1371                 [Test]
1372 #if FEATURE_NO_BSD_SOCKETS
1373                 [ExpectedException (typeof (PlatformNotSupportedException))]
1374 #endif
1375                 /*
1376                  * Properties may only be modified before sending the first request.
1377                  */
1378                 public void ModifyHandlerAfterFirstRequest ()
1379                 {
1380                         var chandler = new HttpClientHandler ();
1381                         chandler.AllowAutoRedirect = true;
1382                         var client = new HttpClient (chandler, true);
1383
1384                         var port = NetworkHelpers.FindFreePort ();
1385                         var listener = CreateListener (l => {
1386                                 var response = l.Response;
1387                                 response.StatusCode = 200;
1388                                 response.OutputStream.WriteByte (55);
1389                         }, port);
1390
1391                         try {
1392                                 client.GetStringAsync ($"http://localhost:{port}/").Wait (WaitTimeout);
1393                                 try {
1394                                         chandler.AllowAutoRedirect = false;
1395                                         Assert.Fail ("#1");
1396                                 } catch (InvalidOperationException) {
1397                                         ;
1398                                 }
1399                         } finally {
1400                                 listener.Abort ();
1401                                 listener.Close ();
1402                         }
1403                 }
1404
1405                 [Test]
1406 #if FEATURE_NO_BSD_SOCKETS
1407                 // Using HttpClientHandler, which indirectly requires BSD sockets.
1408                 [ExpectedException (typeof (PlatformNotSupportedException))]
1409 #endif
1410                 /*
1411                  * However, this policy is not enforced for custom handlers and there
1412                  * is also no way a derived class could tell its HttpClientHandler parent
1413                  * that it just sent a request.
1414                  *
1415                  */
1416                 public void ModifyHandlerAfterFirstRequest_Mock ()
1417                 {
1418                         var ch = new HttpClientHandlerMock ();
1419                         ch.AllowAutoRedirect = true;
1420
1421                         var client = new HttpClient (ch);
1422
1423                         ch.OnSend = (l) => {
1424                                 return Task.FromResult (new HttpResponseMessage ());
1425                         };
1426
1427                         client.GetAsync ("http://xamarin.com").Wait (WaitTimeout);
1428                         ch.AllowAutoRedirect = false;
1429                 }
1430
1431                 HttpListener CreateListener (Action<HttpListenerContext> contextAssert, int port)
1432                 {
1433                         var l = new HttpListener ();
1434                         l.Prefixes.Add (string.Format ("http://+:{0}/", port));
1435                         l.Start ();
1436                         AddListenerContext(l, contextAssert);
1437
1438                         return l;
1439                 }
1440
1441                 HttpListener AddListenerContext (HttpListener l, Action<HttpListenerContext> contextAssert)
1442                 {
1443                         l.BeginGetContext (ar => {
1444                                 var ctx = l.EndGetContext (ar);
1445
1446                                 try {
1447                                         if (contextAssert != null)
1448                                                 contextAssert (ctx);
1449                                 } finally {
1450                                         ctx.Response.Close ();
1451                                 }
1452                         }, null);
1453
1454                         return l;
1455                 }
1456         }
1457 }