diff options
Diffstat (limited to 'chrome/browser/template_url_unittest.cc')
| -rw-r--r-- | chrome/browser/template_url_unittest.cc | 368 |
1 files changed, 368 insertions, 0 deletions
diff --git a/chrome/browser/template_url_unittest.cc b/chrome/browser/template_url_unittest.cc new file mode 100644 index 0000000..375ef40 --- /dev/null +++ b/chrome/browser/template_url_unittest.cc @@ -0,0 +1,368 @@ +// Copyright 2008, Google Inc. +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +#include "base/string_util.h" +#include "chrome/browser/browser_process.h" +#include "chrome/browser/rlz/rlz.h" +#include "chrome/browser/template_url.h" +#include "testing/gtest/include/gtest/gtest.h" + +class TemplateURLTest : public testing::Test { + public: + virtual void TearDown() { + delete TemplateURLRef::google_base_url_; + TemplateURLRef::google_base_url_ = NULL; + } + + void CheckSuggestBaseURL(const wchar_t* base_url, + const wchar_t* base_suggest_url) const { + delete TemplateURLRef::google_base_url_; + TemplateURLRef::google_base_url_ = new std::wstring(base_url); + EXPECT_STREQ(base_suggest_url, + TemplateURLRef::GoogleBaseSuggestURLValue().c_str()); + } +}; + +TEST_F(TemplateURLTest, Defaults) { + TemplateURL url; + ASSERT_FALSE(url.show_in_default_list()); + ASSERT_FALSE(url.safe_for_autoreplace()); + ASSERT_EQ(0, url.prepopulate_id()); +} + +TEST_F(TemplateURLTest, TestValidWithComplete) { + TemplateURLRef ref(L"{searchTerms}", 0, 0); + ASSERT_TRUE(ref.IsValid()); +} + +TEST_F(TemplateURLTest, URLRefTestSearchTerms) { + TemplateURL t_url; + TemplateURLRef ref(L"http://foo{searchTerms}", 0, 0); + ASSERT_TRUE(ref.IsValid()); + + ASSERT_TRUE(ref.SupportsReplacement()); + ASSERT_EQ(L"http://foosearch", ref.ReplaceSearchTerms(t_url, L"search", + TemplateURLRef::NO_SUGGESTIONS_AVAILABLE, std::wstring())); +} + +TEST_F(TemplateURLTest, URLRefTestCount) { + TemplateURL t_url; + TemplateURLRef ref(L"http://foo{searchTerms}{count?}", 0, 0); + ASSERT_TRUE(ref.IsValid()); + ASSERT_TRUE(ref.SupportsReplacement()); + ASSERT_EQ(L"http://fooX", ref.ReplaceSearchTerms(t_url, L"X", + TemplateURLRef::NO_SUGGESTIONS_AVAILABLE, std::wstring())); +} + +TEST_F(TemplateURLTest, URLRefTestCount2) { + TemplateURL t_url; + TemplateURLRef ref(L"http://foo{searchTerms}{count}", 0, 0); + ASSERT_TRUE(ref.IsValid()); + ASSERT_TRUE(ref.SupportsReplacement()); + ASSERT_EQ(L"http://fooX10", ref.ReplaceSearchTerms(t_url, L"X", + TemplateURLRef::NO_SUGGESTIONS_AVAILABLE, std::wstring())); +} + +TEST_F(TemplateURLTest, URLRefTestIndices) { + TemplateURL t_url; + TemplateURLRef ref(L"http://foo{searchTerms}x{startIndex?}y{startPage?}", + 1, 2); + ASSERT_TRUE(ref.IsValid()); + ASSERT_TRUE(ref.SupportsReplacement()); + ASSERT_EQ(L"http://fooXxy", ref.ReplaceSearchTerms(t_url, L"X", + TemplateURLRef::NO_SUGGESTIONS_AVAILABLE, std::wstring())); +} + +TEST_F(TemplateURLTest, URLRefTestIndices2) { + TemplateURL t_url; + TemplateURLRef ref(L"http://foo{searchTerms}x{startIndex}y{startPage}", 1, 2); + ASSERT_TRUE(ref.IsValid()); + ASSERT_TRUE(ref.SupportsReplacement()); + ASSERT_EQ(L"http://fooXx1y2", ref.ReplaceSearchTerms(t_url, L"X", + TemplateURLRef::NO_SUGGESTIONS_AVAILABLE, std::wstring())); +} + +TEST_F(TemplateURLTest, URLRefTestEncoding) { + TemplateURL t_url; + TemplateURLRef ref( + L"http://foo{searchTerms}x{inputEncoding?}y{outputEncoding?}a", 1, 2); + ASSERT_TRUE(ref.IsValid()); + ASSERT_TRUE(ref.SupportsReplacement()); + ASSERT_EQ(L"http://fooXxUTF-8ya", ref.ReplaceSearchTerms(t_url, L"X", + TemplateURLRef::NO_SUGGESTIONS_AVAILABLE, std::wstring())); +} + +TEST_F(TemplateURLTest, InputEncodingBeforeSearchTerm) { + TemplateURL t_url; + TemplateURLRef ref( + L"http://foox{inputEncoding?}a{searchTerms}y{outputEncoding?}b", 1, 2); + ASSERT_TRUE(ref.IsValid()); + ASSERT_TRUE(ref.SupportsReplacement()); + ASSERT_EQ(L"http://fooxUTF-8aXyb", ref.ReplaceSearchTerms(t_url, L"X", + TemplateURLRef::NO_SUGGESTIONS_AVAILABLE, std::wstring())); +} + +TEST_F(TemplateURLTest, URLRefTestEncoding2) { + TemplateURL t_url; + TemplateURLRef ref( + L"http://foo{searchTerms}x{inputEncoding}y{outputEncoding}a", 1, 2); + ASSERT_TRUE(ref.IsValid()); + ASSERT_TRUE(ref.SupportsReplacement()); + ASSERT_EQ(L"http://fooXxUTF-8yUTF-8a", ref.ReplaceSearchTerms(t_url, L"X", + TemplateURLRef::NO_SUGGESTIONS_AVAILABLE, std::wstring())); +} + +TEST_F(TemplateURLTest, URLRefTermToWide) { + struct ToWideCase { + const char* encoded_search_term; + const wchar_t* expected_decoded_term; + } to_wide_cases[] = { + {"hello+world", L"hello world"}, + // Test some big-5 input. + {"%a7A%A6%6e+to+you", L"\x4f60\x597d to you"}, + // Test some UTF-8 input. We should fall back to this when the encoding + // doesn't look like big-5. We have a '5' in the middle, which is an invalid + // Big-5 trailing byte. + {"%e4%bd%a05%e5%a5%bd+to+you", L"\x4f60\x35\x597d to you"}, + // Undecodable input should stay escaped. + {"%91%01+abcd", L"%91%01 abcd"}, + }; + + TemplateURL t_url; + + // Set one input encoding: big-5. This is so we can test fallback to UTF-8. + std::vector<std::string> encodings; + encodings.push_back("big-5"); + t_url.set_input_encodings(encodings); + + TemplateURLRef ref(L"http://foo?q={searchTerms}", 1, 2); + ASSERT_TRUE(ref.IsValid()); + ASSERT_TRUE(ref.SupportsReplacement()); + + for (int i = 0; i < arraysize(to_wide_cases); i++) { + std::wstring result = ref.SearchTermToWide(t_url, + to_wide_cases[i].encoded_search_term); + + EXPECT_EQ(std::wstring(to_wide_cases[i].expected_decoded_term), result); + } +} + +TEST_F(TemplateURLTest, SetFavIcon) { + TemplateURL url; + GURL favicon_url("http://favicon.url"); + url.SetFavIconURL(favicon_url); + ASSERT_EQ(1, url.image_refs().size()); + ASSERT_TRUE(favicon_url == url.GetFavIconURL()); + + GURL favicon_url2("http://favicon2.url"); + url.SetFavIconURL(favicon_url2); + ASSERT_EQ(1, url.image_refs().size()); + ASSERT_TRUE(favicon_url2 == url.GetFavIconURL()); +} + +TEST_F(TemplateURLTest, DisplayURLToURLRef) { + struct TestData { + const std::wstring url; + const std::wstring expected_result; + } data[] = { + { L"http://foo{searchTerms}x{inputEncoding}y{outputEncoding}a", + L"http://foo%sx{inputEncoding}y{outputEncoding}a" }, + { L"http://X", + L"http://X" }, + { L"http://foo{searchTerms", + L"http://foo{searchTerms" }, + { L"http://foo{searchTerms}{language}", + L"http://foo%s{language}" }, + }; + for (int i = 0; i < arraysize(data); ++i) { + TemplateURLRef ref(data[i].url, 1, 2); + EXPECT_EQ(data[i].expected_result, ref.DisplayURL()); + EXPECT_EQ(data[i].url, + TemplateURLRef::DisplayURLToURLRef(ref.DisplayURL())); + } +} + +TEST_F(TemplateURLTest, ReplaceSearchTerms) { + struct TestData { + const std::wstring url; + const std::wstring expected_result; + } data[] = { + { L"{language}{searchTerms}{inputEncoding}", + L"{language}XUTF-8" }, + { L"{language}{inputEncoding}{searchTerms}", + L"{language}UTF-8X" }, + { L"{searchTerms}{language}{inputEncoding}", + L"X{language}UTF-8" }, + { L"{searchTerms}{inputEncoding}{language}", + L"XUTF-8{language}" }, + { L"{inputEncoding}{searchTerms}{language}", + L"UTF-8X{language}" }, + { L"{inputEncoding}{language}{searchTerms}", + L"UTF-8{language}X" }, + { L"{language}a{searchTerms}a{inputEncoding}a", + L"{language}aXaUTF-8a" }, + { L"{language}a{inputEncoding}a{searchTerms}a", + L"{language}aUTF-8aXa" }, + { L"{searchTerms}a{language}a{inputEncoding}a", + L"Xa{language}aUTF-8a" }, + { L"{searchTerms}a{inputEncoding}a{language}a", + L"XaUTF-8a{language}a" }, + { L"{inputEncoding}a{searchTerms}a{language}a", + L"UTF-8aXa{language}a" }, + { L"{inputEncoding}a{language}a{searchTerms}a", + L"UTF-8a{language}aXa" }, + }; + TemplateURL turl; + turl.add_input_encoding("UTF-8"); + for (int i = 0; i < arraysize(data); ++i) { + TemplateURLRef ref(data[i].url, 1, 2); + std::wstring expected_result = data[i].expected_result; + ReplaceSubstringsAfterOffset(&expected_result, 0, L"{language}", + g_browser_process->GetApplicationLocale()); + EXPECT_EQ(expected_result, ref.ReplaceSearchTerms(turl, L"X", + TemplateURLRef::NO_SUGGESTIONS_AVAILABLE, std::wstring())); + } +} + + +// Tests replacing search terms in various encodings and making sure the +// generated URL matches the expected value. +TEST_F(TemplateURLTest, ReplaceArbitrarySearchTerms) { + struct TestData { + const std::string encoding; + const std::wstring search_term; + const std::wstring url; + const std::wstring expected_result; + } data[] = { + { "BIG5", L"\x60BD", L"{searchTerms}{inputEncoding}", L"%B1~BIG5" }, + { "UTF-8", L"blah", L"{searchTerms}{inputEncoding}", L"blahUTF-8" }, + }; + for (int i = 0; i < arraysize(data); ++i) { + TemplateURL turl; + turl.add_input_encoding(data[i].encoding); + TemplateURLRef ref(data[i].url, 1, 2); + std::wstring expected_result = data[i].expected_result; + EXPECT_EQ(data[i].expected_result, ref.ReplaceSearchTerms( + turl, data[i].search_term, TemplateURLRef::NO_SUGGESTIONS_AVAILABLE, + std::wstring())); + } +} + +TEST_F(TemplateURLTest, Suggestions) { + struct TestData { + const int accepted_suggestion; + const std::wstring original_query_for_suggestion; + const std::wstring expected_result; + } data[] = { + { TemplateURLRef::NO_SUGGESTIONS_AVAILABLE, std::wstring(), + L"foo?q=foobar" }, + { TemplateURLRef::NO_SUGGESTIONS_AVAILABLE, L"foo", L"foo?q=foobar" }, + { TemplateURLRef::NO_SUGGESTION_CHOSEN, std::wstring(), + L"foo?aq=f&q=foobar" }, + { TemplateURLRef::NO_SUGGESTION_CHOSEN, L"foo", L"foo?aq=f&q=foobar" }, + { 0, std::wstring(), L"foo?aq=0&oq=&q=foobar" }, + { 1, L"foo", L"foo?aq=1&oq=foo&q=foobar" }, + }; + TemplateURL turl; + turl.add_input_encoding("UTF-8"); + TemplateURLRef ref(L"foo?{google:acceptedSuggestion}" + L"{google:originalQueryForSuggestion}q={searchTerms}", 1, 2); + ASSERT_TRUE(ref.IsValid()); + ASSERT_TRUE(ref.SupportsReplacement()); + for (int i = 0; i < arraysize(data); ++i) { + EXPECT_EQ(data[i].expected_result, ref.ReplaceSearchTerms(turl, L"foobar", + data[i].accepted_suggestion, data[i].original_query_for_suggestion)); + } +} + +TEST_F(TemplateURLTest, RLZ) { + std::wstring rlz_string; + RLZTracker::GetAccessPointRlz(RLZTracker::CHROME_OMNIBOX, &rlz_string); + + TemplateURL t_url; + TemplateURLRef ref(L"{google:RLZ}{searchTerms}", 1, 2); + ASSERT_TRUE(ref.IsValid()); + ASSERT_TRUE(ref.SupportsReplacement()); + ASSERT_EQ(rlz_string + L"x", ref.ReplaceSearchTerms(t_url, L"x", + TemplateURLRef::NO_SUGGESTIONS_AVAILABLE, std::wstring())); +} + +TEST_F(TemplateURLTest, HostAndSearchTermKey) { + struct TestData { + const std::wstring url; + const std::string host; + const std::string path; + const std::string search_term_key; + } data[] = { + { L"http://blah/?foo=bar&q={searchTerms}&b=x", "blah", "/", "q"}, + + // No query key should result in empty values. + { L"http://blah/{searchTerms}", "", "", ""}, + + // No term should result in empty values. + { L"http://blah/", "", "", ""}, + + // Multiple terms should result in empty values. + { L"http://blah/?q={searchTerms}&x={searchTerms}", "", "", ""}, + + // Term in the host shouldn't match. + { L"http://{searchTerms}", "", "", ""}, + + { L"http://blah/?q={searchTerms}", "blah", "/", "q"}, + + // Single term with extra chars in value should match. + { L"http://blah/?q=stock:{searchTerms}", "blah", "/", "q"}, + + }; + + TemplateURL t_url; + for (int i = 0; i < arraysize(data); ++i) { + t_url.SetURL(data[i].url, 0, 0); + EXPECT_EQ(data[i].host, t_url.url()->GetHost()); + EXPECT_EQ(data[i].path, t_url.url()->GetPath()); + EXPECT_EQ(data[i].search_term_key, t_url.url()->GetSearchTermKey()); + } +} + +TEST_F(TemplateURLTest, GoogleBaseSuggestURL) { + static const struct { + const wchar_t* const base_url; + const wchar_t* const base_suggest_url; + } data[] = { + { L"http://google.com/", L"http://clients1.google.com/complete/", }, + { L"http://www.google.com/", L"http://clients1.google.com/complete/", }, + { L"http://www.google.co.uk/", L"http://clients1.google.co.uk/complete/", }, + { L"http://www.google.com.by/", + L"http://clients1.google.com.by/complete/", }, + { L"http://google.com/intl/xx/", L"http://clients1.google.com/complete/", }, + }; + + for (int i = 0; i < arraysize(data); ++i) + CheckSuggestBaseURL(data[i].base_url, data[i].base_suggest_url); +}
\ No newline at end of file |