src/chrome/browser/search_engines/template_url_unittest.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/base_paths.h"
   6 #include "base/command_line.h"
   7 #include "base/strings/string_number_conversions.h"
   8 #include "base/strings/string_util.h"
   9 #include "base/strings/utf_string_conversions.h"
  10 #include "chrome/browser/search_engines/template_url.h"
  11 #include "chrome/common/chrome_switches.h"
  12 #include "components/metrics/proto/omnibox_event.pb.h"
  13 #include "components/metrics/proto/omnibox_input_type.pb.h"
  14 #include "components/search_engines/search_terms_data.h"
  15 #include "testing/gtest/include/gtest/gtest.h"
  16
  17 using base::ASCIIToUTF16;
  18
  19 // TestSearchTermsData --------------------------------------------------------
  20
  21 // Simple implementation of SearchTermsData.
  22 class TestSearchTermsData : public SearchTermsData {
  23  public:
  24   explicit TestSearchTermsData(const std::string& google_base_url);
  25
  26   virtual std::string GoogleBaseURLValue() const OVERRIDE;
  27   virtual base::string16 GetRlzParameterValue(
  28       bool from_app_list) const OVERRIDE;
  29   virtual std::string GetSearchClient() const OVERRIDE;
  30   virtual std::string GoogleImageSearchSource() const OVERRIDE;
  31
  32   void set_google_base_url(const std::string& google_base_url) {
  33     google_base_url_ = google_base_url;
  34   }
  35   void set_search_client(const std::string& search_client) {
  36     search_client_ = search_client;
  37   }
  38
  39  private:
  40   std::string google_base_url_;
  41   std::string search_client_;
  42
  43   DISALLOW_COPY_AND_ASSIGN(TestSearchTermsData);
  44 };
  45
  46 TestSearchTermsData::TestSearchTermsData(const std::string& google_base_url)
  47     : google_base_url_(google_base_url) {
  48 }
  49
  50 std::string TestSearchTermsData::GoogleBaseURLValue() const {
  51   return google_base_url_;
  52 }
  53
  54 base::string16 TestSearchTermsData::GetRlzParameterValue(
  55     bool from_app_list) const {
  56   return ASCIIToUTF16(
  57       from_app_list ? "rlz_parameter_from_app_list" : "rlz_parameter");
  58 }
  59
  60 std::string TestSearchTermsData::GetSearchClient() const {
  61   return search_client_;
  62 }
  63
  64 std::string TestSearchTermsData::GoogleImageSearchSource() const {
  65   return "google_image_search_source";
  66 }
  67
  68 // TemplateURLTest ------------------------------------------------------------
  69
  70 class TemplateURLTest : public testing::Test {
  71  public:
  72   TemplateURLTest() : search_terms_data_("http://www.google.com/") {}
  73   void CheckSuggestBaseURL(const std::string& base_url,
  74                            const std::string& base_suggest_url) const;
  75
  76   TestSearchTermsData search_terms_data_;
  77 };
  78
  79 void TemplateURLTest::CheckSuggestBaseURL(
  80     const std::string& base_url,
  81     const std::string& base_suggest_url) const {
  82   TestSearchTermsData search_terms_data(base_url);
  83   EXPECT_EQ(base_suggest_url, search_terms_data.GoogleBaseSuggestURLValue());
  84 }
  85
  86
  87 // Actual tests ---------------------------------------------------------------
  88
  89 TEST_F(TemplateURLTest, Defaults) {
  90   TemplateURLData data;
  91   EXPECT_FALSE(data.show_in_default_list);
  92   EXPECT_FALSE(data.safe_for_autoreplace);
  93   EXPECT_EQ(0, data.prepopulate_id);
  94 }
  95
  96 TEST_F(TemplateURLTest, TestValidWithComplete) {
  97   TemplateURLData data;
  98   data.SetURL("{searchTerms}");
  99   TemplateURL url(data);
 100   EXPECT_TRUE(url.url_ref().IsValid(search_terms_data_));
 101 }
 102
 103 TEST_F(TemplateURLTest, URLRefTestSearchTerms) {
 104   struct SearchTermsCase {
 105     const char* url;
 106     const base::string16 terms;
 107     const std::string output;
 108   } search_term_cases[] = {
 109     { "http://foo{searchTerms}", ASCIIToUTF16("sea rch/bar"),
 110       "http://foosea%20rch/bar" },
 111     { "http://foo{searchTerms}?boo=abc", ASCIIToUTF16("sea rch/bar"),
 112       "http://foosea%20rch/bar?boo=abc" },
 113     { "http://foo/?boo={searchTerms}", ASCIIToUTF16("sea rch/bar"),
 114       "http://foo/?boo=sea+rch%2Fbar" },
 115     { "http://en.wikipedia.org/{searchTerms}", ASCIIToUTF16("wiki/?"),
 116       "http://en.wikipedia.org/wiki/%3F" }
 117   };
 118   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(search_term_cases); ++i) {
 119     const SearchTermsCase& value = search_term_cases[i];
 120     TemplateURLData data;
 121     data.SetURL(value.url);
 122     TemplateURL url(data);
 123     EXPECT_TRUE(url.url_ref().IsValid(search_terms_data_));
 124     ASSERT_TRUE(url.url_ref().SupportsReplacement(search_terms_data_));
 125     GURL result(url.url_ref().ReplaceSearchTerms(
 126         TemplateURLRef::SearchTermsArgs(value.terms), search_terms_data_));
 127     ASSERT_TRUE(result.is_valid());
 128     EXPECT_EQ(value.output, result.spec());
 129   }
 130 }
 131
 132 TEST_F(TemplateURLTest, URLRefTestCount) {
 133   TemplateURLData data;
 134   data.SetURL("http://foo{searchTerms}{count?}");
 135   TemplateURL url(data);
 136   EXPECT_TRUE(url.url_ref().IsValid(search_terms_data_));
 137   ASSERT_TRUE(url.url_ref().SupportsReplacement(search_terms_data_));
 138   GURL result(url.url_ref().ReplaceSearchTerms(
 139       TemplateURLRef::SearchTermsArgs(ASCIIToUTF16("X")), search_terms_data_));
 140   ASSERT_TRUE(result.is_valid());
 141   EXPECT_EQ("http://foox/", result.spec());
 142 }
 143
 144 TEST_F(TemplateURLTest, URLRefTestCount2) {
 145   TemplateURLData data;
 146   data.SetURL("http://foo{searchTerms}{count}");
 147   TemplateURL url(data);
 148   EXPECT_TRUE(url.url_ref().IsValid(search_terms_data_));
 149   ASSERT_TRUE(url.url_ref().SupportsReplacement(search_terms_data_));
 150   GURL result(url.url_ref().ReplaceSearchTerms(
 151       TemplateURLRef::SearchTermsArgs(ASCIIToUTF16("X")), search_terms_data_));
 152   ASSERT_TRUE(result.is_valid());
 153   EXPECT_EQ("http://foox10/", result.spec());
 154 }
 155
 156 TEST_F(TemplateURLTest, URLRefTestIndices) {
 157   TemplateURLData data;
 158   data.SetURL("http://foo{searchTerms}x{startIndex?}y{startPage?}");
 159   TemplateURL url(data);
 160   EXPECT_TRUE(url.url_ref().IsValid(search_terms_data_));
 161   ASSERT_TRUE(url.url_ref().SupportsReplacement(search_terms_data_));
 162   GURL result(url.url_ref().ReplaceSearchTerms(
 163       TemplateURLRef::SearchTermsArgs(ASCIIToUTF16("X")), search_terms_data_));
 164   ASSERT_TRUE(result.is_valid());
 165   EXPECT_EQ("http://fooxxy/", result.spec());
 166 }
 167
 168 TEST_F(TemplateURLTest, URLRefTestIndices2) {
 169   TemplateURLData data;
 170   data.SetURL("http://foo{searchTerms}x{startIndex}y{startPage}");
 171   TemplateURL url(data);
 172   EXPECT_TRUE(url.url_ref().IsValid(search_terms_data_));
 173   ASSERT_TRUE(url.url_ref().SupportsReplacement(search_terms_data_));
 174   GURL result(url.url_ref().ReplaceSearchTerms(
 175       TemplateURLRef::SearchTermsArgs(ASCIIToUTF16("X")), search_terms_data_));
 176   ASSERT_TRUE(result.is_valid());
 177   EXPECT_EQ("http://fooxx1y1/", result.spec());
 178 }
 179
 180 TEST_F(TemplateURLTest, URLRefTestEncoding) {
 181   TemplateURLData data;
 182   data.SetURL("http://foo{searchTerms}x{inputEncoding?}y{outputEncoding?}a");
 183   TemplateURL url(data);
 184   EXPECT_TRUE(url.url_ref().IsValid(search_terms_data_));
 185   ASSERT_TRUE(url.url_ref().SupportsReplacement(search_terms_data_));
 186   GURL result(url.url_ref().ReplaceSearchTerms(
 187       TemplateURLRef::SearchTermsArgs(ASCIIToUTF16("X")), search_terms_data_));
 188   ASSERT_TRUE(result.is_valid());
 189   EXPECT_EQ("http://fooxxutf-8ya/", result.spec());
 190 }
 191
 192 TEST_F(TemplateURLTest, URLRefTestImageURLWithPOST) {
 193   const char kInvalidPostParamsString[] =
 194       "unknown_template={UnknownTemplate},bad_value=bad{value},"
 195       "{google:sbiSource}";
 196   // List all accpectable parameter format in valid_post_params_string. it is
 197   // expected like: "name0=,name1=value1,name2={template1}"
 198   const char kValidPostParamsString[] =
 199       "image_content={google:imageThumbnail},image_url={google:imageURL},"
 200       "sbisrc={google:imageSearchSource},language={language},empty_param=,"
 201       "constant_param=constant,width={google:imageOriginalWidth}";
 202   const char KImageSearchURL[] = "http://foo.com/sbi";
 203
 204   TemplateURLData data;
 205   data.image_url = KImageSearchURL;
 206
 207   // Try to parse invalid post parameters.
 208   data.image_url_post_params = kInvalidPostParamsString;
 209   TemplateURL url_bad(data);
 210   ASSERT_FALSE(url_bad.image_url_ref().IsValid(search_terms_data_));
 211   const TemplateURLRef::PostParams& bad_post_params =
 212       url_bad.image_url_ref().post_params_;
 213   ASSERT_EQ(2U, bad_post_params.size());
 214   EXPECT_EQ("unknown_template", bad_post_params[0].first);
 215   EXPECT_EQ("{UnknownTemplate}", bad_post_params[0].second);
 216   EXPECT_EQ("bad_value", bad_post_params[1].first);
 217   EXPECT_EQ("bad{value}", bad_post_params[1].second);
 218
 219   // Try to parse valid post parameters.
 220   data.image_url_post_params = kValidPostParamsString;
 221   TemplateURL url(data);
 222   ASSERT_TRUE(url.image_url_ref().IsValid(search_terms_data_));
 223   ASSERT_FALSE(url.image_url_ref().SupportsReplacement(search_terms_data_));
 224
 225   // Check term replacement.
 226   TemplateURLRef::SearchTermsArgs search_args(ASCIIToUTF16("X"));
 227   search_args.image_thumbnail_content = "dummy-image-thumbnail";
 228   search_args.image_url = GURL("http://dummyimage.com/dummy.jpg");
 229   search_args.image_original_size = gfx::Size(10, 10);
 230   // Replacement operation with no post_data buffer should still return
 231   // the parsed URL.
 232   TestSearchTermsData search_terms_data("http://X");
 233   GURL result(url.image_url_ref().ReplaceSearchTerms(
 234       search_args, search_terms_data));
 235   ASSERT_TRUE(result.is_valid());
 236   EXPECT_EQ(KImageSearchURL, result.spec());
 237   TemplateURLRef::PostContent post_content;
 238   result = GURL(url.image_url_ref().ReplaceSearchTerms(
 239       search_args, search_terms_data, &post_content));
 240   ASSERT_TRUE(result.is_valid());
 241   EXPECT_EQ(KImageSearchURL, result.spec());
 242   ASSERT_FALSE(post_content.first.empty());
 243   ASSERT_FALSE(post_content.second.empty());
 244
 245   // Check parsed result of post parameters.
 246   const TemplateURLRef::Replacements& replacements =
 247       url.image_url_ref().replacements_;
 248   const TemplateURLRef::PostParams& post_params =
 249       url.image_url_ref().post_params_;
 250   EXPECT_EQ(7U, post_params.size());
 251   for (TemplateURLRef::PostParams::const_iterator i = post_params.begin();
 252        i != post_params.end(); ++i) {
 253     TemplateURLRef::Replacements::const_iterator j = replacements.begin();
 254     for (; j != replacements.end(); ++j) {
 255       if (j->is_post_param && j->index ==
 256           static_cast<size_t>(i - post_params.begin())) {
 257         switch (j->type) {
 258           case TemplateURLRef::GOOGLE_IMAGE_ORIGINAL_WIDTH:
 259             EXPECT_EQ("width", i->first);
 260             EXPECT_EQ(
 261                 base::IntToString(search_args.image_original_size.width()),
 262                 i->second);
 263             break;
 264           case TemplateURLRef::GOOGLE_IMAGE_SEARCH_SOURCE:
 265             EXPECT_EQ("sbisrc", i->first);
 266             EXPECT_EQ(search_terms_data.GoogleImageSearchSource(), i->second);
 267             break;
 268           case TemplateURLRef::GOOGLE_IMAGE_THUMBNAIL:
 269             EXPECT_EQ("image_content", i->first);
 270             EXPECT_EQ(search_args.image_thumbnail_content, i->second);
 271             break;
 272           case TemplateURLRef::GOOGLE_IMAGE_URL:
 273             EXPECT_EQ("image_url", i->first);
 274             EXPECT_EQ(search_args.image_url.spec(), i->second);
 275             break;
 276           case TemplateURLRef::LANGUAGE:
 277             EXPECT_EQ("language", i->first);
 278             EXPECT_EQ("en", i->second);
 279             break;
 280           default:
 281             ADD_FAILURE();  // Should never go here.
 282         }
 283         break;
 284       }
 285     }
 286     if (j != replacements.end())
 287       continue;
 288     if (i->first == "empty_param") {
 289       EXPECT_TRUE(i->second.empty());
 290     } else if (i->first == "sbisrc") {
 291       EXPECT_FALSE(i->second.empty());
 292     } else {
 293       EXPECT_EQ("constant_param", i->first);
 294       EXPECT_EQ("constant", i->second);
 295     }
 296   }
 297 }
 298
 299 // Test that setting the prepopulate ID from TemplateURL causes the stored
 300 // TemplateURLRef to handle parsing the URL parameters differently.
 301 TEST_F(TemplateURLTest, SetPrepopulatedAndParse) {
 302   TemplateURLData data;
 303   data.SetURL("http://foo{fhqwhgads}bar");
 304   TemplateURL url(data);
 305   TemplateURLRef::Replacements replacements;
 306   bool valid = false;
 307   EXPECT_EQ("http://foo{fhqwhgads}bar", url.url_ref().ParseURL(
 308       "http://foo{fhqwhgads}bar", &replacements, NULL, &valid));
 309   EXPECT_TRUE(replacements.empty());
 310   EXPECT_TRUE(valid);
 311
 312   data.prepopulate_id = 123;
 313   TemplateURL url2(data);
 314   EXPECT_EQ("http://foobar", url2.url_ref().ParseURL("http://foo{fhqwhgads}bar",
 315                                                      &replacements, NULL,
 316                                                      &valid));
 317   EXPECT_TRUE(replacements.empty());
 318   EXPECT_TRUE(valid);
 319 }
 320
 321 TEST_F(TemplateURLTest, InputEncodingBeforeSearchTerm) {
 322   TemplateURLData data;
 323   data.SetURL("http://foox{inputEncoding?}a{searchTerms}y{outputEncoding?}b");
 324   TemplateURL url(data);
 325   EXPECT_TRUE(url.url_ref().IsValid(search_terms_data_));
 326   ASSERT_TRUE(url.url_ref().SupportsReplacement(search_terms_data_));
 327   GURL result(url.url_ref().ReplaceSearchTerms(
 328       TemplateURLRef::SearchTermsArgs(ASCIIToUTF16("X")), search_terms_data_));
 329   ASSERT_TRUE(result.is_valid());
 330   EXPECT_EQ("http://fooxutf-8axyb/", result.spec());
 331 }
 332
 333 TEST_F(TemplateURLTest, URLRefTestEncoding2) {
 334   TemplateURLData data;
 335   data.SetURL("http://foo{searchTerms}x{inputEncoding}y{outputEncoding}a");
 336   TemplateURL url(data);
 337   EXPECT_TRUE(url.url_ref().IsValid(search_terms_data_));
 338   ASSERT_TRUE(url.url_ref().SupportsReplacement(search_terms_data_));
 339   GURL result(url.url_ref().ReplaceSearchTerms(
 340       TemplateURLRef::SearchTermsArgs(ASCIIToUTF16("X")), search_terms_data_));
 341   ASSERT_TRUE(result.is_valid());
 342   EXPECT_EQ("http://fooxxutf-8yutf-8a/", result.spec());
 343 }
 344
 345 TEST_F(TemplateURLTest, URLRefTestSearchTermsUsingTermsData) {
 346   struct SearchTermsCase {
 347     const char* url;
 348     const base::string16 terms;
 349     const char* output;
 350   } search_term_cases[] = {
 351     { "{google:baseURL}{language}{searchTerms}", base::string16(),
 352       "http://example.com/e/en" },
 353     { "{google:baseSuggestURL}{searchTerms}", base::string16(),
 354       "http://example.com/complete/" }
 355   };
 356
 357   TestSearchTermsData search_terms_data("http://example.com/e/");
 358   TemplateURLData data;
 359   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(search_term_cases); ++i) {
 360     const SearchTermsCase& value = search_term_cases[i];
 361     data.SetURL(value.url);
 362     TemplateURL url(data);
 363     EXPECT_TRUE(url.url_ref().IsValid(search_terms_data));
 364     ASSERT_TRUE(url.url_ref().SupportsReplacement(search_terms_data));
 365     GURL result(url.url_ref().ReplaceSearchTerms(
 366         TemplateURLRef::SearchTermsArgs(value.terms), search_terms_data, NULL));
 367     ASSERT_TRUE(result.is_valid());
 368     EXPECT_EQ(value.output, result.spec());
 369   }
 370 }
 371
 372 TEST_F(TemplateURLTest, URLRefTermToWide) {
 373   struct ToWideCase {
 374     const char* encoded_search_term;
 375     const base::string16 expected_decoded_term;
 376   } to_wide_cases[] = {
 377     {"hello+world", ASCIIToUTF16("hello world")},
 378     // Test some big-5 input.
 379     {"%a7A%A6%6e+to+you", base::WideToUTF16(L"\x4f60\x597d to you")},
 380     // Test some UTF-8 input. We should fall back to this when the encoding
 381     // doesn't look like big-5. We have a '5' in the middle, which is an invalid
 382     // Big-5 trailing byte.
 383     {"%e4%bd%a05%e5%a5%bd+to+you",
 384         base::WideToUTF16(L"\x4f60\x35\x597d to you")},
 385     // Undecodable input should stay escaped.
 386     {"%91%01+abcd", base::WideToUTF16(L"%91%01 abcd")},
 387     // Make sure we convert %2B to +.
 388     {"C%2B%2B", ASCIIToUTF16("C++")},
 389     // C%2B is escaped as C%252B, make sure we unescape it properly.
 390     {"C%252B", ASCIIToUTF16("C%2B")},
 391   };
 392
 393   // Set one input encoding: big-5. This is so we can test fallback to UTF-8.
 394   TemplateURLData data;
 395   data.SetURL("http://foo?q={searchTerms}");
 396   data.input_encodings.push_back("big-5");
 397   TemplateURL url(data);
 398   EXPECT_TRUE(url.url_ref().IsValid(search_terms_data_));
 399   ASSERT_TRUE(url.url_ref().SupportsReplacement(search_terms_data_));
 400   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(to_wide_cases); i++) {
 401     EXPECT_EQ(to_wide_cases[i].expected_decoded_term,
 402               url.url_ref().SearchTermToString16(
 403                   to_wide_cases[i].encoded_search_term));
 404   }
 405 }
 406
 407 TEST_F(TemplateURLTest, DisplayURLToURLRef) {
 408   struct TestData {
 409     const std::string url;
 410     const base::string16 expected_result;
 411   } test_data[] = {
 412     { "http://foo{searchTerms}x{inputEncoding}y{outputEncoding}a",
 413       ASCIIToUTF16("http://foo%sx{inputEncoding}y{outputEncoding}a") },
 414     { "http://X",
 415       ASCIIToUTF16("http://X") },
 416     { "http://foo{searchTerms",
 417       ASCIIToUTF16("http://foo{searchTerms") },
 418     { "http://foo{searchTerms}{language}",
 419       ASCIIToUTF16("http://foo%s{language}") },
 420   };
 421   TemplateURLData data;
 422   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
 423     data.SetURL(test_data[i].url);
 424     TemplateURL url(data);
 425     EXPECT_EQ(test_data[i].expected_result,
 426               url.url_ref().DisplayURL(search_terms_data_));
 427     EXPECT_EQ(test_data[i].url,
 428               TemplateURLRef::DisplayURLToURLRef(
 429                   url.url_ref().DisplayURL(search_terms_data_)));
 430   }
 431 }
 432
 433 TEST_F(TemplateURLTest, ReplaceSearchTerms) {
 434   struct TestData {
 435     const std::string url;
 436     const std::string expected_result;
 437   } test_data[] = {
 438     { "http://foo/{language}{searchTerms}{inputEncoding}",
 439       "http://foo/{language}XUTF-8" },
 440     { "http://foo/{language}{inputEncoding}{searchTerms}",
 441       "http://foo/{language}UTF-8X" },
 442     { "http://foo/{searchTerms}{language}{inputEncoding}",
 443       "http://foo/X{language}UTF-8" },
 444     { "http://foo/{searchTerms}{inputEncoding}{language}",
 445       "http://foo/XUTF-8{language}" },
 446     { "http://foo/{inputEncoding}{searchTerms}{language}",
 447       "http://foo/UTF-8X{language}" },
 448     { "http://foo/{inputEncoding}{language}{searchTerms}",
 449       "http://foo/UTF-8{language}X" },
 450     { "http://foo/{language}a{searchTerms}a{inputEncoding}a",
 451       "http://foo/{language}aXaUTF-8a" },
 452     { "http://foo/{language}a{inputEncoding}a{searchTerms}a",
 453       "http://foo/{language}aUTF-8aXa" },
 454     { "http://foo/{searchTerms}a{language}a{inputEncoding}a",
 455       "http://foo/Xa{language}aUTF-8a" },
 456     { "http://foo/{searchTerms}a{inputEncoding}a{language}a",
 457       "http://foo/XaUTF-8a{language}a" },
 458     { "http://foo/{inputEncoding}a{searchTerms}a{language}a",
 459       "http://foo/UTF-8aXa{language}a" },
 460     { "http://foo/{inputEncoding}a{language}a{searchTerms}a",
 461       "http://foo/UTF-8a{language}aXa" },
 462   };
 463   TemplateURLData data;
 464   data.input_encodings.push_back("UTF-8");
 465   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
 466     data.SetURL(test_data[i].url);
 467     TemplateURL url(data);
 468     EXPECT_TRUE(url.url_ref().IsValid(search_terms_data_));
 469     ASSERT_TRUE(url.url_ref().SupportsReplacement(search_terms_data_));
 470     std::string expected_result = test_data[i].expected_result;
 471     ReplaceSubstringsAfterOffset(&expected_result, 0, "{language}",
 472                                  search_terms_data_.GetApplicationLocale());
 473     GURL result(url.url_ref().ReplaceSearchTerms(
 474         TemplateURLRef::SearchTermsArgs(ASCIIToUTF16("X")),
 475         search_terms_data_));
 476     ASSERT_TRUE(result.is_valid());
 477     EXPECT_EQ(expected_result, result.spec());
 478   }
 479 }
 480
 481
 482 // Tests replacing search terms in various encodings and making sure the
 483 // generated URL matches the expected value.
 484 TEST_F(TemplateURLTest, ReplaceArbitrarySearchTerms) {
 485   struct TestData {
 486     const std::string encoding;
 487     const base::string16 search_term;
 488     const std::string url;
 489     const std::string expected_result;
 490   } test_data[] = {
 491     { "BIG5",  base::WideToUTF16(L"\x60BD"),
 492       "http://foo/?{searchTerms}{inputEncoding}",
 493       "http://foo/?%B1~BIG5" },
 494     { "UTF-8", ASCIIToUTF16("blah"),
 495       "http://foo/?{searchTerms}{inputEncoding}",
 496       "http://foo/?blahUTF-8" },
 497     { "Shift_JIS", base::UTF8ToUTF16("\xe3\x81\x82"),
 498       "http://foo/{searchTerms}/bar",
 499       "http://foo/%82%A0/bar"},
 500     { "Shift_JIS", base::UTF8ToUTF16("\xe3\x81\x82 \xe3\x81\x84"),
 501       "http://foo/{searchTerms}/bar",
 502       "http://foo/%82%A0%20%82%A2/bar"},
 503   };
 504   TemplateURLData data;
 505   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
 506     data.SetURL(test_data[i].url);
 507     data.input_encodings.clear();
 508     data.input_encodings.push_back(test_data[i].encoding);
 509     TemplateURL url(data);
 510     EXPECT_TRUE(url.url_ref().IsValid(search_terms_data_));
 511     ASSERT_TRUE(url.url_ref().SupportsReplacement(search_terms_data_));
 512     GURL result(url.url_ref().ReplaceSearchTerms(
 513         TemplateURLRef::SearchTermsArgs(test_data[i].search_term),
 514         search_terms_data_));
 515     ASSERT_TRUE(result.is_valid());
 516     EXPECT_EQ(test_data[i].expected_result, result.spec());
 517   }
 518 }
 519
 520 // Tests replacing assisted query stats (AQS) in various scenarios.
 521 TEST_F(TemplateURLTest, ReplaceAssistedQueryStats) {
 522   struct TestData {
 523     const base::string16 search_term;
 524     const std::string aqs;
 525     const std::string base_url;
 526     const std::string url;
 527     const std::string expected_result;
 528   } test_data[] = {
 529     // No HTTPS, no AQS.
 530     { ASCIIToUTF16("foo"),
 531       "chrome.0.0l6",
 532       "http://foo/",
 533       "{google:baseURL}?{searchTerms}{google:assistedQueryStats}",
 534       "http://foo/?foo" },
 535     // HTTPS available, AQS should be replaced.
 536     { ASCIIToUTF16("foo"),
 537       "chrome.0.0l6",
 538       "https://foo/",
 539       "{google:baseURL}?{searchTerms}{google:assistedQueryStats}",
 540       "https://foo/?fooaqs=chrome.0.0l6&" },
 541     // HTTPS available, however AQS is empty.
 542     { ASCIIToUTF16("foo"),
 543       "",
 544       "https://foo/",
 545       "{google:baseURL}?{searchTerms}{google:assistedQueryStats}",
 546       "https://foo/?foo" },
 547     // No {google:baseURL} and protocol is HTTP, we must not substitute AQS.
 548     { ASCIIToUTF16("foo"),
 549       "chrome.0.0l6",
 550       "http://www.google.com",
 551       "http://foo?{searchTerms}{google:assistedQueryStats}",
 552       "http://foo/?foo" },
 553     // A non-Google search provider with HTTPS should allow AQS.
 554     { ASCIIToUTF16("foo"),
 555       "chrome.0.0l6",
 556       "https://www.google.com",
 557       "https://foo?{searchTerms}{google:assistedQueryStats}",
 558       "https://foo/?fooaqs=chrome.0.0l6&" },
 559   };
 560   TemplateURLData data;
 561   data.input_encodings.push_back("UTF-8");
 562   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
 563     data.SetURL(test_data[i].url);
 564     TemplateURL url(data);
 565     EXPECT_TRUE(url.url_ref().IsValid(search_terms_data_));
 566     ASSERT_TRUE(url.url_ref().SupportsReplacement(search_terms_data_));
 567     TemplateURLRef::SearchTermsArgs search_terms_args(test_data[i].search_term);
 568     search_terms_args.assisted_query_stats = test_data[i].aqs;
 569     search_terms_data_.set_google_base_url(test_data[i].base_url);
 570     GURL result(url.url_ref().ReplaceSearchTerms(search_terms_args,
 571                                                  search_terms_data_));
 572     ASSERT_TRUE(result.is_valid());
 573     EXPECT_EQ(test_data[i].expected_result, result.spec());
 574   }
 575 }
 576
 577 // Tests replacing cursor position.
 578 TEST_F(TemplateURLTest, ReplaceCursorPosition) {
 579   struct TestData {
 580     const base::string16 search_term;
 581     size_t cursor_position;
 582     const std::string url;
 583     const std::string expected_result;
 584   } test_data[] = {
 585     { ASCIIToUTF16("foo"),
 586       base::string16::npos,
 587       "{google:baseURL}?{searchTerms}&{google:cursorPosition}",
 588       "http://www.google.com/?foo&" },
 589     { ASCIIToUTF16("foo"),
 590       2,
 591       "{google:baseURL}?{searchTerms}&{google:cursorPosition}",
 592       "http://www.google.com/?foo&cp=2&" },
 593     { ASCIIToUTF16("foo"),
 594       15,
 595       "{google:baseURL}?{searchTerms}&{google:cursorPosition}",
 596       "http://www.google.com/?foo&cp=15&" },
 597   };
 598   TemplateURLData data;
 599   data.input_encodings.push_back("UTF-8");
 600   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
 601     data.SetURL(test_data[i].url);
 602     TemplateURL url(data);
 603     EXPECT_TRUE(url.url_ref().IsValid(search_terms_data_));
 604     ASSERT_TRUE(url.url_ref().SupportsReplacement(search_terms_data_));
 605     TemplateURLRef::SearchTermsArgs search_terms_args(test_data[i].search_term);
 606     search_terms_args.cursor_position = test_data[i].cursor_position;
 607     GURL result(url.url_ref().ReplaceSearchTerms(search_terms_args,
 608                                                  search_terms_data_));
 609     ASSERT_TRUE(result.is_valid());
 610     EXPECT_EQ(test_data[i].expected_result, result.spec());
 611   }
 612 }
 613
 614 // Tests replacing input type (&oit=).
 615 TEST_F(TemplateURLTest, ReplaceInputType) {
 616   struct TestData {
 617     const base::string16 search_term;
 618     metrics::OmniboxInputType::Type input_type;
 619     const std::string url;
 620     const std::string expected_result;
 621   } test_data[] = {
 622     { ASCIIToUTF16("foo"),
 623       metrics::OmniboxInputType::UNKNOWN,
 624       "{google:baseURL}?{searchTerms}&{google:inputType}",
 625       "http://www.google.com/?foo&oit=1&" },
 626     { ASCIIToUTF16("foo"),
 627       metrics::OmniboxInputType::URL,
 628       "{google:baseURL}?{searchTerms}&{google:inputType}",
 629       "http://www.google.com/?foo&oit=3&" },
 630     { ASCIIToUTF16("foo"),
 631       metrics::OmniboxInputType::FORCED_QUERY,
 632       "{google:baseURL}?{searchTerms}&{google:inputType}",
 633       "http://www.google.com/?foo&oit=5&" },
 634   };
 635   TemplateURLData data;
 636   data.input_encodings.push_back("UTF-8");
 637   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
 638     data.SetURL(test_data[i].url);
 639     TemplateURL url(data);
 640     EXPECT_TRUE(url.url_ref().IsValid(search_terms_data_));
 641     ASSERT_TRUE(url.url_ref().SupportsReplacement(search_terms_data_));
 642     TemplateURLRef::SearchTermsArgs search_terms_args(test_data[i].search_term);
 643     search_terms_args.input_type = test_data[i].input_type;
 644     GURL result(url.url_ref().ReplaceSearchTerms(search_terms_args,
 645                                                  search_terms_data_));
 646     ASSERT_TRUE(result.is_valid());
 647     EXPECT_EQ(test_data[i].expected_result, result.spec());
 648   }
 649 }
 650
 651 // Tests replacing currentPageUrl.
 652 TEST_F(TemplateURLTest, ReplaceCurrentPageUrl) {
 653   struct TestData {
 654     const base::string16 search_term;
 655     const std::string current_page_url;
 656     const std::string url;
 657     const std::string expected_result;
 658   } test_data[] = {
 659     { ASCIIToUTF16("foo"),
 660       "http://www.google.com/",
 661       "{google:baseURL}?{searchTerms}&{google:currentPageUrl}",
 662       "http://www.google.com/?foo&url=http%3A%2F%2Fwww.google.com%2F&" },
 663     { ASCIIToUTF16("foo"),
 664       "",
 665       "{google:baseURL}?{searchTerms}&{google:currentPageUrl}",
 666       "http://www.google.com/?foo&" },
 667     { ASCIIToUTF16("foo"),
 668       "http://g.com/+-/*&=",
 669       "{google:baseURL}?{searchTerms}&{google:currentPageUrl}",
 670       "http://www.google.com/?foo&url=http%3A%2F%2Fg.com%2F%2B-%2F*%26%3D&" },
 671   };
 672   TemplateURLData data;
 673   data.input_encodings.push_back("UTF-8");
 674   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
 675     data.SetURL(test_data[i].url);
 676     TemplateURL url(data);
 677     EXPECT_TRUE(url.url_ref().IsValid(search_terms_data_));
 678     ASSERT_TRUE(url.url_ref().SupportsReplacement(search_terms_data_));
 679     TemplateURLRef::SearchTermsArgs search_terms_args(test_data[i].search_term);
 680     search_terms_args.current_page_url = test_data[i].current_page_url;
 681     GURL result(url.url_ref().ReplaceSearchTerms(search_terms_args,
 682                                                  search_terms_data_));
 683     ASSERT_TRUE(result.is_valid());
 684     EXPECT_EQ(test_data[i].expected_result, result.spec());
 685   }
 686 }
 687
 688 TEST_F(TemplateURLTest, Suggestions) {
 689   struct TestData {
 690     const int accepted_suggestion;
 691     const base::string16 original_query_for_suggestion;
 692     const std::string expected_result;
 693   } test_data[] = {
 694     { TemplateURLRef::NO_SUGGESTIONS_AVAILABLE, base::string16(),
 695       "http://bar/foo?q=foobar" },
 696     { TemplateURLRef::NO_SUGGESTIONS_AVAILABLE, ASCIIToUTF16("foo"),
 697       "http://bar/foo?q=foobar" },
 698     { TemplateURLRef::NO_SUGGESTION_CHOSEN, base::string16(),
 699       "http://bar/foo?q=foobar" },
 700     { TemplateURLRef::NO_SUGGESTION_CHOSEN, ASCIIToUTF16("foo"),
 701       "http://bar/foo?q=foobar" },
 702     { 0, base::string16(), "http://bar/foo?oq=&q=foobar" },
 703     { 1, ASCIIToUTF16("foo"), "http://bar/foo?oq=foo&q=foobar" },
 704   };
 705   TemplateURLData data;
 706   data.SetURL("http://bar/foo?{google:originalQueryForSuggestion}"
 707               "q={searchTerms}");
 708   data.input_encodings.push_back("UTF-8");
 709   TemplateURL url(data);
 710   EXPECT_TRUE(url.url_ref().IsValid(search_terms_data_));
 711   ASSERT_TRUE(url.url_ref().SupportsReplacement(search_terms_data_));
 712   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
 713     TemplateURLRef::SearchTermsArgs search_terms_args(
 714         ASCIIToUTF16("foobar"));
 715     search_terms_args.accepted_suggestion = test_data[i].accepted_suggestion;
 716     search_terms_args.original_query =
 717         test_data[i].original_query_for_suggestion;
 718     GURL result(url.url_ref().ReplaceSearchTerms(search_terms_args,
 719                                                  search_terms_data_));
 720     ASSERT_TRUE(result.is_valid());
 721     EXPECT_EQ(test_data[i].expected_result, result.spec());
 722   }
 723 }
 724
 725 TEST_F(TemplateURLTest, RLZ) {
 726   base::string16 rlz_string = search_terms_data_.GetRlzParameterValue(false);
 727
 728   TemplateURLData data;
 729   data.SetURL("http://bar/?{google:RLZ}{searchTerms}");
 730   TemplateURL url(data);
 731   EXPECT_TRUE(url.url_ref().IsValid(search_terms_data_));
 732   ASSERT_TRUE(url.url_ref().SupportsReplacement(search_terms_data_));
 733   GURL result(url.url_ref().ReplaceSearchTerms(
 734       TemplateURLRef::SearchTermsArgs(ASCIIToUTF16("x")), search_terms_data_));
 735   ASSERT_TRUE(result.is_valid());
 736   EXPECT_EQ("http://bar/?rlz=" + base::UTF16ToUTF8(rlz_string) + "&x",
 737             result.spec());
 738 }
 739
 740 TEST_F(TemplateURLTest, RLZFromAppList) {
 741   base::string16 rlz_string = search_terms_data_.GetRlzParameterValue(true);
 742
 743   TemplateURLData data;
 744   data.SetURL("http://bar/?{google:RLZ}{searchTerms}");
 745   TemplateURL url(data);
 746   EXPECT_TRUE(url.url_ref().IsValid(search_terms_data_));
 747   ASSERT_TRUE(url.url_ref().SupportsReplacement(search_terms_data_));
 748   TemplateURLRef::SearchTermsArgs args(ASCIIToUTF16("x"));
 749   args.from_app_list = true;
 750   GURL result(url.url_ref().ReplaceSearchTerms(args, search_terms_data_));
 751   ASSERT_TRUE(result.is_valid());
 752   EXPECT_EQ("http://bar/?rlz=" + base::UTF16ToUTF8(rlz_string) + "&x",
 753             result.spec());
 754 }
 755
 756 TEST_F(TemplateURLTest, HostAndSearchTermKey) {
 757   struct TestData {
 758     const std::string url;
 759     const std::string host;
 760     const std::string path;
 761     const std::string search_term_key;
 762   } test_data[] = {
 763     { "http://blah/?foo=bar&q={searchTerms}&b=x", "blah", "/", "q"},
 764
 765     // No query key should result in empty values.
 766     { "http://blah/{searchTerms}", "", "", ""},
 767
 768     // No term should result in empty values.
 769     { "http://blah/", "", "", ""},
 770
 771     // Multiple terms should result in empty values.
 772     { "http://blah/?q={searchTerms}&x={searchTerms}", "", "", ""},
 773
 774     // Term in the host shouldn't match.
 775     { "http://{searchTerms}", "", "", ""},
 776
 777     { "http://blah/?q={searchTerms}", "blah", "/", "q"},
 778     { "https://blah/?q={searchTerms}", "blah", "/", "q"},
 779
 780     // Single term with extra chars in value should match.
 781     { "http://blah/?q=stock:{searchTerms}", "blah", "/", "q"},
 782   };
 783
 784   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
 785     TemplateURLData data;
 786     data.SetURL(test_data[i].url);
 787     TemplateURL url(data);
 788     EXPECT_EQ(test_data[i].host, url.url_ref().GetHost(search_terms_data_));
 789     EXPECT_EQ(test_data[i].path, url.url_ref().GetPath(search_terms_data_));
 790     EXPECT_EQ(test_data[i].search_term_key,
 791               url.url_ref().GetSearchTermKey(search_terms_data_));
 792   }
 793 }
 794
 795 TEST_F(TemplateURLTest, GoogleBaseSuggestURL) {
 796   static const struct {
 797     const char* const base_url;
 798     const char* const base_suggest_url;
 799   } data[] = {
 800     { "http://google.com/", "http://google.com/complete/", },
 801     { "http://www.google.com/", "http://www.google.com/complete/", },
 802     { "http://www.google.co.uk/", "http://www.google.co.uk/complete/", },
 803     { "http://www.google.com.by/", "http://www.google.com.by/complete/", },
 804     { "http://google.com/intl/xx/", "http://google.com/complete/", },
 805   };
 806
 807   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(data); ++i)
 808     CheckSuggestBaseURL(data[i].base_url, data[i].base_suggest_url);
 809 }
 810
 811 TEST_F(TemplateURLTest, ParseParameterKnown) {
 812   std::string parsed_url("{searchTerms}");
 813   TemplateURLData data;
 814   data.SetURL(parsed_url);
 815   TemplateURL url(data);
 816   TemplateURLRef::Replacements replacements;
 817   EXPECT_TRUE(url.url_ref().ParseParameter(0, 12, &parsed_url, &replacements));
 818   EXPECT_EQ(std::string(), parsed_url);
 819   ASSERT_EQ(1U, replacements.size());
 820   EXPECT_EQ(0U, replacements[0].index);
 821   EXPECT_EQ(TemplateURLRef::SEARCH_TERMS, replacements[0].type);
 822 }
 823
 824 TEST_F(TemplateURLTest, ParseParameterUnknown) {
 825   std::string parsed_url("{fhqwhgads}abc");
 826   TemplateURLData data;
 827   data.SetURL(parsed_url);
 828   TemplateURL url(data);
 829   TemplateURLRef::Replacements replacements;
 830
 831   // By default, TemplateURLRef should not consider itself prepopulated.
 832   // Therefore we should not replace the unknown parameter.
 833   EXPECT_FALSE(url.url_ref().ParseParameter(0, 10, &parsed_url, &replacements));
 834   EXPECT_EQ("{fhqwhgads}abc", parsed_url);
 835   EXPECT_TRUE(replacements.empty());
 836
 837   // If the TemplateURLRef is prepopulated, we should remove unknown parameters.
 838   parsed_url = "{fhqwhgads}abc";
 839   data.prepopulate_id = 1;
 840   TemplateURL url2(data);
 841   EXPECT_TRUE(url2.url_ref().ParseParameter(0, 10, &parsed_url, &replacements));
 842   EXPECT_EQ("abc", parsed_url);
 843   EXPECT_TRUE(replacements.empty());
 844 }
 845
 846 TEST_F(TemplateURLTest, ParseURLEmpty) {
 847   TemplateURL url((TemplateURLData()));
 848   TemplateURLRef::Replacements replacements;
 849   bool valid = false;
 850   EXPECT_EQ(std::string(),
 851             url.url_ref().ParseURL(std::string(), &replacements, NULL, &valid));
 852   EXPECT_TRUE(replacements.empty());
 853   EXPECT_TRUE(valid);
 854 }
 855
 856 TEST_F(TemplateURLTest, ParseURLNoTemplateEnd) {
 857   TemplateURLData data;
 858   data.SetURL("{");
 859   TemplateURL url(data);
 860   TemplateURLRef::Replacements replacements;
 861   bool valid = false;
 862   EXPECT_EQ(std::string(), url.url_ref().ParseURL("{", &replacements, NULL,
 863                                                   &valid));
 864   EXPECT_TRUE(replacements.empty());
 865   EXPECT_FALSE(valid);
 866 }
 867
 868 TEST_F(TemplateURLTest, ParseURLNoKnownParameters) {
 869   TemplateURLData data;
 870   data.SetURL("{}");
 871   TemplateURL url(data);
 872   TemplateURLRef::Replacements replacements;
 873   bool valid = false;
 874   EXPECT_EQ("{}", url.url_ref().ParseURL("{}", &replacements, NULL, &valid));
 875   EXPECT_TRUE(replacements.empty());
 876   EXPECT_TRUE(valid);
 877 }
 878
 879 TEST_F(TemplateURLTest, ParseURLTwoParameters) {
 880   TemplateURLData data;
 881   data.SetURL("{}{{%s}}");
 882   TemplateURL url(data);
 883   TemplateURLRef::Replacements replacements;
 884   bool valid = false;
 885   EXPECT_EQ("{}{}",
 886             url.url_ref().ParseURL("{}{{searchTerms}}", &replacements, NULL,
 887                                    &valid));
 888   ASSERT_EQ(1U, replacements.size());
 889   EXPECT_EQ(3U, replacements[0].index);
 890   EXPECT_EQ(TemplateURLRef::SEARCH_TERMS, replacements[0].type);
 891   EXPECT_TRUE(valid);
 892 }
 893
 894 TEST_F(TemplateURLTest, ParseURLNestedParameter) {
 895   TemplateURLData data;
 896   data.SetURL("{%s");
 897   TemplateURL url(data);
 898   TemplateURLRef::Replacements replacements;
 899   bool valid = false;
 900   EXPECT_EQ("{",
 901             url.url_ref().ParseURL("{{searchTerms}", &replacements, NULL,
 902                                    &valid));
 903   ASSERT_EQ(1U, replacements.size());
 904   EXPECT_EQ(1U, replacements[0].index);
 905   EXPECT_EQ(TemplateURLRef::SEARCH_TERMS, replacements[0].type);
 906   EXPECT_TRUE(valid);
 907 }
 908
 909 TEST_F(TemplateURLTest, SearchClient) {
 910   const std::string base_url_str("http://google.com/?");
 911   const std::string terms_str("{searchTerms}&{google:searchClient}");
 912   const std::string full_url_str = base_url_str + terms_str;
 913   const base::string16 terms(ASCIIToUTF16(terms_str));
 914   search_terms_data_.set_google_base_url(base_url_str);
 915
 916   TemplateURLData data;
 917   data.SetURL(full_url_str);
 918   TemplateURL url(data);
 919   EXPECT_TRUE(url.url_ref().IsValid(search_terms_data_));
 920   ASSERT_TRUE(url.url_ref().SupportsReplacement(search_terms_data_));
 921   TemplateURLRef::SearchTermsArgs search_terms_args(ASCIIToUTF16("foobar"));
 922
 923   // Check that the URL is correct when a client is not present.
 924   GURL result(url.url_ref().ReplaceSearchTerms(search_terms_args,
 925                                                search_terms_data_));
 926   ASSERT_TRUE(result.is_valid());
 927   EXPECT_EQ("http://google.com/?foobar&", result.spec());
 928
 929   // Check that the URL is correct when a client is present.
 930   search_terms_data_.set_search_client("search_client");
 931   GURL result_2(url.url_ref().ReplaceSearchTerms(search_terms_args,
 932                                                  search_terms_data_));
 933   ASSERT_TRUE(result_2.is_valid());
 934   EXPECT_EQ("http://google.com/?foobar&client=search_client&", result_2.spec());
 935 }
 936
 937 TEST_F(TemplateURLTest, GetURLNoInstantURL) {
 938   TemplateURLData data;
 939   data.SetURL("http://google.com/?q={searchTerms}");
 940   data.suggestions_url = "http://google.com/suggest?q={searchTerms}";
 941   data.alternate_urls.push_back("http://google.com/alt?q={searchTerms}");
 942   data.alternate_urls.push_back("{google:baseURL}/alt/#q={searchTerms}");
 943   TemplateURL url(data);
 944   ASSERT_EQ(3U, url.URLCount());
 945   EXPECT_EQ("http://google.com/alt?q={searchTerms}", url.GetURL(0));
 946   EXPECT_EQ("{google:baseURL}/alt/#q={searchTerms}", url.GetURL(1));
 947   EXPECT_EQ("http://google.com/?q={searchTerms}", url.GetURL(2));
 948 }
 949
 950 TEST_F(TemplateURLTest, GetURLNoSuggestionsURL) {
 951   TemplateURLData data;
 952   data.SetURL("http://google.com/?q={searchTerms}");
 953   data.instant_url = "http://google.com/instant#q={searchTerms}";
 954   data.alternate_urls.push_back("http://google.com/alt?q={searchTerms}");
 955   data.alternate_urls.push_back("{google:baseURL}/alt/#q={searchTerms}");
 956   TemplateURL url(data);
 957   ASSERT_EQ(3U, url.URLCount());
 958   EXPECT_EQ("http://google.com/alt?q={searchTerms}", url.GetURL(0));
 959   EXPECT_EQ("{google:baseURL}/alt/#q={searchTerms}", url.GetURL(1));
 960   EXPECT_EQ("http://google.com/?q={searchTerms}", url.GetURL(2));
 961 }
 962
 963 TEST_F(TemplateURLTest, GetURLOnlyOneURL) {
 964   TemplateURLData data;
 965   data.SetURL("http://www.google.co.uk/");
 966   TemplateURL url(data);
 967   ASSERT_EQ(1U, url.URLCount());
 968   EXPECT_EQ("http://www.google.co.uk/", url.GetURL(0));
 969 }
 970
 971 TEST_F(TemplateURLTest, ExtractSearchTermsFromURL) {
 972   TemplateURLData data;
 973   data.SetURL("http://google.com/?q={searchTerms}");
 974   data.instant_url = "http://google.com/instant#q={searchTerms}";
 975   data.alternate_urls.push_back("http://google.com/alt/#q={searchTerms}");
 976   data.alternate_urls.push_back(
 977       "http://google.com/alt/?ext=foo&q={searchTerms}#ref=bar");
 978   TemplateURL url(data);
 979   base::string16 result;
 980
 981   EXPECT_TRUE(url.ExtractSearchTermsFromURL(
 982       GURL("http://google.com/?q=something"), search_terms_data_, &result));
 983   EXPECT_EQ(ASCIIToUTF16("something"), result);
 984
 985   EXPECT_TRUE(url.ExtractSearchTermsFromURL(
 986       GURL("http://google.com/?espv&q=something"),
 987       search_terms_data_, &result));
 988   EXPECT_EQ(ASCIIToUTF16("something"), result);
 989
 990   EXPECT_TRUE(url.ExtractSearchTermsFromURL(
 991       GURL("http://google.com/?espv=1&q=something"),
 992       search_terms_data_, &result));
 993   EXPECT_EQ(ASCIIToUTF16("something"), result);
 994
 995   EXPECT_TRUE(url.ExtractSearchTermsFromURL(
 996       GURL("http://google.com/?espv=0&q=something"),
 997       search_terms_data_, &result));
 998   EXPECT_EQ(ASCIIToUTF16("something"), result);
 999
1000   EXPECT_TRUE(url.ExtractSearchTermsFromURL(
1001       GURL("http://google.com/alt/#q=something"),
1002       search_terms_data_, &result));
1003   EXPECT_EQ(ASCIIToUTF16("something"), result);
1004
1005   EXPECT_TRUE(url.ExtractSearchTermsFromURL(
1006       GURL("http://google.com/alt/#espv&q=something"),
1007       search_terms_data_, &result));
1008   EXPECT_EQ(ASCIIToUTF16("something"), result);
1009
1010   EXPECT_TRUE(url.ExtractSearchTermsFromURL(
1011       GURL("http://google.com/alt/#espv=1&q=something"),
1012       search_terms_data_, &result));
1013   EXPECT_EQ(ASCIIToUTF16("something"), result);
1014
1015   EXPECT_TRUE(url.ExtractSearchTermsFromURL(
1016       GURL("http://google.com/alt/#espv=0&q=something"),
1017       search_terms_data_, &result));
1018   EXPECT_EQ(ASCIIToUTF16("something"), result);
1019
1020   EXPECT_FALSE(url.ExtractSearchTermsFromURL(
1021       GURL("http://google.ca/?q=something"), search_terms_data_, &result));
1022   EXPECT_EQ(base::string16(), result);
1023
1024   EXPECT_FALSE(url.ExtractSearchTermsFromURL(
1025       GURL("http://google.ca/?q=something&q=anything"),
1026       search_terms_data_, &result));
1027   EXPECT_EQ(base::string16(), result);
1028
1029   EXPECT_FALSE(url.ExtractSearchTermsFromURL(
1030       GURL("http://google.com/foo/?q=foo"), search_terms_data_, &result));
1031   EXPECT_EQ(base::string16(), result);
1032
1033   EXPECT_TRUE(url.ExtractSearchTermsFromURL(
1034       GURL("https://google.com/?q=foo"), search_terms_data_, &result));
1035   EXPECT_EQ(ASCIIToUTF16("foo"), result);
1036
1037   EXPECT_FALSE(url.ExtractSearchTermsFromURL(
1038       GURL("http://google.com:8080/?q=foo"), search_terms_data_, &result));
1039   EXPECT_EQ(base::string16(), result);
1040
1041   EXPECT_TRUE(url.ExtractSearchTermsFromURL(
1042       GURL("http://google.com/?q=1+2+3&b=456"), search_terms_data_, &result));
1043   EXPECT_EQ(ASCIIToUTF16("1 2 3"), result);
1044
1045   EXPECT_TRUE(url.ExtractSearchTermsFromURL(
1046       GURL("http://google.com/alt/?q=123#q=456"),
1047       search_terms_data_, &result));
1048   EXPECT_EQ(ASCIIToUTF16("456"), result);
1049
1050   EXPECT_TRUE(url.ExtractSearchTermsFromURL(
1051       GURL("http://google.com/alt/?a=012&q=123&b=456#f=789"),
1052       search_terms_data_, &result));
1053   EXPECT_EQ(ASCIIToUTF16("123"), result);
1054
1055   EXPECT_TRUE(url.ExtractSearchTermsFromURL(GURL(
1056       "http://google.com/alt/?a=012&q=123&b=456#j=abc&q=789&h=def9"),
1057                                             search_terms_data_, &result));
1058   EXPECT_EQ(ASCIIToUTF16("789"), result);
1059
1060   EXPECT_FALSE(url.ExtractSearchTermsFromURL(
1061       GURL("http://google.com/alt/?q="), search_terms_data_, &result));
1062   EXPECT_EQ(base::string16(), result);
1063
1064   EXPECT_FALSE(url.ExtractSearchTermsFromURL(
1065       GURL("http://google.com/alt/?#q="), search_terms_data_, &result));
1066   EXPECT_EQ(base::string16(), result);
1067
1068   EXPECT_FALSE(url.ExtractSearchTermsFromURL(
1069       GURL("http://google.com/alt/?q=#q="), search_terms_data_, &result));
1070   EXPECT_EQ(base::string16(), result);
1071
1072   EXPECT_FALSE(url.ExtractSearchTermsFromURL(
1073       GURL("http://google.com/alt/?q=123#q="), search_terms_data_, &result));
1074   EXPECT_EQ(base::string16(), result);
1075
1076   EXPECT_TRUE(url.ExtractSearchTermsFromURL(
1077       GURL("http://google.com/alt/?q=#q=123"), search_terms_data_, &result));
1078   EXPECT_EQ(ASCIIToUTF16("123"), result);
1079 }
1080
1081 TEST_F(TemplateURLTest, HasSearchTermsReplacementKey) {
1082   TemplateURLData data;
1083   data.SetURL("http://google.com/?q={searchTerms}");
1084   data.instant_url = "http://google.com/instant#q={searchTerms}";
1085   data.alternate_urls.push_back("http://google.com/alt/#q={searchTerms}");
1086   data.alternate_urls.push_back(
1087       "http://google.com/alt/?ext=foo&q={searchTerms}#ref=bar");
1088   data.search_terms_replacement_key = "espv";
1089   TemplateURL url(data);
1090
1091   // Test with instant enabled required.
1092   EXPECT_FALSE(url.HasSearchTermsReplacementKey(
1093       GURL("http://google.com/")));
1094
1095   EXPECT_TRUE(url.HasSearchTermsReplacementKey(
1096       GURL("http://google.com/?espv")));
1097
1098   EXPECT_TRUE(url.HasSearchTermsReplacementKey(
1099       GURL("http://google.com/#espv")));
1100
1101   EXPECT_FALSE(url.HasSearchTermsReplacementKey(
1102       GURL("http://google.com/?q=something")));
1103
1104   EXPECT_TRUE(url.HasSearchTermsReplacementKey(
1105       GURL("http://google.com/?q=something&espv")));
1106
1107   EXPECT_TRUE(url.HasSearchTermsReplacementKey(
1108       GURL("http://google.com/?q=something&espv=1")));
1109
1110   EXPECT_TRUE(url.HasSearchTermsReplacementKey(
1111       GURL("http://google.com/?q=something&espv=0")));
1112
1113   EXPECT_TRUE(url.HasSearchTermsReplacementKey(
1114       GURL("http://google.com/?espv&q=something")));
1115
1116   EXPECT_TRUE(url.HasSearchTermsReplacementKey(
1117       GURL("http://google.com/?espv=1&q=something")));
1118
1119   EXPECT_TRUE(url.HasSearchTermsReplacementKey(
1120       GURL("http://google.com/?espv=0&q=something")));
1121
1122   EXPECT_FALSE(url.HasSearchTermsReplacementKey(
1123       GURL("http://google.com/alt/#q=something")));
1124
1125   EXPECT_TRUE(url.HasSearchTermsReplacementKey(
1126       GURL("http://google.com/alt/#q=something&espv")));
1127
1128   EXPECT_TRUE(url.HasSearchTermsReplacementKey(
1129       GURL("http://google.com/alt/#q=something&espv=1")));
1130
1131   EXPECT_TRUE(url.HasSearchTermsReplacementKey(
1132       GURL("http://google.com/alt/#q=something&espv=0")));
1133
1134   EXPECT_TRUE(url.HasSearchTermsReplacementKey(
1135       GURL("http://google.com/alt/#espv&q=something")));
1136
1137   EXPECT_TRUE(url.HasSearchTermsReplacementKey(
1138       GURL("http://google.com/alt/#espv=1&q=something")));
1139
1140   EXPECT_TRUE(url.HasSearchTermsReplacementKey(
1141       GURL("http://google.com/alt/#espv=0&q=something")));
1142
1143   EXPECT_TRUE(url.HasSearchTermsReplacementKey(
1144       GURL("http://google.com/?espv#q=something")));
1145
1146   EXPECT_TRUE(url.HasSearchTermsReplacementKey(
1147       GURL("http://google.com/?espv=1#q=something")));
1148
1149   EXPECT_TRUE(url.HasSearchTermsReplacementKey(
1150       GURL("http://google.com/?q=something#espv")));
1151
1152   EXPECT_TRUE(url.HasSearchTermsReplacementKey(
1153       GURL("http://google.com/?q=something#espv=1")));
1154
1155   // This does not ensure the domain matches.
1156   EXPECT_TRUE(url.HasSearchTermsReplacementKey(
1157       GURL("http://bing.com/?espv")));
1158
1159   EXPECT_TRUE(url.HasSearchTermsReplacementKey(
1160       GURL("http://bing.com/#espv")));
1161 }
1162
1163 TEST_F(TemplateURLTest, ReplaceSearchTermsInURL) {
1164   TemplateURLData data;
1165   data.SetURL("http://google.com/?q={searchTerms}");
1166   data.instant_url = "http://google.com/instant#q={searchTerms}";
1167   data.alternate_urls.push_back("http://google.com/alt/#q={searchTerms}");
1168   data.alternate_urls.push_back(
1169       "http://google.com/alt/?ext=foo&q={searchTerms}#ref=bar");
1170   TemplateURL url(data);
1171   TemplateURLRef::SearchTermsArgs search_terms(ASCIIToUTF16("Bob Morane"));
1172   GURL result;
1173
1174   EXPECT_TRUE(url.ReplaceSearchTermsInURL(
1175       GURL("http://google.com/?q=something"), search_terms,
1176       search_terms_data_, &result));
1177   EXPECT_EQ(GURL("http://google.com/?q=Bob%20Morane"), result);
1178
1179   result = GURL("http://should.not.change.com");
1180   EXPECT_FALSE(url.ReplaceSearchTermsInURL(
1181       GURL("http://google.ca/?q=something"), search_terms,
1182       search_terms_data_, &result));
1183   EXPECT_EQ(GURL("http://should.not.change.com"), result);
1184
1185   EXPECT_FALSE(url.ReplaceSearchTermsInURL(
1186       GURL("http://google.com/foo/?q=foo"), search_terms,
1187       search_terms_data_, &result));
1188
1189   EXPECT_TRUE(url.ReplaceSearchTermsInURL(
1190       GURL("https://google.com/?q=foo"), search_terms,
1191       search_terms_data_, &result));
1192   EXPECT_EQ(GURL("https://google.com/?q=Bob%20Morane"), result);
1193
1194   EXPECT_FALSE(url.ReplaceSearchTermsInURL(
1195       GURL("http://google.com:8080/?q=foo"), search_terms,
1196       search_terms_data_, &result));
1197
1198   EXPECT_TRUE(url.ReplaceSearchTermsInURL(
1199       GURL("http://google.com/?q=1+2+3&b=456"), search_terms,
1200       search_terms_data_, &result));
1201   EXPECT_EQ(GURL("http://google.com/?q=Bob%20Morane&b=456"), result);
1202
1203   // Note: Spaces in REF parameters are not escaped. See TryEncoding() in
1204   // template_url.cc for details.
1205   EXPECT_TRUE(url.ReplaceSearchTermsInURL(
1206       GURL("http://google.com/alt/?q=123#q=456"), search_terms,
1207       search_terms_data_, &result));
1208   EXPECT_EQ(GURL("http://google.com/alt/?q=123#q=Bob Morane"), result);
1209
1210   EXPECT_TRUE(url.ReplaceSearchTermsInURL(
1211       GURL("http://google.com/alt/?a=012&q=123&b=456#f=789"), search_terms,
1212       search_terms_data_, &result));
1213   EXPECT_EQ(GURL("http://google.com/alt/?a=012&q=Bob%20Morane&b=456#f=789"),
1214             result);
1215
1216   EXPECT_TRUE(url.ReplaceSearchTermsInURL(
1217       GURL("http://google.com/alt/?a=012&q=123&b=456#j=abc&q=789&h=def9"),
1218       search_terms, search_terms_data_, &result));
1219   EXPECT_EQ(GURL("http://google.com/alt/?a=012&q=123&b=456"
1220                  "#j=abc&q=Bob Morane&h=def9"), result);
1221
1222   EXPECT_FALSE(url.ReplaceSearchTermsInURL(
1223       GURL("http://google.com/alt/?q="), search_terms,
1224       search_terms_data_, &result));
1225
1226   EXPECT_FALSE(url.ReplaceSearchTermsInURL(
1227       GURL("http://google.com/alt/?#q="), search_terms,
1228       search_terms_data_, &result));
1229
1230   EXPECT_FALSE(url.ReplaceSearchTermsInURL(
1231       GURL("http://google.com/alt/?q=#q="), search_terms,
1232       search_terms_data_, &result));
1233
1234   EXPECT_FALSE(url.ReplaceSearchTermsInURL(
1235       GURL("http://google.com/alt/?q=123#q="), search_terms,
1236       search_terms_data_, &result));
1237
1238   EXPECT_TRUE(url.ReplaceSearchTermsInURL(
1239       GURL("http://google.com/alt/?q=#q=123"), search_terms,
1240       search_terms_data_, &result));
1241   EXPECT_EQ(GURL("http://google.com/alt/?q=#q=Bob Morane"), result);
1242 }
1243
1244 // Test the |suggest_query_params| field of SearchTermsArgs.
1245 TEST_F(TemplateURLTest, SuggestQueryParams) {
1246   TemplateURLData data;
1247   // Pick a URL with replacements before, during, and after the query, to ensure
1248   // we don't goof up any of them.
1249   data.SetURL("{google:baseURL}search?q={searchTerms}"
1250       "#{google:originalQueryForSuggestion}x");
1251   TemplateURL url(data);
1252
1253   // Baseline: no |suggest_query_params| field.
1254   TemplateURLRef::SearchTermsArgs search_terms(ASCIIToUTF16("abc"));
1255   search_terms.original_query = ASCIIToUTF16("def");
1256   search_terms.accepted_suggestion = 0;
1257   EXPECT_EQ("http://www.google.com/search?q=abc#oq=def&x",
1258             url.url_ref().ReplaceSearchTerms(search_terms, search_terms_data_));
1259
1260   // Set the suggest_query_params.
1261   search_terms.suggest_query_params = "pq=xyz";
1262   EXPECT_EQ("http://www.google.com/search?pq=xyz&q=abc#oq=def&x",
1263             url.url_ref().ReplaceSearchTerms(search_terms, search_terms_data_));
1264
1265   // Add extra_query_params in the mix, and ensure it works.
1266   search_terms.append_extra_query_params = true;
1267   CommandLine::ForCurrentProcess()->AppendSwitchASCII(
1268       switches::kExtraSearchQueryParams, "a=b");
1269   EXPECT_EQ("http://www.google.com/search?a=b&pq=xyz&q=abc#oq=def&x",
1270             url.url_ref().ReplaceSearchTerms(search_terms, search_terms_data_));
1271 }
1272
1273 // Test the |append_extra_query_params| field of SearchTermsArgs.
1274 TEST_F(TemplateURLTest, ExtraQueryParams) {
1275   TemplateURLData data;
1276   // Pick a URL with replacements before, during, and after the query, to ensure
1277   // we don't goof up any of them.
1278   data.SetURL("{google:baseURL}search?q={searchTerms}"
1279       "#{google:originalQueryForSuggestion}x");
1280   TemplateURL url(data);
1281
1282   // Baseline: no command-line args, no |append_extra_query_params| flag.
1283   TemplateURLRef::SearchTermsArgs search_terms(ASCIIToUTF16("abc"));
1284   search_terms.original_query = ASCIIToUTF16("def");
1285   search_terms.accepted_suggestion = 0;
1286   EXPECT_EQ("http://www.google.com/search?q=abc#oq=def&x",
1287             url.url_ref().ReplaceSearchTerms(search_terms, search_terms_data_));
1288
1289   // Set the flag.  Since there are no command-line args, this should have no
1290   // effect.
1291   search_terms.append_extra_query_params = true;
1292   EXPECT_EQ("http://www.google.com/search?q=abc#oq=def&x",
1293             url.url_ref().ReplaceSearchTerms(search_terms, search_terms_data_));
1294
1295   // Now append the command-line arg.  This should be inserted into the query.
1296   CommandLine::ForCurrentProcess()->AppendSwitchASCII(
1297       switches::kExtraSearchQueryParams, "a=b");
1298   EXPECT_EQ("http://www.google.com/search?a=b&q=abc#oq=def&x",
1299             url.url_ref().ReplaceSearchTerms(search_terms, search_terms_data_));
1300
1301   // Turn off the flag.  Now the command-line arg should be ignored again.
1302   search_terms.append_extra_query_params = false;
1303   EXPECT_EQ("http://www.google.com/search?q=abc#oq=def&x",
1304             url.url_ref().ReplaceSearchTerms(search_terms, search_terms_data_));
1305 }
1306
1307 // Tests replacing pageClassification.
1308 TEST_F(TemplateURLTest, ReplacePageClassification) {
1309   TemplateURLData data;
1310   data.input_encodings.push_back("UTF-8");
1311   data.SetURL("{google:baseURL}?{google:pageClassification}q={searchTerms}");
1312   TemplateURL url(data);
1313   EXPECT_TRUE(url.url_ref().IsValid(search_terms_data_));
1314   ASSERT_TRUE(url.url_ref().SupportsReplacement(search_terms_data_));
1315   TemplateURLRef::SearchTermsArgs search_terms_args(ASCIIToUTF16("foo"));
1316
1317   std::string result = url.url_ref().ReplaceSearchTerms(search_terms_args,
1318                                                         search_terms_data_);
1319   EXPECT_EQ("http://www.google.com/?q=foo", result);
1320
1321   search_terms_args.page_classification = metrics::OmniboxEventProto::NTP;
1322   result = url.url_ref().ReplaceSearchTerms(search_terms_args,
1323                                             search_terms_data_);
1324   EXPECT_EQ("http://www.google.com/?pgcl=1&q=foo", result);
1325
1326   search_terms_args.page_classification =
1327       metrics::OmniboxEventProto::HOME_PAGE;
1328   result = url.url_ref().ReplaceSearchTerms(search_terms_args,
1329                                             search_terms_data_);
1330   EXPECT_EQ("http://www.google.com/?pgcl=3&q=foo", result);
1331 }
1332
1333 // Test the IsSearchResults function.
1334 TEST_F(TemplateURLTest, IsSearchResults) {
1335   TemplateURLData data;
1336   data.SetURL("http://bar/search?q={searchTerms}");
1337   data.instant_url = "http://bar/instant#q={searchTerms}";
1338   data.new_tab_url = "http://bar/newtab";
1339   data.alternate_urls.push_back("http://bar/?q={searchTerms}");
1340   data.alternate_urls.push_back("http://bar/#q={searchTerms}");
1341   data.alternate_urls.push_back("http://bar/search#q{searchTerms}");
1342   data.alternate_urls.push_back("http://bar/webhp#q={searchTerms}");
1343   TemplateURL search_provider(data);
1344
1345   const struct {
1346     const char* const url;
1347     bool result;
1348   } url_data[] = {
1349     { "http://bar/search?q=foo&oq=foo", true, },
1350     { "http://bar/?q=foo&oq=foo", true, },
1351     { "http://bar/#output=search&q=foo&oq=foo", true, },
1352     { "http://bar/webhp#q=foo&oq=foo", true, },
1353     { "http://bar/#q=foo&oq=foo", true, },
1354     { "http://bar/?ext=foo&q=foo#ref=bar", true, },
1355     { "http://bar/url?url=http://www.foo.com/&q=foo#ref=bar", false, },
1356     { "http://bar/", false, },
1357     { "http://foo/", false, },
1358     { "http://bar/newtab", false, },
1359   };
1360
1361   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(url_data); ++i) {
1362     EXPECT_EQ(url_data[i].result,
1363               search_provider.IsSearchURL(GURL(url_data[i].url),
1364                                           search_terms_data_));
1365   }
1366 }
1367
1368 TEST_F(TemplateURLTest, ReflectsBookmarkBarPinned) {
1369   TemplateURLData data;
1370   data.input_encodings.push_back("UTF-8");
1371   data.SetURL("{google:baseURL}?{google:bookmarkBarPinned}q={searchTerms}");
1372   TemplateURL url(data);
1373   EXPECT_TRUE(url.url_ref().IsValid(search_terms_data_));
1374   ASSERT_TRUE(url.url_ref().SupportsReplacement(search_terms_data_));
1375   TemplateURLRef::SearchTermsArgs search_terms_args(ASCIIToUTF16("foo"));
1376
1377   // Do not add the param when InstantExtended is suppressed on SRPs.
1378   url.url_ref_.showing_search_terms_ = false;
1379   std::string result = url.url_ref().ReplaceSearchTerms(search_terms_args,
1380                                                         search_terms_data_);
1381   EXPECT_EQ("http://www.google.com/?q=foo", result);
1382
1383   // Add the param when InstantExtended is not suppressed on SRPs.
1384   url.url_ref_.showing_search_terms_ = true;
1385   search_terms_args.bookmark_bar_pinned = false;
1386   result = url.url_ref().ReplaceSearchTerms(search_terms_args,
1387                                             search_terms_data_);
1388   EXPECT_EQ("http://www.google.com/?bmbp=0&q=foo", result);
1389
1390   url.url_ref_.showing_search_terms_ = true;
1391   search_terms_args.bookmark_bar_pinned = true;
1392   result = url.url_ref().ReplaceSearchTerms(search_terms_args,
1393                                             search_terms_data_);
1394   EXPECT_EQ("http://www.google.com/?bmbp=1&q=foo", result);
1395 }
1396
1397 TEST_F(TemplateURLTest, AnswersHasVersion) {
1398   TemplateURLData data;
1399   search_terms_data_.set_google_base_url("http://bar/");
1400   data.SetURL("http://bar/search?q={searchTerms}&{google:searchVersion}xssi=t");
1401
1402   TemplateURL url(data);
1403   TemplateURLRef::SearchTermsArgs search_terms_args(ASCIIToUTF16("foo"));
1404   std::string result = url.url_ref().ReplaceSearchTerms(search_terms_args,
1405                                                         search_terms_data_);
1406   EXPECT_EQ("http://bar/search?q=foo&xssi=t", result);
1407
1408   CommandLine::ForCurrentProcess()->AppendSwitch(
1409       switches::kEnableAnswersInSuggest);
1410   TemplateURL url2(data);
1411   result = url2.url_ref().ReplaceSearchTerms(search_terms_args,
1412                                              search_terms_data_);
1413   EXPECT_EQ("http://bar/search?q=foo&gs_rn=42&xssi=t", result);
1414 }
1415
1416 TEST_F(TemplateURLTest, SessionToken) {
1417   TemplateURLData data;
1418   search_terms_data_.set_google_base_url("http://bar/");
1419   data.SetURL("http://bar/search?q={searchTerms}&{google:sessionToken}xssi=t");
1420
1421   TemplateURL url(data);
1422   TemplateURLRef::SearchTermsArgs search_terms_args(ASCIIToUTF16("foo"));
1423   search_terms_args.session_token = "SESSIONTOKENGOESHERE";
1424   std::string result = url.url_ref().ReplaceSearchTerms(search_terms_args,
1425                                                         search_terms_data_);
1426   EXPECT_EQ("http://bar/search?q=foo&psi=SESSIONTOKENGOESHERE&xssi=t", result);
1427
1428   TemplateURL url2(data);
1429   search_terms_args.session_token = "";
1430   result = url.url_ref().ReplaceSearchTerms(search_terms_args,
1431                                             search_terms_data_);
1432   EXPECT_EQ("http://bar/search?q=foo&xssi=t", result);
1433 }
1434
1435 TEST_F(TemplateURLTest, ContextualSearchParameters) {
1436   TemplateURLData data;
1437   search_terms_data_.set_google_base_url("http://bar/");
1438   data.SetURL("http://bar/_/contextualsearch?"
1439               "{google:contextualSearchVersion}"
1440               "{google:contextualSearchContextData}");
1441
1442   TemplateURL url(data);
1443   TemplateURLRef::SearchTermsArgs search_terms_args(ASCIIToUTF16("foo"));
1444   std::string result = url.url_ref().ReplaceSearchTerms(search_terms_args,
1445                                                         search_terms_data_);
1446   EXPECT_EQ("http://bar/_/contextualsearch?", result);
1447
1448   TemplateURLRef::SearchTermsArgs::ContextualSearchParams params(
1449       1, 6, 11, "allen", "woody+allen+movies", "www.wikipedia.org",
1450       "utf-8");
1451   search_terms_args.contextual_search_params = params;
1452   result = url.url_ref().ReplaceSearchTerms(search_terms_args,
1453                                             search_terms_data_);
1454   EXPECT_EQ("http://bar/_/contextualsearch?"
1455                 "ctxs=1&"
1456                 "ctxs_start=6&"
1457                 "ctxs_end=11&"
1458                 "q=allen&"
1459                 "ctxs_content=woody+allen+movies&"
1460                 "ctxs_url=www.wikipedia.org&"
1461             "ctxs_encoding=utf-8&", result);
1462 }
1463
1464 TEST_F(TemplateURLTest, GenerateKeyword) {
1465   ASSERT_EQ(ASCIIToUTF16("foo"),
1466             TemplateURL::GenerateKeyword(GURL("http://foo")));
1467   // www. should be stripped.
1468   ASSERT_EQ(ASCIIToUTF16("foo"),
1469             TemplateURL::GenerateKeyword(GURL("http://www.foo")));
1470   // Make sure we don't get a trailing '/'.
1471   ASSERT_EQ(ASCIIToUTF16("blah"),
1472             TemplateURL::GenerateKeyword(GURL("http://blah/")));
1473   // Don't generate the empty string.
1474   ASSERT_EQ(ASCIIToUTF16("www"),
1475             TemplateURL::GenerateKeyword(GURL("http://www.")));
1476 }
1477
1478 TEST_F(TemplateURLTest, GenerateSearchURL) {
1479   struct GenerateSearchURLCase {
1480     const char* test_name;
1481     const char* url;
1482     const char* expected;
1483   } generate_url_cases[] = {
1484     { "invalid URL", "foo{searchTerms}", "" },
1485     { "URL with no replacements", "http://foo/", "http://foo/" },
1486     { "basic functionality", "http://foo/{searchTerms}",
1487       "http://foo/blah.blah.blah.blah.blah" }
1488   };
1489
1490   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(generate_url_cases); ++i) {
1491     TemplateURLData data;
1492     data.SetURL(generate_url_cases[i].url);
1493     TemplateURL t_url(data);
1494     EXPECT_EQ(t_url.GenerateSearchURL(search_terms_data_).spec(),
1495               generate_url_cases[i].expected)
1496         << generate_url_cases[i].test_name << " failed.";
1497   }
1498 }