Remove the rule that "://" means a standard URL. This fixes a number of bugs...

src/gurl_unittest.cc

 // Copyright 2007 Google Inc. All Rights Reserved.
 // Author: brettw@google.com (Brett Wilson)
 
 #include "googleurl/src/gurl.h"
 #include "googleurl/src/url_canon.h"
 #include "googleurl/src/url_test_utils.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
@@ skipping 13 matching lines @@
                       url_canon::Replacements<CHAR>* replacements,
                       const CHAR* str) {
   if (str) {
     url_parse::Component comp;
     if (str[0])
       comp.len = static_cast<int>(strlen(str));
     (replacements->*func)(str, comp);
   }
 }
 
+// Returns the canonicalized string for the given URL string for the
+// GURLTest.Types test.
+std::string TypesTestCase(const char* src) {
+  GURL gurl(src);
+  return gurl.possibly_invalid_spec();
+}
+
 }  // namespace
 
 // Different types of URLs should be handled differently by url_util, and
 // handed off to different canonicalizers.
 TEST(GURLTest, Types) {
-  struct TypeTest {
-    const char* src;
-    const char* expected;
-  } type_cases[] = {
-      // URLs with "://" should be treated as standard and have a hostname, even
-      // when the scheme is unknown.
-    {"something:///HOSTNAME.com/", "something://hostname.com/"},
-      // In the reverse, lacking a "://" means a path URL so no canonicalization
-      // should happen.
-    {"something:HOSTNAME.com/", "something:HOSTNAME.com/"},
-    {"something:/HOSTNAME.com/", "something:/HOSTNAME.com/"},
+  // URLs with unknown schemes should be treated as path URLs, even when they
+  // have things like "://".
+  EXPECT_EQ("something:///HOSTNAME.com/",
+            TypesTestCase("something:///HOSTNAME.com/"));
+
+  // In the reverse, known schemes should always trigger standard URL handling.
+  EXPECT_EQ("http://hostname.com/", TypesTestCase("http:HOSTNAME.com"));
+  EXPECT_EQ("http://hostname.com/", TypesTestCase("http:/HOSTNAME.com"));
+  EXPECT_EQ("http://hostname.com/", TypesTestCase("http://HOSTNAME.com"));
+  EXPECT_EQ("http://hostname.com/", TypesTestCase("http:///HOSTNAME.com"));
+
 #ifdef WIN32
-      // URLs that look like absolute Windows drive specs.
-    {"c:\\foo.txt", "file:///C:/foo.txt"},
-    {"Z|foo.txt", "file:///Z:/foo.txt"},
-    {"\\\\server\\foo.txt", "file://server/foo.txt"},
-    {"//server/foo.txt", "file://server/foo.txt"},
+  // URLs that look like absolute Windows drive specs.
+  EXPECT_EQ("file:///C:/foo.txt", TypesTestCase("c:\\foo.txt"));
+  EXPECT_EQ("file:///Z:/foo.txt", TypesTestCase("Z|foo.txt"));
+  EXPECT_EQ("file://server/foo.txt", TypesTestCase("\\\\server\\foo.txt"));
+  EXPECT_EQ("file://server/foo.txt", TypesTestCase("//server/foo.txt"));
 #endif
-  };
-
-  for (size_t i = 0; i < ARRAYSIZE(type_cases); i++) {
-    GURL gurl(type_cases[i].src);
-    EXPECT_STREQ(type_cases[i].expected, gurl.spec().c_str());
-  }
 }
 
 // Test the basic creation and querying of components in a GURL. We assume
 // the parser is already tested and works, so we are mostly interested if the
 // object does the right thing with the results.
 TEST(GURLTest, Components) {
   GURL url(WStringToUTF16(L"http://user:pass@google.com:99/foo;bar?q=a#ref"));
   EXPECT_TRUE(url.is_valid());
   EXPECT_TRUE(url.SchemeIs("http"));
   EXPECT_FALSE(url.SchemeIsFile());
@@ skipping 86 matching lines @@
     const char* base;
     const char* relative;
     bool expected_valid;
     const char* expected;
   } resolve_cases[] = {
     {"http://www.google.com/", "foo.html", true, "http://www.google.com/foo.html"},
     {"http://www.google.com/", "http://images.google.com/foo.html", true, "http://images.google.com/foo.html"},
     {"http://www.google.com/blah/bloo?c#d", "../../../hello/./world.html?a#b", true, "http://www.google.com/hello/world.html?a#b"},
     {"http://www.google.com/foo#bar", "#com", true, "http://www.google.com/foo#com"},
     {"http://www.google.com/", "Https:images.google.com", true, "https://images.google.com/"},
-      // Unknown schemes with a "://" should be treated as standard.
-    {"somescheme://foo/", "bar", true, "somescheme://foo/bar"},
-      // Unknown schemes with no "://" are not standard.
+      // Unknown schemes are not standard.
     {"data:blahblah", "http://google.com/", true, "http://google.com/"},
     {"data:blahblah", "http:google.com", true, "http://google.com/"},
     {"data:/blahblah", "file.html", false, ""},
   };
 
   for (size_t i = 0; i < ARRAYSIZE(resolve_cases); i++) {
     // 8-bit code path.
     GURL input(resolve_cases[i].base);
     GURL output = input.Resolve(resolve_cases[i].relative);
-    EXPECT_EQ(resolve_cases[i].expected_valid, output.is_valid());
-    EXPECT_EQ(resolve_cases[i].expected, output.spec());
+    EXPECT_EQ(resolve_cases[i].expected_valid, output.is_valid()) << i;
+    EXPECT_EQ(resolve_cases[i].expected, output.spec()) << i;
 
     // Wide code path.
     GURL inputw(ConvertUTF8ToUTF16(resolve_cases[i].base));
     GURL outputw =
         input.Resolve(ConvertUTF8ToUTF16(resolve_cases[i].relative));
-    EXPECT_EQ(resolve_cases[i].expected_valid, outputw.is_valid());
-    EXPECT_EQ(resolve_cases[i].expected, outputw.spec());
+    EXPECT_EQ(resolve_cases[i].expected_valid, outputw.is_valid()) << i;
+    EXPECT_EQ(resolve_cases[i].expected, outputw.spec()) << i;
   }
 }
 
 TEST(GURLTest, GetOrigin) {
   struct TestCase {
     const char* input;
     const char* expected;
   } cases[] = {
     {"http://www.google.com", "http://www.google.com/"},
     {"javascript:window.alert(\"hello,world\");", ""},
@@ skipping 222 matching lines @@
 }
 
 TEST(GURLTest, IsStandard) {
   GURL a("http:foo/bar");
   EXPECT_TRUE(a.IsStandard());
 
   GURL b("foo:bar/baz");
   EXPECT_FALSE(b.IsStandard());
 
   GURL c("foo://bar/baz");
-  EXPECT_TRUE(c.IsStandard());
+  EXPECT_FALSE(c.IsStandard());
 }