Revert 72380 - Remove wstring from autocomplete....

chrome/browser/autocomplete/autocomplete_unittest.cc

 // Copyright (c) 2011 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 "base/message_loop.h"
 #include "base/scoped_ptr.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/autocomplete/autocomplete.h"
 #include "chrome/browser/autocomplete/autocomplete_match.h"
 #include "chrome/browser/autocomplete/keyword_provider.h"
 #include "chrome/browser/autocomplete/search_provider.h"
 #include "chrome/browser/search_engines/template_url.h"
 #include "chrome/browser/search_engines/template_url_model.h"
 #include "chrome/common/notification_observer.h"
 #include "chrome/common/notification_registrar.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/test/testing_profile.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+// identifiers for known autocomplete providers
+#define HISTORY_IDENTIFIER L"Chrome:History"
+#define SEARCH_IDENTIFIER L"google.com/websearch/en"
+
 static std::ostream& operator<<(std::ostream& os,
                                 const AutocompleteResult::const_iterator& it) {
   return os << static_cast<const AutocompleteMatch*>(&(*it));
 }
 
 namespace {
 
 const size_t num_results_per_provider = 3;
 
 // Autocomplete provider that provides known results. Note that this is
 // refcounted so that it can also be a task on the message loop.
 class TestProvider : public AutocompleteProvider {
  public:
-  TestProvider(int relevance, const string16& prefix)
+  TestProvider(int relevance, const std::wstring& prefix)
       : AutocompleteProvider(NULL, NULL, ""),
         relevance_(relevance),
         prefix_(prefix) {
   }
 
   virtual void Start(const AutocompleteInput& input,
                      bool minimal_changes);
 
   void set_listener(ACProviderListener* listener) {
     listener_ = listener;
   }
 
  private:
   ~TestProvider() {}
 
   void Run();
 
   void AddResults(int start_at, int num);
 
   int relevance_;
-  const string16 prefix_;
+  const std::wstring prefix_;
 };
 
 void TestProvider::Start(const AutocompleteInput& input,
                          bool minimal_changes) {
   if (minimal_changes)
     return;
 
   matches_.clear();
 
   // Generate one result synchronously, the rest later.
@@ skipping 12 matching lines @@
   done_ = true;
   DCHECK(listener_);
   listener_->OnProviderUpdate(true);
 }
 
 void TestProvider::AddResults(int start_at, int num) {
   for (int i = start_at; i < num; i++) {
     AutocompleteMatch match(this, relevance_ - i, false,
                             AutocompleteMatch::URL_WHAT_YOU_TYPED);
 
-    match.fill_into_edit = prefix_ + UTF8ToUTF16(base::IntToString(i));
-    match.destination_url = GURL(UTF16ToUTF8(match.fill_into_edit));
+    match.fill_into_edit = prefix_ + UTF8ToWide(base::IntToString(i));
+    match.destination_url = GURL(WideToUTF8(match.fill_into_edit));
 
     match.contents = match.fill_into_edit;
     match.contents_class.push_back(
         ACMatchClassification(0, ACMatchClassification::NONE));
     match.description = match.fill_into_edit;
     match.description_class.push_back(
         ACMatchClassification(0, ACMatchClassification::NONE));
 
     matches_.push_back(match);
   }
@@ skipping 29 matching lines @@
 };
 
 void AutocompleteProviderTest::ResetControllerWithTestProviders(
     bool same_destinations) {
   // Forget about any existing providers.  The controller owns them and will
   // Release() them below, when we delete it during the call to reset().
   providers_.clear();
 
   // Construct two new providers, with either the same or different prefixes.
   TestProvider* providerA = new TestProvider(num_results_per_provider,
-                                             ASCIIToUTF16("http://a"));
+                                             L"http://a");
   providerA->AddRef();
   providers_.push_back(providerA);
 
   TestProvider* providerB = new TestProvider(num_results_per_provider * 2,
-      same_destinations ? ASCIIToUTF16("http://a") : ASCIIToUTF16("http://b"));
+      same_destinations ? L"http://a" : L"http://b");
   providerB->AddRef();
   providers_.push_back(providerB);
 
   // Reset the controller to contain our new providers.
   AutocompleteController* controller = new AutocompleteController(providers_);
   controller_.reset(controller);
   providerA->set_listener(controller);
   providerB->set_listener(controller);
 
   // The providers don't complete synchronously, so listen for "result updated"
@@ skipping 36 matching lines @@
   AutocompleteProvider* search_provider = new SearchProvider(NULL, &profile_);
   search_provider->AddRef();
   providers_.push_back(search_provider);
 
   AutocompleteController* controller = new AutocompleteController(providers_);
   controller_.reset(controller);
 }
 
 void AutocompleteProviderTest::RunTest() {
   result_.Reset();
-  controller_->Start(ASCIIToUTF16("a"), string16(), true, false, true, false);
+  controller_->Start(L"a", std::wstring(), true, false, true, false);
 
   // The message loop will terminate when all autocomplete input has been
   // collected.
   MessageLoop::current()->Run();
 }
 
 void AutocompleteProviderTest::RunExactKeymatchTest(
     bool allow_exact_keyword_match) {
   // Send the controller input which exactly matches the keyword provider we
   // created in ResetControllerWithKeywordAndSearchProviders().  The default
   // match should thus be a keyword match iff |allow_exact_keyword_match| is
   // true.
-  controller_->Start(ASCIIToUTF16("k test"), string16(), true, false,
+  controller_->Start(L"k test", std::wstring(), true, false,
                      allow_exact_keyword_match, true);
   EXPECT_TRUE(controller_->done());
   // ResetControllerWithKeywordAndSearchProviders() adds the keyword provider
   // first, then the search provider.  So if the default match is a keyword
   // match, it will come from provider 0, otherwise from provider 1.
   EXPECT_EQ(providers_[allow_exact_keyword_match ? 0 : 1],
       controller_->result().default_match()->provider);
 }
 
 void AutocompleteProviderTest::Observe(NotificationType type,
@@ skipping 30 matching lines @@
 }
 
 TEST_F(AutocompleteProviderTest, AllowExactKeywordMatch) {
   ResetControllerWithTestProvidersWithKeywordAndSearchProviders();
   RunExactKeymatchTest(true);
   RunExactKeymatchTest(false);
 }
 
 TEST(AutocompleteTest, InputType) {
   struct test_data {
-    const string16 input;
+    const wchar_t* input;
     const AutocompleteInput::Type type;
   } input_cases[] = {
-    { ASCIIToUTF16(""), AutocompleteInput::INVALID },
-    { ASCIIToUTF16("?"), AutocompleteInput::FORCED_QUERY },
-    { ASCIIToUTF16("?foo"), AutocompleteInput::FORCED_QUERY },
-    { ASCIIToUTF16("?foo bar"), AutocompleteInput::FORCED_QUERY },
-    { ASCIIToUTF16("?http://foo.com/bar"), AutocompleteInput::FORCED_QUERY },
-    { ASCIIToUTF16("foo"), AutocompleteInput::UNKNOWN },
-    { ASCIIToUTF16("foo.c"), AutocompleteInput::UNKNOWN },
-    { ASCIIToUTF16("foo.com"), AutocompleteInput::URL },
-    { ASCIIToUTF16("-.com"), AutocompleteInput::UNKNOWN },
-    { ASCIIToUTF16("foo/bar"), AutocompleteInput::URL },
-    { ASCIIToUTF16("foo;bar"), AutocompleteInput::QUERY },
-    { ASCIIToUTF16("foo/bar baz"), AutocompleteInput::UNKNOWN },
-    { ASCIIToUTF16("foo bar.com"), AutocompleteInput::QUERY },
-    { ASCIIToUTF16("foo bar"), AutocompleteInput::QUERY },
-    { ASCIIToUTF16("foo+bar"), AutocompleteInput::QUERY },
-    { ASCIIToUTF16("foo+bar.com"), AutocompleteInput::UNKNOWN },
-    { ASCIIToUTF16("\"foo:bar\""), AutocompleteInput::QUERY },
-    { ASCIIToUTF16("link:foo.com"), AutocompleteInput::UNKNOWN },
-    { ASCIIToUTF16("foo:81"), AutocompleteInput::URL },
-    { ASCIIToUTF16("www.foo.com:81"), AutocompleteInput::URL },
-    { ASCIIToUTF16("localhost:8080"), AutocompleteInput::URL },
-    { ASCIIToUTF16("foo.com:123456"), AutocompleteInput::QUERY },
-    { ASCIIToUTF16("foo.com:abc"), AutocompleteInput::QUERY },
-    { ASCIIToUTF16("1.2.3.4:abc"), AutocompleteInput::QUERY },
-    { ASCIIToUTF16("user@foo.com"), AutocompleteInput::UNKNOWN },
-    { ASCIIToUTF16("user:pass@"), AutocompleteInput::UNKNOWN },
-    { ASCIIToUTF16("user:pass@!foo.com"), AutocompleteInput::UNKNOWN },
-    { ASCIIToUTF16("user:pass@foo"), AutocompleteInput::URL },
-    { ASCIIToUTF16("user:pass@foo.c"), AutocompleteInput::URL },
-    { ASCIIToUTF16("user:pass@foo.com"), AutocompleteInput::URL },
-    { ASCIIToUTF16("user:pass@foo.com:81"), AutocompleteInput::URL },
-    { ASCIIToUTF16("user:pass@foo:81"), AutocompleteInput::URL },
-    { ASCIIToUTF16("1.2"), AutocompleteInput::UNKNOWN },
-    { ASCIIToUTF16("1.2/45"), AutocompleteInput::UNKNOWN },
-    { ASCIIToUTF16("1.2:45"), AutocompleteInput::UNKNOWN },
-    { ASCIIToUTF16("user@1.2:45"), AutocompleteInput::UNKNOWN },
-    { ASCIIToUTF16("user:pass@1.2:45"), AutocompleteInput::URL },
-    { ASCIIToUTF16("ps/2 games"), AutocompleteInput::UNKNOWN },
-    { ASCIIToUTF16("en.wikipedia.org/wiki/James Bond"),
-        AutocompleteInput::URL },
+    { L"", AutocompleteInput::INVALID },
+    { L"?", AutocompleteInput::FORCED_QUERY },
+    { L"?foo", AutocompleteInput::FORCED_QUERY },
+    { L"?foo bar", AutocompleteInput::FORCED_QUERY },
+    { L"?http://foo.com/bar", AutocompleteInput::FORCED_QUERY },
+    { L"foo", AutocompleteInput::UNKNOWN },
+    { L"foo.c", AutocompleteInput::UNKNOWN },
+    { L"foo.com", AutocompleteInput::URL },
+    { L"-.com", AutocompleteInput::UNKNOWN },
+    { L"foo/bar", AutocompleteInput::URL },
+    { L"foo;bar", AutocompleteInput::QUERY },
+    { L"foo/bar baz", AutocompleteInput::UNKNOWN },
+    { L"foo bar.com", AutocompleteInput::QUERY },
+    { L"foo bar", AutocompleteInput::QUERY },
+    { L"foo+bar", AutocompleteInput::QUERY },
+    { L"foo+bar.com", AutocompleteInput::UNKNOWN },
+    { L"\"foo:bar\"", AutocompleteInput::QUERY },
+    { L"link:foo.com", AutocompleteInput::UNKNOWN },
+    { L"foo:81", AutocompleteInput::URL },
+    { L"www.foo.com:81", AutocompleteInput::URL },
+    { L"localhost:8080", AutocompleteInput::URL },
+    { L"foo.com:123456", AutocompleteInput::QUERY },
+    { L"foo.com:abc", AutocompleteInput::QUERY },
+    { L"1.2.3.4:abc", AutocompleteInput::QUERY },
+    { L"user@foo.com", AutocompleteInput::UNKNOWN },
+    { L"user:pass@", AutocompleteInput::UNKNOWN },
+    { L"user:pass@!foo.com", AutocompleteInput::UNKNOWN },
+    { L"user:pass@foo", AutocompleteInput::URL },
+    { L"user:pass@foo.c", AutocompleteInput::URL },
+    { L"user:pass@foo.com", AutocompleteInput::URL },
+    { L"user:pass@foo.com:81", AutocompleteInput::URL },
+    { L"user:pass@foo:81", AutocompleteInput::URL },
+    { L"1.2", AutocompleteInput::UNKNOWN },
+    { L"1.2/45", AutocompleteInput::UNKNOWN },
+    { L"1.2:45", AutocompleteInput::UNKNOWN },
+    { L"user@1.2:45", AutocompleteInput::UNKNOWN },
+    { L"user:pass@1.2:45", AutocompleteInput::URL },
+    { L"ps/2 games", AutocompleteInput::UNKNOWN },
+    { L"en.wikipedia.org/wiki/James Bond", AutocompleteInput::URL },
     // In Chrome itself, mailto: will get handled by ShellExecute, but in
     // unittest mode, we don't have the data loaded in the external protocol
     // handler to know this.
-    // { ASCIIToUTF16("mailto:abuse@foo.com"), AutocompleteInput::URL },
-    { ASCIIToUTF16("view-source:http://www.foo.com/"), AutocompleteInput::URL },
-    { ASCIIToUTF16("javascript:alert(\"Hey there!\");"),
-        AutocompleteInput::URL },
+    // { L"mailto:abuse@foo.com", AutocompleteInput::URL },
+    { L"view-source:http://www.foo.com/", AutocompleteInput::URL },
+    { L"javascript:alert(\"Hey there!\");", AutocompleteInput::URL },
 #if defined(OS_WIN)
-    { ASCIIToUTF16("C:\\Program Files"), AutocompleteInput::URL },
-    { ASCIIToUTF16("\\\\Server\\Folder\\File"), AutocompleteInput::URL },
+    { L"C:\\Program Files", AutocompleteInput::URL },
+    { L"\\\\Server\\Folder\\File", AutocompleteInput::URL },
 #endif  // defined(OS_WIN)
-    { ASCIIToUTF16("http:foo"), AutocompleteInput::URL },
-    { ASCIIToUTF16("http://foo"), AutocompleteInput::URL },
-    { ASCIIToUTF16("http://foo.c"), AutocompleteInput::URL },
-    { ASCIIToUTF16("http://foo.com"), AutocompleteInput::URL },
-    { ASCIIToUTF16("http://foo_bar.com"), AutocompleteInput::URL },
-    { ASCIIToUTF16("http://foo/bar baz"), AutocompleteInput::URL },
-    { ASCIIToUTF16("http://-.com"), AutocompleteInput::UNKNOWN },
-    { ASCIIToUTF16("http://_foo_.com"), AutocompleteInput::UNKNOWN },
-    { ASCIIToUTF16("http://foo.com:abc"), AutocompleteInput::QUERY },
-    { ASCIIToUTF16("http://foo.com:123456"), AutocompleteInput::QUERY },
-    { ASCIIToUTF16("http://1.2.3.4:abc"), AutocompleteInput::QUERY },
-    { ASCIIToUTF16("http:user@foo.com"), AutocompleteInput::URL },
-    { ASCIIToUTF16("http://user@foo.com"), AutocompleteInput::URL },
-    { ASCIIToUTF16("http:user:pass@foo.com"), AutocompleteInput::URL },
-    { ASCIIToUTF16("http://user:pass@foo.com"), AutocompleteInput::URL },
-    { ASCIIToUTF16("http://1.2"), AutocompleteInput::URL },
-    { ASCIIToUTF16("http://1.2/45"), AutocompleteInput::URL },
-    { ASCIIToUTF16("http:ps/2 games"), AutocompleteInput::URL },
-    { ASCIIToUTF16("http://ps/2 games"), AutocompleteInput::URL },
-    { ASCIIToUTF16("https://foo.com"), AutocompleteInput::URL },
-    { ASCIIToUTF16("127.0.0.1"), AutocompleteInput::URL },
-    { ASCIIToUTF16("127.0.1"), AutocompleteInput::UNKNOWN },
-    { ASCIIToUTF16("127.0.1/"), AutocompleteInput::UNKNOWN },
-    { ASCIIToUTF16("browser.tabs.closeButtons"), AutocompleteInput::UNKNOWN },
-    { WideToUTF16(L"\u6d4b\u8bd5"), AutocompleteInput::UNKNOWN },
-    { ASCIIToUTF16("[2001:]"), AutocompleteInput::QUERY },  // Not a valid IP
-    { ASCIIToUTF16("[2001:dB8::1]"), AutocompleteInput::URL },
-    { ASCIIToUTF16("192.168.0.256"),
-        AutocompleteInput::QUERY },  // Invalid IPv4 literal.
-    { ASCIIToUTF16("[foo.com]"),
-        AutocompleteInput::QUERY },  // Invalid IPv6 literal.
+    { L"http:foo", AutocompleteInput::URL },
+    { L"http://foo", AutocompleteInput::URL },
+    { L"http://foo.c", AutocompleteInput::URL },
+    { L"http://foo.com", AutocompleteInput::URL },
+    { L"http://foo_bar.com", AutocompleteInput::URL },
+    { L"http://foo/bar baz", AutocompleteInput::URL },
+    { L"http://-.com", AutocompleteInput::UNKNOWN },
+    { L"http://_foo_.com", AutocompleteInput::UNKNOWN },
+    { L"http://foo.com:abc", AutocompleteInput::QUERY },
+    { L"http://foo.com:123456", AutocompleteInput::QUERY },
+    { L"http://1.2.3.4:abc", AutocompleteInput::QUERY },
+    { L"http:user@foo.com", AutocompleteInput::URL },
+    { L"http://user@foo.com", AutocompleteInput::URL },
+    { L"http:user:pass@foo.com", AutocompleteInput::URL },
+    { L"http://user:pass@foo.com", AutocompleteInput::URL },
+    { L"http://1.2", AutocompleteInput::URL },
+    { L"http://1.2/45", AutocompleteInput::URL },
+    { L"http:ps/2 games", AutocompleteInput::URL },
+    { L"http://ps/2 games", AutocompleteInput::URL },
+    { L"https://foo.com", AutocompleteInput::URL },
+    { L"127.0.0.1", AutocompleteInput::URL },
+    { L"127.0.1", AutocompleteInput::UNKNOWN },
+    { L"127.0.1/", AutocompleteInput::UNKNOWN },
+    { L"browser.tabs.closeButtons", AutocompleteInput::UNKNOWN },
+    { L"\u6d4b\u8bd5", AutocompleteInput::UNKNOWN },
+    { L"[2001:]", AutocompleteInput::QUERY },  // Not a valid IP
+    { L"[2001:dB8::1]", AutocompleteInput::URL },
+    { L"192.168.0.256", AutocompleteInput::QUERY },  // Invalid IPv4 literal.
+    { L"[foo.com]", AutocompleteInput::QUERY },  // Invalid IPv6 literal.
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(input_cases); ++i) {
     SCOPED_TRACE(input_cases[i].input);
-    AutocompleteInput input(input_cases[i].input, string16(), true, false,
+    AutocompleteInput input(input_cases[i].input, std::wstring(), true, false,
                             true, false);
     EXPECT_EQ(input_cases[i].type, input.type());
   }
 }
 
 TEST(AutocompleteTest, InputTypeWithDesiredTLD) {
   struct test_data {
-    const string16 input;
+    const wchar_t* input;
     const AutocompleteInput::Type type;
   } input_cases[] = {
-    { ASCIIToUTF16("401k"), AutocompleteInput::REQUESTED_URL },
-    { ASCIIToUTF16("999999999999999"), AutocompleteInput::REQUESTED_URL },
+    { L"401k", AutocompleteInput::REQUESTED_URL },
+    { L"999999999999999", AutocompleteInput::REQUESTED_URL },
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(input_cases); ++i) {
-    AutocompleteInput input(input_cases[i].input, ASCIIToUTF16("com"), true,
-                            false, true, false);
+    AutocompleteInput input(input_cases[i].input, L"com", true, false, true,
+                            false);
     EXPECT_EQ(input_cases[i].type, input.type()) << "Input: " <<
         input_cases[i].input;
   }
 }
 
 // This tests for a regression where certain input in the omnibox caused us to
 // crash. As long as the test completes without crashing, we're fine.
 TEST(AutocompleteTest, InputCrash) {
-  AutocompleteInput input(WideToUTF16(L"\uff65@s"), string16(), true, false,
-                          true, false);
+  AutocompleteInput input(L"\uff65@s", std::wstring(), true, false, true,
+                          false);
 }
 
 // Test comparing matches relevance.
 TEST(AutocompleteMatch, MoreRelevant) {
   struct RelevantCases {
     int r1;
     int r2;
     bool expected_result;
   } cases[] = {
     {  10,   0, true  },
@@ skipping 12 matching lines @@
     m2.relevance = cases[i].r2;
     EXPECT_EQ(cases[i].expected_result,
               AutocompleteMatch::MoreRelevant(m1, m2));
   }
 }
 
 TEST(AutocompleteInput, ParseForEmphasizeComponent) {
   using url_parse::Component;
   Component kInvalidComponent(0, -1);
   struct test_data {
-    const string16 input;
+    const wchar_t* input;
     const Component scheme;
     const Component host;
   } input_cases[] = {
-    { ASCIIToUTF16(""), kInvalidComponent, kInvalidComponent },
-    { ASCIIToUTF16("?"), kInvalidComponent, kInvalidComponent },
-    { ASCIIToUTF16("?http://foo.com/bar"), kInvalidComponent,
-        kInvalidComponent },
-    { ASCIIToUTF16("foo/bar baz"), kInvalidComponent, Component(0, 3) },
-    { ASCIIToUTF16("http://foo/bar baz"), Component(0, 4), Component(7, 3) },
-    { ASCIIToUTF16("link:foo.com"), Component(0, 4), kInvalidComponent },
-    { ASCIIToUTF16("www.foo.com:81"), kInvalidComponent, Component(0, 11) },
-    { WideToUTF16(L"\u6d4b\u8bd5"), kInvalidComponent, Component(0, 2) },
-    { ASCIIToUTF16("view-source:http://www.foo.com/"), Component(12, 4),
-        Component(19, 11) },
-    { ASCIIToUTF16("view-source:https://example.com/"),
+    { L"", kInvalidComponent, kInvalidComponent },
+    { L"?", kInvalidComponent, kInvalidComponent },
+    { L"?http://foo.com/bar", kInvalidComponent, kInvalidComponent },
+    { L"foo/bar baz", kInvalidComponent, Component(0, 3) },
+    { L"http://foo/bar baz", Component(0, 4), Component(7, 3) },
+    { L"link:foo.com", Component(0, 4), kInvalidComponent },
+    { L"www.foo.com:81", kInvalidComponent, Component(0, 11) },
+    { L"\u6d4b\u8bd5", kInvalidComponent, Component(0, 2) },
+    { L"view-source:http://www.foo.com/", Component(12, 4), Component(19, 11) },
+    { L"view-source:https://example.com/",
       Component(12, 5), Component(20, 11) },
-    { ASCIIToUTF16("view-source:www.foo.com"), kInvalidComponent,
-        Component(12, 11) },
-    { ASCIIToUTF16("view-source:"), Component(0, 11), kInvalidComponent },
-    { ASCIIToUTF16("view-source:garbage"), kInvalidComponent,
-        Component(12, 7) },
-    { ASCIIToUTF16("view-source:http://http://foo"), Component(12, 4),
-        Component(19, 4) },
-    { ASCIIToUTF16("view-source:view-source:http://example.com/"),
-        Component(12, 11), kInvalidComponent }
+    { L"view-source:www.foo.com", kInvalidComponent, Component(12, 11) },
+    { L"view-source:", Component(0, 11), kInvalidComponent },
+    { L"view-source:garbage", kInvalidComponent, Component(12, 7) },
+    { L"view-source:http://http://foo", Component(12, 4), Component(19, 4) },
+    { L"view-source:view-source:http://example.com/",
+      Component(12, 11), kInvalidComponent }
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(input_cases); ++i) {
     Component scheme, host;
     AutocompleteInput::ParseForEmphasizeComponents(input_cases[i].input,
-                                                   string16(),
+                                                   std::wstring(),
                                                    &scheme,
                                                    &host);
-    AutocompleteInput input(input_cases[i].input, string16(), true, false,
+    AutocompleteInput input(input_cases[i].input, std::wstring(), true, false,
                             true, false);
     EXPECT_EQ(input_cases[i].scheme.begin, scheme.begin) << "Input: " <<
         input_cases[i].input;
     EXPECT_EQ(input_cases[i].scheme.len, scheme.len) << "Input: " <<
         input_cases[i].input;
     EXPECT_EQ(input_cases[i].host.begin, host.begin) << "Input: " <<
         input_cases[i].input;
     EXPECT_EQ(input_cases[i].host.len, host.len) << "Input: " <<
         input_cases[i].input;
   }
 }
 
 }  // namespace