url/gurl_unittest.cc

   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
  17 using url_test_utils::WStringToUTF16;
  18 using url_test_utils::ConvertUTF8ToUTF16;
  19
  20 namespace {
  21
  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,
  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.
  37 std::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.
  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/"));
  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.
  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());
  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
  90 TEST(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
 106 TEST(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
 139 TEST(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 .
 175 TEST(GURLTest, SelfAssign) {
 176   GURL a("filesystem:http://example.com/temporary/");
 177   // This should not crash.
 178   a = a;
 179 }
 180
 181 TEST(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.
 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());
 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
 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
 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
 269 TEST(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
 290 TEST(GURLTest, GetAsReferrer) {
 291   struct TestCase {
 292     const char* input;
 293     const char* expected;
 294   } cases[] = {
 295     {"http://www.google.com", "http://www.google.com/"},
 296     {"http://user:pass@www.google.com:21/blah#baz", "http://www.google.com:21/blah"},
 297     {"http://user@www.google.com", "http://www.google.com/"},
 298     {"http://:pass@www.google.com", "http://www.google.com/"},
 299     {"http://:@www.google.com", "http://www.google.com/"},
 300     {"http://www.google.com/temp/foo?q#b", "http://www.google.com/temp/foo?q"},
 301   };
 302   for (size_t i = 0; i < ARRAYSIZE(cases); i++) {
 303     GURL url(cases[i].input);
 304     GURL origin = url.GetAsReferrer();
 305     EXPECT_EQ(cases[i].expected, origin.spec());
 306   }
 307 }
 308
 309 TEST(GURLTest, GetWithEmptyPath) {
 310   struct TestCase {
 311     const char* input;
 312     const char* expected;
 313   } cases[] = {
 314     {"http://www.google.com", "http://www.google.com/"},
 315     {"javascript:window.alert(\"hello, world\");", ""},
 316     {"http://www.google.com/foo/bar.html?baz=22", "http://www.google.com/"},
 317     {"filesystem:http://www.google.com/temporary/bar.html?baz=22", "filesystem:http://www.google.com/temporary/"},
 318     {"filesystem:file:///temporary/bar.html?baz=22", "filesystem:file:///temporary/"},
 319   };
 320
 321   for (size_t i = 0; i < ARRAYSIZE(cases); i++) {
 322     GURL url(cases[i].input);
 323     GURL empty_path = url.GetWithEmptyPath();
 324     EXPECT_EQ(cases[i].expected, empty_path.spec());
 325   }
 326 }
 327
 328 TEST(GURLTest, Replacements) {
 329   // The url canonicalizer replacement test will handle most of these case.
 330   // The most important thing to do here is to check that the proper
 331   // canonicalizer gets called based on the scheme of the input.
 332   struct ReplaceCase {
 333     const char* base;
 334     const char* scheme;
 335     const char* username;
 336     const char* password;
 337     const char* host;
 338     const char* port;
 339     const char* path;
 340     const char* query;
 341     const char* ref;
 342     const char* expected;
 343   } replace_cases[] = {
 344     {"http://www.google.com/foo/bar.html?foo#bar", NULL, NULL, NULL, NULL, NULL, "/", "", "", "http://www.google.com/"},
 345     {"http://www.google.com/foo/bar.html?foo#bar", "javascript", "", "", "", "", "window.open('foo');", "", "", "javascript:window.open('foo');"},
 346     {"file:///C:/foo/bar.txt", "http", NULL, NULL, "www.google.com", "99", "/foo","search", "ref", "http://www.google.com:99/foo?search#ref"},
 347 #ifdef WIN32
 348     {"http://www.google.com/foo/bar.html?foo#bar", "file", "", "", "", "", "c:\\", "", "", "file:///C:/"},
 349 #endif
 350     {"filesystem:http://www.google.com/foo/bar.html?foo#bar", NULL, NULL, NULL, NULL, NULL, "/", "", "", "filesystem:http://www.google.com/foo/"},
 351   };
 352
 353   for (size_t i = 0; i < ARRAYSIZE(replace_cases); i++) {
 354     const ReplaceCase& cur = replace_cases[i];
 355     GURL url(cur.base);
 356     GURL::Replacements repl;
 357     SetupReplacement(&GURL::Replacements::SetScheme, &repl, cur.scheme);
 358     SetupReplacement(&GURL::Replacements::SetUsername, &repl, cur.username);
 359     SetupReplacement(&GURL::Replacements::SetPassword, &repl, cur.password);
 360     SetupReplacement(&GURL::Replacements::SetHost, &repl, cur.host);
 361     SetupReplacement(&GURL::Replacements::SetPort, &repl, cur.port);
 362     SetupReplacement(&GURL::Replacements::SetPath, &repl, cur.path);
 363     SetupReplacement(&GURL::Replacements::SetQuery, &repl, cur.query);
 364     SetupReplacement(&GURL::Replacements::SetRef, &repl, cur.ref);
 365     GURL output = url.ReplaceComponents(repl);
 366
 367     EXPECT_EQ(replace_cases[i].expected, output.spec());
 368     EXPECT_EQ(output.SchemeIsFileSystem(), output.inner_url() != NULL);
 369   }
 370 }
 371
 372 TEST(GURLTest, ClearFragmentOnDataUrl) {
 373   // http://crbug.com/291747 - a data URL may legitimately have trailing
 374   // whitespace in the spec after the ref is cleared. Test this does not trigger
 375   // the url_parse::Parsed importing validation DCHECK in GURL.
 376   GURL url(" data: one ? two # three ");
 377
 378   // By default the trailing whitespace will have been stripped.
 379   EXPECT_EQ("data: one ? two # three", url.spec());
 380   GURL::Replacements repl;
 381   repl.ClearRef();
 382   GURL url_no_ref = url.ReplaceComponents(repl);
 383
 384   EXPECT_EQ("data: one ? two ", url_no_ref.spec());
 385
 386   // Importing a parsed url via this constructor overload will retain trailing
 387   // whitespace.
 388   GURL import_url(url_no_ref.spec(),
 389                   url_no_ref.parsed_for_possibly_invalid_spec(),
 390                   url_no_ref.is_valid());
 391   EXPECT_EQ(url_no_ref, import_url);
 392   EXPECT_EQ(import_url.query(), " two ");
 393 }
 394
 395 TEST(GURLTest, PathForRequest) {
 396   struct TestCase {
 397     const char* input;
 398     const char* expected;
 399     const char* inner_expected;
 400   } cases[] = {
 401     {"http://www.google.com", "/", NULL},
 402     {"http://www.google.com/", "/", NULL},
 403     {"http://www.google.com/foo/bar.html?baz=22", "/foo/bar.html?baz=22", NULL},
 404     {"http://www.google.com/foo/bar.html#ref", "/foo/bar.html", NULL},
 405     {"http://www.google.com/foo/bar.html?query#ref", "/foo/bar.html?query", NULL},
 406     {"filesystem:http://www.google.com/temporary/foo/bar.html?query#ref", "/foo/bar.html?query", "/temporary"},
 407     {"filesystem:http://www.google.com/temporary/foo/bar.html?query", "/foo/bar.html?query", "/temporary"},
 408   };
 409
 410   for (size_t i = 0; i < ARRAYSIZE(cases); i++) {
 411     GURL url(cases[i].input);
 412     std::string path_request = url.PathForRequest();
 413     EXPECT_EQ(cases[i].expected, path_request);
 414     EXPECT_EQ(cases[i].inner_expected == NULL, url.inner_url() == NULL);
 415     if (url.inner_url() && cases[i].inner_expected)
 416       EXPECT_EQ(cases[i].inner_expected, url.inner_url()->PathForRequest());
 417   }
 418 }
 419
 420 TEST(GURLTest, EffectiveIntPort) {
 421   struct PortTest {
 422     const char* spec;
 423     int expected_int_port;
 424   } port_tests[] = {
 425     // http
 426     {"http://www.google.com/", 80},
 427     {"http://www.google.com:80/", 80},
 428     {"http://www.google.com:443/", 443},
 429
 430     // https
 431     {"https://www.google.com/", 443},
 432     {"https://www.google.com:443/", 443},
 433     {"https://www.google.com:80/", 80},
 434
 435     // ftp
 436     {"ftp://www.google.com/", 21},
 437     {"ftp://www.google.com:21/", 21},
 438     {"ftp://www.google.com:80/", 80},
 439
 440     // gopher
 441     {"gopher://www.google.com/", 70},
 442     {"gopher://www.google.com:70/", 70},
 443     {"gopher://www.google.com:80/", 80},
 444
 445     // file - no port
 446     {"file://www.google.com/", url_parse::PORT_UNSPECIFIED},
 447     {"file://www.google.com:443/", url_parse::PORT_UNSPECIFIED},
 448
 449     // data - no port
 450     {"data:www.google.com:90", url_parse::PORT_UNSPECIFIED},
 451     {"data:www.google.com", url_parse::PORT_UNSPECIFIED},
 452
 453     // filesystem - no port
 454     {"filesystem:http://www.google.com:90/t/foo", url_parse::PORT_UNSPECIFIED},
 455     {"filesystem:file:///t/foo", url_parse::PORT_UNSPECIFIED},
 456   };
 457
 458   for (size_t i = 0; i < ARRAYSIZE(port_tests); i++) {
 459     GURL url(port_tests[i].spec);
 460     EXPECT_EQ(port_tests[i].expected_int_port, url.EffectiveIntPort());
 461   }
 462 }
 463
 464 TEST(GURLTest, IPAddress) {
 465   struct IPTest {
 466     const char* spec;
 467     bool expected_ip;
 468   } ip_tests[] = {
 469     {"http://www.google.com/", false},
 470     {"http://192.168.9.1/", true},
 471     {"http://192.168.9.1.2/", false},
 472     {"http://192.168.m.1/", false},
 473     {"http://2001:db8::1/", false},
 474     {"http://[2001:db8::1]/", true},
 475     {"", false},
 476     {"some random input!", false},
 477   };
 478
 479   for (size_t i = 0; i < ARRAYSIZE(ip_tests); i++) {
 480     GURL url(ip_tests[i].spec);
 481     EXPECT_EQ(ip_tests[i].expected_ip, url.HostIsIPAddress());
 482   }
 483 }
 484
 485 TEST(GURLTest, HostNoBrackets) {
 486   struct TestCase {
 487     const char* input;
 488     const char* expected_host;
 489     const char* expected_plainhost;
 490   } cases[] = {
 491     {"http://www.google.com", "www.google.com", "www.google.com"},
 492     {"http://[2001:db8::1]/", "[2001:db8::1]", "2001:db8::1"},
 493     {"http://[::]/", "[::]", "::"},
 494
 495     // Don't require a valid URL, but don't crash either.
 496     {"http://[]/", "[]", ""},
 497     {"http://[x]/", "[x]", "x"},
 498     {"http://[x/", "[x", "[x"},
 499     {"http://x]/", "x]", "x]"},
 500     {"http://[/", "[", "["},
 501     {"http://]/", "]", "]"},
 502     {"", "", ""},
 503   };
 504   for (size_t i = 0; i < ARRAYSIZE(cases); i++) {
 505     GURL url(cases[i].input);
 506     EXPECT_EQ(cases[i].expected_host, url.host());
 507     EXPECT_EQ(cases[i].expected_plainhost, url.HostNoBrackets());
 508   }
 509 }
 510
 511 TEST(GURLTest, DomainIs) {
 512   const char google_domain[] = "google.com";
 513
 514   GURL url_1("http://www.google.com:99/foo");
 515   EXPECT_TRUE(url_1.DomainIs(google_domain));
 516
 517   GURL url_2("http://google.com:99/foo");
 518   EXPECT_TRUE(url_2.DomainIs(google_domain));
 519
 520   GURL url_3("http://google.com./foo");
 521   EXPECT_TRUE(url_3.DomainIs(google_domain));
 522
 523   GURL url_4("http://google.com/foo");
 524   EXPECT_FALSE(url_4.DomainIs("google.com."));
 525
 526   GURL url_5("http://google.com./foo");
 527   EXPECT_TRUE(url_5.DomainIs("google.com."));
 528
 529   GURL url_6("http://www.google.com./foo");
 530   EXPECT_TRUE(url_6.DomainIs(".com."));
 531
 532   GURL url_7("http://www.balabala.com/foo");
 533   EXPECT_FALSE(url_7.DomainIs(google_domain));
 534
 535   GURL url_8("http://www.google.com.cn/foo");
 536   EXPECT_FALSE(url_8.DomainIs(google_domain));
 537
 538   GURL url_9("http://www.iamnotgoogle.com/foo");
 539   EXPECT_FALSE(url_9.DomainIs(google_domain));
 540
 541   GURL url_10("http://www.iamnotgoogle.com../foo");
 542   EXPECT_FALSE(url_10.DomainIs(".com"));
 543
 544   GURL url_11("filesystem:http://www.google.com:99/foo/");
 545   EXPECT_TRUE(url_11.DomainIs(google_domain));
 546
 547   GURL url_12("filesystem:http://www.iamnotgoogle.com/foo/");
 548   EXPECT_FALSE(url_12.DomainIs(google_domain));
 549 }
 550
 551 // Newlines should be stripped from inputs.
 552 TEST(GURLTest, Newlines) {
 553   // Constructor.
 554   GURL url_1(" \t ht\ntp://\twww.goo\rgle.com/as\ndf \n ");
 555   EXPECT_EQ("http://www.google.com/asdf", url_1.spec());
 556
 557   // Relative path resolver.
 558   GURL url_2 = url_1.Resolve(" \n /fo\to\r ");
 559   EXPECT_EQ("http://www.google.com/foo", url_2.spec());
 560
 561   // Note that newlines are NOT stripped from ReplaceComponents.
 562 }
 563
 564 TEST(GURLTest, IsStandard) {
 565   GURL a("http:foo/bar");
 566   EXPECT_TRUE(a.IsStandard());
 567
 568   GURL b("foo:bar/baz");
 569   EXPECT_FALSE(b.IsStandard());
 570
 571   GURL c("foo://bar/baz");
 572   EXPECT_FALSE(c.IsStandard());
 573 }
 574
 575 TEST(GURLTest, SchemeIsHTTPOrHTTPS) {
 576   EXPECT_TRUE(GURL("http://bar/").SchemeIsHTTPOrHTTPS());
 577   EXPECT_TRUE(GURL("HTTPS://BAR").SchemeIsHTTPOrHTTPS());
 578   EXPECT_FALSE(GURL("ftp://bar/").SchemeIsHTTPOrHTTPS());
 579 }
 580
 581 TEST(GURLTest, SchemeIsWSOrWSS) {
 582   EXPECT_TRUE(GURL("WS://BAR/").SchemeIsWSOrWSS());
 583   EXPECT_TRUE(GURL("wss://bar/").SchemeIsWSOrWSS());
 584   EXPECT_FALSE(GURL("http://bar/").SchemeIsWSOrWSS());
 585 }