net/http/http_util_unittest.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include <algorithm>
   6
   7 #include "base/basictypes.h"
   8 #include "base/strings/string_util.h"
   9 #include "net/http/http_util.h"
  10 #include "testing/gtest/include/gtest/gtest.h"
  11
  12 using net::HttpUtil;
  13
  14 namespace {
  15 class HttpUtilTest : public testing::Test {};
  16 }
  17
  18 TEST(HttpUtilTest, IsSafeHeader) {
  19   static const char* unsafe_headers[] = {
  20     "sec-",
  21     "sEc-",
  22     "sec-foo",
  23     "sEc-FoO",
  24     "proxy-",
  25     "pRoXy-",
  26     "proxy-foo",
  27     "pRoXy-FoO",
  28     "accept-charset",
  29     "accept-encoding",
  30     "access-control-request-headers",
  31     "access-control-request-method",
  32     "connection",
  33     "content-length",
  34     "cookie",
  35     "cookie2",
  36     "content-transfer-encoding",
  37     "date",
  38     "expect",
  39     "host",
  40     "keep-alive",
  41     "origin",
  42     "referer",
  43     "te",
  44     "trailer",
  45     "transfer-encoding",
  46     "upgrade",
  47     "user-agent",
  48     "via",
  49   };
  50   for (size_t i = 0; i < arraysize(unsafe_headers); ++i) {
  51     EXPECT_FALSE(HttpUtil::IsSafeHeader(unsafe_headers[i]))
  52       << unsafe_headers[i];
  53     EXPECT_FALSE(HttpUtil::IsSafeHeader(StringToUpperASCII(std::string(
  54         unsafe_headers[i])))) << unsafe_headers[i];
  55   }
  56   static const char* safe_headers[] = {
  57     "foo",
  58     "x-",
  59     "x-foo",
  60     "content-disposition",
  61     "update",
  62     "accept-charseta",
  63     "accept_charset",
  64     "accept-encodinga",
  65     "accept_encoding",
  66     "access-control-request-headersa",
  67     "access-control-request-header",
  68     "access_control_request_header",
  69     "access-control-request-methoda",
  70     "access_control_request_method",
  71     "connectiona",
  72     "content-lengtha",
  73     "content_length",
  74     "cookiea",
  75     "cookie2a",
  76     "cookie3",
  77     "content-transfer-encodinga",
  78     "content_transfer_encoding",
  79     "datea",
  80     "expecta",
  81     "hosta",
  82     "keep-alivea",
  83     "keep_alive",
  84     "origina",
  85     "referera",
  86     "referrer",
  87     "tea",
  88     "trailera",
  89     "transfer-encodinga",
  90     "transfer_encoding",
  91     "upgradea",
  92     "user-agenta",
  93     "user_agent",
  94     "viaa",
  95   };
  96   for (size_t i = 0; i < arraysize(safe_headers); ++i) {
  97     EXPECT_TRUE(HttpUtil::IsSafeHeader(safe_headers[i])) << safe_headers[i];
  98     EXPECT_TRUE(HttpUtil::IsSafeHeader(StringToUpperASCII(std::string(
  99         safe_headers[i])))) << safe_headers[i];
 100   }
 101 }
 102
 103 TEST(HttpUtilTest, HasHeader) {
 104   static const struct {
 105     const char* headers;
 106     const char* name;
 107     bool expected_result;
 108   } tests[] = {
 109     { "", "foo", false },
 110     { "foo\r\nbar", "foo", false },
 111     { "ffoo: 1", "foo", false },
 112     { "foo: 1", "foo", true },
 113     { "foo: 1\r\nbar: 2", "foo", true },
 114     { "fOO: 1\r\nbar: 2", "foo", true },
 115     { "g: 0\r\nfoo: 1\r\nbar: 2", "foo", true },
 116   };
 117   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
 118     bool result = HttpUtil::HasHeader(tests[i].headers, tests[i].name);
 119     EXPECT_EQ(tests[i].expected_result, result);
 120   }
 121 }
 122
 123 TEST(HttpUtilTest, StripHeaders) {
 124   static const char* headers =
 125       "Origin: origin\r\n"
 126       "Content-Type: text/plain\r\n"
 127       "Cookies: foo1\r\n"
 128       "Custom: baz\r\n"
 129       "COOKIES: foo2\r\n"
 130       "Server: Apache\r\n"
 131       "OrIGin: origin2\r\n";
 132
 133   static const char* header_names[] = {
 134     "origin", "content-type", "cookies"
 135   };
 136
 137   static const char* expected_stripped_headers =
 138       "Custom: baz\r\n"
 139       "Server: Apache\r\n";
 140
 141   EXPECT_EQ(expected_stripped_headers,
 142             HttpUtil::StripHeaders(headers, header_names,
 143                                    arraysize(header_names)));
 144 }
 145
 146 TEST(HttpUtilTest, HeadersIterator) {
 147   std::string headers = "foo: 1\t\r\nbar: hello world\r\nbaz: 3 \r\n";
 148
 149   HttpUtil::HeadersIterator it(headers.begin(), headers.end(), "\r\n");
 150
 151   ASSERT_TRUE(it.GetNext());
 152   EXPECT_EQ(std::string("foo"), it.name());
 153   EXPECT_EQ(std::string("1"), it.values());
 154
 155   ASSERT_TRUE(it.GetNext());
 156   EXPECT_EQ(std::string("bar"), it.name());
 157   EXPECT_EQ(std::string("hello world"), it.values());
 158
 159   ASSERT_TRUE(it.GetNext());
 160   EXPECT_EQ(std::string("baz"), it.name());
 161   EXPECT_EQ(std::string("3"), it.values());
 162
 163   EXPECT_FALSE(it.GetNext());
 164 }
 165
 166 TEST(HttpUtilTest, HeadersIterator_MalformedLine) {
 167   std::string headers = "foo: 1\n: 2\n3\nbar: 4";
 168
 169   HttpUtil::HeadersIterator it(headers.begin(), headers.end(), "\n");
 170
 171   ASSERT_TRUE(it.GetNext());
 172   EXPECT_EQ(std::string("foo"), it.name());
 173   EXPECT_EQ(std::string("1"), it.values());
 174
 175   ASSERT_TRUE(it.GetNext());
 176   EXPECT_EQ(std::string("bar"), it.name());
 177   EXPECT_EQ(std::string("4"), it.values());
 178
 179   EXPECT_FALSE(it.GetNext());
 180 }
 181
 182 TEST(HttpUtilTest, HeadersIterator_AdvanceTo) {
 183   std::string headers = "foo: 1\r\n: 2\r\n3\r\nbar: 4";
 184
 185   HttpUtil::HeadersIterator it(headers.begin(), headers.end(), "\r\n");
 186   EXPECT_TRUE(it.AdvanceTo("foo"));
 187   EXPECT_EQ("foo", it.name());
 188   EXPECT_TRUE(it.AdvanceTo("bar"));
 189   EXPECT_EQ("bar", it.name());
 190   EXPECT_FALSE(it.AdvanceTo("blat"));
 191   EXPECT_FALSE(it.GetNext());  // should be at end of headers
 192 }
 193
 194 TEST(HttpUtilTest, HeadersIterator_Reset) {
 195   std::string headers = "foo: 1\r\n: 2\r\n3\r\nbar: 4";
 196   HttpUtil::HeadersIterator it(headers.begin(), headers.end(), "\r\n");
 197   // Search past "foo".
 198   EXPECT_TRUE(it.AdvanceTo("bar"));
 199   // Now try advancing to "foo".  This time it should fail since the iterator
 200   // position is past it.
 201   EXPECT_FALSE(it.AdvanceTo("foo"));
 202   it.Reset();
 203   // Now that we reset the iterator position, we should find 'foo'
 204   EXPECT_TRUE(it.AdvanceTo("foo"));
 205 }
 206
 207 TEST(HttpUtilTest, ValuesIterator) {
 208   std::string values = " must-revalidate,   no-cache=\"foo, bar\"\t, private ";
 209
 210   HttpUtil::ValuesIterator it(values.begin(), values.end(), ',');
 211
 212   ASSERT_TRUE(it.GetNext());
 213   EXPECT_EQ(std::string("must-revalidate"), it.value());
 214
 215   ASSERT_TRUE(it.GetNext());
 216   EXPECT_EQ(std::string("no-cache=\"foo, bar\""), it.value());
 217
 218   ASSERT_TRUE(it.GetNext());
 219   EXPECT_EQ(std::string("private"), it.value());
 220
 221   EXPECT_FALSE(it.GetNext());
 222 }
 223
 224 TEST(HttpUtilTest, ValuesIterator_Blanks) {
 225   std::string values = " \t ";
 226
 227   HttpUtil::ValuesIterator it(values.begin(), values.end(), ',');
 228
 229   EXPECT_FALSE(it.GetNext());
 230 }
 231
 232 TEST(HttpUtilTest, Unquote) {
 233   // Replace <backslash> " with ".
 234   EXPECT_STREQ("xyz\"abc", HttpUtil::Unquote("\"xyz\\\"abc\"").c_str());
 235
 236   // Replace <backslash> <backslash> with <backslash>
 237   EXPECT_STREQ("xyz\\abc", HttpUtil::Unquote("\"xyz\\\\abc\"").c_str());
 238   EXPECT_STREQ("xyz\\\\\\abc",
 239                HttpUtil::Unquote("\"xyz\\\\\\\\\\\\abc\"").c_str());
 240
 241   // Replace <backslash> X with X
 242   EXPECT_STREQ("xyzXabc", HttpUtil::Unquote("\"xyz\\Xabc\"").c_str());
 243
 244   // Act as identity function on unquoted inputs.
 245   EXPECT_STREQ("X", HttpUtil::Unquote("X").c_str());
 246   EXPECT_STREQ("\"", HttpUtil::Unquote("\"").c_str());
 247
 248   // Allow single quotes to act as quote marks.
 249   // Not part of RFC 2616.
 250   EXPECT_STREQ("x\"", HttpUtil::Unquote("'x\"'").c_str());
 251 }
 252
 253 TEST(HttpUtilTest, Quote) {
 254   EXPECT_STREQ("\"xyz\\\"abc\"", HttpUtil::Quote("xyz\"abc").c_str());
 255
 256   // Replace <backslash> <backslash> with <backslash>
 257   EXPECT_STREQ("\"xyz\\\\abc\"", HttpUtil::Quote("xyz\\abc").c_str());
 258
 259   // Replace <backslash> X with X
 260   EXPECT_STREQ("\"xyzXabc\"", HttpUtil::Quote("xyzXabc").c_str());
 261 }
 262
 263 TEST(HttpUtilTest, LocateEndOfHeaders) {
 264   struct {
 265     const char* input;
 266     int expected_result;
 267   } tests[] = {
 268     { "foo\r\nbar\r\n\r\n", 12 },
 269     { "foo\nbar\n\n", 9 },
 270     { "foo\r\nbar\r\n\r\njunk", 12 },
 271     { "foo\nbar\n\njunk", 9 },
 272     { "foo\nbar\n\r\njunk", 10 },
 273     { "foo\nbar\r\n\njunk", 10 },
 274   };
 275   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
 276     int input_len = static_cast<int>(strlen(tests[i].input));
 277     int eoh = HttpUtil::LocateEndOfHeaders(tests[i].input, input_len);
 278     EXPECT_EQ(tests[i].expected_result, eoh);
 279   }
 280 }
 281
 282 TEST(HttpUtilTest, AssembleRawHeaders) {
 283   struct {
 284     const char* input;  // with '|' representing '\0'
 285     const char* expected_result;  // with '\0' changed to '|'
 286   } tests[] = {
 287     { "HTTP/1.0 200 OK\r\nFoo: 1\r\nBar: 2\r\n\r\n",
 288       "HTTP/1.0 200 OK|Foo: 1|Bar: 2||" },
 289
 290     { "HTTP/1.0 200 OK\nFoo: 1\nBar: 2\n\n",
 291       "HTTP/1.0 200 OK|Foo: 1|Bar: 2||" },
 292
 293     // Valid line continuation (single SP).
 294     {
 295       "HTTP/1.0 200 OK\n"
 296       "Foo: 1\n"
 297       " continuation\n"
 298       "Bar: 2\n\n",
 299
 300       "HTTP/1.0 200 OK|"
 301       "Foo: 1 continuation|"
 302       "Bar: 2||"
 303     },
 304
 305     // Valid line continuation (single HT).
 306     {
 307       "HTTP/1.0 200 OK\n"
 308       "Foo: 1\n"
 309       "\tcontinuation\n"
 310       "Bar: 2\n\n",
 311
 312       "HTTP/1.0 200 OK|"
 313       "Foo: 1 continuation|"
 314       "Bar: 2||"
 315     },
 316
 317     // Valid line continuation (multiple SP).
 318     {
 319       "HTTP/1.0 200 OK\n"
 320       "Foo: 1\n"
 321       "   continuation\n"
 322       "Bar: 2\n\n",
 323
 324       "HTTP/1.0 200 OK|"
 325       "Foo: 1 continuation|"
 326       "Bar: 2||"
 327     },
 328
 329     // Valid line continuation (multiple HT).
 330     {
 331       "HTTP/1.0 200 OK\n"
 332       "Foo: 1\n"
 333       "\t\t\tcontinuation\n"
 334       "Bar: 2\n\n",
 335
 336       "HTTP/1.0 200 OK|"
 337       "Foo: 1 continuation|"
 338       "Bar: 2||"
 339     },
 340
 341     // Valid line continuation (mixed HT, SP).
 342     {
 343       "HTTP/1.0 200 OK\n"
 344       "Foo: 1\n"
 345       " \t \t continuation\n"
 346       "Bar: 2\n\n",
 347
 348       "HTTP/1.0 200 OK|"
 349       "Foo: 1 continuation|"
 350       "Bar: 2||"
 351     },
 352
 353     // Valid multi-line continuation
 354     {
 355       "HTTP/1.0 200 OK\n"
 356       "Foo: 1\n"
 357       " continuation1\n"
 358       "\tcontinuation2\n"
 359       "  continuation3\n"
 360       "Bar: 2\n\n",
 361
 362       "HTTP/1.0 200 OK|"
 363       "Foo: 1 continuation1 continuation2 continuation3|"
 364       "Bar: 2||"
 365     },
 366
 367     // Continuation of quoted value.
 368     // This is different from what Firefox does, since it
 369     // will preserve the LWS.
 370     {
 371       "HTTP/1.0 200 OK\n"
 372       "Etag: \"34534-d3\n"
 373       "    134q\"\n"
 374       "Bar: 2\n\n",
 375
 376       "HTTP/1.0 200 OK|"
 377       "Etag: \"34534-d3 134q\"|"
 378       "Bar: 2||"
 379     },
 380
 381     // Valid multi-line continuation, full LWS lines
 382     {
 383       "HTTP/1.0 200 OK\n"
 384       "Foo: 1\n"
 385       "         \n"
 386       "\t\t\t\t\n"
 387       "\t  continuation\n"
 388       "Bar: 2\n\n",
 389
 390       // One SP per continued line = 3.
 391       "HTTP/1.0 200 OK|"
 392       "Foo: 1   continuation|"
 393       "Bar: 2||"
 394     },
 395
 396     // Valid multi-line continuation, all LWS
 397     {
 398       "HTTP/1.0 200 OK\n"
 399       "Foo: 1\n"
 400       "         \n"
 401       "\t\t\t\t\n"
 402       "\t  \n"
 403       "Bar: 2\n\n",
 404
 405       // One SP per continued line = 3.
 406       "HTTP/1.0 200 OK|"
 407       "Foo: 1   |"
 408       "Bar: 2||"
 409     },
 410
 411     // Valid line continuation (No value bytes in first line).
 412     {
 413       "HTTP/1.0 200 OK\n"
 414       "Foo:\n"
 415       " value\n"
 416       "Bar: 2\n\n",
 417
 418       "HTTP/1.0 200 OK|"
 419       "Foo: value|"
 420       "Bar: 2||"
 421     },
 422
 423     // Not a line continuation (can't continue status line).
 424     {
 425       "HTTP/1.0 200 OK\n"
 426       " Foo: 1\n"
 427       "Bar: 2\n\n",
 428
 429       "HTTP/1.0 200 OK|"
 430       " Foo: 1|"
 431       "Bar: 2||"
 432     },
 433
 434     // Not a line continuation (can't continue status line).
 435     {
 436       "HTTP/1.0\n"
 437       " 200 OK\n"
 438       "Foo: 1\n"
 439       "Bar: 2\n\n",
 440
 441       "HTTP/1.0|"
 442       " 200 OK|"
 443       "Foo: 1|"
 444       "Bar: 2||"
 445     },
 446
 447     // Not a line continuation (can't continue status line).
 448     {
 449       "HTTP/1.0 404\n"
 450       " Not Found\n"
 451       "Foo: 1\n"
 452       "Bar: 2\n\n",
 453
 454       "HTTP/1.0 404|"
 455       " Not Found|"
 456       "Foo: 1|"
 457       "Bar: 2||"
 458     },
 459
 460     // Unterminated status line.
 461     {
 462       "HTTP/1.0 200 OK",
 463
 464       "HTTP/1.0 200 OK||"
 465     },
 466
 467     // Single terminated, with headers
 468     {
 469       "HTTP/1.0 200 OK\n"
 470       "Foo: 1\n"
 471       "Bar: 2\n",
 472
 473       "HTTP/1.0 200 OK|"
 474       "Foo: 1|"
 475       "Bar: 2||"
 476     },
 477
 478     // Not terminated, with headers
 479     {
 480       "HTTP/1.0 200 OK\n"
 481       "Foo: 1\n"
 482       "Bar: 2",
 483
 484       "HTTP/1.0 200 OK|"
 485       "Foo: 1|"
 486       "Bar: 2||"
 487     },
 488
 489     // Not a line continuation (VT)
 490     {
 491       "HTTP/1.0 200 OK\n"
 492       "Foo: 1\n"
 493       "\vInvalidContinuation\n"
 494       "Bar: 2\n\n",
 495
 496       "HTTP/1.0 200 OK|"
 497       "Foo: 1|"
 498       "\vInvalidContinuation|"
 499       "Bar: 2||"
 500     },
 501
 502     // Not a line continuation (formfeed)
 503     {
 504       "HTTP/1.0 200 OK\n"
 505       "Foo: 1\n"
 506       "\fInvalidContinuation\n"
 507       "Bar: 2\n\n",
 508
 509       "HTTP/1.0 200 OK|"
 510       "Foo: 1|"
 511       "\fInvalidContinuation|"
 512       "Bar: 2||"
 513     },
 514
 515     // Not a line continuation -- can't continue header names.
 516     {
 517       "HTTP/1.0 200 OK\n"
 518       "Serv\n"
 519       " er: Apache\n"
 520       "\tInvalidContinuation\n"
 521       "Bar: 2\n\n",
 522
 523       "HTTP/1.0 200 OK|"
 524       "Serv|"
 525       " er: Apache|"
 526       "\tInvalidContinuation|"
 527       "Bar: 2||"
 528     },
 529
 530     // Not a line continuation -- no value to continue.
 531     {
 532       "HTTP/1.0 200 OK\n"
 533       "Foo: 1\n"
 534       "garbage\n"
 535       "  not-a-continuation\n"
 536       "Bar: 2\n\n",
 537
 538       "HTTP/1.0 200 OK|"
 539       "Foo: 1|"
 540       "garbage|"
 541       "  not-a-continuation|"
 542       "Bar: 2||",
 543     },
 544
 545     // Not a line continuation -- no valid name.
 546     {
 547       "HTTP/1.0 200 OK\n"
 548       ": 1\n"
 549       "  garbage\n"
 550       "Bar: 2\n\n",
 551
 552       "HTTP/1.0 200 OK|"
 553       ": 1|"
 554       "  garbage|"
 555       "Bar: 2||",
 556     },
 557
 558     // Not a line continuation -- no valid name (whitespace)
 559     {
 560       "HTTP/1.0 200 OK\n"
 561       "   : 1\n"
 562       "  garbage\n"
 563       "Bar: 2\n\n",
 564
 565       "HTTP/1.0 200 OK|"
 566       "   : 1|"
 567       "  garbage|"
 568       "Bar: 2||",
 569     },
 570
 571     // Embed NULLs in the status line. They should not be understood
 572     // as line separators.
 573     {
 574       "HTTP/1.0 200 OK|Bar2:0|Baz2:1\r\nFoo: 1\r\nBar: 2\r\n\r\n",
 575       "HTTP/1.0 200 OKBar2:0Baz2:1|Foo: 1|Bar: 2||"
 576     },
 577
 578     // Embed NULLs in a header line. They should not be understood as
 579     // line separators.
 580     {
 581       "HTTP/1.0 200 OK\nFoo: 1|Foo2: 3\nBar: 2\n\n",
 582       "HTTP/1.0 200 OK|Foo: 1Foo2: 3|Bar: 2||"
 583     },
 584   };
 585   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
 586     std::string input = tests[i].input;
 587     std::replace(input.begin(), input.end(), '|', '\0');
 588     std::string raw = HttpUtil::AssembleRawHeaders(input.data(), input.size());
 589     std::replace(raw.begin(), raw.end(), '\0', '|');
 590     EXPECT_EQ(tests[i].expected_result, raw);
 591   }
 592 }
 593
 594 // Test SpecForRequest() and PathForRequest().
 595 TEST(HttpUtilTest, RequestUrlSanitize) {
 596   struct {
 597     const char* url;
 598     const char* expected_spec;
 599     const char* expected_path;
 600   } tests[] = {
 601     { // Check that #hash is removed.
 602       "http://www.google.com:78/foobar?query=1#hash",
 603       "http://www.google.com:78/foobar?query=1",
 604       "/foobar?query=1"
 605     },
 606     { // The reference may itself contain # -- strip all of it.
 607       "http://192.168.0.1?query=1#hash#10#11#13#14",
 608       "http://192.168.0.1/?query=1",
 609       "/?query=1"
 610     },
 611     { // Strip username/password.
 612       "http://user:pass@google.com",
 613       "http://google.com/",
 614       "/"
 615     }
 616   };
 617   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
 618     GURL url(GURL(tests[i].url));
 619     std::string expected_spec(tests[i].expected_spec);
 620     std::string expected_path(tests[i].expected_path);
 621
 622     EXPECT_EQ(expected_spec, HttpUtil::SpecForRequest(url));
 623     EXPECT_EQ(expected_path, HttpUtil::PathForRequest(url));
 624   }
 625 }
 626
 627 TEST(HttpUtilTest, GenerateAcceptLanguageHeader) {
 628   EXPECT_EQ(std::string("en-US,fr;q=0.8,de;q=0.6"),
 629             HttpUtil::GenerateAcceptLanguageHeader("en-US,fr,de"));
 630   EXPECT_EQ(std::string("en-US,fr;q=0.8,de;q=0.6,ko;q=0.4,zh-CN;q=0.2,"
 631                         "ja;q=0.2"),
 632             HttpUtil::GenerateAcceptLanguageHeader("en-US,fr,de,ko,zh-CN,ja"));
 633 }
 634
 635 // HttpResponseHeadersTest.GetMimeType also tests ParseContentType.
 636 TEST(HttpUtilTest, ParseContentType) {
 637   const struct {
 638     const char* content_type;
 639     const char* expected_mime_type;
 640     const char* expected_charset;
 641     const bool expected_had_charset;
 642     const char* expected_boundary;
 643   } tests[] = {
 644     { "text/html; charset=utf-8",
 645       "text/html",
 646       "utf-8",
 647       true,
 648       ""
 649     },
 650     { "text/html; charset =utf-8",
 651       "text/html",
 652       "utf-8",
 653       true,
 654       ""
 655     },
 656     { "text/html; charset= utf-8",
 657       "text/html",
 658       "utf-8",
 659       true,
 660       ""
 661     },
 662     { "text/html; charset=utf-8 ",
 663       "text/html",
 664       "utf-8",
 665       true,
 666       ""
 667     },
 668     { "text/html; boundary=\"WebKit-ada-df-dsf-adsfadsfs\"",
 669       "text/html",
 670       "",
 671       false,
 672       "\"WebKit-ada-df-dsf-adsfadsfs\""
 673     },
 674     { "text/html; boundary =\"WebKit-ada-df-dsf-adsfadsfs\"",
 675       "text/html",
 676       "",
 677       false,
 678       "\"WebKit-ada-df-dsf-adsfadsfs\""
 679     },
 680     { "text/html; boundary= \"WebKit-ada-df-dsf-adsfadsfs\"",
 681       "text/html",
 682       "",
 683       false,
 684       "\"WebKit-ada-df-dsf-adsfadsfs\""
 685     },
 686     { "text/html; boundary= \"WebKit-ada-df-dsf-adsfadsfs\"   ",
 687       "text/html",
 688       "",
 689       false,
 690       "\"WebKit-ada-df-dsf-adsfadsfs\""
 691     },
 692     { "text/html; boundary=\"WebKit-ada-df-dsf-adsfadsfs  \"",
 693       "text/html",
 694       "",
 695       false,
 696       "\"WebKit-ada-df-dsf-adsfadsfs  \""
 697     },
 698     { "text/html; boundary=WebKit-ada-df-dsf-adsfadsfs",
 699       "text/html",
 700       "",
 701       false,
 702       "WebKit-ada-df-dsf-adsfadsfs"
 703     },
 704     // TODO(abarth): Add more interesting test cases.
 705   };
 706   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
 707     std::string mime_type;
 708     std::string charset;
 709     bool had_charset = false;
 710     std::string boundary;
 711     net::HttpUtil::ParseContentType(tests[i].content_type, &mime_type,
 712                                     &charset, &had_charset, &boundary);
 713     EXPECT_EQ(tests[i].expected_mime_type, mime_type) << "i=" << i;
 714     EXPECT_EQ(tests[i].expected_charset, charset) << "i=" << i;
 715     EXPECT_EQ(tests[i].expected_had_charset, had_charset) << "i=" << i;
 716     EXPECT_EQ(tests[i].expected_boundary, boundary) << "i=" << i;
 717   }
 718 }
 719
 720 TEST(HttpUtilTest, ParseRanges) {
 721   const struct {
 722     const char* headers;
 723     bool expected_return_value;
 724     size_t expected_ranges_size;
 725     const struct {
 726       int64 expected_first_byte_position;
 727       int64 expected_last_byte_position;
 728       int64 expected_suffix_length;
 729     } expected_ranges[10];
 730   } tests[] = {
 731     { "Range: bytes=0-10",
 732       true,
 733       1,
 734       { {0, 10, -1}, }
 735     },
 736     { "Range: bytes=10-0",
 737       false,
 738       0,
 739       {}
 740     },
 741     { "Range: BytES=0-10",
 742       true,
 743       1,
 744       { {0, 10, -1}, }
 745     },
 746     { "Range: megabytes=0-10",
 747       false,
 748       0,
 749       {}
 750     },
 751     { "Range: bytes0-10",
 752       false,
 753       0,
 754       {}
 755     },
 756     { "Range: bytes=0-0,0-10,10-20,100-200,100-,-200",
 757       true,
 758       6,
 759       { {0, 0, -1},
 760         {0, 10, -1},
 761         {10, 20, -1},
 762         {100, 200, -1},
 763         {100, -1, -1},
 764         {-1, -1, 200},
 765       }
 766     },
 767     { "Range: bytes=0-10\r\n"
 768       "Range: bytes=0-10,10-20,100-200,100-,-200",
 769       true,
 770       1,
 771       { {0, 10, -1}
 772       }
 773     },
 774     { "Range: bytes=",
 775       false,
 776       0,
 777       {}
 778     },
 779     { "Range: bytes=-",
 780       false,
 781       0,
 782       {}
 783     },
 784     { "Range: bytes=0-10-",
 785       false,
 786       0,
 787       {}
 788     },
 789     { "Range: bytes=-0-10",
 790       false,
 791       0,
 792       {}
 793     },
 794     { "Range: bytes =0-10\r\n",
 795       true,
 796       1,
 797       { {0, 10, -1}
 798       }
 799     },
 800     { "Range: bytes=  0-10      \r\n",
 801       true,
 802       1,
 803       { {0, 10, -1}
 804       }
 805     },
 806     { "Range: bytes  =   0  -   10      \r\n",
 807       true,
 808       1,
 809       { {0, 10, -1}
 810       }
 811     },
 812     { "Range: bytes=   0-1   0\r\n",
 813       false,
 814       0,
 815       {}
 816     },
 817     { "Range: bytes=   0-     -10\r\n",
 818       false,
 819       0,
 820       {}
 821     },
 822     { "Range: bytes=   0  -  1   ,   10 -20,   100- 200 ,  100-,  -200 \r\n",
 823       true,
 824       5,
 825       { {0, 1, -1},
 826         {10, 20, -1},
 827         {100, 200, -1},
 828         {100, -1, -1},
 829         {-1, -1, 200},
 830       }
 831     },
 832   };
 833
 834   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
 835     std::vector<net::HttpByteRange> ranges;
 836     bool return_value = HttpUtil::ParseRanges(std::string(tests[i].headers),
 837                                               &ranges);
 838     EXPECT_EQ(tests[i].expected_return_value, return_value);
 839     if (return_value) {
 840       EXPECT_EQ(tests[i].expected_ranges_size, ranges.size());
 841       for (size_t j = 0; j < ranges.size(); ++j) {
 842         EXPECT_EQ(tests[i].expected_ranges[j].expected_first_byte_position,
 843                   ranges[j].first_byte_position());
 844         EXPECT_EQ(tests[i].expected_ranges[j].expected_last_byte_position,
 845                   ranges[j].last_byte_position());
 846         EXPECT_EQ(tests[i].expected_ranges[j].expected_suffix_length,
 847                   ranges[j].suffix_length());
 848       }
 849     }
 850   }
 851 }
 852
 853 namespace {
 854 void CheckCurrentNameValuePair(HttpUtil::NameValuePairsIterator* parser,
 855                                bool expect_valid,
 856                                std::string expected_name,
 857                                std::string expected_value) {
 858   ASSERT_EQ(expect_valid, parser->valid());
 859   if (!expect_valid) {
 860     return;
 861   }
 862
 863   // Let's make sure that these never change (i.e., when a quoted value is
 864   // unquoted, it should be cached on the first calls and not regenerated
 865   // later).
 866   std::string::const_iterator first_value_begin = parser->value_begin();
 867   std::string::const_iterator first_value_end = parser->value_end();
 868
 869   ASSERT_EQ(expected_name, std::string(parser->name_begin(),
 870                                        parser->name_end()));
 871   ASSERT_EQ(expected_name, parser->name());
 872   ASSERT_EQ(expected_value, std::string(parser->value_begin(),
 873                                         parser->value_end()));
 874   ASSERT_EQ(expected_value, parser->value());
 875
 876   // Make sure they didn't/don't change.
 877   ASSERT_TRUE(first_value_begin == parser->value_begin());
 878   ASSERT_TRUE(first_value_end == parser->value_end());
 879 }
 880
 881 void CheckNextNameValuePair(HttpUtil::NameValuePairsIterator* parser,
 882                             bool expect_next,
 883                             bool expect_valid,
 884                             std::string expected_name,
 885                             std::string expected_value) {
 886   ASSERT_EQ(expect_next, parser->GetNext());
 887   ASSERT_EQ(expect_valid, parser->valid());
 888   if (!expect_next || !expect_valid) {
 889     return;
 890   }
 891
 892   CheckCurrentNameValuePair(parser,
 893                             expect_valid,
 894                             expected_name,
 895                             expected_value);
 896 }
 897
 898 void CheckInvalidNameValuePair(std::string valid_part,
 899                                std::string invalid_part) {
 900   std::string whole_string = valid_part + invalid_part;
 901
 902   HttpUtil::NameValuePairsIterator valid_parser(valid_part.begin(),
 903                                                 valid_part.end(),
 904                                                 ';');
 905   HttpUtil::NameValuePairsIterator invalid_parser(whole_string.begin(),
 906                                                   whole_string.end(),
 907                                                   ';');
 908
 909   ASSERT_TRUE(valid_parser.valid());
 910   ASSERT_TRUE(invalid_parser.valid());
 911
 912   // Both parsers should return all the same values until "valid_parser" is
 913   // exhausted.
 914   while (valid_parser.GetNext()) {
 915     ASSERT_TRUE(invalid_parser.GetNext());
 916     ASSERT_TRUE(valid_parser.valid());
 917     ASSERT_TRUE(invalid_parser.valid());
 918     ASSERT_EQ(valid_parser.name(), invalid_parser.name());
 919     ASSERT_EQ(valid_parser.value(), invalid_parser.value());
 920   }
 921
 922   // valid_parser is exhausted and remains 'valid'
 923   ASSERT_TRUE(valid_parser.valid());
 924
 925   // invalid_parser's corresponding call to GetNext also returns false...
 926   ASSERT_FALSE(invalid_parser.GetNext());
 927   // ...but the parser is in an invalid state.
 928   ASSERT_FALSE(invalid_parser.valid());
 929 }
 930
 931 }  // anonymous namespace
 932
 933 TEST(HttpUtilTest, NameValuePairsIteratorCopyAndAssign) {
 934   std::string data = "alpha='\\'a\\''; beta=\" b \"; cappa='c;'; delta=\"d\"";
 935   HttpUtil::NameValuePairsIterator parser_a(data.begin(), data.end(), ';');
 936
 937   EXPECT_TRUE(parser_a.valid());
 938   ASSERT_NO_FATAL_FAILURE(
 939       CheckNextNameValuePair(&parser_a, true, true, "alpha", "'a'"));
 940
 941   HttpUtil::NameValuePairsIterator parser_b(parser_a);
 942   // a and b now point to same location
 943   ASSERT_NO_FATAL_FAILURE(
 944       CheckCurrentNameValuePair(&parser_b, true, "alpha", "'a'"));
 945   ASSERT_NO_FATAL_FAILURE(
 946       CheckCurrentNameValuePair(&parser_a, true, "alpha", "'a'"));
 947
 948   // advance a, no effect on b
 949   ASSERT_NO_FATAL_FAILURE(
 950       CheckNextNameValuePair(&parser_a, true, true, "beta", " b "));
 951   ASSERT_NO_FATAL_FAILURE(
 952       CheckCurrentNameValuePair(&parser_b, true, "alpha", "'a'"));
 953
 954   // assign b the current state of a, no effect on a
 955   parser_b = parser_a;
 956   ASSERT_NO_FATAL_FAILURE(
 957       CheckCurrentNameValuePair(&parser_b, true, "beta", " b "));
 958   ASSERT_NO_FATAL_FAILURE(
 959       CheckCurrentNameValuePair(&parser_a, true, "beta", " b "));
 960
 961   // advance b, no effect on a
 962   ASSERT_NO_FATAL_FAILURE(
 963       CheckNextNameValuePair(&parser_b, true, true, "cappa", "c;"));
 964   ASSERT_NO_FATAL_FAILURE(
 965       CheckCurrentNameValuePair(&parser_a, true, "beta", " b "));
 966 }
 967
 968 TEST(HttpUtilTest, NameValuePairsIteratorEmptyInput) {
 969   std::string data;
 970   HttpUtil::NameValuePairsIterator parser(data.begin(), data.end(), ';');
 971
 972   EXPECT_TRUE(parser.valid());
 973   ASSERT_NO_FATAL_FAILURE(CheckNextNameValuePair(
 974       &parser, false, true, std::string(), std::string()));
 975 }
 976
 977 TEST(HttpUtilTest, NameValuePairsIterator) {
 978   std::string data = "alpha=1; beta= 2 ;cappa =' 3; ';"
 979                      "delta= \" \\\"4\\\" \"; e= \" '5'\"; e=6;"
 980                      "f='\\'\\h\\e\\l\\l\\o\\ \\w\\o\\r\\l\\d\\'';"
 981                      "g=''; h='hello'";
 982   HttpUtil::NameValuePairsIterator parser(data.begin(), data.end(), ';');
 983   EXPECT_TRUE(parser.valid());
 984
 985   ASSERT_NO_FATAL_FAILURE(
 986       CheckNextNameValuePair(&parser, true, true, "alpha", "1"));
 987   ASSERT_NO_FATAL_FAILURE(
 988       CheckNextNameValuePair(&parser, true, true, "beta", "2"));
 989   ASSERT_NO_FATAL_FAILURE(
 990       CheckNextNameValuePair(&parser, true, true, "cappa", " 3; "));
 991   ASSERT_NO_FATAL_FAILURE(
 992       CheckNextNameValuePair(&parser, true, true, "delta", " \"4\" "));
 993   ASSERT_NO_FATAL_FAILURE(
 994       CheckNextNameValuePair(&parser, true, true, "e", " '5'"));
 995   ASSERT_NO_FATAL_FAILURE(
 996       CheckNextNameValuePair(&parser, true, true, "e", "6"));
 997   ASSERT_NO_FATAL_FAILURE(
 998       CheckNextNameValuePair(&parser, true, true, "f", "'hello world'"));
 999   ASSERT_NO_FATAL_FAILURE(
1000       CheckNextNameValuePair(&parser, true, true, "g", std::string()));
1001   ASSERT_NO_FATAL_FAILURE(
1002       CheckNextNameValuePair(&parser, true, true, "h", "hello"));
1003   ASSERT_NO_FATAL_FAILURE(CheckNextNameValuePair(
1004       &parser, false, true, std::string(), std::string()));
1005 }
1006
1007 TEST(HttpUtilTest, NameValuePairsIteratorIllegalInputs) {
1008   ASSERT_NO_FATAL_FAILURE(CheckInvalidNameValuePair("alpha=1", "; beta"));
1009   ASSERT_NO_FATAL_FAILURE(CheckInvalidNameValuePair(std::string(), "beta"));
1010
1011   ASSERT_NO_FATAL_FAILURE(CheckInvalidNameValuePair("alpha=1", "; 'beta'=2"));
1012   ASSERT_NO_FATAL_FAILURE(CheckInvalidNameValuePair(std::string(), "'beta'=2"));
1013   ASSERT_NO_FATAL_FAILURE(CheckInvalidNameValuePair("alpha=1", ";beta="));
1014   ASSERT_NO_FATAL_FAILURE(CheckInvalidNameValuePair("alpha=1",
1015                                                     ";beta=;cappa=2"));
1016
1017   // According to the spec this is an error, but it doesn't seem appropriate to
1018   // change our behaviour to be less permissive at this time.
1019   // See NameValuePairsIteratorExtraSeparators test
1020   // ASSERT_NO_FATAL_FAILURE(CheckInvalidNameValuePair("alpha=1", ";; beta=2"));
1021 }
1022
1023 // If we are going to support extra separators against the spec, let's just make
1024 // sure they work rationally.
1025 TEST(HttpUtilTest, NameValuePairsIteratorExtraSeparators) {
1026   std::string data = " ; ;;alpha=1; ;; ; beta= 2;cappa=3;;; ; ";
1027   HttpUtil::NameValuePairsIterator parser(data.begin(), data.end(), ';');
1028   EXPECT_TRUE(parser.valid());
1029
1030   ASSERT_NO_FATAL_FAILURE(
1031       CheckNextNameValuePair(&parser, true, true, "alpha", "1"));
1032   ASSERT_NO_FATAL_FAILURE(
1033       CheckNextNameValuePair(&parser, true, true, "beta", "2"));
1034   ASSERT_NO_FATAL_FAILURE(
1035       CheckNextNameValuePair(&parser, true, true, "cappa", "3"));
1036   ASSERT_NO_FATAL_FAILURE(CheckNextNameValuePair(
1037       &parser, false, true, std::string(), std::string()));
1038 }
1039
1040 // See comments on the implementation of NameValuePairsIterator::GetNext
1041 // regarding this derogation from the spec.
1042 TEST(HttpUtilTest, NameValuePairsIteratorMissingEndQuote) {
1043   std::string data = "name='value";
1044   HttpUtil::NameValuePairsIterator parser(data.begin(), data.end(), ';');
1045   EXPECT_TRUE(parser.valid());
1046
1047   ASSERT_NO_FATAL_FAILURE(
1048       CheckNextNameValuePair(&parser, true, true, "name", "value"));
1049   ASSERT_NO_FATAL_FAILURE(CheckNextNameValuePair(
1050       &parser, false, true, std::string(), std::string()));
1051 }