Correctly ignore unknown parameters in prepopulated URLs.

chrome/browser/search_engines/template_url_unittest.cc

 // Copyright (c) 2012 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/base_paths.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/rlz/rlz.h"
 #include "chrome/browser/search_engines/search_terms_data.h"
@@ skipping 148 matching lines @@
   GURL result(url.url_ref().ReplaceSearchTerms(ASCIIToUTF16("X"),
       TemplateURLRef::NO_SUGGESTIONS_AVAILABLE, string16()));
   ASSERT_TRUE(result.is_valid());
   EXPECT_EQ("http://fooxxutf-8ya/", result.spec());
 }
 
 // Test that setting the prepopulate ID from TemplateURL causes the stored
 // TemplateURLRef to handle parsing the URL parameters differently.
 TEST_F(TemplateURLTest, SetPrepopulatedAndParse) {
   TemplateURLData data;
-  data.SetURL("http://foo{fhqwhgads}");
+  data.SetURL("http://foo{fhqwhgads}bar");
   TemplateURL url(NULL, data);
   TemplateURLRef::Replacements replacements;
   bool valid = false;
-  EXPECT_EQ("http://foo{fhqwhgads}",
-      url.url_ref().ParseURL("http://foo{fhqwhgads}", &replacements, &valid));
+  EXPECT_EQ("http://foo{fhqwhgads}bar", url.url_ref().ParseURL(
+      "http://foo{fhqwhgads}bar", &replacements, &valid));
   EXPECT_TRUE(replacements.empty());
   EXPECT_TRUE(valid);
 
   data.prepopulate_id = 123;
   TemplateURL url2(NULL, data);
-  EXPECT_EQ("http://foo", url2.url_ref().ParseURL("http://foo{fhqwhgads}",
-                                                  &replacements, &valid));
+  EXPECT_EQ("http://foobar", url2.url_ref().ParseURL("http://foo{fhqwhgads}bar",
+                                                     &replacements, &valid));
   EXPECT_TRUE(replacements.empty());
   EXPECT_TRUE(valid);
 }
 
 TEST_F(TemplateURLTest, InputEncodingBeforeSearchTerm) {
   TemplateURLData data;
   data.SetURL("http://foox{inputEncoding?}a{searchTerms}y{outputEncoding?}b");
   TemplateURL url(NULL, data);
   EXPECT_TRUE(url.url_ref().IsValid());
   ASSERT_TRUE(url.url_ref().SupportsReplacement());
@@ skipping 306 matching lines @@
   TemplateURL url(NULL, data);
   TemplateURLRef::Replacements replacements;
   EXPECT_TRUE(url.url_ref().ParseParameter(0, 12, &parsed_url, &replacements));
   EXPECT_EQ(std::string(), parsed_url);
   ASSERT_EQ(1U, replacements.size());
   EXPECT_EQ(0U, replacements[0].index);
   EXPECT_EQ(TemplateURLRef::SEARCH_TERMS, replacements[0].type);
 }
 
 TEST_F(TemplateURLTest, ParseParameterUnknown) {
-  std::string parsed_url("{fhqwhgads}");
+  std::string parsed_url("{fhqwhgads}abc");
   TemplateURLData data;
   data.SetURL(parsed_url);
   TemplateURL url(NULL, data);
   TemplateURLRef::Replacements replacements;
 
   // By default, TemplateURLRef should not consider itself prepopulated.
   // Therefore we should not replace the unknown parameter.
   EXPECT_FALSE(url.url_ref().ParseParameter(0, 10, &parsed_url, &replacements));
-  EXPECT_EQ("{fhqwhgads}", parsed_url);
+  EXPECT_EQ("{fhqwhgads}abc", parsed_url);
   EXPECT_TRUE(replacements.empty());
 
   // If the TemplateURLRef is prepopulated, we should remove unknown parameters.
-  parsed_url = "{fhqwhgads}";
+  parsed_url = "{fhqwhgads}abc";
   data.prepopulate_id = 1;
   TemplateURL url2(NULL, data);
   EXPECT_FALSE(url2.url_ref().ParseParameter(0, 10, &parsed_url,
                                              &replacements));
-  EXPECT_EQ(std::string(), parsed_url);
+  EXPECT_EQ("abc", parsed_url);
   EXPECT_TRUE(replacements.empty());
 }
 
 TEST_F(TemplateURLTest, ParseURLEmpty) {
   TemplateURL url(NULL, TemplateURLData());
   TemplateURLRef::Replacements replacements;
   bool valid = false;
   EXPECT_EQ(std::string(),
             url.url_ref().ParseURL(std::string(), &replacements, &valid));
   EXPECT_TRUE(replacements.empty());
@@ skipping 42 matching lines @@
   TemplateURL url(NULL, data);
   TemplateURLRef::Replacements replacements;
   bool valid = false;
   EXPECT_EQ("{",
             url.url_ref().ParseURL("{{searchTerms}", &replacements, &valid));
   ASSERT_EQ(1U, replacements.size());
   EXPECT_EQ(1U, replacements[0].index);
   EXPECT_EQ(TemplateURLRef::SEARCH_TERMS, replacements[0].type);
   EXPECT_TRUE(valid);
 }