url/url_parse_unittest.cc

   1 // Copyright 2013 The Chromium Authors
   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 <stddef.h>
   6
   7 #include "testing/gtest/include/gtest/gtest.h"
   8 #include "url/third_party/mozilla/url_parse.h"
   9
  10 // Interesting IE file:isms...
  11 //
  12 //  file:/foo/bar              file:///foo/bar
  13 //      The result here seems totally invalid!?!? This isn't UNC.
  14 //
  15 //  file:/
  16 //  file:// or any other number of slashes
  17 //      IE6 doesn't do anything at all if you click on this link. No error:
  18 //      nothing. IE6's history system seems to always color this link, so I'm
  19 //      guessing that it maps internally to the empty URL.
  20 //
  21 //  C:\                        file:///C:/
  22 //  /                          file:///C:/
  23 //  /foo                       file:///C:/foo
  24 //      Interestingly, IE treats "/" as an alias for "c:\", which makes sense,
  25 //      but is weird to think about on Windows.
  26 //
  27 //  file:foo/                  file:foo/  (invalid?!?!?)
  28 //  file:/foo/                 file:///foo/  (invalid?!?!?)
  29 //  file://foo/                file://foo/   (UNC to server "foo")
  30 //  file:///foo/               file:///foo/  (invalid)
  31 //  file:////foo/              file://foo/   (UNC to server "foo")
  32 //      Any more than four slashes is also treated as UNC.
  33 //
  34 //  file:C:/                   file://C:/
  35 //  file:/C:/                  file://C:/
  36 //      The number of slashes after "file:" don't matter if the thing following
  37 //      it looks like an absolute drive path. Also, slashes and backslashes are
  38 //      equally valid here.
  39
  40 namespace url {
  41 namespace {
  42
  43 // Used for regular URL parse cases.
  44 struct URLParseCase {
  45   const char* input;
  46
  47   const char* scheme;
  48   const char* username;
  49   const char* password;
  50   const char* host;
  51   int port;
  52   const char* path;
  53   const char* query;
  54   const char* ref;
  55 };
  56
  57 // Simpler version of URLParseCase for testing path URLs.
  58 struct PathURLParseCase {
  59   const char* input;
  60
  61   const char* scheme;
  62   const char* path;
  63 };
  64
  65 // Simpler version of URLParseCase for testing mailto URLs.
  66 struct MailtoURLParseCase {
  67   const char* input;
  68
  69   const char* scheme;
  70   const char* path;
  71   const char* query;
  72 };
  73
  74 // More complicated version of URLParseCase for testing filesystem URLs.
  75 struct FileSystemURLParseCase {
  76   const char* input;
  77
  78   const char* inner_scheme;
  79   const char* inner_username;
  80   const char* inner_password;
  81   const char* inner_host;
  82   int inner_port;
  83   const char* inner_path;
  84   const char* path;
  85   const char* query;
  86   const char* ref;
  87 };
  88
  89 bool ComponentMatches(const char* input,
  90                       const char* reference,
  91                       const Component& component) {
  92   // Check that the -1 sentinel is the only allowed negative value.
  93   EXPECT_TRUE(component.is_valid() || component.len == -1);
  94
  95   // Begin should be valid.
  96   EXPECT_LE(0, component.begin);
  97
  98   // A NULL reference means the component should be nonexistent.
  99   if (!reference)
 100     return component.len == -1;
 101   if (!component.is_valid())
 102     return false;  // Reference is not NULL but we don't have anything
 103
 104   if (strlen(reference) != static_cast<size_t>(component.len))
 105     return false;  // Lengths don't match
 106
 107   // Now check the actual characters.
 108   return strncmp(reference, &input[component.begin], component.len) == 0;
 109 }
 110
 111 void ExpectInvalidComponent(const Component& component) {
 112   EXPECT_EQ(0, component.begin);
 113   EXPECT_EQ(-1, component.len);
 114 }
 115
 116 // Parsed ----------------------------------------------------------------------
 117
 118 TEST(URLParser, Length) {
 119   const char* length_cases[] = {
 120       // One with everything in it.
 121     "http://user:pass@host:99/foo?bar#baz",
 122       // One with nothing in it.
 123     "",
 124       // Working backwards, let's start taking off stuff from the full one.
 125     "http://user:pass@host:99/foo?bar#",
 126     "http://user:pass@host:99/foo?bar",
 127     "http://user:pass@host:99/foo?",
 128     "http://user:pass@host:99/foo",
 129     "http://user:pass@host:99/",
 130     "http://user:pass@host:99",
 131     "http://user:pass@host:",
 132     "http://user:pass@host",
 133     "http://host",
 134     "http://user@",
 135     "http:",
 136   };
 137   for (const char* length_case : length_cases) {
 138     int true_length = static_cast<int>(strlen(length_case));
 139
 140     Parsed parsed;
 141     ParseStandardURL(length_case, true_length, &parsed);
 142
 143     EXPECT_EQ(true_length, parsed.Length());
 144   }
 145 }
 146
 147 TEST(URLParser, CountCharactersBefore) {
 148   struct CountCase {
 149     const char* url;
 150     Parsed::ComponentType component;
 151     bool include_delimiter;
 152     int expected_count;
 153   } count_cases[] = {
 154   // Test each possibility in the case where all components are present.
 155   //    0         1         2
 156   //    0123456789012345678901
 157     {"http://u:p@h:8/p?q#r", Parsed::SCHEME, true, 0},
 158     {"http://u:p@h:8/p?q#r", Parsed::SCHEME, false, 0},
 159     {"http://u:p@h:8/p?q#r", Parsed::USERNAME, true, 7},
 160     {"http://u:p@h:8/p?q#r", Parsed::USERNAME, false, 7},
 161     {"http://u:p@h:8/p?q#r", Parsed::PASSWORD, true, 9},
 162     {"http://u:p@h:8/p?q#r", Parsed::PASSWORD, false, 9},
 163     {"http://u:p@h:8/p?q#r", Parsed::HOST, true, 11},
 164     {"http://u:p@h:8/p?q#r", Parsed::HOST, false, 11},
 165     {"http://u:p@h:8/p?q#r", Parsed::PORT, true, 12},
 166     {"http://u:p@h:8/p?q#r", Parsed::PORT, false, 13},
 167     {"http://u:p@h:8/p?q#r", Parsed::PATH, false, 14},
 168     {"http://u:p@h:8/p?q#r", Parsed::PATH, true, 14},
 169     {"http://u:p@h:8/p?q#r", Parsed::QUERY, true, 16},
 170     {"http://u:p@h:8/p?q#r", Parsed::QUERY, false, 17},
 171     {"http://u:p@h:8/p?q#r", Parsed::REF, true, 18},
 172     {"http://u:p@h:8/p?q#r", Parsed::REF, false, 19},
 173       // Now test when the requested component is missing.
 174     {"http://u:p@h:8/p?", Parsed::REF, true, 17},
 175     {"http://u:p@h:8/p?q", Parsed::REF, true, 18},
 176     {"http://u:p@h:8/p#r", Parsed::QUERY, true, 16},
 177     {"http://u:p@h:8#r", Parsed::PATH, true, 14},
 178     {"http://u:p@h/", Parsed::PORT, true, 12},
 179     {"http://u:p@/", Parsed::HOST, true, 11},
 180       // This case is a little weird. It will report that the password would
 181       // start where the host begins. This is arguably correct, although you
 182       // could also argue that it should start at the '@' sign. Doing it
 183       // starting with the '@' sign is actually harder, so we don't bother.
 184     {"http://u@h/", Parsed::PASSWORD, true, 9},
 185     {"http://h/", Parsed::USERNAME, true, 7},
 186     {"http:", Parsed::USERNAME, true, 5},
 187     {"", Parsed::SCHEME, true, 0},
 188       // Make sure a random component still works when there's nothing there.
 189     {"", Parsed::REF, true, 0},
 190       // File URLs are special with no host, so we test those.
 191     {"file:///c:/foo", Parsed::USERNAME, true, 7},
 192     {"file:///c:/foo", Parsed::PASSWORD, true, 7},
 193     {"file:///c:/foo", Parsed::HOST, true, 7},
 194     {"file:///c:/foo", Parsed::PATH, true, 7},
 195   };
 196   for (const auto& count_case : count_cases) {
 197     int length = static_cast<int>(strlen(count_case.url));
 198
 199     // Simple test to distinguish file and standard URLs.
 200     Parsed parsed;
 201     if (length > 0 && count_case.url[0] == 'f') {
 202       ParseFileURL(count_case.url, length, &parsed);
 203     } else {
 204       ParseStandardURL(count_case.url, length, &parsed);
 205     }
 206
 207     int chars_before = parsed.CountCharactersBefore(
 208         count_case.component, count_case.include_delimiter);
 209     EXPECT_EQ(count_case.expected_count, chars_before);
 210   }
 211 }
 212
 213 // Standard --------------------------------------------------------------------
 214
 215 // clang-format off
 216 // Input                               Scheme  Usrname  Passwd     Host         Port Path       Query        Ref
 217 // ------------------------------------ ------- -------- ---------- ------------ --- ---------- ------------ -----
 218 static URLParseCase cases[] = {
 219   // Regular URL with all the parts
 220 {"http://user:pass@foo:21/bar;par?b#c", "http", "user",  "pass",    "foo",       21, "/bar;par","b",          "c"},
 221
 222   // Known schemes should lean towards authority identification
 223 {"http:foo.com",                        "http", nullptr, nullptr,   "foo.com",    -1, nullptr,   nullptr,     nullptr},
 224
 225   // Spaces!
 226 {"\t   :foo.com   \n",                  "",     nullptr, nullptr,   "foo.com",    -1, nullptr,   nullptr,     nullptr},
 227 {" foo.com  ",                          nullptr,nullptr, nullptr,   "foo.com",    -1, nullptr,   nullptr,     nullptr},
 228 {"a:\t foo.com",                        "a",    nullptr, nullptr,   "\t foo.com", -1, nullptr,   nullptr,     nullptr},
 229 {"http://f:21/ b ? d # e ",             "http", nullptr, nullptr,   "f",          21, "/ b ",    " d ",       " e"},
 230
 231   // Invalid port numbers should be identified and turned into -2, empty port
 232   // numbers should be -1. Spaces aren't allowed in port numbers
 233 {"http://f:/c",                         "http", nullptr, nullptr,   "f",          -1, "/c",      nullptr,     nullptr},
 234 {"http://f:0/c",                        "http", nullptr, nullptr,   "f",           0, "/c",      nullptr,     nullptr},
 235 {"http://f:00000000000000/c",           "http", nullptr, nullptr,   "f",           0, "/c",      nullptr,     nullptr},
 236 {"http://f:00000000000000000000080/c",  "http", nullptr, nullptr,   "f",          80, "/c",      nullptr,     nullptr},
 237 {"http://f:b/c",                        "http", nullptr, nullptr,   "f",          -2, "/c",      nullptr,     nullptr},
 238 {"http://f: /c",                        "http", nullptr, nullptr,   "f",          -2, "/c",      nullptr,     nullptr},
 239 {"http://f:\n/c",                       "http", nullptr, nullptr,   "f",          -2, "/c",      nullptr,     nullptr},
 240 {"http://f:fifty-two/c",                "http", nullptr, nullptr,   "f",          -2, "/c",      nullptr,     nullptr},
 241 {"http://f:999999/c",                   "http", nullptr, nullptr,   "f",          -2, "/c",      nullptr,     nullptr},
 242 {"http://f: 21 / b ? d # e ",           "http", nullptr, nullptr,   "f",          -2, "/ b ",    " d ",       " e"},
 243
 244   // Creative URLs missing key elements
 245 {"",                                    nullptr,nullptr, nullptr,   nullptr,      -1, nullptr,   nullptr,     nullptr},
 246 {"  \t",                                nullptr,nullptr, nullptr,   nullptr,      -1, nullptr,   nullptr,     nullptr},
 247 {":foo.com/",                           "",     nullptr, nullptr,   "foo.com",    -1, "/",       nullptr,     nullptr},
 248 {":foo.com\\",                          "",     nullptr, nullptr,   "foo.com",    -1, "\\",      nullptr,     nullptr},
 249 {":",                                   "",     nullptr, nullptr,   nullptr,      -1, nullptr,   nullptr,     nullptr},
 250 {":a",                                  "",     nullptr, nullptr,   "a",          -1, nullptr,   nullptr,     nullptr},
 251 {":/",                                  "",     nullptr, nullptr,   nullptr,      -1, nullptr,   nullptr,     nullptr},
 252 {":\\",                                 "",     nullptr, nullptr,   nullptr,      -1, nullptr,   nullptr,     nullptr},
 253 {":#",                                  "",     nullptr, nullptr,   nullptr,      -1, nullptr,   nullptr,     ""},
 254 {"#",                                   nullptr,nullptr, nullptr,   nullptr,      -1, nullptr,   nullptr,     ""},
 255 {"#/",                                  nullptr,nullptr, nullptr,   nullptr,      -1, nullptr,   nullptr,     "/"},
 256 {"#\\",                                 nullptr,nullptr, nullptr,   nullptr,      -1, nullptr,   nullptr,     "\\"},
 257 {"#;?",                                 nullptr,nullptr, nullptr,   nullptr,      -1, nullptr,   nullptr,     ";?"},
 258 {"?",                                   nullptr,nullptr, nullptr,   nullptr,      -1, nullptr,   "",          nullptr},
 259 {"/",                                   nullptr,nullptr, nullptr,   nullptr,      -1, nullptr,   nullptr,     nullptr},
 260 {":23",                                 "",     nullptr, nullptr,   "23",         -1, nullptr,   nullptr,     nullptr},
 261 {"/:23",                                "/",    nullptr, nullptr,   "23",         -1, nullptr,   nullptr,     nullptr},
 262 {"//",                                  nullptr,nullptr, nullptr,   nullptr,      -1, nullptr,   nullptr,     nullptr},
 263 {"::",                                  "",     nullptr, nullptr,   nullptr,      -1, nullptr,   nullptr,     nullptr},
 264 {"::23",                                "",     nullptr, nullptr,   nullptr,      23, nullptr,   nullptr,     nullptr},
 265 {"foo://",                              "foo",  nullptr, nullptr,   nullptr,      -1, nullptr,   nullptr,     nullptr},
 266
 267   // Username/passwords and things that look like them
 268 {"http://a:b@c:29/d",                   "http", "a",    "b",       "c",           29, "/d",      nullptr,     nullptr},
 269 {"http::@c:29",                         "http", "",     "",        "c",           29, nullptr,   nullptr,     nullptr},
 270   // ... "]" in the password field isn't allowed, but we tolerate it here...
 271 {"http://&a:foo(b]c@d:2/",              "http", "&a",   "foo(b]c", "d",            2, "/",       nullptr,     nullptr},
 272 {"http://::@c@d:2",                     "http", "",     ":@c",     "d",            2, nullptr,   nullptr,     nullptr},
 273 {"http://foo.com:b@d/",                 "http", "foo.com","b",     "d",           -1, "/",       nullptr,     nullptr},
 274
 275 {"http://foo.com/\\@",                  "http", nullptr, nullptr,   "foo.com",    -1, "/\\@",    nullptr,     nullptr},
 276 {"http:\\\\foo.com\\",                  "http", nullptr, nullptr,   "foo.com",    -1, "\\",      nullptr,     nullptr},
 277 {"http:\\\\a\\b:c\\d@foo.com\\",        "http", nullptr, nullptr,   "a",          -1, "\\b:c\\d@foo.com\\", nullptr,nullptr},
 278
 279   // Tolerate different numbers of slashes.
 280 {"foo:/",                               "foo",  nullptr, nullptr,   nullptr,      -1, nullptr,   nullptr,     nullptr},
 281 {"foo:/bar.com/",                       "foo",  nullptr, nullptr,   "bar.com",    -1, "/",       nullptr,     nullptr},
 282 {"foo://///////",                       "foo",  nullptr, nullptr,   nullptr,      -1, nullptr,   nullptr,     nullptr},
 283 {"foo://///////bar.com/",               "foo",  nullptr, nullptr,   "bar.com",    -1, "/",       nullptr,     nullptr},
 284 {"foo:////://///",                      "foo",  nullptr, nullptr,   nullptr,      -1, "/////",   nullptr,     nullptr},
 285
 286   // Raw file paths on Windows aren't handled by the parser.
 287 {"c:/foo",                              "c",    nullptr, nullptr,   "foo",        -1, nullptr,   nullptr,     nullptr},
 288 {"//foo/bar",                           nullptr,nullptr, nullptr,   "foo",        -1, "/bar",    nullptr,     nullptr},
 289
 290   // Use the first question mark for the query and the ref.
 291 {"http://foo/path;a??e#f#g",            "http", nullptr, nullptr,   "foo",        -1, "/path;a", "?e",        "f#g"},
 292 {"http://foo/abcd?efgh?ijkl",           "http", nullptr, nullptr,   "foo",        -1, "/abcd",   "efgh?ijkl", nullptr},
 293 {"http://foo/abcd#foo?bar",             "http", nullptr, nullptr,   "foo",        -1, "/abcd",   nullptr,     "foo?bar"},
 294
 295   // IPv6, check also interesting uses of colons.
 296 {"[61:24:74]:98",                       "[61",  nullptr, nullptr,   "24:74]",     98, nullptr,   nullptr,     nullptr},
 297 {"http://[61:27]:98",                   "http", nullptr, nullptr,   "[61:27]",    98, nullptr,   nullptr,     nullptr},
 298 {"http:[61:27]/:foo",                   "http", nullptr, nullptr,   "[61:27]",    -1, "/:foo",   nullptr,     nullptr},
 299 {"http://[1::2]:3:4",                   "http", nullptr, nullptr,   "[1::2]:3",    4, nullptr,   nullptr,     nullptr},
 300
 301   // Partially-complete IPv6 literals, and related cases.
 302 {"http://2001::1",                      "http", nullptr, nullptr,   "2001:",       1, nullptr,   nullptr,     nullptr},
 303 {"http://[2001::1",                     "http", nullptr, nullptr,   "[2001::1",   -1, nullptr,   nullptr,     nullptr},
 304 {"http://2001::1]",                     "http", nullptr, nullptr,   "2001::1]",   -1, nullptr,   nullptr,     nullptr},
 305 {"http://2001::1]:80",                  "http", nullptr, nullptr,   "2001::1]",   80, nullptr,   nullptr,     nullptr},
 306 {"http://[2001::1]",                    "http", nullptr, nullptr,   "[2001::1]",  -1, nullptr,   nullptr,     nullptr},
 307 {"http://[2001::1]:80",                 "http", nullptr, nullptr,   "[2001::1]",  80, nullptr,   nullptr,     nullptr},
 308 {"http://[[::]]",                       "http", nullptr, nullptr,   "[[::]]",     -1, nullptr,   nullptr,     nullptr},
 309
 310 };
 311 // clang-format on
 312
 313 TEST(URLParser, Standard) {
 314   // Declared outside for loop to try to catch cases in init() where we forget
 315   // to reset something that is reset by the constructor.
 316   Parsed parsed;
 317   for (const auto& i : cases) {
 318     const char* url = i.input;
 319     ParseStandardURL(url, static_cast<int>(strlen(url)), &parsed);
 320     int port = ParsePort(url, parsed.port);
 321
 322     EXPECT_TRUE(ComponentMatches(url, i.scheme, parsed.scheme));
 323     EXPECT_TRUE(ComponentMatches(url, i.username, parsed.username));
 324     EXPECT_TRUE(ComponentMatches(url, i.password, parsed.password));
 325     EXPECT_TRUE(ComponentMatches(url, i.host, parsed.host));
 326     EXPECT_EQ(i.port, port);
 327     EXPECT_TRUE(ComponentMatches(url, i.path, parsed.path));
 328     EXPECT_TRUE(ComponentMatches(url, i.query, parsed.query));
 329     EXPECT_TRUE(ComponentMatches(url, i.ref, parsed.ref));
 330   }
 331 }
 332
 333 // PathURL --------------------------------------------------------------------
 334
 335 // Various incarnations of path URLs.
 336 // clang-format off
 337 static PathURLParseCase path_cases[] = {
 338 {"",                                        nullptr,       nullptr},
 339 {":",                                       "",            nullptr},
 340 {":/",                                      "",            "/"},
 341 {"/",                                       nullptr,       "/"},
 342 {" This is \\interesting// \t",             nullptr,       "This is \\interesting// \t"},
 343 {"about:",                                  "about",       nullptr},
 344 {"about:blank",                             "about",       "blank"},
 345 {"  about: blank ",                         "about",       " blank "},
 346 {"javascript :alert(\"He:/l\\l#o?foo\"); ", "javascript ", "alert(\"He:/l\\l#o?foo\"); "},
 347 };
 348 // clang-format on
 349
 350 TEST(URLParser, PathURL) {
 351   // Declared outside for loop to try to catch cases in init() where we forget
 352   // to reset something that is reset by the constructor.
 353   Parsed parsed;
 354   for (size_t i = 0; i < std::size(path_cases); i++) {
 355     const char* url = path_cases[i].input;
 356     ParsePathURL(url, static_cast<int>(strlen(url)), false, &parsed);
 357
 358     EXPECT_TRUE(ComponentMatches(url, path_cases[i].scheme, parsed.scheme))
 359         << i;
 360     EXPECT_TRUE(ComponentMatches(url, path_cases[i].path, parsed.GetContent()))
 361         << i;
 362
 363     // The remaining components are never used for path URLs.
 364     ExpectInvalidComponent(parsed.username);
 365     ExpectInvalidComponent(parsed.password);
 366     ExpectInvalidComponent(parsed.host);
 367     ExpectInvalidComponent(parsed.port);
 368   }
 369 }
 370
 371 // Various incarnations of file URLs.
 372 // clang-format off
 373 static URLParseCase file_cases[] = {
 374 #ifdef WIN32
 375 {"file:server",              "file", nullptr, nullptr, "server", -1, nullptr,       nullptr, nullptr},
 376 {"  file: server  \t",       "file", nullptr, nullptr, " server",-1, nullptr,       nullptr, nullptr},
 377 {"FiLe:c|",                  "FiLe", nullptr, nullptr, nullptr,  -1, "c|",          nullptr, nullptr},
 378 {"FILE:/\\\\/server/file",   "FILE", nullptr, nullptr, "server", -1, "/file",       nullptr, nullptr},
 379 {"file://server/",           "file", nullptr, nullptr, "server", -1, "/",           nullptr, nullptr},
 380 {"file://localhost/c:/",     "file", nullptr, nullptr, "localhost", -1, "/c:/",     nullptr, nullptr},
 381 {"file://127.0.0.1/c|\\",    "file", nullptr, nullptr, "127.0.0.1", -1, "/c|\\",    nullptr, nullptr},
 382 {"file:/",                   "file", nullptr, nullptr, nullptr,  -1, nullptr,       nullptr, nullptr},
 383 {"file:",                    "file", nullptr, nullptr, nullptr,  -1, nullptr,       nullptr, nullptr},
 384   // If there is a Windows drive letter, treat any number of slashes as the
 385   // path part.
 386 {"file:c:\\fo\\b",           "file", nullptr, nullptr, nullptr,  -1, "c:\\fo\\b",   nullptr, nullptr},
 387 {"file:/c:\\foo/bar",        "file", nullptr, nullptr, nullptr,  -1, "/c:\\foo/bar",nullptr, nullptr},
 388 {"file://c:/f\\b",           "file", nullptr, nullptr, nullptr,  -1, "/c:/f\\b",    nullptr, nullptr},
 389 {"file:///C:/foo",           "file", nullptr, nullptr, nullptr,  -1, "/C:/foo",     nullptr, nullptr},
 390 {"file://///\\/\\/c:\\f\\b", "file", nullptr, nullptr, nullptr,  -1, "/c:\\f\\b",   nullptr, nullptr},
 391   // If there is not a drive letter, we should treat is as UNC EXCEPT for
 392   // three slashes, which we treat as a Unix style path.
 393 {"file:server/file",         "file", nullptr, nullptr, "server", -1, "/file",       nullptr, nullptr},
 394 {"file:/server/file",        "file", nullptr, nullptr, "server", -1, "/file",       nullptr, nullptr},
 395 {"file://server/file",       "file", nullptr, nullptr, "server", -1, "/file",       nullptr, nullptr},
 396 {"file:///server/file",      "file", nullptr, nullptr, nullptr,  -1, "/server/file",nullptr, nullptr},
 397 {"file://\\server/file",     "file", nullptr, nullptr, nullptr,  -1, "\\server/file",nullptr, nullptr},
 398 {"file:////server/file",     "file", nullptr, nullptr, "server", -1, "/file",       nullptr, nullptr},
 399   // Queries and refs are valid for file URLs as well.
 400 {"file:///C:/foo.html?#",   "file", nullptr, nullptr,  nullptr,  -1, "/C:/foo.html",  "",   ""},
 401 {"file:///C:/foo.html?query=yes#ref", "file", nullptr, nullptr, nullptr, -1, "/C:/foo.html", "query=yes", "ref"},
 402 #else  // WIN32
 403   // No slashes.
 404   {"file:",                    "file", nullptr, nullptr, nullptr,   -1, nullptr,          nullptr, nullptr},
 405   {"file:path",                "file", nullptr, nullptr, nullptr,   -1, "path",           nullptr, nullptr},
 406   {"file:path/",               "file", nullptr, nullptr, nullptr,   -1, "path/",          nullptr, nullptr},
 407   {"file:path/f.txt",          "file", nullptr, nullptr, nullptr,   -1, "path/f.txt",     nullptr, nullptr},
 408   // One slash.
 409   {"file:/",                   "file", nullptr, nullptr, nullptr,   -1, "/",              nullptr, nullptr},
 410   {"file:/path",               "file", nullptr, nullptr, nullptr,   -1, "/path",          nullptr, nullptr},
 411   {"file:/path/",              "file", nullptr, nullptr, nullptr,   -1, "/path/",         nullptr, nullptr},
 412   {"file:/path/f.txt",         "file", nullptr, nullptr, nullptr,   -1, "/path/f.txt",    nullptr, nullptr},
 413   // Two slashes.
 414   {"file://",                  "file", nullptr, nullptr, nullptr,   -1, nullptr,          nullptr, nullptr},
 415   {"file://server",            "file", nullptr, nullptr, "server",  -1, nullptr,          nullptr, nullptr},
 416   {"file://server/",           "file", nullptr, nullptr, "server",  -1, "/",              nullptr, nullptr},
 417   {"file://server/f.txt",      "file", nullptr, nullptr, "server",  -1, "/f.txt",         nullptr, nullptr},
 418   // Three slashes.
 419   {"file:///",                 "file", nullptr, nullptr, nullptr,   -1, "/",              nullptr, nullptr},
 420   {"file:///path",             "file", nullptr, nullptr, nullptr,   -1, "/path",          nullptr, nullptr},
 421   {"file:///path/",            "file", nullptr, nullptr, nullptr,   -1, "/path/",         nullptr, nullptr},
 422   {"file:///path/f.txt",       "file", nullptr, nullptr, nullptr,   -1, "/path/f.txt",    nullptr, nullptr},
 423   // More than three slashes.
 424   {"file:////",                "file", nullptr, nullptr, nullptr,   -1, "/",              nullptr, nullptr},
 425   {"file:////path",            "file", nullptr, nullptr, nullptr,   -1, "/path",          nullptr, nullptr},
 426   {"file:////path/",           "file", nullptr, nullptr, nullptr,   -1, "/path/",         nullptr, nullptr},
 427   {"file:////path/f.txt",      "file", nullptr, nullptr, nullptr,   -1, "/path/f.txt",    nullptr, nullptr},
 428   // Schemeless URLs
 429   {"path/f.txt",               nullptr,nullptr, nullptr, nullptr,    -1, "path/f.txt",    nullptr, nullptr},
 430   {"path:80/f.txt",            "path", nullptr, nullptr, nullptr,    -1, "80/f.txt",      nullptr, nullptr},
 431   {"path/f.txt:80",            "path/f.txt",nullptr, nullptr, nullptr,-1,"80",            nullptr, nullptr}, // Wrong.
 432   {"/path/f.txt",              nullptr,nullptr, nullptr, nullptr,    -1, "/path/f.txt",   nullptr, nullptr},
 433   {"/path:80/f.txt",           nullptr,nullptr, nullptr, nullptr,    -1, "/path:80/f.txt",nullptr, nullptr},
 434   {"/path/f.txt:80",           nullptr,nullptr, nullptr, nullptr,    -1, "/path/f.txt:80",nullptr, nullptr},
 435   {"//server/f.txt",           nullptr,nullptr, nullptr, "server",   -1, "/f.txt",        nullptr, nullptr},
 436   {"//server:80/f.txt",        nullptr,nullptr, nullptr, "server:80",-1, "/f.txt",        nullptr, nullptr},
 437   {"//server/f.txt:80",        nullptr,nullptr, nullptr, "server",   -1, "/f.txt:80",     nullptr, nullptr},
 438   {"///path/f.txt",            nullptr,nullptr, nullptr, nullptr,    -1, "/path/f.txt",   nullptr, nullptr},
 439   {"///path:80/f.txt",         nullptr,nullptr, nullptr, nullptr,    -1, "/path:80/f.txt",nullptr, nullptr},
 440   {"///path/f.txt:80",         nullptr,nullptr, nullptr, nullptr,    -1, "/path/f.txt:80",nullptr, nullptr},
 441   {"////path/f.txt",           nullptr,nullptr, nullptr, nullptr,    -1, "/path/f.txt",   nullptr, nullptr},
 442   {"////path:80/f.txt",        nullptr,nullptr, nullptr, nullptr,    -1, "/path:80/f.txt",nullptr, nullptr},
 443   {"////path/f.txt:80",        nullptr,nullptr, nullptr, nullptr,    -1, "/path/f.txt:80",nullptr, nullptr},
 444   // Queries and refs are valid for file URLs as well.
 445   {"file:///foo.html?#",       "file", nullptr, nullptr, nullptr,    -1, "/foo.html",     "",   ""},
 446   {"file:///foo.html?q=y#ref", "file", nullptr, nullptr, nullptr,    -1, "/foo.html",    "q=y", "ref"},
 447 #endif  // WIN32
 448 };
 449 // clang-format on
 450
 451 TEST(URLParser, ParseFileURL) {
 452   // Declared outside for loop to try to catch cases in init() where we forget
 453   // to reset something that is reset by the construtor.
 454   Parsed parsed;
 455   for (size_t i = 0; i < std::size(file_cases); i++) {
 456     const char* url = file_cases[i].input;
 457     ParseFileURL(url, static_cast<int>(strlen(url)), &parsed);
 458     int port = ParsePort(url, parsed.port);
 459
 460     EXPECT_TRUE(ComponentMatches(url, file_cases[i].scheme, parsed.scheme))
 461         << " for case #" << i << " [" << url << "] "
 462         << parsed.scheme.begin << ", " << parsed.scheme.len;
 463
 464     EXPECT_TRUE(ComponentMatches(url, file_cases[i].username, parsed.username))
 465         << " for case #" << i << " [" << url << "] "
 466         << parsed.username.begin << ", " << parsed.username.len;
 467
 468     EXPECT_TRUE(ComponentMatches(url, file_cases[i].password, parsed.password))
 469         << " for case #" << i << " [" << url << "] "
 470         << parsed.password.begin << ", " << parsed.password.len;
 471
 472     EXPECT_TRUE(ComponentMatches(url, file_cases[i].host, parsed.host))
 473         << " for case #" << i << " [" << url << "] "
 474         << parsed.host.begin << ", " << parsed.host.len;
 475
 476     EXPECT_EQ(file_cases[i].port, port)
 477         << " for case #" << i << " [ " << url << "] " << port;
 478
 479     EXPECT_TRUE(ComponentMatches(url, file_cases[i].path, parsed.path))
 480         << " for case #" << i << " [" << url << "] "
 481         << parsed.path.begin << ", " << parsed.path.len;
 482
 483     EXPECT_TRUE(ComponentMatches(url, file_cases[i].query, parsed.query))
 484         << " for case #" << i << " [" << url << "] "
 485         << parsed.query.begin << ", " << parsed.query.len;
 486
 487     EXPECT_TRUE(ComponentMatches(url, file_cases[i].ref, parsed.ref))
 488         << " for case #" << i << " [ "<< url << "] "
 489         << parsed.query.begin << ", " << parsed.scheme.len;
 490   }
 491 }
 492
 493
 494 TEST(URLParser, ExtractFileName) {
 495   struct FileCase {
 496     const char* input;
 497     const char* expected;
 498   } extract_cases[] = {
 499       {"http://www.google.com", nullptr},
 500       {"http://www.google.com/", ""},
 501       {"http://www.google.com/search", "search"},
 502       {"http://www.google.com/search/", ""},
 503       {"http://www.google.com/foo/bar.html?baz=22", "bar.html"},
 504       {"http://www.google.com/foo/bar.html#ref", "bar.html"},
 505       {"http://www.google.com/search/;param", ""},
 506       {"http://www.google.com/foo/bar.html;param#ref", "bar.html"},
 507       {"http://www.google.com/foo/bar.html;foo;param#ref", "bar.html"},
 508       {"http://www.google.com/foo/bar.html?query#ref", "bar.html"},
 509       {"http://www.google.com/foo;/bar.html", "bar.html"},
 510       {"http://www.google.com/foo;/", ""},
 511       {"http://www.google.com/foo;", "foo"},
 512       {"http://www.google.com/;", ""},
 513       {"http://www.google.com/foo;bar;html", "foo"},
 514   };
 515
 516   for (const auto& extract_case : extract_cases) {
 517     const char* url = extract_case.input;
 518     int len = static_cast<int>(strlen(url));
 519
 520     Parsed parsed;
 521     ParseStandardURL(url, len, &parsed);
 522
 523     Component file_name;
 524     ExtractFileName(url, parsed.path, &file_name);
 525
 526     EXPECT_TRUE(ComponentMatches(url, extract_case.expected, file_name));
 527   }
 528 }
 529
 530 // Returns true if the parameter with index |parameter| in the given URL's
 531 // query string. The expected key can be NULL to indicate no such key index
 532 // should exist. The parameter number is 1-based.
 533 static bool NthParameterIs(const char* url,
 534                            int parameter,
 535                            const char* expected_key,
 536                            const char* expected_value) {
 537   Parsed parsed;
 538   ParseStandardURL(url, static_cast<int>(strlen(url)), &parsed);
 539
 540   Component query = parsed.query;
 541
 542   for (int i = 1; i <= parameter; i++) {
 543     Component key, value;
 544     if (!ExtractQueryKeyValue(url, &query, &key, &value)) {
 545       if (parameter >= i && !expected_key)
 546         return true;  // Expected nonexistent key, got one.
 547       return false;  // Not enough keys.
 548     }
 549
 550     if (i == parameter) {
 551       if (!expected_key)
 552         return false;
 553
 554       if (strncmp(&url[key.begin], expected_key, key.len) != 0)
 555         return false;
 556       if (strncmp(&url[value.begin], expected_value, value.len) != 0)
 557         return false;
 558       return true;
 559     }
 560   }
 561   return expected_key == nullptr;  // We didn't find that many parameters.
 562 }
 563
 564 TEST(URLParser, ExtractQueryKeyValue) {
 565   EXPECT_TRUE(NthParameterIs("http://www.google.com", 1, nullptr, nullptr));
 566
 567   // Basic case.
 568   char a[] = "http://www.google.com?arg1=1&arg2=2&bar";
 569   EXPECT_TRUE(NthParameterIs(a, 1, "arg1", "1"));
 570   EXPECT_TRUE(NthParameterIs(a, 2, "arg2", "2"));
 571   EXPECT_TRUE(NthParameterIs(a, 3, "bar", ""));
 572   EXPECT_TRUE(NthParameterIs(a, 4, nullptr, nullptr));
 573
 574   // Empty param at the end.
 575   char b[] = "http://www.google.com?foo=bar&";
 576   EXPECT_TRUE(NthParameterIs(b, 1, "foo", "bar"));
 577   EXPECT_TRUE(NthParameterIs(b, 2, nullptr, nullptr));
 578
 579   // Empty param at the beginning.
 580   char c[] = "http://www.google.com?&foo=bar";
 581   EXPECT_TRUE(NthParameterIs(c, 1, "", ""));
 582   EXPECT_TRUE(NthParameterIs(c, 2, "foo", "bar"));
 583   EXPECT_TRUE(NthParameterIs(c, 3, nullptr, nullptr));
 584
 585   // Empty key with value.
 586   char d[] = "http://www.google.com?=foo";
 587   EXPECT_TRUE(NthParameterIs(d, 1, "", "foo"));
 588   EXPECT_TRUE(NthParameterIs(d, 2, nullptr, nullptr));
 589
 590   // Empty value with key.
 591   char e[] = "http://www.google.com?foo=";
 592   EXPECT_TRUE(NthParameterIs(e, 1, "foo", ""));
 593   EXPECT_TRUE(NthParameterIs(e, 2, nullptr, nullptr));
 594
 595   // Empty key and values.
 596   char f[] = "http://www.google.com?&&==&=";
 597   EXPECT_TRUE(NthParameterIs(f, 1, "", ""));
 598   EXPECT_TRUE(NthParameterIs(f, 2, "", ""));
 599   EXPECT_TRUE(NthParameterIs(f, 3, "", "="));
 600   EXPECT_TRUE(NthParameterIs(f, 4, "", ""));
 601   EXPECT_TRUE(NthParameterIs(f, 5, nullptr, nullptr));
 602 }
 603
 604 // MailtoURL --------------------------------------------------------------------
 605
 606 // clang-format off
 607 static MailtoURLParseCase mailto_cases[] = {
 608 //|input                       |scheme   |path               |query
 609 {"mailto:foo@gmail.com",        "mailto", "foo@gmail.com",    nullptr},
 610 {"  mailto: to  \t",            "mailto", " to",              nullptr},
 611 {"mailto:addr1%2C%20addr2 ",    "mailto", "addr1%2C%20addr2", nullptr},
 612 {"Mailto:addr1, addr2 ",        "Mailto", "addr1, addr2",     nullptr},
 613 {"mailto:addr1:addr2 ",         "mailto", "addr1:addr2",      nullptr},
 614 {"mailto:?to=addr1,addr2",      "mailto", nullptr,            "to=addr1,addr2"},
 615 {"mailto:?to=addr1%2C%20addr2", "mailto", nullptr,            "to=addr1%2C%20addr2"},
 616 {"mailto:addr1?to=addr2",       "mailto", "addr1",            "to=addr2"},
 617 {"mailto:?body=#foobar#",       "mailto", nullptr,            "body=#foobar#",},
 618 {"mailto:#?body=#foobar#",      "mailto", "#",                "body=#foobar#"},
 619 };
 620 // clang-format on
 621
 622 TEST(URLParser, MailtoUrl) {
 623   // Declared outside for loop to try to catch cases in init() where we forget
 624   // to reset something that is reset by the constructor.
 625   Parsed parsed;
 626   for (const auto& mailto_case : mailto_cases) {
 627     const char* url = mailto_case.input;
 628     ParseMailtoURL(url, static_cast<int>(strlen(url)), &parsed);
 629     int port = ParsePort(url, parsed.port);
 630
 631     EXPECT_TRUE(ComponentMatches(url, mailto_case.scheme, parsed.scheme));
 632     EXPECT_TRUE(ComponentMatches(url, mailto_case.path, parsed.path));
 633     EXPECT_TRUE(ComponentMatches(url, mailto_case.query, parsed.query));
 634     EXPECT_EQ(PORT_UNSPECIFIED, port);
 635
 636     // The remaining components are never used for mailto URLs.
 637     ExpectInvalidComponent(parsed.username);
 638     ExpectInvalidComponent(parsed.password);
 639     ExpectInvalidComponent(parsed.port);
 640     ExpectInvalidComponent(parsed.ref);
 641   }
 642 }
 643
 644 // Various incarnations of filesystem URLs.
 645 static FileSystemURLParseCase filesystem_cases[] = {
 646     // Regular URL with all the parts
 647     {"filesystem:http://user:pass@foo:21/temporary/bar;par?b#c", "http", "user",
 648      "pass", "foo", 21, "/temporary", "/bar;par", "b", "c"},
 649     {"filesystem:https://foo/persistent/bar;par/", "https", nullptr, nullptr,
 650      "foo", -1, "/persistent", "/bar;par/", nullptr, nullptr},
 651     {"filesystem:file:///persistent/bar;par/", "file", nullptr, nullptr,
 652      nullptr, -1, "/persistent", "/bar;par/", nullptr, nullptr},
 653     {"filesystem:file:///persistent/bar;par/?query#ref", "file", nullptr,
 654      nullptr, nullptr, -1, "/persistent", "/bar;par/", "query", "ref"},
 655     {"filesystem:file:///persistent", "file", nullptr, nullptr, nullptr, -1,
 656      "/persistent", "", nullptr, nullptr},
 657 };
 658
 659 TEST(URLParser, FileSystemURL) {
 660   // Declared outside for loop to try to catch cases in init() where we forget
 661   // to reset something that is reset by the constructor.
 662   Parsed parsed;
 663   for (const auto& filesystem_case : filesystem_cases) {
 664     const char* url = filesystem_case.input;
 665     ParseFileSystemURL(url, static_cast<int>(strlen(url)), &parsed);
 666
 667     EXPECT_TRUE(ComponentMatches(url, "filesystem", parsed.scheme));
 668     EXPECT_EQ(!filesystem_case.inner_scheme, !parsed.inner_parsed());
 669     // Only check the inner_parsed if there is one.
 670     if (parsed.inner_parsed()) {
 671       EXPECT_TRUE(ComponentMatches(url, filesystem_case.inner_scheme,
 672           parsed.inner_parsed()->scheme));
 673       EXPECT_TRUE(ComponentMatches(url, filesystem_case.inner_username,
 674           parsed.inner_parsed()->username));
 675       EXPECT_TRUE(ComponentMatches(url, filesystem_case.inner_password,
 676           parsed.inner_parsed()->password));
 677       EXPECT_TRUE(ComponentMatches(url, filesystem_case.inner_host,
 678           parsed.inner_parsed()->host));
 679       int port = ParsePort(url, parsed.inner_parsed()->port);
 680       EXPECT_EQ(filesystem_case.inner_port, port);
 681
 682       // The remaining components are never used for filesystem URLs.
 683       ExpectInvalidComponent(parsed.inner_parsed()->query);
 684       ExpectInvalidComponent(parsed.inner_parsed()->ref);
 685     }
 686
 687     EXPECT_TRUE(ComponentMatches(url, filesystem_case.path, parsed.path));
 688     EXPECT_TRUE(ComponentMatches(url, filesystem_case.query, parsed.query));
 689     EXPECT_TRUE(ComponentMatches(url, filesystem_case.ref, parsed.ref));
 690
 691     // The remaining components are never used for filesystem URLs.
 692     ExpectInvalidComponent(parsed.username);
 693     ExpectInvalidComponent(parsed.password);
 694     ExpectInvalidComponent(parsed.host);
 695     ExpectInvalidComponent(parsed.port);
 696   }
 697 }
 698
 699 }  // namespace
 700 }  // namespace url