Fix SchemeHostPort::GetURL() and add more tests

url/scheme_host_port_unittest.cc

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include "base/macros.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 #include "url/scheme_host_port.h"
 
 namespace {
 
+void ExpectParsedUrlsEqual(const GURL& a, const GURL& b) {
+  EXPECT_EQ(a, b);
+  const url::Parsed& a_parsed = a.parsed_for_possibly_invalid_spec();
+  const url::Parsed& b_parsed = b.parsed_for_possibly_invalid_spec();
+  EXPECT_EQ(a_parsed.scheme.begin, b_parsed.scheme.begin);
+  EXPECT_EQ(a_parsed.scheme.len, b_parsed.scheme.len);
+  EXPECT_EQ(a_parsed.username.begin, b_parsed.username.begin);
+  EXPECT_EQ(a_parsed.username.len, b_parsed.username.len);
+  EXPECT_EQ(a_parsed.password.begin, b_parsed.password.begin);
+  EXPECT_EQ(a_parsed.password.len, b_parsed.password.len);
+  EXPECT_EQ(a_parsed.host.begin, b_parsed.host.begin);
+  EXPECT_EQ(a_parsed.host.len, b_parsed.host.len);
+  EXPECT_EQ(a_parsed.port.begin, b_parsed.port.begin);
+  EXPECT_EQ(a_parsed.port.len, b_parsed.port.len);
+  EXPECT_EQ(a_parsed.path.begin, b_parsed.path.begin);
+  EXPECT_EQ(a_parsed.path.len, b_parsed.path.len);
+  EXPECT_EQ(a_parsed.query.begin, b_parsed.query.begin);
+  EXPECT_EQ(a_parsed.query.len, b_parsed.query.len);
+  EXPECT_EQ(a_parsed.ref.begin, b_parsed.ref.begin);
+  EXPECT_EQ(a_parsed.ref.len, b_parsed.ref.len);
+}
+
 TEST(SchemeHostPortTest, Invalid) {
   url::SchemeHostPort invalid;
   EXPECT_EQ("", invalid.scheme());
   EXPECT_EQ("", invalid.host());
   EXPECT_EQ(0, invalid.port());
   EXPECT_TRUE(invalid.IsInvalid());
   EXPECT_TRUE(invalid.Equals(invalid));
 
   const char* urls[] = {"data:text/html,Hello!",
                         "javascript:alert(1)",
                         "file://example.com:443/etc/passwd",
                         "blob:https://example.com/uuid-goes-here",
                         "filesystem:https://example.com/temporary/yay.png"};
 
   for (auto* test : urls) {
     SCOPED_TRACE(test);
     GURL url(test);
     url::SchemeHostPort tuple(url);
     EXPECT_EQ("", tuple.scheme());
     EXPECT_EQ("", tuple.host());
     EXPECT_EQ(0, tuple.port());
     EXPECT_TRUE(tuple.IsInvalid());
     EXPECT_TRUE(tuple.Equals(tuple));
     EXPECT_TRUE(tuple.Equals(invalid));
     EXPECT_TRUE(invalid.Equals(tuple));
+    ExpectParsedUrlsEqual(GURL(tuple.Serialize()), tuple.GetURL());
   }
 }
 
 TEST(SchemeHostPortTest, ExplicitConstruction) {
   struct TestCases {
     const char* scheme;
     const char* host;
     uint16_t port;
   } cases[] = {
       {"http", "example.com", 80},
       {"http", "example.com", 123},
       {"https", "example.com", 443},
       {"https", "example.com", 123},
       {"file", "", 0},
       {"file", "example.com", 0},
   };
 
   for (const auto& test : cases) {
     SCOPED_TRACE(testing::Message() << test.scheme << "://" << test.host << ":"
                                     << test.port);
     url::SchemeHostPort tuple(test.scheme, test.host, test.port);
     EXPECT_EQ(test.scheme, tuple.scheme());
     EXPECT_EQ(test.host, tuple.host());
     EXPECT_EQ(test.port, tuple.port());
     EXPECT_FALSE(tuple.IsInvalid());
     EXPECT_TRUE(tuple.Equals(tuple));
+    ExpectParsedUrlsEqual(GURL(tuple.Serialize()), tuple.GetURL());
   }
 }
 
 TEST(SchemeHostPortTest, InvalidConstruction) {
   struct TestCases {
     const char* scheme;
     const char* host;
     uint16_t port;
   } cases[] = {{"", "", 0},
                {"data", "", 0},
@@ skipping 15 matching lines @@
 
   for (const auto& test : cases) {
     SCOPED_TRACE(testing::Message() << test.scheme << "://" << test.host << ":"
                                     << test.port);
     url::SchemeHostPort tuple(test.scheme, test.host, test.port);
     EXPECT_EQ("", tuple.scheme());
     EXPECT_EQ("", tuple.host());
     EXPECT_EQ(0, tuple.port());
     EXPECT_TRUE(tuple.IsInvalid());
     EXPECT_TRUE(tuple.Equals(tuple));
+    ExpectParsedUrlsEqual(GURL(tuple.Serialize()), tuple.GetURL());
   }
 }
 
 TEST(SchemeHostPortTest, InvalidConstructionWithEmbeddedNulls) {
   struct TestCases {
     const char* scheme;
     size_t scheme_length;
     const char* host;
     size_t host_length;
     uint16_t port;
   } cases[] = {{"http\0more", 9, "example.com", 11, 80},
                {"http\0", 5, "example.com", 11, 80},
                {"\0http", 5, "example.com", 11, 80},
                {"http", 4, "example.com\0not-example.com", 27, 80},
                {"http", 4, "example.com\0", 12, 80},
                {"http", 4, "\0example.com", 12, 80}};
 
   for (const auto& test : cases) {
     SCOPED_TRACE(testing::Message() << test.scheme << "://" << test.host << ":"
                                     << test.port);
     url::SchemeHostPort tuple(std::string(test.scheme, test.scheme_length),
                               std::string(test.host, test.host_length),
                               test.port);
     EXPECT_EQ("", tuple.scheme());
     EXPECT_EQ("", tuple.host());
     EXPECT_EQ(0, tuple.port());
     EXPECT_TRUE(tuple.IsInvalid());
+    ExpectParsedUrlsEqual(GURL(tuple.Serialize()), tuple.GetURL());
   }
 }
 
 TEST(SchemeHostPortTest, GURLConstruction) {
   struct TestCases {
     const char* url;
     const char* scheme;
     const char* host;
     uint16_t port;
   } cases[] = {
@@ skipping 15 matching lines @@
   for (const auto& test : cases) {
     SCOPED_TRACE(test.url);
     GURL url(test.url);
     EXPECT_TRUE(url.is_valid());
     url::SchemeHostPort tuple(url);
     EXPECT_EQ(test.scheme, tuple.scheme());
     EXPECT_EQ(test.host, tuple.host());
     EXPECT_EQ(test.port, tuple.port());
     EXPECT_FALSE(tuple.IsInvalid());
     EXPECT_TRUE(tuple.Equals(tuple));
+    ExpectParsedUrlsEqual(GURL(tuple.Serialize()), tuple.GetURL());
   }
 }
 
 TEST(SchemeHostPortTest, Serialization) {
   struct TestCases {
     const char* url;
     const char* expected;
   } cases[] = {
       {"http://192.168.9.1/", "http://192.168.9.1"},
       {"http://[2001:db8::1]/", "http://[2001:db8::1]"},
       {"http://☃.net/", "http://xn--n3h.net"},
       {"http://example.com/", "http://example.com"},
       {"http://example.com:123/", "http://example.com:123"},
       {"https://example.com/", "https://example.com"},
       {"https://example.com:123/", "https://example.com:123"},
       {"file:///etc/passwd", "file://"},
       {"file://example.com/etc/passwd", "file://example.com"},
   };
 
   for (const auto& test : cases) {
     SCOPED_TRACE(test.url);
     GURL url(test.url);
     url::SchemeHostPort tuple(url);
     EXPECT_EQ(test.expected, tuple.Serialize());
+    ExpectParsedUrlsEqual(GURL(tuple.Serialize()), tuple.GetURL());
   }
 }
 
 TEST(SchemeHostPortTest, Comparison) {
   // These tuples are arranged in increasing order:
   struct SchemeHostPorts {
     const char* scheme;
     const char* host;
     uint16_t port;
   } tuples[] = {
@@ skipping 13 matching lines @@
     for (size_t j = i; j < arraysize(tuples); j++) {
       url::SchemeHostPort to_compare(tuples[j].scheme, tuples[j].host,
                                      tuples[j].port);
       EXPECT_EQ(i < j, current < to_compare) << i << " < " << j;
       EXPECT_EQ(j < i, to_compare < current) << j << " < " << i;
     }
   }
 }
 
 }  // namespace url