| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2014 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 "components/bookmarks/core/browser/bookmark_index.h" | |
| 6 | |
| 7 #include <string> | |
| 8 #include <vector> | |
| 9 | |
| 10 #include "base/macros.h" | |
| 11 #include "base/strings/string_number_conversions.h" | |
| 12 #include "base/strings/string_split.h" | |
| 13 #include "base/strings/string_util.h" | |
| 14 #include "base/strings/utf_string_conversions.h" | |
| 15 #include "components/bookmarks/core/browser/bookmark_match.h" | |
| 16 #include "components/bookmarks/core/browser/bookmark_model.h" | |
| 17 #include "components/bookmarks/core/test/bookmark_test_helpers.h" | |
| 18 #include "components/bookmarks/core/test/test_bookmark_client.h" | |
| 19 #include "testing/gtest/include/gtest/gtest.h" | |
| 20 | |
| 21 using base::ASCIIToUTF16; | |
| 22 using base::UTF8ToUTF16; | |
| 23 | |
| 24 namespace { | |
| 25 | |
| 26 const char kAboutBlankURL[] = "about:blank"; | |
| 27 | |
| 28 class BookmarkClientMock : public test::TestBookmarkClient { | |
| 29 public: | |
| 30 BookmarkClientMock(const std::map<GURL, int>& typed_count_map) | |
| 31 : typed_count_map_(typed_count_map) {} | |
| 32 | |
| 33 virtual bool SupportsTypedCountForNodes() OVERRIDE { return true; } | |
| 34 | |
| 35 virtual void GetTypedCountForNodes( | |
| 36 const NodeSet& nodes, | |
| 37 NodeTypedCountPairs* node_typed_count_pairs) OVERRIDE { | |
| 38 for (NodeSet::const_iterator it = nodes.begin(); it != nodes.end(); ++it) { | |
| 39 const BookmarkNode* node = *it; | |
| 40 std::map<GURL, int>::const_iterator found = | |
| 41 typed_count_map_.find(node->url()); | |
| 42 if (found == typed_count_map_.end()) | |
| 43 continue; | |
| 44 | |
| 45 node_typed_count_pairs->push_back(std::make_pair(node, found->second)); | |
| 46 } | |
| 47 } | |
| 48 | |
| 49 private: | |
| 50 const std::map<GURL, int> typed_count_map_; | |
| 51 | |
| 52 DISALLOW_COPY_AND_ASSIGN(BookmarkClientMock); | |
| 53 }; | |
| 54 | |
| 55 class BookmarkIndexTest : public testing::Test { | |
| 56 public: | |
| 57 BookmarkIndexTest() : model_(client_.CreateModel(false)) {} | |
| 58 | |
| 59 typedef std::pair<std::string, std::string> TitleAndURL; | |
| 60 | |
| 61 void AddBookmarks(const char** titles, const char** urls, size_t count) { | |
| 62 // The pair is (title, url). | |
| 63 std::vector<TitleAndURL> bookmarks; | |
| 64 for (size_t i = 0; i < count; ++i) { | |
| 65 TitleAndURL bookmark(titles[i], urls[i]); | |
| 66 bookmarks.push_back(bookmark); | |
| 67 } | |
| 68 AddBookmarks(bookmarks); | |
| 69 } | |
| 70 | |
| 71 void AddBookmarks(const std::vector<TitleAndURL>& bookmarks) { | |
| 72 for (size_t i = 0; i < bookmarks.size(); ++i) { | |
| 73 model_->AddURL(model_->other_node(), static_cast<int>(i), | |
| 74 ASCIIToUTF16(bookmarks[i].first), | |
| 75 GURL(bookmarks[i].second)); | |
| 76 } | |
| 77 } | |
| 78 | |
| 79 void ExpectMatches(const std::string& query, | |
| 80 const char** expected_titles, | |
| 81 size_t expected_count) { | |
| 82 std::vector<std::string> title_vector; | |
| 83 for (size_t i = 0; i < expected_count; ++i) | |
| 84 title_vector.push_back(expected_titles[i]); | |
| 85 ExpectMatches(query, title_vector); | |
| 86 } | |
| 87 | |
| 88 void ExpectMatches(const std::string& query, | |
| 89 const std::vector<std::string>& expected_titles) { | |
| 90 std::vector<BookmarkMatch> matches; | |
| 91 model_->GetBookmarksMatching(ASCIIToUTF16(query), 1000, &matches); | |
| 92 ASSERT_EQ(expected_titles.size(), matches.size()); | |
| 93 for (size_t i = 0; i < expected_titles.size(); ++i) { | |
| 94 bool found = false; | |
| 95 for (size_t j = 0; j < matches.size(); ++j) { | |
| 96 if (ASCIIToUTF16(expected_titles[i]) == matches[j].node->GetTitle()) { | |
| 97 matches.erase(matches.begin() + j); | |
| 98 found = true; | |
| 99 break; | |
| 100 } | |
| 101 } | |
| 102 ASSERT_TRUE(found); | |
| 103 } | |
| 104 } | |
| 105 | |
| 106 void ExtractMatchPositions(const std::string& string, | |
| 107 BookmarkMatch::MatchPositions* matches) { | |
| 108 std::vector<std::string> match_strings; | |
| 109 base::SplitString(string, ':', &match_strings); | |
| 110 for (size_t i = 0; i < match_strings.size(); ++i) { | |
| 111 std::vector<std::string> chunks; | |
| 112 base::SplitString(match_strings[i], ',', &chunks); | |
| 113 ASSERT_EQ(2U, chunks.size()); | |
| 114 matches->push_back(BookmarkMatch::MatchPosition()); | |
| 115 int chunks0, chunks1; | |
| 116 EXPECT_TRUE(base::StringToInt(chunks[0], &chunks0)); | |
| 117 EXPECT_TRUE(base::StringToInt(chunks[1], &chunks1)); | |
| 118 matches->back().first = chunks0; | |
| 119 matches->back().second = chunks1; | |
| 120 } | |
| 121 } | |
| 122 | |
| 123 void ExpectMatchPositions( | |
| 124 const BookmarkMatch::MatchPositions& actual_positions, | |
| 125 const BookmarkMatch::MatchPositions& expected_positions) { | |
| 126 ASSERT_EQ(expected_positions.size(), actual_positions.size()); | |
| 127 for (size_t i = 0; i < expected_positions.size(); ++i) { | |
| 128 EXPECT_EQ(expected_positions[i].first, actual_positions[i].first); | |
| 129 EXPECT_EQ(expected_positions[i].second, actual_positions[i].second); | |
| 130 } | |
| 131 } | |
| 132 | |
| 133 protected: | |
| 134 test::TestBookmarkClient client_; | |
| 135 scoped_ptr<BookmarkModel> model_; | |
| 136 | |
| 137 private: | |
| 138 DISALLOW_COPY_AND_ASSIGN(BookmarkIndexTest); | |
| 139 }; | |
| 140 | |
| 141 // Various permutations with differing input, queries and output that exercises | |
| 142 // all query paths. | |
| 143 TEST_F(BookmarkIndexTest, GetBookmarksMatching) { | |
| 144 struct TestData { | |
| 145 const std::string titles; | |
| 146 const std::string query; | |
| 147 const std::string expected; | |
| 148 } data[] = { | |
| 149 // Trivial test case of only one term, exact match. | |
| 150 { "a;b", "A", "a" }, | |
| 151 | |
| 152 // Prefix match, one term. | |
| 153 { "abcd;abc;b", "abc", "abcd;abc" }, | |
| 154 | |
| 155 // Prefix match, multiple terms. | |
| 156 { "abcd cdef;abcd;abcd cdefg", "abc cde", "abcd cdef;abcd cdefg"}, | |
| 157 | |
| 158 // Exact and prefix match. | |
| 159 { "ab cdef;abcd;abcd cdefg", "ab cdef", "ab cdef"}, | |
| 160 | |
| 161 // Exact and prefix match. | |
| 162 { "ab cdef ghij;ab;cde;cdef;ghi;cdef ab;ghij ab", | |
| 163 "ab cde ghi", | |
| 164 "ab cdef ghij"}, | |
| 165 | |
| 166 // Title with term multiple times. | |
| 167 { "ab ab", "ab", "ab ab"}, | |
| 168 | |
| 169 // Make sure quotes don't do a prefix match. | |
| 170 { "think", "\"thi\"", ""}, | |
| 171 | |
| 172 // Prefix matches against multiple candidates. | |
| 173 { "abc1 abc2 abc3 abc4", "abc", "abc1 abc2 abc3 abc4"}, | |
| 174 }; | |
| 175 for (size_t i = 0; i < ARRAYSIZE_UNSAFE(data); ++i) { | |
| 176 std::vector<std::string> titles; | |
| 177 base::SplitString(data[i].titles, ';', &titles); | |
| 178 std::vector<TitleAndURL> bookmarks; | |
| 179 for (size_t j = 0; j < titles.size(); ++j) { | |
| 180 TitleAndURL bookmark(titles[j], kAboutBlankURL); | |
| 181 bookmarks.push_back(bookmark); | |
| 182 } | |
| 183 AddBookmarks(bookmarks); | |
| 184 | |
| 185 std::vector<std::string> expected; | |
| 186 if (!data[i].expected.empty()) | |
| 187 base::SplitString(data[i].expected, ';', &expected); | |
| 188 | |
| 189 ExpectMatches(data[i].query, expected); | |
| 190 | |
| 191 model_ = client_.CreateModel(false); | |
| 192 } | |
| 193 } | |
| 194 | |
| 195 // Analogous to GetBookmarksMatching, this test tests various permutations | |
| 196 // of title, URL, and input to see if the title/URL matches the input as | |
| 197 // expected. | |
| 198 TEST_F(BookmarkIndexTest, GetBookmarksMatchingWithURLs) { | |
| 199 struct TestData { | |
| 200 const std::string query; | |
| 201 const std::string title; | |
| 202 const std::string url; | |
| 203 const bool should_be_retrieved; | |
| 204 } data[] = { | |
| 205 // Test single-word inputs. Include both exact matches and prefix matches. | |
| 206 { "foo", "Foo", "http://www.bar.com/", true }, | |
| 207 { "foo", "Foodie", "http://www.bar.com/", true }, | |
| 208 { "foo", "Bar", "http://www.foo.com/", true }, | |
| 209 { "foo", "Bar", "http://www.foodie.com/", true }, | |
| 210 { "foo", "Foo", "http://www.foo.com/", true }, | |
| 211 { "foo", "Bar", "http://www.bar.com/", false }, | |
| 212 { "foo", "Bar", "http://www.bar.com/blah/foo/blah-again/ ", true }, | |
| 213 { "foo", "Bar", "http://www.bar.com/blah/foodie/blah-again/ ", true }, | |
| 214 { "foo", "Bar", "http://www.bar.com/blah-foo/blah-again/ ", true }, | |
| 215 { "foo", "Bar", "http://www.bar.com/blah-foodie/blah-again/ ", true }, | |
| 216 { "foo", "Bar", "http://www.bar.com/blahafoo/blah-again/ ", false }, | |
| 217 | |
| 218 // Test multi-word inputs. | |
| 219 { "foo bar", "Foo Bar", "http://baz.com/", true }, | |
| 220 { "foo bar", "Foodie Bar", "http://baz.com/", true }, | |
| 221 { "bar foo", "Foo Bar", "http://baz.com/", true }, | |
| 222 { "bar foo", "Foodie Barly", "http://baz.com/", true }, | |
| 223 { "foo bar", "Foo Baz", "http://baz.com/", false }, | |
| 224 { "foo bar", "Foo Baz", "http://bar.com/", true }, | |
| 225 { "foo bar", "Foo Baz", "http://barly.com/", true }, | |
| 226 { "foo bar", "Foodie Baz", "http://barly.com/", true }, | |
| 227 { "bar foo", "Foo Baz", "http://bar.com/", true }, | |
| 228 { "bar foo", "Foo Baz", "http://barly.com/", true }, | |
| 229 { "foo bar", "Baz Bar", "http://blah.com/foo", true }, | |
| 230 { "foo bar", "Baz Barly", "http://blah.com/foodie", true }, | |
| 231 { "foo bar", "Baz Bur", "http://blah.com/foo/bar", true }, | |
| 232 { "foo bar", "Baz Bur", "http://blah.com/food/barly", true }, | |
| 233 { "foo bar", "Baz Bur", "http://bar.com/blah/foo", true }, | |
| 234 { "foo bar", "Baz Bur", "http://barly.com/blah/food", true }, | |
| 235 { "foo bar", "Baz Bur", "http://bar.com/blah/flub", false }, | |
| 236 { "foo bar", "Baz Bur", "http://foo.com/blah/flub", false } | |
| 237 }; | |
| 238 | |
| 239 for (size_t i = 0; i < ARRAYSIZE_UNSAFE(data); ++i) { | |
| 240 model_ = client_.CreateModel(true); | |
| 241 std::vector<TitleAndURL> bookmarks; | |
| 242 bookmarks.push_back(TitleAndURL(data[i].title, data[i].url)); | |
| 243 AddBookmarks(bookmarks); | |
| 244 | |
| 245 std::vector<std::string> expected; | |
| 246 if (data[i].should_be_retrieved) | |
| 247 expected.push_back(data[i].title); | |
| 248 | |
| 249 ExpectMatches(data[i].query, expected); | |
| 250 } | |
| 251 } | |
| 252 | |
| 253 TEST_F(BookmarkIndexTest, Normalization) { | |
| 254 struct TestData { | |
| 255 const char* const title; | |
| 256 const char* const query; | |
| 257 } data[] = { | |
| 258 { "fooa\xcc\x88-test", "foo\xc3\xa4-test" }, | |
| 259 { "fooa\xcc\x88-test", "fooa\xcc\x88-test" }, | |
| 260 { "fooa\xcc\x88-test", "foo\xc3\xa4" }, | |
| 261 { "fooa\xcc\x88-test", "fooa\xcc\x88" }, | |
| 262 { "fooa\xcc\x88-test", "foo" }, | |
| 263 { "foo\xc3\xa4-test", "foo\xc3\xa4-test" }, | |
| 264 { "foo\xc3\xa4-test", "fooa\xcc\x88-test" }, | |
| 265 { "foo\xc3\xa4-test", "foo\xc3\xa4" }, | |
| 266 { "foo\xc3\xa4-test", "fooa\xcc\x88" }, | |
| 267 { "foo\xc3\xa4-test", "foo" }, | |
| 268 { "foo", "foo" } | |
| 269 }; | |
| 270 | |
| 271 GURL url(kAboutBlankURL); | |
| 272 for (size_t i = 0; i < ARRAYSIZE_UNSAFE(data); ++i) { | |
| 273 model_->AddURL(model_->other_node(), 0, UTF8ToUTF16(data[i].title), url); | |
| 274 std::vector<BookmarkMatch> matches; | |
| 275 model_->GetBookmarksMatching(UTF8ToUTF16(data[i].query), 10, &matches); | |
| 276 EXPECT_EQ(1u, matches.size()); | |
| 277 model_ = client_.CreateModel(false); | |
| 278 } | |
| 279 } | |
| 280 | |
| 281 // Makes sure match positions are updated appropriately for title matches. | |
| 282 TEST_F(BookmarkIndexTest, MatchPositionsTitles) { | |
| 283 struct TestData { | |
| 284 const std::string title; | |
| 285 const std::string query; | |
| 286 const std::string expected_title_match_positions; | |
| 287 } data[] = { | |
| 288 // Trivial test case of only one term, exact match. | |
| 289 { "a", "A", "0,1" }, | |
| 290 { "foo bar", "bar", "4,7" }, | |
| 291 { "fooey bark", "bar foo", "0,3:6,9" }, | |
| 292 // Non-trivial tests. | |
| 293 { "foobar foo", "foobar foo", "0,6:7,10" }, | |
| 294 { "foobar foo", "foo foobar", "0,6:7,10" }, | |
| 295 { "foobar foobar", "foobar foo", "0,6:7,13" }, | |
| 296 { "foobar foobar", "foo foobar", "0,6:7,13" }, | |
| 297 }; | |
| 298 for (size_t i = 0; i < ARRAYSIZE_UNSAFE(data); ++i) { | |
| 299 std::vector<TitleAndURL> bookmarks; | |
| 300 TitleAndURL bookmark(data[i].title, kAboutBlankURL); | |
| 301 bookmarks.push_back(bookmark); | |
| 302 AddBookmarks(bookmarks); | |
| 303 | |
| 304 std::vector<BookmarkMatch> matches; | |
| 305 model_->GetBookmarksMatching(ASCIIToUTF16(data[i].query), 1000, &matches); | |
| 306 ASSERT_EQ(1U, matches.size()); | |
| 307 | |
| 308 BookmarkMatch::MatchPositions expected_title_matches; | |
| 309 ExtractMatchPositions(data[i].expected_title_match_positions, | |
| 310 &expected_title_matches); | |
| 311 ExpectMatchPositions(matches[0].title_match_positions, | |
| 312 expected_title_matches); | |
| 313 | |
| 314 model_ = client_.CreateModel(false); | |
| 315 } | |
| 316 } | |
| 317 | |
| 318 // Makes sure match positions are updated appropriately for URL matches. | |
| 319 TEST_F(BookmarkIndexTest, MatchPositionsURLs) { | |
| 320 // The encoded stuff between /wiki/ and the # is 第二次世界大戦 | |
| 321 const std::string ja_wiki_url = "http://ja.wikipedia.org/wiki/%E7%AC%AC%E4" | |
| 322 "%BA%8C%E6%AC%A1%E4%B8%96%E7%95%8C%E5%A4%A7%E6%88%A6#.E3.83.B4.E3.82.A7" | |
| 323 ".E3.83.AB.E3.82.B5.E3.82.A4.E3.83.A6.E4.BD.93.E5.88.B6"; | |
| 324 struct TestData { | |
| 325 const std::string query; | |
| 326 const std::string url; | |
| 327 const std::string expected_url_match_positions; | |
| 328 } data[] = { | |
| 329 { "foo", "http://www.foo.com/", "11,14" }, | |
| 330 { "foo", "http://www.foodie.com/", "11,14" }, | |
| 331 { "foo", "http://www.foofoo.com/", "11,14" }, | |
| 332 { "www", "http://www.foo.com/", "7,10" }, | |
| 333 { "foo", "http://www.foodie.com/blah/foo/fi", "11,14:27,30" }, | |
| 334 { "foo", "http://www.blah.com/blah/foo/fi", "25,28" }, | |
| 335 { "foo www", "http://www.foodie.com/blah/foo/fi", "7,10:11,14:27,30" }, | |
| 336 { "www foo", "http://www.foodie.com/blah/foo/fi", "7,10:11,14:27,30" }, | |
| 337 { "www bla", "http://www.foodie.com/blah/foo/fi", "7,10:22,25" }, | |
| 338 { "http", "http://www.foo.com/", "0,4" }, | |
| 339 { "http www", "http://www.foo.com/", "0,4:7,10" }, | |
| 340 { "http foo", "http://www.foo.com/", "0,4:11,14" }, | |
| 341 { "http foo", "http://www.bar.com/baz/foodie/hi", "0,4:23,26" }, | |
| 342 { "第二次", ja_wiki_url, "29,56" }, | |
| 343 { "ja 第二次", ja_wiki_url, "7,9:29,56" }, | |
| 344 { "第二次 E3.8", ja_wiki_url, "29,56:94,98:103,107:" | |
| 345 "112,116:121,125:" | |
| 346 "130,134:139,143" } | |
| 347 }; | |
| 348 | |
| 349 for (size_t i = 0; i < ARRAYSIZE_UNSAFE(data); ++i) { | |
| 350 model_ = client_.CreateModel(true); | |
| 351 std::vector<TitleAndURL> bookmarks; | |
| 352 TitleAndURL bookmark("123456", data[i].url); | |
| 353 bookmarks.push_back(bookmark); | |
| 354 AddBookmarks(bookmarks); | |
| 355 | |
| 356 std::vector<BookmarkMatch> matches; | |
| 357 model_->GetBookmarksMatching(UTF8ToUTF16(data[i].query), 1000, &matches); | |
| 358 ASSERT_EQ(1U, matches.size()) << data[i].url << data[i].query; | |
| 359 | |
| 360 BookmarkMatch::MatchPositions expected_url_matches; | |
| 361 ExtractMatchPositions(data[i].expected_url_match_positions, | |
| 362 &expected_url_matches); | |
| 363 ExpectMatchPositions(matches[0].url_match_positions, expected_url_matches); | |
| 364 } | |
| 365 } | |
| 366 | |
| 367 // Makes sure index is updated when a node is removed. | |
| 368 TEST_F(BookmarkIndexTest, Remove) { | |
| 369 const char* titles[] = { "a", "b" }; | |
| 370 const char* urls[] = { kAboutBlankURL, kAboutBlankURL }; | |
| 371 AddBookmarks(titles, urls, ARRAYSIZE_UNSAFE(titles)); | |
| 372 | |
| 373 // Remove the node and make sure we don't get back any results. | |
| 374 model_->Remove(model_->other_node(), 0); | |
| 375 ExpectMatches("A", NULL, 0U); | |
| 376 } | |
| 377 | |
| 378 // Makes sure index is updated when a node's title is changed. | |
| 379 TEST_F(BookmarkIndexTest, ChangeTitle) { | |
| 380 const char* titles[] = { "a", "b" }; | |
| 381 const char* urls[] = { kAboutBlankURL, kAboutBlankURL }; | |
| 382 AddBookmarks(titles, urls, ARRAYSIZE_UNSAFE(titles)); | |
| 383 | |
| 384 // Remove the node and make sure we don't get back any results. | |
| 385 const char* expected[] = { "blah" }; | |
| 386 model_->SetTitle(model_->other_node()->GetChild(0), ASCIIToUTF16("blah")); | |
| 387 ExpectMatches("BlAh", expected, ARRAYSIZE_UNSAFE(expected)); | |
| 388 } | |
| 389 | |
| 390 // Makes sure no more than max queries is returned. | |
| 391 TEST_F(BookmarkIndexTest, HonorMax) { | |
| 392 const char* titles[] = { "abcd", "abcde" }; | |
| 393 const char* urls[] = { kAboutBlankURL, kAboutBlankURL }; | |
| 394 AddBookmarks(titles, urls, ARRAYSIZE_UNSAFE(titles)); | |
| 395 | |
| 396 std::vector<BookmarkMatch> matches; | |
| 397 model_->GetBookmarksMatching(ASCIIToUTF16("ABc"), 1, &matches); | |
| 398 EXPECT_EQ(1U, matches.size()); | |
| 399 } | |
| 400 | |
| 401 // Makes sure if the lower case string of a bookmark title is more characters | |
| 402 // than the upper case string no match positions are returned. | |
| 403 TEST_F(BookmarkIndexTest, EmptyMatchOnMultiwideLowercaseString) { | |
| 404 const BookmarkNode* n1 = model_->AddURL(model_->other_node(), 0, | |
| 405 base::WideToUTF16(L"\u0130 i"), | |
| 406 GURL("http://www.google.com")); | |
| 407 | |
| 408 std::vector<BookmarkMatch> matches; | |
| 409 model_->GetBookmarksMatching(ASCIIToUTF16("i"), 100, &matches); | |
| 410 ASSERT_EQ(1U, matches.size()); | |
| 411 EXPECT_EQ(n1, matches[0].node); | |
| 412 EXPECT_TRUE(matches[0].title_match_positions.empty()); | |
| 413 } | |
| 414 | |
| 415 TEST_F(BookmarkIndexTest, GetResultsSortedByTypedCount) { | |
| 416 struct TestData { | |
| 417 const GURL url; | |
| 418 const char* title; | |
| 419 const int typed_count; | |
| 420 } data[] = { | |
| 421 { GURL("http://www.google.com/"), "Google", 100 }, | |
| 422 { GURL("http://maps.google.com/"), "Google Maps", 40 }, | |
| 423 { GURL("http://docs.google.com/"), "Google Docs", 50 }, | |
| 424 { GURL("http://reader.google.com/"), "Google Reader", 80 }, | |
| 425 }; | |
| 426 | |
| 427 std::map<GURL, int> typed_count_map; | |
| 428 for (size_t i = 0; i < ARRAYSIZE_UNSAFE(data); ++i) | |
| 429 typed_count_map.insert(std::make_pair(data[i].url, data[i].typed_count)); | |
| 430 | |
| 431 BookmarkClientMock client(typed_count_map); | |
| 432 scoped_ptr<BookmarkModel> model = client.CreateModel(false); | |
| 433 | |
| 434 for (size_t i = 0; i < ARRAYSIZE_UNSAFE(data); ++i) | |
| 435 // Populate the BookmarkIndex. | |
| 436 model->AddURL( | |
| 437 model->other_node(), i, UTF8ToUTF16(data[i].title), data[i].url); | |
| 438 | |
| 439 // Populate match nodes. | |
| 440 std::vector<BookmarkMatch> matches; | |
| 441 model->GetBookmarksMatching(ASCIIToUTF16("google"), 4, &matches); | |
| 442 | |
| 443 // The resulting order should be: | |
| 444 // 1. Google (google.com) 100 | |
| 445 // 2. Google Reader (google.com/reader) 80 | |
| 446 // 3. Google Docs (docs.google.com) 50 | |
| 447 // 4. Google Maps (maps.google.com) 40 | |
| 448 ASSERT_EQ(4, static_cast<int>(matches.size())); | |
| 449 EXPECT_EQ(data[0].url, matches[0].node->url()); | |
| 450 EXPECT_EQ(data[3].url, matches[1].node->url()); | |
| 451 EXPECT_EQ(data[2].url, matches[2].node->url()); | |
| 452 EXPECT_EQ(data[1].url, matches[3].node->url()); | |
| 453 | |
| 454 matches.clear(); | |
| 455 // Select top two matches. | |
| 456 model->GetBookmarksMatching(ASCIIToUTF16("google"), 2, &matches); | |
| 457 | |
| 458 ASSERT_EQ(2, static_cast<int>(matches.size())); | |
| 459 EXPECT_EQ(data[0].url, matches[0].node->url()); | |
| 460 EXPECT_EQ(data[3].url, matches[1].node->url()); | |
| 461 } | |
| 462 | |
| 463 } // namespace | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 284893003:
Move bookmarks/core/... to bookmarks/... (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master