Use search_term_value_prefix_ & search_term_value_suffix_ to specify the location of {searchTerms} …

components/search_engines/template_url_unittest.cc

 // Copyright 2014 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/base_paths.h"
 #include "base/command_line.h"
 #include "base/i18n/case_conversion.h"
 #include "base/macros.h"
@@ skipping 760 matching lines @@
             result.spec());
 }
 
 TEST_F(TemplateURLTest, HostAndSearchTermKey) {
   struct TestData {
     const std::string url;
     const std::string host;
     const std::string path;
     const std::string search_term_key;
   } test_data[] = {
-    { "http://blah/?foo=bar&q={searchTerms}&b=x", "blah", "/", "q"},
-    { "http://blah/{searchTerms}", "blah", "/", ""},
+      {"http://blah/?foo=bar&q={searchTerms}&b=x", "blah", "/", "q"},
+      {"http://blah/{searchTerms}", "blah", "", ""},
 
-    // No term should result in empty values.
-    { "http://blah/", "", "", ""},
+      // No term should result in empty values.
+      {"http://blah/", "", "", ""},
 
-    // Multiple terms should result in empty values.
-    { "http://blah/?q={searchTerms}&x={searchTerms}", "", "", ""},
+      // Multiple terms should result in empty values.
+      {"http://blah/?q={searchTerms}&x={searchTerms}", "", "", ""},
 
-    // Term in the host shouldn't match.
-    { "http://{searchTerms}", "", "", ""},
+      // Term in the host shouldn't match.
+      {"http://{searchTerms}", "", "", ""},
 
-    { "http://blah/?q={searchTerms}", "blah", "/", "q"},
-    { "https://blah/?q={searchTerms}", "blah", "/", "q"},
+      {"http://blah/?q={searchTerms}", "blah", "/", "q"},
+      {"https://blah/?q={searchTerms}", "blah", "/", "q"},
 
-    // Single term with extra chars in value should match.
-    { "http://blah/?q=stock:{searchTerms}", "blah", "/", "q"},
+      // Single term with extra chars in value should match.
+      {"http://blah/?q=stock:{searchTerms}", "blah", "/", "q"},
   };
 
   for (size_t i = 0; i < arraysize(test_data); ++i) {
     TemplateURLData data;
     data.SetURL(test_data[i].url);
     TemplateURL url(data);
     EXPECT_EQ(test_data[i].host, url.url_ref().GetHost(search_terms_data_));
     EXPECT_EQ(test_data[i].path, url.url_ref().GetPath(search_terms_data_));
     EXPECT_EQ(test_data[i].search_term_key,
               url.url_ref().GetSearchTermKey(search_terms_data_));
   }
 }
 
 TEST_F(TemplateURLTest, SearchTermKeyLocation) {
   struct TestData {
     const std::string url;
     const url::Parsed::ComponentType location;
     const std::string path;
-    size_t position_in_path;
+    const std::string key;
+    const std::string value_prefix;
+    const std::string value_suffix;
   } test_data[] = {
-    { "http://blah/{searchTerms}/", url::Parsed::PATH, "//", 1 },
-    { "http://blah/{searchTerms}", url::Parsed::PATH, "/", 1 },
-    { "http://blah/begin/{searchTerms}/end", url::Parsed::PATH, "/begin//end", 7 },
+      {"http://blah/{searchTerms}/", url::Parsed::PATH, "", "", "/", "/"},
+      {"http://blah/{searchTerms}", url::Parsed::PATH, "", "", "/", ""},
+      {"http://blah/begin/{searchTerms}/end", url::Parsed::PATH, "", "",
+       "/begin/", "/end"},
+      {"http://blah/?foo=bar&q={searchTerms}&b=x", url::Parsed::QUERY, "/", "q",
+       "", ""},
+      {"http://blah/?foo=bar#x={searchTerms}&b=x", url::Parsed::REF, "/", "x",
+       "", ""},
+      {"http://www.example.com/?q=chromium-{searchTerms}@chromium.org/info",
+       url::Parsed::QUERY, "/", "q", "chromium-", "@chromium.org/info"},
 
-    { "http://blah/?foo=bar&q={searchTerms}&b=x", url::Parsed::QUERY,
-      "/", std::string::npos },
-    { "http://blah/?foo=bar#x={searchTerms}&b=x", url::Parsed::REF,
-      "/", std::string::npos },
-    // searchTerms is a key, not a value, so this should result in an empty
-    // value.
-    { "http://blah/?foo=bar#x=012345678901234&a=b&{searchTerms}=x",
-      url::Parsed::QUERY, std::string(), std::string::npos },
+      // searchTerms is a key, not a value, so this should result in an empty
+      // value.
+      {"http://blah/?foo=bar#x=012345678901234&a=b&{searchTerms}=x",
+       url::Parsed::QUERY, "", "", "", ""},
 
-    // Multiple search terms should result in empty values.
-    { "http://blah/{searchTerms}?q={searchTerms}", url::Parsed::QUERY,
-      "", std::string::npos },
-    { "http://blah/{searchTerms}#x={searchTerms}", url::Parsed::QUERY,
-      "", std::string::npos },
-    { "http://blah/?q={searchTerms}#x={searchTerms}", url::Parsed::QUERY,
-      "", std::string::npos },
+      // Multiple search terms should result in empty values.
+      {"http://blah/{searchTerms}?q={searchTerms}", url::Parsed::QUERY, "", "",
+       "", ""},
+      {"http://blah/{searchTerms}#x={searchTerms}", url::Parsed::QUERY, "", "",
+       "", ""},
+      {"http://blah/?q={searchTerms}#x={searchTerms}", url::Parsed::QUERY, "",
+       "", "", ""},
   };
 
   for (size_t i = 0; i < arraysize(test_data); ++i) {
     TemplateURLData data;
     data.SetURL(test_data[i].url);
     TemplateURL url(data);
     EXPECT_EQ(test_data[i].location,
               url.url_ref().GetSearchTermKeyLocation(search_terms_data_));
     EXPECT_EQ(test_data[i].path,
               url.url_ref().GetPath(search_terms_data_));
-    EXPECT_EQ(test_data[i].position_in_path,
-              url.url_ref().GetSearchTermPositionInPath(search_terms_data_));
+    EXPECT_EQ(test_data[i].key,
+              url.url_ref().GetSearchTermKey(search_terms_data_));
+    EXPECT_EQ(test_data[i].value_prefix,
+              url.url_ref().GetSearchTermValuePrefix(search_terms_data_));
+    EXPECT_EQ(test_data[i].value_suffix,
+              url.url_ref().GetSearchTermValueSuffix(search_terms_data_));
   }
 }
 
 TEST_F(TemplateURLTest, GoogleBaseSuggestURL) {
   static const struct {
     const char* const base_url;
     const char* const base_suggest_url;
   } data[] = {
     { "http://google.com/", "http://google.com/complete/", },
     { "http://www.google.com/", "http://www.google.com/complete/", },
@@ skipping 1065 matching lines @@
   EXPECT_EQ(google_util::kInstantExtendedAPIParam,
             turl.search_terms_replacement_key());
   // Expect that replacement of {google:instantExtendedEnabledKey} in search url
   // is correct.
   GURL search_generated = turl.GenerateSearchURL(search_terms_data_);
   EXPECT_TRUE(turl.HasSearchTermsReplacementKey(search_generated));
   net::QueryIterator it(search_generated);
   ASSERT_FALSE(it.IsAtEnd());
   EXPECT_EQ(google_util::kInstantExtendedAPIParam, it.GetKey());
 }