Allow systematic prefix search in bookmarks.

components/bookmarks/browser/bookmark_index_unittest.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "components/bookmarks/browser/bookmark_index.h"
 
 #include <string>
 #include <vector>
 
 #include "base/macros.h"
@@ skipping 65 matching lines @@
                      GURL(bookmarks[i].second));
     }
   }
 
   void ExpectMatches(const std::string& query,
                      const char** expected_titles,
                      size_t expected_count) {
     std::vector<std::string> title_vector;
     for (size_t i = 0; i < expected_count; ++i)
       title_vector.push_back(expected_titles[i]);
-    ExpectMatches(query, title_vector);
+    ExpectMatches(query, false /* always_prefix_search */, title_vector);
   }
 
   void ExpectMatches(const std::string& query,
+                     bool always_prefix_search,
                      const std::vector<std::string>& expected_titles) {
     std::vector<BookmarkMatch> matches;
-    model_->GetBookmarksMatching(ASCIIToUTF16(query), 1000, &matches);
+    if (always_prefix_search)
+      model_->GetBookmarksMatchingPrefixes(ASCIIToUTF16(query), 1000, &matches);
+    else
+      model_->GetBookmarksMatching(ASCIIToUTF16(query), 1000, &matches);
     ASSERT_EQ(expected_titles.size(), matches.size());
     for (size_t i = 0; i < expected_titles.size(); ++i) {
       bool found = false;
       for (size_t j = 0; j < matches.size(); ++j) {
         if (ASCIIToUTF16(expected_titles[i]) == matches[j].node->GetTitle()) {
           matches.erase(matches.begin() + j);
           found = true;
           break;
         }
       }
@@ skipping 61 matching lines @@
       "ab cde ghi",
       "ab cdef ghij"},
 
     // Title with term multiple times.
     { "ab ab",                      "ab",       "ab ab"},
 
     // Make sure quotes don't do a prefix match.
     { "think",                      "\"thi\"",  ""},
 
     // Prefix matches against multiple candidates.
-    { "abc1 abc2 abc3 abc4", "abc", "abc1 abc2 abc3 abc4"},
+    { "abc1 abc2 abc3 abc4",        "abc",      "abc1 abc2 abc3 abc4"},
+
+    // Prefix match on the first term.
+    { "abc",                        "a",        "" },
+
+    // Prefix match on subsequent terms.
+    { "abc def",                    "abc d",    "" },
+
+
   };
   for (size_t i = 0; i < arraysize(data); ++i) {
     std::vector<std::string> titles;
+    base::SplitString(data[i].titles, ';', &titles);
+    std::vector<TitleAndURL> bookmarks;
+    for (size_t j = 0; j < titles.size(); ++j) {
+      TitleAndURL bookmark(titles[j], kAboutBlankURL);
+      bookmarks.push_back(bookmark);
+    }
+    AddBookmarks(bookmarks);
+
+    std::vector<std::string> expected;
+    if (!data[i].expected.empty())
+      base::SplitString(data[i].expected, ';', &expected);
+
+    ExpectMatches(data[i].query, false /* always_prefix_search */, expected);
+
+    model_ = client_.CreateModel();
+  }
+}
+
+TEST_F(BookmarkIndexTest, GetBookmarksMatchingAlwaysPrefixSearch) {
+  struct TestData {
+    const std::string titles;
+    const std::string query;
+    const std::string expected;
+  } data[] = {
+    // Trivial test case of only one term, exact match.
+    { "z;y",                        "Z",        "z" },
+
+    // Prefix match, one term.
+    { "abcd;abc;b",                 "abc",      "abcd;abc" },
+
+    // Prefix match, multiple terms.
+    { "abcd cdef;abcd;abcd cdefg",  "abc cde",  "abcd cdef;abcd cdefg" },
+
+    // Exact and prefix match.
+    { "ab cdef ghij;ab;cde;cdef;ghi;cdef ab;ghij ab",
+      "ab cde ghi",
+      "ab cdef ghij" },
+
+    // Title with term multiple times.
+    { "ab ab",                      "ab",       "ab ab" },
+
+    // Make sure quotes don't do a prefix match.
+    { "think",                      "\"thi\"",  "" },
+
+    // Prefix matches against multiple candidates.
+    { "abc1 abc2 abc3 abc4",        "abc",      "abc1 abc2 abc3 abc4" },
+
+    // Prefix match on the first term.
+    { "abc",                        "a",        "abc" },
+
+    // Prefix match on subsequent terms.
+    { "abc def",                    "abc d",    "abc def" },
+
+    // Exact and prefix match.
+    { "ab cdef;abcd;abcd cdefg",    "ab cdef",  "ab cdef;abcd cdefg" },
+  };
+  for (size_t i = 0; i < arraysize(data); ++i) {
+    std::vector<std::string> titles;
     base::SplitString(data[i].titles, ';', &titles);
     std::vector<TitleAndURL> bookmarks;
     for (size_t j = 0; j < titles.size(); ++j) {
       TitleAndURL bookmark(titles[j], kAboutBlankURL);
       bookmarks.push_back(bookmark);
     }
     AddBookmarks(bookmarks);
 
     std::vector<std::string> expected;
     if (!data[i].expected.empty())
       base::SplitString(data[i].expected, ';', &expected);
 
-    ExpectMatches(data[i].query, expected);
+    ExpectMatches(data[i].query, true /* always_prefix_search */, expected);
 
     model_ = client_.CreateModel();
   }
 }
 
 // Analogous to GetBookmarksMatching, this test tests various permutations
 // of title, URL, and input to see if the title/URL matches the input as
 // expected.
 TEST_F(BookmarkIndexTest, GetBookmarksMatchingWithURLs) {
   struct TestData {
@@ skipping 39 matching lines @@
   for (size_t i = 0; i < arraysize(data); ++i) {
     model_ = client_.CreateModel();
     std::vector<TitleAndURL> bookmarks;
     bookmarks.push_back(TitleAndURL(data[i].title, data[i].url));
     AddBookmarks(bookmarks);
 
     std::vector<std::string> expected;
     if (data[i].should_be_retrieved)
       expected.push_back(data[i].title);
 
-    ExpectMatches(data[i].query, expected);
+    ExpectMatches(data[i].query, false /* always_prefix_search */, expected);
   }
 }
 
 TEST_F(BookmarkIndexTest, Normalization) {
   struct TestData {
     const char* const title;
     const char* const query;
   } data[] = {
     { "fooa\xcc\x88-test", "foo\xc3\xa4-test" },
     { "fooa\xcc\x88-test", "fooa\xcc\x88-test" },
@@ skipping 195 matching lines @@
   // Select top two matches.
   model->GetBookmarksMatching(ASCIIToUTF16("google"), 2, &matches);
 
   ASSERT_EQ(2, static_cast<int>(matches.size()));
   EXPECT_EQ(data[0].url, matches[0].node->url());
   EXPECT_EQ(data[3].url, matches[1].node->url());
 }
 
 }  // namespace
 }  // namespace bookmarks