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

   1 //
   2 // HttpRequestMessageTest.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 System.Text.RegularExpressions;
  33 using NUnit.Framework;
  34 using System.Net.Http;
  35 using System.Net;
  36 using System.Net.Http.Headers;
  37 using System.Linq;
  38
  39 namespace MonoTests.System.Net.Http
  40 {
  41         [TestFixture]
  42         public class HttpRequestMessageTest
  43         {
  44                 [Test]
  45                 public void Ctor_Invalid ()
  46                 {
  47                         try {
  48                                 new HttpRequestMessage (null, "");
  49                                 Assert.Fail ("#1");
  50                         } catch (ArgumentNullException) {
  51                         }
  52                 }
  53
  54                 [Test]
  55                 public void Ctor_Default ()
  56                 {
  57                         var m = new HttpRequestMessage ();
  58                         Assert.IsNull (m.Content, "#1");
  59                         Assert.IsNotNull (m.Headers, "#2");
  60                         Assert.AreEqual (HttpMethod.Get, m.Method, "#3");
  61                         Assert.IsNotNull (m.Properties, "#4");
  62                         Assert.IsNull (m.RequestUri, "#5");
  63                         Assert.AreEqual (new Version (1, 1), m.Version, "#6");
  64
  65                         Assert.AreEqual ("Method: GET, RequestUri: '<null>', Version: 1.1, Content: <null>, Headers:\r\n{\r\n}", m.ToString (), "#7");
  66                 }
  67
  68                 [Test]
  69                 public void Ctor_Uri ()
  70                 {
  71                         var c = new HttpRequestMessage (HttpMethod.Get, new Uri ("http://xamarin.com"));
  72                         Assert.AreEqual ("http://xamarin.com/", c.RequestUri.AbsoluteUri, "#1");
  73
  74                         c = new HttpRequestMessage (HttpMethod.Get, new Uri ("https://xamarin.com"));
  75                         Assert.AreEqual ("https://xamarin.com/", c.RequestUri.AbsoluteUri, "#2");
  76
  77                         c = new HttpRequestMessage (HttpMethod.Get, new Uri ("HTTP://xamarin.com:8080"));
  78                         Assert.AreEqual ("http://xamarin.com:8080/", c.RequestUri.AbsoluteUri, "#3");
  79
  80                         var a = Uri.UriSchemeHttps;
  81                         var b = new Uri ("http://xamarin.com");
  82
  83                         try {
  84                                 new HttpRequestMessage (HttpMethod.Get, new Uri ("ftp://xamarin.com"));
  85                                 Assert.Fail ("#4");
  86                         } catch (ArgumentException) {
  87                         }
  88                 }
  89
  90                 [Test]
  91                 public void Ctor_RelativeUri ()
  92                 {
  93                         var client = new HttpClient ();
  94                         client.BaseAddress = new Uri ("http://en.wikipedia.org/wiki/");
  95                         var uri = new Uri ("Computer", UriKind.Relative);
  96                         var req = new HttpRequestMessage (HttpMethod.Get, uri);
  97                         // HttpRequestMessage does not rewrite it here.
  98                         Assert.AreEqual (req.RequestUri, uri);
  99                 }
 100
 101                 [Test]
 102                 public void Ctor_RelativeUriString ()
 103                 {
 104                         var client = new HttpClient ();
 105                         client.BaseAddress = new Uri ("http://en.wikipedia.org/wiki/");
 106                         var req = new HttpRequestMessage (HttpMethod.Get, "Computer");
 107                         // HttpRequestMessage does not rewrite it here.
 108                         Assert.IsFalse (req.RequestUri.IsAbsoluteUri);
 109                 }
 110
 111                 [Test]
 112                 public void Headers ()
 113                 {
 114                         HttpRequestMessage message = new HttpRequestMessage ();
 115                         HttpRequestHeaders headers = message.Headers;
 116
 117                         headers.Accept.Add (new MediaTypeWithQualityHeaderValue ("audio/x"));
 118                         headers.AcceptCharset.Add (new StringWithQualityHeaderValue ("str-v", 0.002));
 119                         headers.AcceptEncoding.Add (new StringWithQualityHeaderValue ("str-enc", 0.44));
 120                         headers.AcceptLanguage.Add (new StringWithQualityHeaderValue ("str-lang", 0.41));
 121                         headers.Authorization = new AuthenticationHeaderValue ("sh-aut", "par");
 122                         headers.CacheControl = new CacheControlHeaderValue () {
 123                                 MaxAge = TimeSpan.MaxValue
 124                         };
 125                         headers.Connection.Add ("test-value");
 126                         headers.ConnectionClose = true;
 127                         headers.Date = new DateTimeOffset (DateTime.Today);
 128                         headers.Expect.Add (new NameValueWithParametersHeaderValue ("en", "ev"));
 129                         headers.ExpectContinue = true;
 130                         headers.From = "webmaster@w3.org";
 131                         headers.Host = "host";
 132                         headers.IfMatch.Add (new EntityTagHeaderValue ("\"tag\"", true));
 133                         headers.IfModifiedSince = new DateTimeOffset (DateTime.Today);
 134                         headers.IfNoneMatch.Add (new EntityTagHeaderValue ("\"tag2\"", true));
 135                         headers.IfRange = new RangeConditionHeaderValue (new DateTimeOffset (DateTime.Today));
 136                         headers.IfUnmodifiedSince = new DateTimeOffset? (DateTimeOffset.Now);
 137                         headers.MaxForwards = 0x15b3;
 138                         headers.Pragma.Add (new NameValueHeaderValue ("name", "value"));
 139                         headers.ProxyAuthorization = new AuthenticationHeaderValue ("s", "p");
 140                         headers.Range = new RangeHeaderValue (5L, 30L);
 141                         headers.Referrer = new Uri ("http://xamarin.com");
 142                         headers.TE.Add (new TransferCodingWithQualityHeaderValue ("TE", 0.3));
 143                         headers.Trailer.Add ("value");
 144                         headers.TransferEncoding.Add (new TransferCodingHeaderValue ("tchv"));
 145                         headers.TransferEncodingChunked = true;
 146                         headers.Upgrade.Add (new ProductHeaderValue ("prod", "ver"));
 147                         headers.UserAgent.Add (new ProductInfoHeaderValue ("(comment)"));
 148                         headers.Via.Add (new ViaHeaderValue ("protocol", "rec-by"));
 149                         headers.Warning.Add (new WarningHeaderValue (5, "agent", "\"txt\""));
 150
 151                         try {
 152                                 headers.Add ("authorization", "");
 153                                 Assert.Fail ("Authorization");
 154                         } catch (FormatException) {
 155                         }
 156
 157                         try {
 158                                 headers.Add ("connection", "extra ß ");
 159                                 Assert.Fail ("Date");
 160                         } catch (FormatException) {
 161                         }
 162
 163                         try {
 164                                 headers.Add ("date", "");
 165                                 Assert.Fail ("Date");
 166                         } catch (FormatException) {
 167                         }
 168
 169                         try {
 170                                 headers.Add ("from", "a@w3.org");
 171                                 Assert.Fail ("From");
 172                         } catch (FormatException) {
 173                         }
 174
 175                         try {
 176                                 headers.Add ("hOst", "host");
 177                                 Assert.Fail ("Host");
 178                         } catch (FormatException) {
 179                         }
 180
 181                         try {
 182                                 headers.Add ("if-modified-since", "");
 183                                 Assert.Fail ("if-modified-since");
 184                         } catch (FormatException) {
 185                         }
 186
 187                         try {
 188                                 headers.Add ("if-range", "");
 189                                 Assert.Fail ("if-range");
 190                         } catch (FormatException) {
 191                         }
 192
 193                         try {
 194                                 headers.Add ("if-unmodified-since", "");
 195                                 Assert.Fail ("if-unmodified-since");
 196                         } catch (FormatException) {
 197                         }
 198
 199                         try {
 200                                 headers.Add ("max-forwards", "");
 201                                 Assert.Fail ("max-forwards");
 202                         } catch (FormatException) {
 203                         }
 204
 205                         try {
 206                                 headers.Add ("proxy-authorization", "");
 207                                 Assert.Fail ("proxy-authorization");
 208                         } catch (FormatException) {
 209                         }
 210
 211                         try {
 212                                 headers.Add ("range", "");
 213                         } catch (FormatException) {
 214                         }
 215
 216                         try {
 217                                 headers.Add ("referer", "");
 218                                 Assert.Fail ("referer");
 219                         } catch (FormatException) {
 220                         }
 221
 222                         try {
 223                                 headers.Add ("pragma", "nocache,RequestID=1,g=");
 224                                 Assert.Fail ("pragma");
 225                         } catch (FormatException) {
 226                         }
 227
 228                         headers.Add ("accept", "audio/y");
 229                         headers.Add ("accept-charset", "achs");
 230                         headers.Add ("accept-encoding", "aenc");
 231                         headers.Add ("accept-language", "alan");
 232                         headers.Add ("expect", "exp");
 233                         headers.Add ("if-match", "\"v\"");
 234                         headers.Add ("if-none-match", "\"v2\"");
 235                         headers.Add ("TE", "0.8");
 236                         headers.Add ("trailer", "value2");
 237                         headers.Add ("transfer-encoding", "ttt");
 238                         headers.Add ("upgrade", "uuu");
 239                         headers.Add ("user-agent", "uaua");
 240                         headers.Add ("via", "prot v");
 241                         headers.Add ("warning", "4 ww \"t\"");
 242                         headers.Add ("pragma", "nocache,R=1,g");
 243
 244                         Assert.IsTrue (headers.Accept.SequenceEqual (
 245                                 new[] {
 246                                         new MediaTypeWithQualityHeaderValue ("audio/x"),
 247                                         new MediaTypeWithQualityHeaderValue ("audio/y")
 248                                 }
 249                         ));
 250
 251                         Assert.IsTrue (headers.AcceptCharset.SequenceEqual (
 252                                 new[] {
 253                                         new StringWithQualityHeaderValue ("str-v", 0.002),
 254                                         new StringWithQualityHeaderValue ("achs")
 255                                 }
 256                         ));
 257
 258                         Assert.IsTrue (headers.AcceptEncoding.SequenceEqual (
 259                                 new[] {
 260                                         new StringWithQualityHeaderValue ("str-enc", 0.44),
 261                                         new StringWithQualityHeaderValue ("aenc")
 262                                 }
 263                         ));
 264
 265                         Assert.IsTrue (headers.AcceptLanguage.SequenceEqual (
 266                                 new[] {
 267                                         new StringWithQualityHeaderValue ("str-lang", 0.41),
 268                                         new StringWithQualityHeaderValue ("alan")
 269                                 }
 270                         ));
 271
 272                         Assert.AreEqual (new AuthenticationHeaderValue ("sh-aut", "par"), headers.Authorization);
 273
 274                         var cch = new CacheControlHeaderValue () {
 275                                         MaxAge = TimeSpan.MaxValue,
 276                                 };
 277
 278                         Assert.AreEqual (cch, headers.CacheControl);
 279
 280                         Assert.IsTrue (headers.Connection.SequenceEqual (
 281                                 new string[] { "test-value", "close" }));
 282
 283                         Assert.AreEqual (headers.Date, new DateTimeOffset (DateTime.Today));
 284
 285                         Assert.IsTrue (headers.Expect.SequenceEqual (
 286                                 new [] {
 287                                         new NameValueWithParametersHeaderValue ("en", "ev"),
 288                                         new NameValueWithParametersHeaderValue ("100-continue"),
 289                                         new NameValueWithParametersHeaderValue ("exp")
 290                                 }));
 291
 292                         Assert.AreEqual (headers.From, "webmaster@w3.org");
 293
 294                         Assert.IsTrue (headers.IfMatch.SequenceEqual (
 295                                 new EntityTagHeaderValue[] {
 296                                         new EntityTagHeaderValue ("\"tag\"", true),
 297                                         new EntityTagHeaderValue ("\"v\"", false)
 298                                 }
 299                         ));
 300
 301                         Assert.AreEqual (headers.IfModifiedSince, new DateTimeOffset (DateTime.Today));
 302                         Assert.IsTrue (headers.IfNoneMatch.SequenceEqual (new EntityTagHeaderValue[] { new EntityTagHeaderValue ("\"tag2\"", true), new EntityTagHeaderValue ("\"v2\"", false) }));
 303                         Assert.AreEqual (new DateTimeOffset (DateTime.Today), headers.IfRange.Date);
 304                         Assert.AreEqual (headers.MaxForwards, 0x15b3);
 305                         Assert.AreEqual ("p", headers.ProxyAuthorization.Parameter);
 306                         Assert.AreEqual ("s", headers.ProxyAuthorization.Scheme);
 307                         Assert.AreEqual (5, headers.Range.Ranges.First ().From);
 308                         Assert.AreEqual (30, headers.Range.Ranges.First ().To);
 309                         Assert.AreEqual ("bytes", headers.Range.Unit);
 310                         Assert.AreEqual (headers.Referrer, new Uri ("http://xamarin.com"));
 311                         Assert.IsTrue (headers.TE.SequenceEqual (new TransferCodingWithQualityHeaderValue[] { new TransferCodingWithQualityHeaderValue ("TE", 0.3), new TransferCodingWithQualityHeaderValue ("0.8") }), "29");
 312                         Assert.IsTrue (headers.Trailer.SequenceEqual (
 313                                 new string[] {
 314                                         "value", "value2"
 315                                 }), "30");
 316
 317                         Assert.IsTrue (headers.TransferEncoding.SequenceEqual (
 318                                 new[] {
 319                                         new TransferCodingHeaderValue ("tchv"),
 320                                         new TransferCodingHeaderValue ("chunked"),
 321                                         new TransferCodingHeaderValue ("ttt")
 322                                 }
 323                         ));
 324
 325                         Assert.IsTrue (headers.Upgrade.SequenceEqual (
 326                                 new[] {
 327                                         new ProductHeaderValue ("prod", "ver"),
 328                                         new ProductHeaderValue ("uuu")
 329                                 }
 330                         ));
 331
 332                         Assert.IsTrue (headers.UserAgent.SequenceEqual (
 333                                 new[] {
 334                                         new ProductInfoHeaderValue ("(comment)"),
 335                                         new ProductInfoHeaderValue ("uaua", null)
 336                                 }
 337                         ));
 338
 339                         Assert.IsTrue (headers.Via.SequenceEqual (
 340                                 new[] {
 341                                         new ViaHeaderValue ("protocol", "rec-by"),
 342                                         new ViaHeaderValue ("prot", "v")
 343                                 }
 344                         ));
 345
 346                         Assert.IsTrue (headers.Warning.SequenceEqual (
 347                                 new[] {
 348                                         new WarningHeaderValue (5, "agent", "\"txt\""),
 349                                         new WarningHeaderValue (4, "ww", "\"t\"")
 350                                 }
 351                         ));
 352
 353                         Assert.IsTrue (headers.Pragma.SequenceEqual (
 354                                 new[] {
 355                                         new NameValueHeaderValue ("name", "value"),
 356                                         new NameValueHeaderValue ("nocache", null),
 357                                         new NameValueHeaderValue ("R", "1"),
 358                                         new NameValueHeaderValue ("g", null)
 359                                 }
 360                         ));
 361                 }
 362
 363                 [Test]
 364                 public void Header_BaseImplementation ()
 365                 {
 366                         HttpRequestMessage message = new HttpRequestMessage ();
 367                         HttpRequestHeaders headers = message.Headers;
 368
 369                         headers.Add ("a", "a-value");
 370                         headers.Add ("b", new List<string> { "v1", "v2" });
 371                         headers.Add ("c", null as string);
 372                         headers.Add ("d", new string[0]);
 373
 374                         Assert.IsTrue (headers.TryAddWithoutValidation ("accept", "audio"), "#0");
 375
 376                         Assert.IsFalse (headers.Contains ("nn"), "#1a");
 377                         Assert.IsTrue (headers.Contains ("b"), "#1b");
 378
 379                         var values = headers.GetValues ("b").ToList ();
 380                         Assert.AreEqual ("v1", values[0], "#2a");
 381                         Assert.AreEqual ("v2", values[1], "#2b");
 382
 383                         Assert.IsFalse (headers.Remove ("p"), "#3a");
 384                         Assert.IsTrue (headers.Remove ("b"), "#3b");
 385                         Assert.IsFalse (headers.Contains ("b"), "#3b-c");
 386
 387                         IEnumerable<string> values2;
 388                         Assert.IsTrue (headers.TryGetValues ("c", out values2));
 389                         values = values2.ToList ();
 390                         Assert.AreEqual ("", values[0], "#4a");
 391
 392                         int counter = 0;
 393                         foreach (var i in headers) {
 394                                 ++counter;
 395                         }
 396
 397                         Assert.AreEqual (3, counter, "#5");
 398
 399                         headers.Clear ();
 400
 401                         headers.Accept.Add (new MediaTypeWithQualityHeaderValue ("audio/x"));
 402                         Assert.IsTrue (headers.TryAddWithoutValidation ("accept", "audio"), "#55");
 403
 404                         values = headers.GetValues ("accept").ToList ();
 405                         Assert.AreEqual (2, values.Count, "#6");
 406                         Assert.AreEqual ("audio/x", values[0], "#6a");
 407                         Assert.AreEqual ("audio", values[1], "#6b");
 408                         Assert.AreEqual (1, headers.Accept.Count, "#6c");
 409
 410                         headers.Clear ();
 411
 412                         Assert.IsTrue (headers.TryAddWithoutValidation ("from", new[] { "a@a.com", "ssss@oo.com" }), "#70");
 413                         values = headers.GetValues ("from").ToList ();
 414
 415                         Assert.AreEqual (2, values.Count, "#7");
 416                         Assert.AreEqual ("a@a.com", values[0], "#7a");
 417                         Assert.AreEqual ("ssss@oo.com", values[1], "#7b");
 418                         Assert.AreEqual ("a@a.com", headers.From, "#7c");
 419
 420                         headers.Clear ();
 421
 422                         Assert.IsTrue (headers.TryAddWithoutValidation ("Date", "wrong date"), "#8-0");
 423                         var value = headers.Date;
 424                         Assert.IsNull (headers.Date, "#8");
 425                 }
 426
 427                 [Test]
 428                 public void Headers_Invalid ()
 429                 {
 430                         HttpRequestMessage message = new HttpRequestMessage ();
 431                         HttpRequestHeaders headers = message.Headers;
 432
 433                         try {
 434                                 headers.Add ("Allow", "");
 435                                 Assert.Fail ("#1");
 436                         } catch (InvalidOperationException) {
 437                         }
 438
 439                         try {
 440                                 headers.Add (null, "");
 441                                 Assert.Fail ("#2");
 442                         } catch (ArgumentException) {
 443                         }
 444
 445                         try {
 446                                 headers.Add ("mm", null as IEnumerable<string>);
 447                                 Assert.Fail ("#2b");
 448                         } catch (ArgumentNullException) {
 449                         }
 450
 451                         try {
 452                                 headers.Add ("accept", "audio");
 453                                 Assert.Fail ("#2c");
 454                         } catch (FormatException) {
 455                         }
 456
 457                         Assert.IsFalse (headers.TryAddWithoutValidation ("Allow", ""), "#3"); ;
 458
 459                         Assert.IsFalse (headers.TryAddWithoutValidation (null, ""), "#4");
 460
 461                         try {
 462                                 headers.Contains (null);
 463                                 Assert.Fail ("#5");
 464                         } catch (ArgumentException) {
 465                         }
 466
 467                         try {
 468                                 headers.GetValues (null);
 469                                 Assert.Fail ("#6a");
 470                         } catch (ArgumentException) {
 471                         }
 472
 473                         try {
 474                                 headers.GetValues ("bbbb");
 475                                 Assert.Fail ("#6b");
 476                         } catch (InvalidOperationException) {
 477                         }
 478
 479                         try {
 480                                 headers.Add ("from", new[] { "a@a.com", "ssss@oo.com" });
 481                                 Assert.Fail ("#7a");
 482                         } catch (FormatException) {
 483                         }
 484
 485                         Assert.IsTrue (headers.TryAddWithoutValidation ("from", "a@a.com"), "#7-0");
 486                         try {
 487                                 headers.Add ("from", "valid@w3.org");
 488                                 Assert.Fail ("#7b");
 489                         } catch (FormatException) {
 490                         }
 491                 }
 492
 493                 [Test]
 494                 public void Headers_Response ()
 495                 {
 496                         HttpRequestMessage message = new HttpRequestMessage ();
 497                         HttpRequestHeaders headers = message.Headers;
 498
 499                         headers.Add ("Age", "vv");
 500                         Assert.AreEqual ("vv", headers.GetValues ("Age").First (), "#1");
 501
 502                         headers.Clear ();
 503                         headers.TryAddWithoutValidation ("Age", "vv");
 504                         Assert.AreEqual ("vv", headers.GetValues ("Age").First (), "#2");
 505
 506                         // .NET encloses the "Age: vv" with two whitespaces.
 507                         var normalized = Regex.Replace (message.ToString (), @"\s", "");
 508                         Assert.AreEqual ("Method:GET,RequestUri:'<null>',Version:1.1,Content:<null>,Headers:{Age:vv}", normalized, "#3");
 509                 }
 510
 511                 [Test]
 512                 public void Headers_ExpectContinue ()
 513                 {
 514                         HttpRequestMessage message = new HttpRequestMessage ();
 515                         HttpRequestHeaders headers = message.Headers;
 516                         Assert.IsNull (headers.ExpectContinue, "#1");
 517
 518                         headers.ExpectContinue = false;
 519                         Assert.IsFalse (headers.ExpectContinue.Value, "#2");
 520
 521                         headers.Clear ();
 522
 523                         headers.ExpectContinue = true;
 524                         headers.ExpectContinue = true;
 525                         headers.ExpectContinue = true;
 526                         headers.ExpectContinue = true;
 527                         Assert.IsTrue (headers.ExpectContinue.Value, "#3");
 528                         Assert.AreEqual (1, headers.GetValues ("expect").ToList ().Count, "#4");
 529
 530                         headers.Clear ();
 531                         headers.Expect.Add (new NameValueWithParametersHeaderValue ("100-conTinuE"));
 532                         Assert.IsTrue (headers.ExpectContinue.Value, "#5");
 533                 }
 534
 535                 [Test]
 536                 public void Headers_ConnectionClose ()
 537                 {
 538                         HttpRequestMessage message = new HttpRequestMessage ();
 539                         HttpRequestHeaders headers = message.Headers;
 540                         Assert.IsNull (headers.ConnectionClose, "#1");
 541
 542                         headers.ConnectionClose = false;
 543                         Assert.IsFalse (headers.ConnectionClose.Value, "#2");
 544
 545                         headers.Clear ();
 546
 547                         headers.ConnectionClose = true;
 548                         Assert.IsTrue (headers.ConnectionClose.Value, "#3");
 549
 550                         headers.Clear ();
 551                         headers.Connection.Add ("Close");
 552                         Assert.IsTrue (headers.ConnectionClose.Value, "#4");
 553                 }
 554
 555                 [Test]
 556                 public void Headers_From_Invalid ()
 557                 {
 558                         HttpRequestMessage message = new HttpRequestMessage ();
 559                         HttpRequestHeaders headers = message.Headers;
 560                         headers.From = null;
 561                         headers.From = "";
 562                         try {
 563                                 headers.From = " ";
 564                                 Assert.Fail ("#1");
 565                         } catch (FormatException) {
 566                         }
 567                         try {
 568                                 headers.From = "test";
 569                                 Assert.Fail ("#2");
 570                         } catch (FormatException) {
 571                         }
 572                 }
 573
 574                 [Test]
 575                 public void Headers_TransferEncodingChunked ()
 576                 {
 577                         HttpRequestMessage message = new HttpRequestMessage ();
 578                         HttpRequestHeaders headers = message.Headers;
 579                         Assert.IsNull (headers.TransferEncodingChunked, "#1");
 580
 581                         headers.TransferEncodingChunked = false;
 582                         Assert.IsFalse (headers.TransferEncodingChunked.Value, "#2");
 583
 584                         headers.Clear ();
 585
 586                         headers.TransferEncodingChunked = true;
 587                         Assert.IsTrue (headers.TransferEncodingChunked.Value, "#3");
 588                         Assert.AreEqual (1, headers.TransferEncoding.Count, "#3b");
 589                 }
 590
 591                 [Test]
 592                 public void Properties ()
 593                 {
 594                         var c = new HttpRequestMessage ();
 595                         c.Content = null;
 596                         c.Method = HttpMethod.Post;
 597                         c.Properties.Add ("a", "test");
 598                         c.RequestUri = null;
 599                         c.Version = HttpVersion.Version10;
 600
 601                         Assert.IsNull (c.Content, "#1");
 602                         Assert.AreEqual (HttpMethod.Post, c.Method, "#2");
 603                         Assert.AreEqual ("test", c.Properties["a"], "#3");
 604                         Assert.IsNull (c.RequestUri, "#4");
 605                         Assert.AreEqual (HttpVersion.Version10, c.Version, "#5");
 606                 }
 607
 608                 [Test]
 609                 public void Properties_Invalid ()
 610                 {
 611                         var c = new HttpRequestMessage ();
 612                         try {
 613                                 c.Method = null;
 614                                 Assert.Fail ("#1");
 615                         } catch (ArgumentNullException) {
 616                         }
 617
 618                         try {
 619                                 c.RequestUri = new Uri ("ftp://xamarin.com");
 620                                 Assert.Fail ("#2");
 621                         } catch (ArgumentException) {
 622                         }
 623
 624                         try {
 625                                 c.Version = null;
 626                                 Assert.Fail ("#3");
 627                         } catch (ArgumentNullException) {
 628                         }
 629                 }
 630         }
 631 }