gurl_unittest.cc revision f2477e01787aa58f445919b809d89e252beef54f
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. 4 5#include "testing/gtest/include/gtest/gtest.h" 6#include "url/gurl.h" 7#include "url/url_canon.h" 8#include "url/url_test_utils.h" 9 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. 13#ifndef ARRAYSIZE 14#define ARRAYSIZE ARRAYSIZE_UNSAFE 15#endif 16 17using url_test_utils::WStringToUTF16; 18using url_test_utils::ConvertUTF8ToUTF16; 19 20namespace { 21 22template<typename CHAR> 23void SetupReplacement(void (url_canon::Replacements<CHAR>::*func)(const CHAR*, 24 const url_parse::Component&), 25 url_canon::Replacements<CHAR>* replacements, 26 const CHAR* str) { 27 if (str) { 28 url_parse::Component comp; 29 if (str[0]) 30 comp.len = static_cast<int>(strlen(str)); 31 (replacements->*func)(str, comp); 32 } 33} 34 35// Returns the canonicalized string for the given URL string for the 36// GURLTest.Types test. 37std::string TypesTestCase(const char* src) { 38 GURL gurl(src); 39 return gurl.possibly_invalid_spec(); 40} 41 42} // namespace 43 44// Different types of URLs should be handled differently by url_util, and 45// handed off to different canonicalizers. 46TEST(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/")); 51 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")); 57 58#ifdef WIN32 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")); 64#endif 65} 66 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. 70TEST(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()); 75 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()); 78 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()); 88} 89 90TEST(GURLTest, Empty) { 91 GURL url; 92 EXPECT_FALSE(url.is_valid()); 93 EXPECT_EQ("", url.spec()); 94 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()); 104} 105 106TEST(GURLTest, Copy) { 107 GURL url(WStringToUTF16(L"http://user:pass@google.com:99/foo;bar?q=a#ref")); 108 109 GURL url2(url); 110 EXPECT_TRUE(url2.is_valid()); 111 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()); 122 123 // Copying of invalid URL should be invalid 124 GURL 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()); 137} 138 139TEST(GURLTest, Assign) { 140 GURL url(WStringToUTF16(L"http://user:pass@google.com:99/foo;bar?q=a#ref")); 141 142 GURL url2; 143 url2 = url; 144 EXPECT_TRUE(url2.is_valid()); 145 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()); 156 157 // Assignment of invalid URL should be invalid 158 GURL invalid; 159 GURL invalid2; 160 invalid2 = 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()); 172} 173 174// This is a regression test for http://crbug.com/309975 . 175TEST(GURLTest, SelfAssign) { 176 GURL a("filesystem:http://example.com/temporary/"); 177 // This should not crash. 178 a = a; 179} 180 181TEST(GURLTest, CopyFileSystem) { 182 GURL url(WStringToUTF16(L"filesystem:https://user:pass@google.com:99/t/foo;bar?q=a#ref")); 183 184 GURL url2(url); 185 EXPECT_TRUE(url2.is_valid()); 186 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()); 197 198 const GURL* inner = url2.inner_url(); 199 ASSERT_TRUE(inner); 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()); 209} 210 211// Given an invalid URL, we should still get most of the components. 212TEST(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()); 216 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()); 226} 227 228TEST(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 231 // works properly. 232 struct ResolveCase { 233 const char* base; 234 const char* relative; 235 bool expected_valid; 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"}, 249 }; 250 251 for (size_t i = 0; i < ARRAYSIZE(resolve_cases); i++) { 252 // 8-bit code path. 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); 258 259 // Wide code path. 260 GURL inputw(ConvertUTF8ToUTF16(resolve_cases[i].base)); 261 GURL outputw = 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); 266 } 267} 268 269TEST(GURLTest, GetOrigin) { 270 struct TestCase { 271 const char* input; 272 const char* expected; 273 } cases[] = { 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/"}, 282 }; 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()); 287 } 288} 289 290TEST(GURLTest, GetWithEmptyPath) { 291 struct TestCase { 292 const char* input; 293 const char* expected; 294 } cases[] = { 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/"}, 300 }; 301 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()); 306 } 307} 308 309TEST(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. 313 struct ReplaceCase { 314 const char* base; 315 const char* scheme; 316 const char* username; 317 const char* password; 318 const char* host; 319 const char* port; 320 const char* path; 321 const char* query; 322 const char* ref; 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"}, 328#ifdef WIN32 329 {"http://www.google.com/foo/bar.html?foo#bar", "file", "", "", "", "", "c:\\", "", "", "file:///C:/"}, 330#endif 331 {"filesystem:http://www.google.com/foo/bar.html?foo#bar", NULL, NULL, NULL, NULL, NULL, "/", "", "", "filesystem:http://www.google.com/foo/"}, 332 }; 333 334 for (size_t i = 0; i < ARRAYSIZE(replace_cases); i++) { 335 const ReplaceCase& cur = replace_cases[i]; 336 GURL url(cur.base); 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); 347 348 EXPECT_EQ(replace_cases[i].expected, output.spec()); 349 EXPECT_EQ(output.SchemeIsFileSystem(), output.inner_url() != NULL); 350 } 351} 352 353TEST(GURLTest, ClearFragmentOnDataUrl) { 354 // http://crbug.com/291747 - a data URL may legitimately have trailing 355 // whitespace in the spec after the ref is cleared. Test this does not trigger 356 // the url_parse::Parsed importing validation DCHECK in GURL. 357 GURL url(" data: one ? two # three "); 358 359 // By default the trailing whitespace will have been stripped. 360 EXPECT_EQ("data: one ? two # three", url.spec()); 361 GURL::Replacements repl; 362 repl.ClearRef(); 363 GURL url_no_ref = url.ReplaceComponents(repl); 364 365 EXPECT_EQ("data: one ? two ", url_no_ref.spec()); 366 367 // Importing a parsed url via this constructor overload will retain trailing 368 // whitespace. 369 GURL import_url(url_no_ref.spec(), 370 url_no_ref.parsed_for_possibly_invalid_spec(), 371 url_no_ref.is_valid()); 372 EXPECT_EQ(url_no_ref, import_url); 373 EXPECT_EQ(import_url.query(), " two "); 374} 375 376TEST(GURLTest, PathForRequest) { 377 struct TestCase { 378 const char* input; 379 const char* expected; 380 const char* inner_expected; 381 } cases[] = { 382 {"http://www.google.com", "/", NULL}, 383 {"http://www.google.com/", "/", NULL}, 384 {"http://www.google.com/foo/bar.html?baz=22", "/foo/bar.html?baz=22", NULL}, 385 {"http://www.google.com/foo/bar.html#ref", "/foo/bar.html", NULL}, 386 {"http://www.google.com/foo/bar.html?query#ref", "/foo/bar.html?query", NULL}, 387 {"filesystem:http://www.google.com/temporary/foo/bar.html?query#ref", "/foo/bar.html?query", "/temporary"}, 388 {"filesystem:http://www.google.com/temporary/foo/bar.html?query", "/foo/bar.html?query", "/temporary"}, 389 }; 390 391 for (size_t i = 0; i < ARRAYSIZE(cases); i++) { 392 GURL url(cases[i].input); 393 std::string path_request = url.PathForRequest(); 394 EXPECT_EQ(cases[i].expected, path_request); 395 EXPECT_EQ(cases[i].inner_expected == NULL, url.inner_url() == NULL); 396 if (url.inner_url() && cases[i].inner_expected) 397 EXPECT_EQ(cases[i].inner_expected, url.inner_url()->PathForRequest()); 398 } 399} 400 401TEST(GURLTest, EffectiveIntPort) { 402 struct PortTest { 403 const char* spec; 404 int expected_int_port; 405 } port_tests[] = { 406 // http 407 {"http://www.google.com/", 80}, 408 {"http://www.google.com:80/", 80}, 409 {"http://www.google.com:443/", 443}, 410 411 // https 412 {"https://www.google.com/", 443}, 413 {"https://www.google.com:443/", 443}, 414 {"https://www.google.com:80/", 80}, 415 416 // ftp 417 {"ftp://www.google.com/", 21}, 418 {"ftp://www.google.com:21/", 21}, 419 {"ftp://www.google.com:80/", 80}, 420 421 // gopher 422 {"gopher://www.google.com/", 70}, 423 {"gopher://www.google.com:70/", 70}, 424 {"gopher://www.google.com:80/", 80}, 425 426 // file - no port 427 {"file://www.google.com/", url_parse::PORT_UNSPECIFIED}, 428 {"file://www.google.com:443/", url_parse::PORT_UNSPECIFIED}, 429 430 // data - no port 431 {"data:www.google.com:90", url_parse::PORT_UNSPECIFIED}, 432 {"data:www.google.com", url_parse::PORT_UNSPECIFIED}, 433 434 // filesystem - no port 435 {"filesystem:http://www.google.com:90/t/foo", url_parse::PORT_UNSPECIFIED}, 436 {"filesystem:file:///t/foo", url_parse::PORT_UNSPECIFIED}, 437 }; 438 439 for (size_t i = 0; i < ARRAYSIZE(port_tests); i++) { 440 GURL url(port_tests[i].spec); 441 EXPECT_EQ(port_tests[i].expected_int_port, url.EffectiveIntPort()); 442 } 443} 444 445TEST(GURLTest, IPAddress) { 446 struct IPTest { 447 const char* spec; 448 bool expected_ip; 449 } ip_tests[] = { 450 {"http://www.google.com/", false}, 451 {"http://192.168.9.1/", true}, 452 {"http://192.168.9.1.2/", false}, 453 {"http://192.168.m.1/", false}, 454 {"http://2001:db8::1/", false}, 455 {"http://[2001:db8::1]/", true}, 456 {"", false}, 457 {"some random input!", false}, 458 }; 459 460 for (size_t i = 0; i < ARRAYSIZE(ip_tests); i++) { 461 GURL url(ip_tests[i].spec); 462 EXPECT_EQ(ip_tests[i].expected_ip, url.HostIsIPAddress()); 463 } 464} 465 466TEST(GURLTest, HostNoBrackets) { 467 struct TestCase { 468 const char* input; 469 const char* expected_host; 470 const char* expected_plainhost; 471 } cases[] = { 472 {"http://www.google.com", "www.google.com", "www.google.com"}, 473 {"http://[2001:db8::1]/", "[2001:db8::1]", "2001:db8::1"}, 474 {"http://[::]/", "[::]", "::"}, 475 476 // Don't require a valid URL, but don't crash either. 477 {"http://[]/", "[]", ""}, 478 {"http://[x]/", "[x]", "x"}, 479 {"http://[x/", "[x", "[x"}, 480 {"http://x]/", "x]", "x]"}, 481 {"http://[/", "[", "["}, 482 {"http://]/", "]", "]"}, 483 {"", "", ""}, 484 }; 485 for (size_t i = 0; i < ARRAYSIZE(cases); i++) { 486 GURL url(cases[i].input); 487 EXPECT_EQ(cases[i].expected_host, url.host()); 488 EXPECT_EQ(cases[i].expected_plainhost, url.HostNoBrackets()); 489 } 490} 491 492TEST(GURLTest, DomainIs) { 493 const char google_domain[] = "google.com"; 494 495 GURL url_1("http://www.google.com:99/foo"); 496 EXPECT_TRUE(url_1.DomainIs(google_domain)); 497 498 GURL url_2("http://google.com:99/foo"); 499 EXPECT_TRUE(url_2.DomainIs(google_domain)); 500 501 GURL url_3("http://google.com./foo"); 502 EXPECT_TRUE(url_3.DomainIs(google_domain)); 503 504 GURL url_4("http://google.com/foo"); 505 EXPECT_FALSE(url_4.DomainIs("google.com.")); 506 507 GURL url_5("http://google.com./foo"); 508 EXPECT_TRUE(url_5.DomainIs("google.com.")); 509 510 GURL url_6("http://www.google.com./foo"); 511 EXPECT_TRUE(url_6.DomainIs(".com.")); 512 513 GURL url_7("http://www.balabala.com/foo"); 514 EXPECT_FALSE(url_7.DomainIs(google_domain)); 515 516 GURL url_8("http://www.google.com.cn/foo"); 517 EXPECT_FALSE(url_8.DomainIs(google_domain)); 518 519 GURL url_9("http://www.iamnotgoogle.com/foo"); 520 EXPECT_FALSE(url_9.DomainIs(google_domain)); 521 522 GURL url_10("http://www.iamnotgoogle.com../foo"); 523 EXPECT_FALSE(url_10.DomainIs(".com")); 524 525 GURL url_11("filesystem:http://www.google.com:99/foo/"); 526 EXPECT_TRUE(url_11.DomainIs(google_domain)); 527 528 GURL url_12("filesystem:http://www.iamnotgoogle.com/foo/"); 529 EXPECT_FALSE(url_12.DomainIs(google_domain)); 530} 531 532// Newlines should be stripped from inputs. 533TEST(GURLTest, Newlines) { 534 // Constructor. 535 GURL url_1(" \t ht\ntp://\twww.goo\rgle.com/as\ndf \n "); 536 EXPECT_EQ("http://www.google.com/asdf", url_1.spec()); 537 538 // Relative path resolver. 539 GURL url_2 = url_1.Resolve(" \n /fo\to\r "); 540 EXPECT_EQ("http://www.google.com/foo", url_2.spec()); 541 542 // Note that newlines are NOT stripped from ReplaceComponents. 543} 544 545TEST(GURLTest, IsStandard) { 546 GURL a("http:foo/bar"); 547 EXPECT_TRUE(a.IsStandard()); 548 549 GURL b("foo:bar/baz"); 550 EXPECT_FALSE(b.IsStandard()); 551 552 GURL c("foo://bar/baz"); 553 EXPECT_FALSE(c.IsStandard()); 554} 555 556TEST(GURLTest, SchemeIsHTTPOrHTTPS) { 557 EXPECT_TRUE(GURL("http://bar/").SchemeIsHTTPOrHTTPS()); 558 EXPECT_TRUE(GURL("HTTPS://BAR").SchemeIsHTTPOrHTTPS()); 559 EXPECT_FALSE(GURL("ftp://bar/").SchemeIsHTTPOrHTTPS()); 560} 561 562TEST(GURLTest, SchemeIsWSOrWSS) { 563 EXPECT_TRUE(GURL("WS://BAR/").SchemeIsWSOrWSS()); 564 EXPECT_TRUE(GURL("wss://bar/").SchemeIsWSOrWSS()); 565 EXPECT_FALSE(GURL("http://bar/").SchemeIsWSOrWSS()); 566} 567