Add GURL::HostNoBracketsPiece()

url/gurl_unittest.cc

 // Copyright 2013 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 "base/macros.h"
 #include "base/strings/utf_string_conversions.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
@@ skipping 543 matching lines @@
     {"", false},
     {"some random input!", false},
   };
 
   for (size_t i = 0; i < arraysize(ip_tests); i++) {
     GURL url(ip_tests[i].spec);
     EXPECT_EQ(ip_tests[i].expected_ip, url.HostIsIPAddress());
   }
 }
 
-TEST(GURLTest, HostNoBrackets) {
+// Type-parameterized test for variants of the host returning methods.
+template <typename StringType>
+class GURLHostTest : public ::testing::Test {

[brettw, 2017/06/30 19:33:14]

This is a lot of hard-to-read complexity, when I think we could just add a third
line in the for loop in HostNoBrackets to check that the host piece also
matches. Can you do that instead?

[Adam Rice, 2017/07/03 04:51:51]

Thank you! I was so fixated on the type difference I couldn't see the simple way
of doing it.

+ public:
+  // The GURL methods are wrapped to deal with having different method names for
+  // the types.
+  StringType host(const GURL& url) { return url.host(); }
+  StringType HostNoBrackets(const GURL& url) { return url.HostNoBrackets(); }
+};
+
+template <>
+class GURLHostTest<base::StringPiece> : public ::testing::Test {
+ public:
+  base::StringPiece host(const GURL& url) { return url.host_piece(); }
+  base::StringPiece HostNoBrackets(const GURL& url) {
+    return url.HostNoBracketsPiece();
+  }
+};
+
+using GURLHostTestTypes = ::testing::Types<std::string, base::StringPiece>;
+TYPED_TEST_CASE(GURLHostTest, GURLHostTestTypes);
+
+TYPED_TEST(GURLHostTest, HostNoBrackets) {
   struct TestCase {
     const char* input;
     const char* expected_host;
     const char* expected_plainhost;
   } cases[] = {
     {"http://www.google.com", "www.google.com", "www.google.com"},
     {"http://[2001:db8::1]/", "[2001:db8::1]", "2001:db8::1"},
     {"http://[::]/", "[::]", "::"},
 
     // Don't require a valid URL, but don't crash either.
     {"http://[]/", "[]", ""},
     {"http://[x]/", "[x]", "x"},
     {"http://[x/", "[x", "[x"},
     {"http://x]/", "x]", "x]"},
     {"http://[/", "[", "["},
     {"http://]/", "]", "]"},
     {"", "", ""},
   };
   for (size_t i = 0; i < arraysize(cases); i++) {
     GURL url(cases[i].input);
-    EXPECT_EQ(cases[i].expected_host, url.host());
-    EXPECT_EQ(cases[i].expected_plainhost, url.HostNoBrackets());
+    EXPECT_EQ(cases[i].expected_host, this->host(url));
+    EXPECT_EQ(cases[i].expected_plainhost, this->HostNoBrackets(url));
   }
 }
 
 TEST(GURLTest, DomainIs) {
   GURL url_1("http://google.com/foo");
   EXPECT_TRUE(url_1.DomainIs("google.com"));
 
   // Subdomain and port are ignored.
   GURL url_2("http://www.google.com:99/foo");
   EXPECT_TRUE(url_2.DomainIs("google.com"));
@@ skipping 226 matching lines @@
     // A versus B.
     EXPECT_EQ(test_case.are_equals,
               GURL(test_case.url_a).EqualsIgnoringRef(GURL(test_case.url_b)));
     // B versus A.
     EXPECT_EQ(test_case.are_equals,
               GURL(test_case.url_b).EqualsIgnoringRef(GURL(test_case.url_a)));
   }
 }
 
 }  // namespace url