1 // Copyright 2013 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.
5 #include "testing/gtest/include/gtest/gtest.h"
7 #include "url/url_canon.h"
8 #include "url/url_test_utils.h"
10 // Some implementations of base/basictypes.h may define ARRAYSIZE.
11 // If it's not defined, we define it to the ARRAYSIZE_UNSAFE macro
12 // which is in our version of basictypes.h.
14 #define ARRAYSIZE ARRAYSIZE_UNSAFE
17 using url_test_utils::WStringToUTF16;
18 using url_test_utils::ConvertUTF8ToUTF16;
22 template<typename CHAR>
23 void SetupReplacement(void (url_canon::Replacements<CHAR>::*func)(const CHAR*,
24 const url_parse::Component&),
25 url_canon::Replacements<CHAR>* replacements,
28 url_parse::Component comp;
30 comp.len = static_cast<int>(strlen(str));
31 (replacements->*func)(str, comp);
35 // Returns the canonicalized string for the given URL string for the
36 // GURLTest.Types test.
37 std::string TypesTestCase(const char* src) {
39 return gurl.possibly_invalid_spec();
44 // Different types of URLs should be handled differently by url_util, and
45 // handed off to different canonicalizers.
46 TEST(GURLTest, Types) {
47 // URLs with unknown schemes should be treated as path URLs, even when they
48 // have things like "://".
49 EXPECT_EQ("something:///HOSTNAME.com/",
50 TypesTestCase("something:///HOSTNAME.com/"));
52 // In the reverse, known schemes should always trigger standard URL handling.
53 EXPECT_EQ("http://hostname.com/", TypesTestCase("http:HOSTNAME.com"));
54 EXPECT_EQ("http://hostname.com/", TypesTestCase("http:/HOSTNAME.com"));
55 EXPECT_EQ("http://hostname.com/", TypesTestCase("http://HOSTNAME.com"));
56 EXPECT_EQ("http://hostname.com/", TypesTestCase("http:///HOSTNAME.com"));
59 // URLs that look like absolute Windows drive specs.
60 EXPECT_EQ("file:///C:/foo.txt", TypesTestCase("c:\\foo.txt"));
61 EXPECT_EQ("file:///Z:/foo.txt", TypesTestCase("Z|foo.txt"));
62 EXPECT_EQ("file://server/foo.txt", TypesTestCase("\\\\server\\foo.txt"));
63 EXPECT_EQ("file://server/foo.txt", TypesTestCase("//server/foo.txt"));
67 // Test the basic creation and querying of components in a GURL. We assume
68 // the parser is already tested and works, so we are mostly interested if the
69 // object does the right thing with the results.
70 TEST(GURLTest, Components) {
71 GURL url(WStringToUTF16(L"http://user:pass@google.com:99/foo;bar?q=a#ref"));
72 EXPECT_TRUE(url.is_valid());
73 EXPECT_TRUE(url.SchemeIs("http"));
74 EXPECT_FALSE(url.SchemeIsFile());
76 // This is the narrow version of the URL, which should match the wide input.
77 EXPECT_EQ("http://user:pass@google.com:99/foo;bar?q=a#ref", url.spec());
79 EXPECT_EQ("http", url.scheme());
80 EXPECT_EQ("user", url.username());
81 EXPECT_EQ("pass", url.password());
82 EXPECT_EQ("google.com", url.host());
83 EXPECT_EQ("99", url.port());
84 EXPECT_EQ(99, url.IntPort());
85 EXPECT_EQ("/foo;bar", url.path());
86 EXPECT_EQ("q=a", url.query());
87 EXPECT_EQ("ref", url.ref());
90 TEST(GURLTest, Empty) {
92 EXPECT_FALSE(url.is_valid());
93 EXPECT_EQ("", url.spec());
95 EXPECT_EQ("", url.scheme());
96 EXPECT_EQ("", url.username());
97 EXPECT_EQ("", url.password());
98 EXPECT_EQ("", url.host());
99 EXPECT_EQ("", url.port());
100 EXPECT_EQ(url_parse::PORT_UNSPECIFIED, url.IntPort());
101 EXPECT_EQ("", url.path());
102 EXPECT_EQ("", url.query());
103 EXPECT_EQ("", url.ref());
106 TEST(GURLTest, Copy) {
107 GURL url(WStringToUTF16(L"http://user:pass@google.com:99/foo;bar?q=a#ref"));
110 EXPECT_TRUE(url2.is_valid());
112 EXPECT_EQ("http://user:pass@google.com:99/foo;bar?q=a#ref", url2.spec());
113 EXPECT_EQ("http", url2.scheme());
114 EXPECT_EQ("user", url2.username());
115 EXPECT_EQ("pass", url2.password());
116 EXPECT_EQ("google.com", url2.host());
117 EXPECT_EQ("99", url2.port());
118 EXPECT_EQ(99, url2.IntPort());
119 EXPECT_EQ("/foo;bar", url2.path());
120 EXPECT_EQ("q=a", url2.query());
121 EXPECT_EQ("ref", url2.ref());
123 // Copying of invalid URL should be invalid
125 GURL invalid2(invalid);
126 EXPECT_FALSE(invalid2.is_valid());
127 EXPECT_EQ("", invalid2.spec());
128 EXPECT_EQ("", invalid2.scheme());
129 EXPECT_EQ("", invalid2.username());
130 EXPECT_EQ("", invalid2.password());
131 EXPECT_EQ("", invalid2.host());
132 EXPECT_EQ("", invalid2.port());
133 EXPECT_EQ(url_parse::PORT_UNSPECIFIED, invalid2.IntPort());
134 EXPECT_EQ("", invalid2.path());
135 EXPECT_EQ("", invalid2.query());
136 EXPECT_EQ("", invalid2.ref());
139 TEST(GURLTest, Assign) {
140 GURL url(WStringToUTF16(L"http://user:pass@google.com:99/foo;bar?q=a#ref"));
144 EXPECT_TRUE(url2.is_valid());
146 EXPECT_EQ("http://user:pass@google.com:99/foo;bar?q=a#ref", url2.spec());
147 EXPECT_EQ("http", url2.scheme());
148 EXPECT_EQ("user", url2.username());
149 EXPECT_EQ("pass", url2.password());
150 EXPECT_EQ("google.com", url2.host());
151 EXPECT_EQ("99", url2.port());
152 EXPECT_EQ(99, url2.IntPort());
153 EXPECT_EQ("/foo;bar", url2.path());
154 EXPECT_EQ("q=a", url2.query());
155 EXPECT_EQ("ref", url2.ref());
157 // Assignment of invalid URL should be invalid
161 EXPECT_FALSE(invalid2.is_valid());
162 EXPECT_EQ("", invalid2.spec());
163 EXPECT_EQ("", invalid2.scheme());
164 EXPECT_EQ("", invalid2.username());
165 EXPECT_EQ("", invalid2.password());
166 EXPECT_EQ("", invalid2.host());
167 EXPECT_EQ("", invalid2.port());
168 EXPECT_EQ(url_parse::PORT_UNSPECIFIED, invalid2.IntPort());
169 EXPECT_EQ("", invalid2.path());
170 EXPECT_EQ("", invalid2.query());
171 EXPECT_EQ("", invalid2.ref());
174 // This is a regression test for http://crbug.com/309975 .
175 TEST(GURLTest, SelfAssign) {
176 GURL a("filesystem:http://example.com/temporary/");
177 // This should not crash.
181 TEST(GURLTest, CopyFileSystem) {
182 GURL url(WStringToUTF16(L"filesystem:https://user:pass@google.com:99/t/foo;bar?q=a#ref"));
185 EXPECT_TRUE(url2.is_valid());
187 EXPECT_EQ("filesystem:https://user:pass@google.com:99/t/foo;bar?q=a#ref", url2.spec());
188 EXPECT_EQ("filesystem", url2.scheme());
189 EXPECT_EQ("", url2.username());
190 EXPECT_EQ("", url2.password());
191 EXPECT_EQ("", url2.host());
192 EXPECT_EQ("", url2.port());
193 EXPECT_EQ(url_parse::PORT_UNSPECIFIED, url2.IntPort());
194 EXPECT_EQ("/foo;bar", url2.path());
195 EXPECT_EQ("q=a", url2.query());
196 EXPECT_EQ("ref", url2.ref());
198 const GURL* inner = url2.inner_url();
200 EXPECT_EQ("https", inner->scheme());
201 EXPECT_EQ("user", inner->username());
202 EXPECT_EQ("pass", inner->password());
203 EXPECT_EQ("google.com", inner->host());
204 EXPECT_EQ("99", inner->port());
205 EXPECT_EQ(99, inner->IntPort());
206 EXPECT_EQ("/t", inner->path());
207 EXPECT_EQ("", inner->query());
208 EXPECT_EQ("", inner->ref());
211 // Given an invalid URL, we should still get most of the components.
212 TEST(GURLTest, Invalid) {
213 GURL url("http:google.com:foo");
214 EXPECT_FALSE(url.is_valid());
215 EXPECT_EQ("http://google.com:foo/", url.possibly_invalid_spec());
217 EXPECT_EQ("http", url.scheme());
218 EXPECT_EQ("", url.username());
219 EXPECT_EQ("", url.password());
220 EXPECT_EQ("google.com", url.host());
221 EXPECT_EQ("foo", url.port());
222 EXPECT_EQ(url_parse::PORT_INVALID, url.IntPort());
223 EXPECT_EQ("/", url.path());
224 EXPECT_EQ("", url.query());
225 EXPECT_EQ("", url.ref());
228 TEST(GURLTest, Resolve) {
229 // The tricky cases for relative URL resolving are tested in the
230 // canonicalizer unit test. Here, we just test that the GURL integration
234 const char* relative;
236 const char* expected;
237 } resolve_cases[] = {
238 {"http://www.google.com/", "foo.html", true, "http://www.google.com/foo.html"},
239 {"http://www.google.com/", "http://images.google.com/foo.html", true, "http://images.google.com/foo.html"},
240 {"http://www.google.com/blah/bloo?c#d", "../../../hello/./world.html?a#b", true, "http://www.google.com/hello/world.html?a#b"},
241 {"http://www.google.com/foo#bar", "#com", true, "http://www.google.com/foo#com"},
242 {"http://www.google.com/", "Https:images.google.com", true, "https://images.google.com/"},
243 // A non-standard base can be replaced with a standard absolute URL.
244 {"data:blahblah", "http://google.com/", true, "http://google.com/"},
245 {"data:blahblah", "http:google.com", true, "http://google.com/"},
246 // Filesystem URLs have different paths to test.
247 {"filesystem:http://www.google.com/type/", "foo.html", true, "filesystem:http://www.google.com/type/foo.html"},
248 {"filesystem:http://www.google.com/type/", "../foo.html", true, "filesystem:http://www.google.com/type/foo.html"},
251 for (size_t i = 0; i < ARRAYSIZE(resolve_cases); i++) {
253 GURL input(resolve_cases[i].base);
254 GURL output = input.Resolve(resolve_cases[i].relative);
255 EXPECT_EQ(resolve_cases[i].expected_valid, output.is_valid()) << i;
256 EXPECT_EQ(resolve_cases[i].expected, output.spec()) << i;
257 EXPECT_EQ(output.SchemeIsFileSystem(), output.inner_url() != NULL);
260 GURL inputw(ConvertUTF8ToUTF16(resolve_cases[i].base));
262 input.Resolve(ConvertUTF8ToUTF16(resolve_cases[i].relative));
263 EXPECT_EQ(resolve_cases[i].expected_valid, outputw.is_valid()) << i;
264 EXPECT_EQ(resolve_cases[i].expected, outputw.spec()) << i;
265 EXPECT_EQ(outputw.SchemeIsFileSystem(), outputw.inner_url() != NULL);
269 TEST(GURLTest, GetOrigin) {
272 const char* expected;
274 {"http://www.google.com", "http://www.google.com/"},
275 {"javascript:window.alert(\"hello,world\");", ""},
276 {"http://user:pass@www.google.com:21/blah#baz", "http://www.google.com:21/"},
277 {"http://user@www.google.com", "http://www.google.com/"},
278 {"http://:pass@www.google.com", "http://www.google.com/"},
279 {"http://:@www.google.com", "http://www.google.com/"},
280 {"filesystem:http://www.google.com/temp/foo?q#b", "http://www.google.com/"},
281 {"filesystem:http://user:pass@google.com:21/blah#baz", "http://google.com:21/"},
283 for (size_t i = 0; i < ARRAYSIZE(cases); i++) {
284 GURL url(cases[i].input);
285 GURL origin = url.GetOrigin();
286 EXPECT_EQ(cases[i].expected, origin.spec());
290 TEST(GURLTest, GetWithEmptyPath) {
293 const char* expected;
295 {"http://www.google.com", "http://www.google.com/"},
296 {"javascript:window.alert(\"hello, world\");", ""},
297 {"http://www.google.com/foo/bar.html?baz=22", "http://www.google.com/"},
298 {"filesystem:http://www.google.com/temporary/bar.html?baz=22", "filesystem:http://www.google.com/temporary/"},
299 {"filesystem:file:///temporary/bar.html?baz=22", "filesystem:file:///temporary/"},
302 for (size_t i = 0; i < ARRAYSIZE(cases); i++) {
303 GURL url(cases[i].input);
304 GURL empty_path = url.GetWithEmptyPath();
305 EXPECT_EQ(cases[i].expected, empty_path.spec());
309 TEST(GURLTest, Replacements) {
310 // The url canonicalizer replacement test will handle most of these case.
311 // The most important thing to do here is to check that the proper
312 // canonicalizer gets called based on the scheme of the input.
316 const char* username;
317 const char* password;
323 const char* expected;
324 } replace_cases[] = {
325 {"http://www.google.com/foo/bar.html?foo#bar", NULL, NULL, NULL, NULL, NULL, "/", "", "", "http://www.google.com/"},
326 {"http://www.google.com/foo/bar.html?foo#bar", "javascript", "", "", "", "", "window.open('foo');", "", "", "javascript:window.open('foo');"},
327 {"file:///C:/foo/bar.txt", "http", NULL, NULL, "www.google.com", "99", "/foo","search", "ref", "http://www.google.com:99/foo?search#ref"},
329 {"http://www.google.com/foo/bar.html?foo#bar", "file", "", "", "", "", "c:\\", "", "", "file:///C:/"},
331 {"filesystem:http://www.google.com/foo/bar.html?foo#bar", NULL, NULL, NULL, NULL, NULL, "/", "", "", "filesystem:http://www.google.com/foo/"},
334 for (size_t i = 0; i < ARRAYSIZE(replace_cases); i++) {
335 const ReplaceCase& cur = replace_cases[i];
337 GURL::Replacements repl;
338 SetupReplacement(&GURL::Replacements::SetScheme, &repl, cur.scheme);
339 SetupReplacement(&GURL::Replacements::SetUsername, &repl, cur.username);
340 SetupReplacement(&GURL::Replacements::SetPassword, &repl, cur.password);
341 SetupReplacement(&GURL::Replacements::SetHost, &repl, cur.host);
342 SetupReplacement(&GURL::Replacements::SetPort, &repl, cur.port);
343 SetupReplacement(&GURL::Replacements::SetPath, &repl, cur.path);
344 SetupReplacement(&GURL::Replacements::SetQuery, &repl, cur.query);
345 SetupReplacement(&GURL::Replacements::SetRef, &repl, cur.ref);
346 GURL output = url.ReplaceComponents(repl);
348 EXPECT_EQ(replace_cases[i].expected, output.spec());
349 EXPECT_EQ(output.SchemeIsFileSystem(), output.inner_url() != NULL);
353 TEST(GURLTest, PathForRequest) {
356 const char* expected;
357 const char* inner_expected;
359 {"http://www.google.com", "/", NULL},
360 {"http://www.google.com/", "/", NULL},
361 {"http://www.google.com/foo/bar.html?baz=22", "/foo/bar.html?baz=22", NULL},
362 {"http://www.google.com/foo/bar.html#ref", "/foo/bar.html", NULL},
363 {"http://www.google.com/foo/bar.html?query#ref", "/foo/bar.html?query", NULL},
364 {"filesystem:http://www.google.com/temporary/foo/bar.html?query#ref", "/foo/bar.html?query", "/temporary"},
365 {"filesystem:http://www.google.com/temporary/foo/bar.html?query", "/foo/bar.html?query", "/temporary"},
368 for (size_t i = 0; i < ARRAYSIZE(cases); i++) {
369 GURL url(cases[i].input);
370 std::string path_request = url.PathForRequest();
371 EXPECT_EQ(cases[i].expected, path_request);
372 EXPECT_EQ(cases[i].inner_expected == NULL, url.inner_url() == NULL);
373 if (url.inner_url() && cases[i].inner_expected)
374 EXPECT_EQ(cases[i].inner_expected, url.inner_url()->PathForRequest());
378 TEST(GURLTest, EffectiveIntPort) {
381 int expected_int_port;
384 {"http://www.google.com/", 80},
385 {"http://www.google.com:80/", 80},
386 {"http://www.google.com:443/", 443},
389 {"https://www.google.com/", 443},
390 {"https://www.google.com:443/", 443},
391 {"https://www.google.com:80/", 80},
394 {"ftp://www.google.com/", 21},
395 {"ftp://www.google.com:21/", 21},
396 {"ftp://www.google.com:80/", 80},
399 {"gopher://www.google.com/", 70},
400 {"gopher://www.google.com:70/", 70},
401 {"gopher://www.google.com:80/", 80},
404 {"file://www.google.com/", url_parse::PORT_UNSPECIFIED},
405 {"file://www.google.com:443/", url_parse::PORT_UNSPECIFIED},
408 {"data:www.google.com:90", url_parse::PORT_UNSPECIFIED},
409 {"data:www.google.com", url_parse::PORT_UNSPECIFIED},
411 // filesystem - no port
412 {"filesystem:http://www.google.com:90/t/foo", url_parse::PORT_UNSPECIFIED},
413 {"filesystem:file:///t/foo", url_parse::PORT_UNSPECIFIED},
416 for (size_t i = 0; i < ARRAYSIZE(port_tests); i++) {
417 GURL url(port_tests[i].spec);
418 EXPECT_EQ(port_tests[i].expected_int_port, url.EffectiveIntPort());
422 TEST(GURLTest, IPAddress) {
427 {"http://www.google.com/", false},
428 {"http://192.168.9.1/", true},
429 {"http://192.168.9.1.2/", false},
430 {"http://192.168.m.1/", false},
431 {"http://2001:db8::1/", false},
432 {"http://[2001:db8::1]/", true},
434 {"some random input!", false},
437 for (size_t i = 0; i < ARRAYSIZE(ip_tests); i++) {
438 GURL url(ip_tests[i].spec);
439 EXPECT_EQ(ip_tests[i].expected_ip, url.HostIsIPAddress());
443 TEST(GURLTest, HostNoBrackets) {
446 const char* expected_host;
447 const char* expected_plainhost;
449 {"http://www.google.com", "www.google.com", "www.google.com"},
450 {"http://[2001:db8::1]/", "[2001:db8::1]", "2001:db8::1"},
451 {"http://[::]/", "[::]", "::"},
453 // Don't require a valid URL, but don't crash either.
454 {"http://[]/", "[]", ""},
455 {"http://[x]/", "[x]", "x"},
456 {"http://[x/", "[x", "[x"},
457 {"http://x]/", "x]", "x]"},
458 {"http://[/", "[", "["},
459 {"http://]/", "]", "]"},
462 for (size_t i = 0; i < ARRAYSIZE(cases); i++) {
463 GURL url(cases[i].input);
464 EXPECT_EQ(cases[i].expected_host, url.host());
465 EXPECT_EQ(cases[i].expected_plainhost, url.HostNoBrackets());
469 TEST(GURLTest, DomainIs) {
470 const char google_domain[] = "google.com";
472 GURL url_1("http://www.google.com:99/foo");
473 EXPECT_TRUE(url_1.DomainIs(google_domain));
475 GURL url_2("http://google.com:99/foo");
476 EXPECT_TRUE(url_2.DomainIs(google_domain));
478 GURL url_3("http://google.com./foo");
479 EXPECT_TRUE(url_3.DomainIs(google_domain));
481 GURL url_4("http://google.com/foo");
482 EXPECT_FALSE(url_4.DomainIs("google.com."));
484 GURL url_5("http://google.com./foo");
485 EXPECT_TRUE(url_5.DomainIs("google.com."));
487 GURL url_6("http://www.google.com./foo");
488 EXPECT_TRUE(url_6.DomainIs(".com."));
490 GURL url_7("http://www.balabala.com/foo");
491 EXPECT_FALSE(url_7.DomainIs(google_domain));
493 GURL url_8("http://www.google.com.cn/foo");
494 EXPECT_FALSE(url_8.DomainIs(google_domain));
496 GURL url_9("http://www.iamnotgoogle.com/foo");
497 EXPECT_FALSE(url_9.DomainIs(google_domain));
499 GURL url_10("http://www.iamnotgoogle.com../foo");
500 EXPECT_FALSE(url_10.DomainIs(".com"));
502 GURL url_11("filesystem:http://www.google.com:99/foo/");
503 EXPECT_TRUE(url_11.DomainIs(google_domain));
505 GURL url_12("filesystem:http://www.iamnotgoogle.com/foo/");
506 EXPECT_FALSE(url_12.DomainIs(google_domain));
509 // Newlines should be stripped from inputs.
510 TEST(GURLTest, Newlines) {
512 GURL url_1(" \t ht\ntp://\twww.goo\rgle.com/as\ndf \n ");
513 EXPECT_EQ("http://www.google.com/asdf", url_1.spec());
515 // Relative path resolver.
516 GURL url_2 = url_1.Resolve(" \n /fo\to\r ");
517 EXPECT_EQ("http://www.google.com/foo", url_2.spec());
519 // Note that newlines are NOT stripped from ReplaceComponents.
522 TEST(GURLTest, IsStandard) {
523 GURL a("http:foo/bar");
524 EXPECT_TRUE(a.IsStandard());
526 GURL b("foo:bar/baz");
527 EXPECT_FALSE(b.IsStandard());
529 GURL c("foo://bar/baz");
530 EXPECT_FALSE(c.IsStandard());