Move googleurl into the Chrome repo.
Original location:
https://code.google.com/p/google-url/
This includes changes up to r184.
These files are unchanged from the Google Code repo and do not yet build.
Updating includes, etc. will be done in a separate pass.
Review URL: https://codereview.chromium.org/13821004
git-svn-id: svn://svn.chromium.org/chrome/trunk/src@193439 0039d316-1c4b-4281-b951-d872f2087c98
diff --git a/url/url_parse_unittest.cc b/url/url_parse_unittest.cc
new file mode 100644
index 0000000..cc3eb1b
--- /dev/null
+++ b/url/url_parse_unittest.cc
@@ -0,0 +1,649 @@
+// Copyright 2007, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+// * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#include "base/basictypes.h"
+#include "googleurl/src/url_parse.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+// Some implementations of base/basictypes.h may define ARRAYSIZE.
+// If it's not defined, we define it to the ARRAYSIZE_UNSAFE macro
+// which is in our version of basictypes.h.
+#ifndef ARRAYSIZE
+#define ARRAYSIZE ARRAYSIZE_UNSAFE
+#endif
+
+// Interesting IE file:isms...
+//
+// file:/foo/bar file:///foo/bar
+// The result here seems totally invalid!?!? This isn't UNC.
+//
+// file:/
+// file:// or any other number of slashes
+// IE6 doesn't do anything at all if you click on this link. No error:
+// nothing. IE6's history system seems to always color this link, so I'm
+// guessing that it maps internally to the empty URL.
+//
+// C:\ file:///C:/
+// / file:///C:/
+// /foo file:///C:/foo
+// Interestingly, IE treats "/" as an alias for "c:\", which makes sense,
+// but is weird to think about on Windows.
+//
+// file:foo/ file:foo/ (invalid?!?!?)
+// file:/foo/ file:///foo/ (invalid?!?!?)
+// file://foo/ file://foo/ (UNC to server "foo")
+// file:///foo/ file:///foo/ (invalid)
+// file:////foo/ file://foo/ (UNC to server "foo")
+// Any more than four slashes is also treated as UNC.
+//
+// file:C:/ file://C:/
+// file:/C:/ file://C:/
+// The number of slashes after "file:" don't matter if the thing following
+// it looks like an absolute drive path. Also, slashes and backslashes are
+// equally valid here.
+
+namespace {
+
+// Used for regular URL parse cases.
+struct URLParseCase {
+ const char* input;
+
+ const char* scheme;
+ const char* username;
+ const char* password;
+ const char* host;
+ int port;
+ const char* path;
+ const char* query;
+ const char* ref;
+};
+
+// Simpler version of URLParseCase for testing path URLs.
+struct PathURLParseCase {
+ const char* input;
+
+ const char* scheme;
+ const char* path;
+};
+
+// Simpler version of URLParseCase for testing mailto URLs.
+struct MailtoURLParseCase {
+ const char* input;
+
+ const char* scheme;
+ const char* path;
+ const char* query;
+};
+
+// More complicated version of URLParseCase for testing filesystem URLs.
+struct FileSystemURLParseCase {
+ const char* input;
+
+ const char* inner_scheme;
+ const char* inner_username;
+ const char* inner_password;
+ const char* inner_host;
+ int inner_port;
+ const char* inner_path;
+ const char* path;
+ const char* query;
+ const char* ref;
+};
+
+bool ComponentMatches(const char* input,
+ const char* reference,
+ const url_parse::Component& component) {
+ // If the component is nonexistant (length == -1), it should begin at 0.
+ EXPECT_TRUE(component.len >= 0 || component.len == -1);
+
+ // Begin should be valid.
+ EXPECT_LE(0, component.begin);
+
+ // A NULL reference means the component should be nonexistant.
+ if (!reference)
+ return component.len == -1;
+ if (component.len < 0)
+ return false; // Reference is not NULL but we don't have anything
+
+ if (strlen(reference) != static_cast<size_t>(component.len))
+ return false; // Lengths don't match
+
+ // Now check the actual characters.
+ return strncmp(reference, &input[component.begin], component.len) == 0;
+}
+
+void ExpectInvalidComponent(const url_parse::Component& component) {
+ EXPECT_EQ(0, component.begin);
+ EXPECT_EQ(-1, component.len);
+}
+
+} // namespace
+
+// Parsed ----------------------------------------------------------------------
+
+TEST(URLParser, Length) {
+ const char* length_cases[] = {
+ // One with everything in it.
+ "http://user:pass@host:99/foo?bar#baz",
+ // One with nothing in it.
+ "",
+ // Working backwards, let's start taking off stuff from the full one.
+ "http://user:pass@host:99/foo?bar#",
+ "http://user:pass@host:99/foo?bar",
+ "http://user:pass@host:99/foo?",
+ "http://user:pass@host:99/foo",
+ "http://user:pass@host:99/",
+ "http://user:pass@host:99",
+ "http://user:pass@host:",
+ "http://user:pass@host",
+ "http://host",
+ "http://user@",
+ "http:",
+ };
+ for (size_t i = 0; i < arraysize(length_cases); i++) {
+ int true_length = static_cast<int>(strlen(length_cases[i]));
+
+ url_parse::Parsed parsed;
+ url_parse::ParseStandardURL(length_cases[i], true_length, &parsed);
+
+ EXPECT_EQ(true_length, parsed.Length());
+ }
+}
+
+TEST(URLParser, CountCharactersBefore) {
+ using namespace url_parse;
+ struct CountCase {
+ const char* url;
+ Parsed::ComponentType component;
+ bool include_delimiter;
+ int expected_count;
+ } count_cases[] = {
+ // Test each possibility in the case where all components are present.
+// 0 1 2
+// 0123456789012345678901
+ {"http://u:p@h:8/p?q#r", Parsed::SCHEME, true, 0},
+ {"http://u:p@h:8/p?q#r", Parsed::SCHEME, false, 0},
+ {"http://u:p@h:8/p?q#r", Parsed::USERNAME, true, 7},
+ {"http://u:p@h:8/p?q#r", Parsed::USERNAME, false, 7},
+ {"http://u:p@h:8/p?q#r", Parsed::PASSWORD, true, 9},
+ {"http://u:p@h:8/p?q#r", Parsed::PASSWORD, false, 9},
+ {"http://u:p@h:8/p?q#r", Parsed::HOST, true, 11},
+ {"http://u:p@h:8/p?q#r", Parsed::HOST, false, 11},
+ {"http://u:p@h:8/p?q#r", Parsed::PORT, true, 12},
+ {"http://u:p@h:8/p?q#r", Parsed::PORT, false, 13},
+ {"http://u:p@h:8/p?q#r", Parsed::PATH, false, 14},
+ {"http://u:p@h:8/p?q#r", Parsed::PATH, true, 14},
+ {"http://u:p@h:8/p?q#r", Parsed::QUERY, true, 16},
+ {"http://u:p@h:8/p?q#r", Parsed::QUERY, false, 17},
+ {"http://u:p@h:8/p?q#r", Parsed::REF, true, 18},
+ {"http://u:p@h:8/p?q#r", Parsed::REF, false, 19},
+ // Now test when the requested component is missing.
+ {"http://u:p@h:8/p?", Parsed::REF, true, 17},
+ {"http://u:p@h:8/p?q", Parsed::REF, true, 18},
+ {"http://u:p@h:8/p#r", Parsed::QUERY, true, 16},
+ {"http://u:p@h:8#r", Parsed::PATH, true, 14},
+ {"http://u:p@h/", Parsed::PORT, true, 12},
+ {"http://u:p@/", Parsed::HOST, true, 11},
+ // This case is a little weird. It will report that the password would
+ // start where the host begins. This is arguably correct, although you
+ // could also argue that it should start at the '@' sign. Doing it
+ // starting with the '@' sign is actually harder, so we don't bother.
+ {"http://u@h/", Parsed::PASSWORD, true, 9},
+ {"http://h/", Parsed::USERNAME, true, 7},
+ {"http:", Parsed::USERNAME, true, 5},
+ {"", Parsed::SCHEME, true, 0},
+ // Make sure a random component still works when there's nothing there.
+ {"", Parsed::REF, true, 0},
+ // File URLs are special with no host, so we test those.
+ {"file:///c:/foo", Parsed::USERNAME, true, 7},
+ {"file:///c:/foo", Parsed::PASSWORD, true, 7},
+ {"file:///c:/foo", Parsed::HOST, true, 7},
+ {"file:///c:/foo", Parsed::PATH, true, 7},
+ };
+ for (size_t i = 0; i < ARRAYSIZE(count_cases); i++) {
+ int length = static_cast<int>(strlen(count_cases[i].url));
+
+ // Simple test to distinguish file and standard URLs.
+ url_parse::Parsed parsed;
+ if (length > 0 && count_cases[i].url[0] == 'f')
+ url_parse::ParseFileURL(count_cases[i].url, length, &parsed);
+ else
+ url_parse::ParseStandardURL(count_cases[i].url, length, &parsed);
+
+ int chars_before = parsed.CountCharactersBefore(
+ count_cases[i].component, count_cases[i].include_delimiter);
+ EXPECT_EQ(count_cases[i].expected_count, chars_before);
+ }
+}
+
+// Standard --------------------------------------------------------------------
+
+// Input Scheme Usrname Passwd Host Port Path Query Ref
+// ------------------------------------ ------- ------- ---------- ------------ --- ---------- ------------ -----
+static URLParseCase cases[] = {
+ // Regular URL with all the parts
+{"http://user:pass@foo:21/bar;par?b#c", "http", "user", "pass", "foo", 21, "/bar;par","b", "c"},
+
+ // Known schemes should lean towards authority identification
+{"http:foo.com", "http", NULL, NULL, "foo.com", -1, NULL, NULL, NULL},
+
+ // Spaces!
+{"\t :foo.com \n", "", NULL, NULL, "foo.com", -1, NULL, NULL, NULL},
+{" foo.com ", NULL, NULL, NULL, "foo.com", -1, NULL, NULL, NULL},
+{"a:\t foo.com", "a", NULL, NULL, "\t foo.com", -1, NULL, NULL, NULL},
+{"http://f:21/ b ? d # e ", "http", NULL, NULL, "f", 21, "/ b ", " d ", " e"},
+
+ // Invalid port numbers should be identified and turned into -2, empty port
+ // numbers should be -1. Spaces aren't allowed in port numbers
+{"http://f:/c", "http", NULL, NULL, "f", -1, "/c", NULL, NULL},
+{"http://f:0/c", "http", NULL, NULL, "f", 0, "/c", NULL, NULL},
+{"http://f:00000000000000/c", "http", NULL, NULL, "f", 0, "/c", NULL, NULL},
+{"http://f:00000000000000000000080/c", "http", NULL, NULL, "f", 80, "/c", NULL, NULL},
+{"http://f:b/c", "http", NULL, NULL, "f", -2, "/c", NULL, NULL},
+{"http://f: /c", "http", NULL, NULL, "f", -2, "/c", NULL, NULL},
+{"http://f:\n/c", "http", NULL, NULL, "f", -2, "/c", NULL, NULL},
+{"http://f:fifty-two/c", "http", NULL, NULL, "f", -2, "/c", NULL, NULL},
+{"http://f:999999/c", "http", NULL, NULL, "f", -2, "/c", NULL, NULL},
+{"http://f: 21 / b ? d # e ", "http", NULL, NULL, "f", -2, "/ b ", " d ", " e"},
+
+ // Creative URLs missing key elements
+{"", NULL, NULL, NULL, NULL, -1, NULL, NULL, NULL},
+{" \t", NULL, NULL, NULL, NULL, -1, NULL, NULL, NULL},
+{":foo.com/", "", NULL, NULL, "foo.com", -1, "/", NULL, NULL},
+{":foo.com\\", "", NULL, NULL, "foo.com", -1, "\\", NULL, NULL},
+{":", "", NULL, NULL, NULL, -1, NULL, NULL, NULL},
+{":a", "", NULL, NULL, "a", -1, NULL, NULL, NULL},
+{":/", "", NULL, NULL, NULL, -1, NULL, NULL, NULL},
+{":\\", "", NULL, NULL, NULL, -1, NULL, NULL, NULL},
+{":#", "", NULL, NULL, NULL, -1, NULL, NULL, ""},
+{"#", NULL, NULL, NULL, NULL, -1, NULL, NULL, ""},
+{"#/", NULL, NULL, NULL, NULL, -1, NULL, NULL, "/"},
+{"#\\", NULL, NULL, NULL, NULL, -1, NULL, NULL, "\\"},
+{"#;?", NULL, NULL, NULL, NULL, -1, NULL, NULL, ";?"},
+{"?", NULL, NULL, NULL, NULL, -1, NULL, "", NULL},
+{"/", NULL, NULL, NULL, NULL, -1, NULL, NULL, NULL},
+{":23", "", NULL, NULL, "23", -1, NULL, NULL, NULL},
+{"/:23", "/", NULL, NULL, "23", -1, NULL, NULL, NULL},
+{"//", NULL, NULL, NULL, NULL, -1, NULL, NULL, NULL},
+{"::", "", NULL, NULL, NULL, -1, NULL, NULL, NULL},
+{"::23", "", NULL, NULL, NULL, 23, NULL, NULL, NULL},
+{"foo://", "foo", NULL, NULL, NULL, -1, NULL, NULL, NULL},
+
+ // Username/passwords and things that look like them
+{"http://a:b@c:29/d", "http", "a", "b", "c", 29, "/d", NULL, NULL},
+{"http::@c:29", "http", "", "", "c", 29, NULL, NULL, NULL},
+ // ... "]" in the password field isn't allowed, but we tolerate it here...
+{"http://&a:foo(b]c@d:2/", "http", "&a", "foo(b]c", "d", 2, "/", NULL, NULL},
+{"http://::@c@d:2", "http", "", ":@c", "d", 2, NULL, NULL, NULL},
+{"http://foo.com:b@d/", "http", "foo.com", "b", "d", -1, "/", NULL, NULL},
+
+{"http://foo.com/\\@", "http", NULL, NULL, "foo.com", -1, "/\\@", NULL, NULL},
+{"http:\\\\foo.com\\", "http", NULL, NULL, "foo.com", -1, "\\", NULL, NULL},
+{"http:\\\\a\\b:c\\[email protected]\\", "http", NULL, NULL, "a", -1, "\\b:c\\[email protected]\\", NULL, NULL},
+
+ // Tolerate different numbers of slashes.
+{"foo:/", "foo", NULL, NULL, NULL, -1, NULL, NULL, NULL},
+{"foo:/bar.com/", "foo", NULL, NULL, "bar.com", -1, "/", NULL, NULL},
+{"foo://///////", "foo", NULL, NULL, NULL, -1, NULL, NULL, NULL},
+{"foo://///////bar.com/", "foo", NULL, NULL, "bar.com", -1, "/", NULL, NULL},
+{"foo:////://///", "foo", NULL, NULL, NULL, -1, "/////", NULL, NULL},
+
+ // Raw file paths on Windows aren't handled by the parser.
+{"c:/foo", "c", NULL, NULL, "foo", -1, NULL, NULL, NULL},
+{"//foo/bar", NULL, NULL, NULL, "foo", -1, "/bar", NULL, NULL},
+
+ // Use the first question mark for the query and the ref.
+{"http://foo/path;a??e#f#g", "http", NULL, NULL, "foo", -1, "/path;a", "?e", "f#g"},
+{"http://foo/abcd?efgh?ijkl", "http", NULL, NULL, "foo", -1, "/abcd", "efgh?ijkl", NULL},
+{"http://foo/abcd#foo?bar", "http", NULL, NULL, "foo", -1, "/abcd", NULL, "foo?bar"},
+
+ // IPv6, check also interesting uses of colons.
+{"[61:24:74]:98", "[61", NULL, NULL, "24:74]", 98, NULL, NULL, NULL},
+{"http://[61:27]:98", "http", NULL, NULL, "[61:27]", 98, NULL, NULL, NULL},
+{"http:[61:27]/:foo", "http", NULL, NULL, "[61:27]", -1, "/:foo", NULL, NULL},
+{"http://[1::2]:3:4", "http", NULL, NULL, "[1::2]:3", 4, NULL, NULL, NULL},
+
+ // Partially-complete IPv6 literals, and related cases.
+{"http://2001::1", "http", NULL, NULL, "2001:", 1, NULL, NULL, NULL},
+{"http://[2001::1", "http", NULL, NULL, "[2001::1", -1, NULL, NULL, NULL},
+{"http://2001::1]", "http", NULL, NULL, "2001::1]", -1, NULL, NULL, NULL},
+{"http://2001::1]:80", "http", NULL, NULL, "2001::1]", 80, NULL, NULL, NULL},
+{"http://[2001::1]", "http", NULL, NULL, "[2001::1]", -1, NULL, NULL, NULL},
+{"http://[2001::1]:80", "http", NULL, NULL, "[2001::1]", 80, NULL, NULL, NULL},
+{"http://[[::]]", "http", NULL, NULL, "[[::]]", -1, NULL, NULL, NULL},
+
+};
+
+TEST(URLParser, Standard) {
+ // Declared outside for loop to try to catch cases in init() where we forget
+ // to reset something that is reset by the constructor.
+ url_parse::Parsed parsed;
+ for (size_t i = 0; i < arraysize(cases); i++) {
+ const char* url = cases[i].input;
+ url_parse::ParseStandardURL(url, static_cast<int>(strlen(url)), &parsed);
+ int port = url_parse::ParsePort(url, parsed.port);
+
+ EXPECT_TRUE(ComponentMatches(url, cases[i].scheme, parsed.scheme));
+ EXPECT_TRUE(ComponentMatches(url, cases[i].username, parsed.username));
+ EXPECT_TRUE(ComponentMatches(url, cases[i].password, parsed.password));
+ EXPECT_TRUE(ComponentMatches(url, cases[i].host, parsed.host));
+ EXPECT_EQ(cases[i].port, port);
+ EXPECT_TRUE(ComponentMatches(url, cases[i].path, parsed.path));
+ EXPECT_TRUE(ComponentMatches(url, cases[i].query, parsed.query));
+ EXPECT_TRUE(ComponentMatches(url, cases[i].ref, parsed.ref));
+ }
+}
+
+// PathURL --------------------------------------------------------------------
+
+// Various incarnations of path URLs.
+static PathURLParseCase path_cases[] = {
+{"", NULL, NULL},
+{":", "", NULL},
+{":/", "", "/"},
+{"/", NULL, "/"},
+{" This is \\interesting// \t", NULL, "This is \\interesting//"},
+{"about:", "about", NULL},
+{"about:blank", "about", "blank"},
+{" about: blank ", "about", " blank"},
+{"javascript :alert(\"He:/l\\l#o?foo\"); ", "javascript ", "alert(\"He:/l\\l#o?foo\");"},
+};
+
+TEST(URLParser, PathURL) {
+ // Declared outside for loop to try to catch cases in init() where we forget
+ // to reset something that is reset by the construtor.
+ url_parse::Parsed parsed;
+ for (size_t i = 0; i < arraysize(path_cases); i++) {
+ const char* url = path_cases[i].input;
+ url_parse::ParsePathURL(url, static_cast<int>(strlen(url)), &parsed);
+
+ EXPECT_TRUE(ComponentMatches(url, path_cases[i].scheme, parsed.scheme));
+ EXPECT_TRUE(ComponentMatches(url, path_cases[i].path, parsed.path));
+
+ // The remaining components are never used for path urls.
+ ExpectInvalidComponent(parsed.username);
+ ExpectInvalidComponent(parsed.password);
+ ExpectInvalidComponent(parsed.host);
+ ExpectInvalidComponent(parsed.port);
+ ExpectInvalidComponent(parsed.query);
+ ExpectInvalidComponent(parsed.ref);
+ }
+}
+
+#ifdef WIN32
+
+// WindowsFile ----------------------------------------------------------------
+
+// Various incarnations of file URLs. These are for Windows only.
+static URLParseCase file_cases[] = {
+{"file:server", "file", NULL, NULL, "server", -1, NULL, NULL, NULL},
+{" file: server \t", "file", NULL, NULL, " server",-1, NULL, NULL, NULL},
+{"FiLe:c|", "FiLe", NULL, NULL, NULL, -1, "c|", NULL, NULL},
+{"FILE:/\\\\/server/file", "FILE", NULL, NULL, "server", -1, "/file", NULL, NULL},
+{"file://server/", "file", NULL, NULL, "server", -1, "/", NULL, NULL},
+{"file://localhost/c:/", "file", NULL, NULL, NULL, -1, "/c:/", NULL, NULL},
+{"file://127.0.0.1/c|\\", "file", NULL, NULL, NULL, -1, "/c|\\", NULL, NULL},
+{"file:/", "file", NULL, NULL, NULL, -1, NULL, NULL, NULL},
+{"file:", "file", NULL, NULL, NULL, -1, NULL, NULL, NULL},
+ // If there is a Windows drive letter, treat any number of slashes as the
+ // path part.
+{"file:c:\\fo\\b", "file", NULL, NULL, NULL, -1, "c:\\fo\\b", NULL, NULL},
+{"file:/c:\\foo/bar", "file", NULL, NULL, NULL, -1, "/c:\\foo/bar",NULL, NULL},
+{"file://c:/f\\b", "file", NULL, NULL, NULL, -1, "/c:/f\\b", NULL, NULL},
+{"file:///C:/foo", "file", NULL, NULL, NULL, -1, "/C:/foo", NULL, NULL},
+{"file://///\\/\\/c:\\f\\b", "file", NULL, NULL, NULL, -1, "/c:\\f\\b", NULL, NULL},
+ // If there is not a drive letter, we should treat is as UNC EXCEPT for
+ // three slashes, which we treat as a Unix style path.
+{"file:server/file", "file", NULL, NULL, "server", -1, "/file", NULL, NULL},
+{"file:/server/file", "file", NULL, NULL, "server", -1, "/file", NULL, NULL},
+{"file://server/file", "file", NULL, NULL, "server", -1, "/file", NULL, NULL},
+{"file:///server/file", "file", NULL, NULL, NULL, -1, "/server/file",NULL, NULL},
+{"file://\\server/file", "file", NULL, NULL, NULL, -1, "\\server/file",NULL, NULL},
+{"file:////server/file", "file", NULL, NULL, "server", -1, "/file", NULL, NULL},
+ // Queries and refs are valid for file URLs as well.
+{"file:///C:/foo.html?#", "file", NULL, NULL, NULL, -1, "/C:/foo.html", "", ""},
+{"file:///C:/foo.html?query=yes#ref", "file", NULL, NULL, NULL, -1, "/C:/foo.html", "query=yes", "ref"},
+};
+
+TEST(URLParser, WindowsFile) {
+ // Declared outside for loop to try to catch cases in init() where we forget
+ // to reset something that is reset by the construtor.
+ url_parse::Parsed parsed;
+ for (int i = 0; i < arraysize(file_cases); i++) {
+ const char* url = file_cases[i].input;
+ url_parse::ParseFileURL(url, static_cast<int>(strlen(url)), &parsed);
+ int port = url_parse::ParsePort(url, parsed.port);
+
+ EXPECT_TRUE(ComponentMatches(url, file_cases[i].scheme, parsed.scheme));
+ EXPECT_TRUE(ComponentMatches(url, file_cases[i].username, parsed.username));
+ EXPECT_TRUE(ComponentMatches(url, file_cases[i].password, parsed.password));
+ EXPECT_TRUE(ComponentMatches(url, file_cases[i].host, parsed.host));
+ EXPECT_EQ(file_cases[i].port, port);
+ EXPECT_TRUE(ComponentMatches(url, file_cases[i].path, parsed.path));
+ EXPECT_TRUE(ComponentMatches(url, file_cases[i].query, parsed.query));
+ EXPECT_TRUE(ComponentMatches(url, file_cases[i].ref, parsed.ref));
+ }
+}
+
+#endif // WIN32
+
+TEST(URLParser, ExtractFileName) {
+ struct FileCase {
+ const char* input;
+ const char* expected;
+ } file_cases[] = {
+ {"http://www.google.com", NULL},
+ {"http://www.google.com/", ""},
+ {"http://www.google.com/search", "search"},
+ {"http://www.google.com/search/", ""},
+ {"http://www.google.com/foo/bar.html?baz=22", "bar.html"},
+ {"http://www.google.com/foo/bar.html#ref", "bar.html"},
+ {"http://www.google.com/search/;param", ""},
+ {"http://www.google.com/foo/bar.html;param#ref", "bar.html"},
+ {"http://www.google.com/foo/bar.html;foo;param#ref", "bar.html;foo"},
+ {"http://www.google.com/foo/bar.html?query#ref", "bar.html"},
+ };
+
+ for (size_t i = 0; i < ARRAYSIZE(file_cases); i++) {
+ const char* url = file_cases[i].input;
+ int len = static_cast<int>(strlen(url));
+
+ url_parse::Parsed parsed;
+ url_parse::ParseStandardURL(url, len, &parsed);
+
+ url_parse::Component file_name;
+ url_parse::ExtractFileName(url, parsed.path, &file_name);
+
+ EXPECT_TRUE(ComponentMatches(url, file_cases[i].expected, file_name));
+ }
+}
+
+// Returns true if the parameter with index |parameter| in the given URL's
+// query string. The expected key can be NULL to indicate no such key index
+// should exist. The parameter number is 1-based.
+static bool NthParameterIs(const char* url,
+ int parameter,
+ const char* expected_key,
+ const char* expected_value) {
+ url_parse::Parsed parsed;
+ url_parse::ParseStandardURL(url, static_cast<int>(strlen(url)), &parsed);
+
+ url_parse::Component query = parsed.query;
+
+ for (int i = 1; i <= parameter; i++) {
+ url_parse::Component key, value;
+ if (!url_parse::ExtractQueryKeyValue(url, &query, &key, &value)) {
+ if (parameter >= i && !expected_key)
+ return true; // Expected nonexistant key, got one.
+ return false; // Not enough keys.
+ }
+
+ if (i == parameter) {
+ if (!expected_key)
+ return false;
+
+ if (strncmp(&url[key.begin], expected_key, key.len) != 0)
+ return false;
+ if (strncmp(&url[value.begin], expected_value, value.len) != 0)
+ return false;
+ return true;
+ }
+ }
+ return expected_key == NULL; // We didn't find that many parameters.
+}
+
+TEST(URLParser, ExtractQueryKeyValue) {
+ EXPECT_TRUE(NthParameterIs("http://www.google.com", 1, NULL, NULL));
+
+ // Basic case.
+ char a[] = "http://www.google.com?arg1=1&arg2=2&bar";
+ EXPECT_TRUE(NthParameterIs(a, 1, "arg1", "1"));
+ EXPECT_TRUE(NthParameterIs(a, 2, "arg2", "2"));
+ EXPECT_TRUE(NthParameterIs(a, 3, "bar", ""));
+ EXPECT_TRUE(NthParameterIs(a, 4, NULL, NULL));
+
+ // Empty param at the end.
+ char b[] = "http://www.google.com?foo=bar&";
+ EXPECT_TRUE(NthParameterIs(b, 1, "foo", "bar"));
+ EXPECT_TRUE(NthParameterIs(b, 2, NULL, NULL));
+
+ // Empty param at the beginning.
+ char c[] = "http://www.google.com?&foo=bar";
+ EXPECT_TRUE(NthParameterIs(c, 1, "", ""));
+ EXPECT_TRUE(NthParameterIs(c, 2, "foo", "bar"));
+ EXPECT_TRUE(NthParameterIs(c, 3, NULL, NULL));
+
+ // Empty key with value.
+ char d[] = "http://www.google.com?=foo";
+ EXPECT_TRUE(NthParameterIs(d, 1, "", "foo"));
+ EXPECT_TRUE(NthParameterIs(d, 2, NULL, NULL));
+
+ // Empty value with key.
+ char e[] = "http://www.google.com?foo=";
+ EXPECT_TRUE(NthParameterIs(e, 1, "foo", ""));
+ EXPECT_TRUE(NthParameterIs(e, 2, NULL, NULL));
+
+ // Empty key and values.
+ char f[] = "http://www.google.com?&&==&=";
+ EXPECT_TRUE(NthParameterIs(f, 1, "", ""));
+ EXPECT_TRUE(NthParameterIs(f, 2, "", ""));
+ EXPECT_TRUE(NthParameterIs(f, 3, "", "="));
+ EXPECT_TRUE(NthParameterIs(f, 4, "", ""));
+ EXPECT_TRUE(NthParameterIs(f, 5, NULL, NULL));
+}
+
+// MailtoURL --------------------------------------------------------------------
+
+static MailtoURLParseCase mailto_cases[] = {
+//|input |scheme |path |query
+{"mailto:[email protected]", "mailto", "[email protected]", NULL},
+{" mailto: to \t", "mailto", " to", NULL},
+{"mailto:addr1%2C%20addr2 ", "mailto", "addr1%2C%20addr2", NULL},
+{"Mailto:addr1, addr2 ", "Mailto", "addr1, addr2", NULL},
+{"mailto:addr1:addr2 ", "mailto", "addr1:addr2", NULL},
+{"mailto:?to=addr1,addr2", "mailto", NULL, "to=addr1,addr2"},
+{"mailto:?to=addr1%2C%20addr2", "mailto", NULL, "to=addr1%2C%20addr2"},
+{"mailto:addr1?to=addr2", "mailto", "addr1", "to=addr2"},
+{"mailto:?body=#foobar#", "mailto", NULL, "body=#foobar#",},
+{"mailto:#?body=#foobar#", "mailto", "#", "body=#foobar#"},
+};
+
+TEST(URLParser, MailtoUrl) {
+ // Declared outside for loop to try to catch cases in init() where we forget
+ // to reset something that is reset by the construtor.
+ url_parse::Parsed parsed;
+ for (size_t i = 0; i < arraysize(mailto_cases); ++i) {
+ const char* url = mailto_cases[i].input;
+ url_parse::ParseMailtoURL(url, static_cast<int>(strlen(url)), &parsed);
+ int port = url_parse::ParsePort(url, parsed.port);
+
+ EXPECT_TRUE(ComponentMatches(url, mailto_cases[i].scheme, parsed.scheme));
+ EXPECT_TRUE(ComponentMatches(url, mailto_cases[i].path, parsed.path));
+ EXPECT_TRUE(ComponentMatches(url, mailto_cases[i].query, parsed.query));
+ EXPECT_EQ(url_parse::PORT_UNSPECIFIED, port);
+
+ // The remaining components are never used for mailto urls.
+ ExpectInvalidComponent(parsed.username);
+ ExpectInvalidComponent(parsed.password);
+ ExpectInvalidComponent(parsed.port);
+ ExpectInvalidComponent(parsed.ref);
+ }
+}
+
+// Various incarnations of filesystem URLs.
+static FileSystemURLParseCase filesystem_cases[] = {
+ // Regular URL with all the parts
+{"filesystem:http://user:pass@foo:21/temporary/bar;par?b#c", "http", "user", "pass", "foo", 21, "/temporary", "/bar;par", "b", "c"},
+{"filesystem:https://foo/persistent/bar;par/", "https", NULL, NULL, "foo", -1, "/persistent", "/bar;par/", NULL, NULL},
+{"filesystem:file:///persistent/bar;par/", "file", NULL, NULL, NULL, -1, "/persistent", "/bar;par/", NULL, NULL},
+{"filesystem:file:///persistent/bar;par/?query#ref", "file", NULL, NULL, NULL, -1, "/persistent", "/bar;par/", "query", "ref"},
+{"filesystem:file:///persistent", "file", NULL, NULL, NULL, -1, "/persistent", "", NULL, NULL},
+};
+
+TEST(URLParser, FileSystemURL) {
+ // Declared outside for loop to try to catch cases in init() where we forget
+ // to reset something that is reset by the construtor.
+ url_parse::Parsed parsed;
+ for (size_t i = 0; i < arraysize(filesystem_cases); i++) {
+ const FileSystemURLParseCase* parsecase = &filesystem_cases[i];
+ const char* url = parsecase->input;
+ url_parse::ParseFileSystemURL(url, static_cast<int>(strlen(url)), &parsed);
+
+ EXPECT_TRUE(ComponentMatches(url, "filesystem", parsed.scheme));
+ EXPECT_EQ(!parsecase->inner_scheme, !parsed.inner_parsed());
+ // Only check the inner_parsed if there is one.
+ if (parsed.inner_parsed()) {
+ EXPECT_TRUE(ComponentMatches(url, parsecase->inner_scheme,
+ parsed.inner_parsed()->scheme));
+ EXPECT_TRUE(ComponentMatches(url, parsecase->inner_username,
+ parsed.inner_parsed()->username));
+ EXPECT_TRUE(ComponentMatches(url, parsecase->inner_password,
+ parsed.inner_parsed()->password));
+ EXPECT_TRUE(ComponentMatches(url, parsecase->inner_host,
+ parsed.inner_parsed()->host));
+ int port = url_parse::ParsePort(url, parsed.inner_parsed()->port);
+ EXPECT_EQ(parsecase->inner_port, port);
+
+ // The remaining components are never used for filesystem urls.
+ ExpectInvalidComponent(parsed.inner_parsed()->query);
+ ExpectInvalidComponent(parsed.inner_parsed()->ref);
+ }
+
+ EXPECT_TRUE(ComponentMatches(url, parsecase->path, parsed.path));
+ EXPECT_TRUE(ComponentMatches(url, parsecase->query, parsed.query));
+ EXPECT_TRUE(ComponentMatches(url, parsecase->ref, parsed.ref));
+
+ // The remaining components are never used for filesystem urls.
+ ExpectInvalidComponent(parsed.username);
+ ExpectInvalidComponent(parsed.password);
+ ExpectInvalidComponent(parsed.host);
+ ExpectInvalidComponent(parsed.port);
+ }
+}
+
