blob: 86bcbaffeb11ddf7461b809ed86d6c698294bd20 [file] [log] [blame]
// Copyright 2012 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "components/omnibox/browser/bookmark_provider.h"
#include <array>
#include "components/query_parser/query_parser.h"
#include "third_party/omnibox_proto/groups.pb.h"
#include <stddef.h>
#include <memory>
#include <string>
#include <vector>
#include "base/memory/ref_counted.h"
#include "base/strings/string_number_conversions.h"
#include "base/strings/string_split.h"
#include "base/strings/utf_string_conversions.h"
#include "base/test/scoped_feature_list.h"
#include "base/uuid.h"
#include "components/bookmarks/browser/bookmark_model.h"
#include "components/bookmarks/browser/titled_url_match.h"
#include "components/bookmarks/test/test_bookmark_client.h"
#include "components/omnibox/browser/mock_autocomplete_provider_client.h"
#include "components/omnibox/browser/omnibox_field_trial.h"
#include "components/omnibox/browser/test_scheme_classifier.h"
#include "components/omnibox/browser/titled_url_match_utils.h"
#include "components/omnibox/common/omnibox_features.h"
#include "components/search_engines/search_engines_test_environment.h"
#include "components/search_engines/template_url.h"
#include "components/search_engines/template_url_service.h"
#include "components/search_engines/template_url_starter_pack_data.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "third_party/metrics_proto/omnibox_event.pb.h"
#include "third_party/metrics_proto/omnibox_focus_type.pb.h"
using bookmarks::BookmarkModel;
using bookmarks::BookmarkNode;
using bookmarks::TitledUrlMatch;
namespace {
// The bookmark corpus against which we will simulate searches.
struct BookmarksTestInfo {
std::string title;
std::string url;
};
auto bookmark_provider_test_data = std::to_array<BookmarksTestInfo>({
{"abc def", "http://www.catsanddogs.com/a"},
{"abcde", "http://www.catsanddogs.com/b"},
{"abcdef", "http://www.catsanddogs.com/c"},
{"carry carbon carefully", "http://www.catsanddogs.com/d"},
{"a definition", "http://www.catsanddogs.com/e"},
{"ghi jkl", "http://www.catsanddogs.com/f"},
{"jkl ghi", "http://www.catsanddogs.com/g"},
{"mno pqr short", "http://www.catsanddogs.com/f"},
{"pqr mno loooong", "http://www.catsanddogs.com/g"},
{"frankly frankly frank", "http://www.catsanddogs.com/h"},
{"foobar foobar", "http://www.foobar.com/"},
{"domain", "http://www.domain.com/http/"},
{"repeat", "http://www.repeat.com/1/repeat/2/"},
// For testing inline_autocompletion.
{"http://blah.com/", "http://blah.com/"},
{"http://fiddle.com/", "http://fiddle.com/"},
{"http://www.www.com/", "http://www.www.com/"},
{"chrome://version", "chrome://version"},
{"chrome://omnibox", "chrome://omnibox"},
// For testing ranking with different URLs.
{"achlorhydric featherheads resuscitates mockingbirds",
"http://www.manylongwords.com/1a"},
{"achlorhydric mockingbirds resuscitates featherhead",
"http://www.manylongwords.com/2b"},
{"featherhead resuscitates achlorhydric mockingbirds",
"http://www.manylongwords.com/3c"},
{"mockingbirds resuscitates featherheads achlorhydric",
"http://www.manylongwords.com/4d"},
// For testing URL boosting. (URLs referenced multiple times are boosted.)
{"burning worms #1", "http://www.burns.com/"},
{"burning worms #2", "http://www.worms.com/"},
{"worming burns #10", "http://www.burns.com/"},
// For testing strange spacing in bookmark titles.
{" hello1 hello2 ", "http://whatever.com/"},
{"", "http://emptytitle.com/"},
// For testing short bookmarks.
{"testing short bookmarks", "https://zzz.com"},
// For testing bookmarks search in keyword mode.
{"@bookmarks", "chrome://bookmarks"},
// For testing max matches.
{"zyx1", "http://randomsite.com/zyx1"},
{"zyx2", "http://randomsite.com/zyx2"},
{"zyx3", "http://randomsite.com/zyx3"},
{"zyx4", "http://randomsite.com/zyx4"},
{"zyx5", "http://randomsite.com/zyx5"},
{"zyx6", "http://randomsite.com/zyx6"},
{"zyx7", "http://randomsite.com/zyx7"},
{"zyx8", "http://randomsite.com/zyx8"},
{"zyx9", "http://randomsite.com/zyx9"},
});
// Structures and functions supporting the BookmarkProviderTest.Positions
// unit test.
struct TestBookmarkPosition {
TestBookmarkPosition(size_t begin, size_t end) : begin(begin), end(end) {}
bool operator==(const TestBookmarkPosition& other) const {
return begin == other.begin && end == other.end;
}
size_t begin;
size_t end;
};
typedef std::vector<TestBookmarkPosition> TestBookmarkPositions;
// Return |positions| as a formatted string for unit test diagnostic output.
std::string TestBookmarkPositionsAsString(
const TestBookmarkPositions& positions) {
std::string position_string("{");
for (auto i = positions.begin(); i != positions.end(); ++i) {
if (i != positions.begin())
position_string += ", ";
position_string += "{" + base::NumberToString(i->begin) + ", " +
base::NumberToString(i->end) + "}";
}
position_string += "}\n";
return position_string;
}
// Return the positions in |matches| as a formatted string for unit test
// diagnostic output.
std::u16string MatchesAsString16(const ACMatches& matches) {
std::u16string matches_string;
for (auto i = matches.begin(); i != matches.end(); ++i) {
matches_string.append(u" '");
matches_string.append(i->description);
matches_string.append(u"'\n");
}
return matches_string;
}
// Convenience function to make comparing ACMatchClassifications against the
// test expectations structure easier.
TestBookmarkPositions PositionsFromAutocompleteMatch(
const AutocompleteMatch& match) {
TestBookmarkPositions positions;
bool started = false;
size_t start = 0;
for (auto i = match.description_class.begin();
i != match.description_class.end(); ++i) {
if (i->style & AutocompleteMatch::ACMatchClassification::MATCH) {
// We have found the start of a match.
EXPECT_FALSE(started);
started = true;
start = i->offset;
} else if (started) {
// We have found the end of a match.
started = false;
positions.push_back(TestBookmarkPosition(start, i->offset));
start = 0;
}
}
// Record the final position if the last match goes to the end of the
// candidate string.
if (started)
positions.push_back(TestBookmarkPosition(start, match.description.size()));
return positions;
}
} // namespace
class BookmarkProviderTest : public testing::Test {
public:
BookmarkProviderTest();
BookmarkProviderTest(const BookmarkProviderTest&) = delete;
BookmarkProviderTest& operator=(const BookmarkProviderTest&) = delete;
protected:
void SetUp() override;
// Starts fresh with a new BookmarkProvider.
void ResetProvider();
// Invokes |Start()| with |input_text| and returns the number of matches
// provided.
[[nodiscard]] size_t GetNumMatches(std::string input_text);
search_engines::SearchEnginesTestEnvironment search_engines_test_environment_;
std::unique_ptr<MockAutocompleteProviderClient> provider_client_;
std::unique_ptr<BookmarkModel> local_or_syncable_model_;
scoped_refptr<BookmarkProvider> provider_;
TestSchemeClassifier classifier_;
};
BookmarkProviderTest::BookmarkProviderTest() {
local_or_syncable_model_ = bookmarks::TestBookmarkClient::CreateModel();
}
void BookmarkProviderTest::SetUp() {
provider_client_ = std::make_unique<MockAutocompleteProviderClient>();
ON_CALL(*provider_client_, GetBookmarkModel())
.WillByDefault(testing::Return(local_or_syncable_model_.get()));
ON_CALL(*provider_client_, GetSchemeClassifier())
.WillByDefault(testing::ReturnRef(classifier_));
provider_client_->set_template_url_service(
search_engines_test_environment_.template_url_service());
ResetProvider();
const BookmarkNode* other_node = local_or_syncable_model_->other_node();
for (size_t i = 0; i < std::size(bookmark_provider_test_data); ++i) {
const BookmarksTestInfo& cur(bookmark_provider_test_data[i]);
const GURL url(cur.url);
local_or_syncable_model_->AddURL(other_node, other_node->children().size(),
base::ASCIIToUTF16(cur.title), url);
}
}
void BookmarkProviderTest::ResetProvider() {
provider_ = new BookmarkProvider(provider_client_.get());
}
size_t BookmarkProviderTest::GetNumMatches(std::string input_text) {
AutocompleteInput input(base::UTF8ToUTF16(input_text),
metrics::OmniboxEventProto::OTHER,
TestSchemeClassifier());
provider_->Start(input, /*minimal_changes=*/false);
return provider_->matches().size();
}
TEST_F(BookmarkProviderTest, Positions) {
// Simulate searches.
// Description of |positions|:
// The first index represents the collection of positions for each expected
// match. The count of the actual subarrays in each instance of |query_data|
// must equal |match_count|. The second index represents each expected
// match position. The third index represents the |start| and |end| of the
// expected match's position within the |test_data|. This array must be
// terminated by an entry with a value of '0' for |end|.
// Example:
// Consider the line for 'def' below:
// {"def", 2, {{{4, 7}, {XXX, 0}}, {{2, 5}, {11, 14}, {XXX, 0}}}},
// There are two expected matches:
// 0. {{4, 7}, {XXX, 0}}
// 1. {{2, 5}, {11 ,14}, {XXX, 0}}
// For the first match, [0], there is one match within the bookmark's title
// expected, {4, 7}, which maps to the 'def' within "abc def". The 'XXX'
// value is ignored. The second match, [1], indicates that two matches are
// expected within the bookmark title "a definite definition". In each case,
// the {XXX, 0} indicates the end of the subarray. Or:
// Match #1 Match #2
// ------------------ ----------------------------
// Pos1 Term Pos1 Pos2 Term
// ------ -------- ------ -------- --------
// {"def", 2, {{{4, 7}, {999, 0}}, {{2, 5}, {11, 14}, {999, 0}}}},
//
struct QueryData {
std::string query;
std::vector<TestBookmarkPositions> positions_per_match;
};
std::vector<QueryData> queries = {
// This first set is primarily for position detection validation.
{"abc", {{{0, 3}}, {{0, 3}}, {{0, 3}}}},
{"abcde", {{{0, 5}}, {{0, 5}}}},
{"foo bar", {}},
{"fooey bark", {}},
{"def", {{{2, 5}}, {{4, 7}}}},
{"mno pqr", {{{0, 7}}, {{0, 3}, {4, 7}}}},
// NB: GetBookmarksMatching(...) uses exact match for "a" in title or URL.
{"a", {{{0, 1}}, {{0, 1}}}},
{"a d", {{{0, 1}, {4, 5}}, {{0, 3}}}},
{"carry carbon", {{{0, 12}}}},
// NB: GetBookmarksMatching(...) sorts the match positions.
{"carbon carry", {{{0, 5}, {6, 12}}}},
{"arbon", {}},
{"ar", {}},
{"arry", {}},
// Quoted terms are single terms.
{"\"carry carbon\"", {{{0, 5}, {6, 12}}}},
{"\"carry carbon\" care", {{{0, 5}, {6, 12}, {13, 17}}}},
// Quoted terms require complete word matches.
{"\"carry carbo\"", {}},
// This set uses duplicated and/or overlaps search terms in the title.
{"frank", {{{0, 5}}}},
{"frankly", {{{0, 7}}}},
{"frankly frankly", {{{0, 15}}}},
{"foobar foo", {{{0, 10}}}},
{"foo foobar", {{{0, 6}, {7, 13}}}},
// This ensures that leading whitespace in the title is correctly offset.
{"hello", {{{0, 5}}}},
// This ensures that empty titles yield empty classifications.
{"emptytitle", {{}}},
};
for (const auto& query : queries) {
AutocompleteInput input(base::ASCIIToUTF16(query.query),
metrics::OmniboxEventProto::OTHER,
TestSchemeClassifier());
provider_->Start(input, /*minimal_changes=*/false);
const ACMatches& matches(provider_->matches());
// Validate number of results is as expected.
EXPECT_LE(matches.size(), query.positions_per_match.size())
<< "One or more of the following matches were unexpected:\n"
<< MatchesAsString16(matches) << "For query '" << query.query << "'.";
EXPECT_GE(matches.size(), query.positions_per_match.size())
<< "One or more expected matches are missing. Matches found:\n"
<< MatchesAsString16(matches) << "for query '" << query.query << "'.";
// Validate positions within each match is as expected.
for (size_t i = 0; i < matches.size(); ++i) {
TestBookmarkPositions actual_positions(
PositionsFromAutocompleteMatch(matches[i]));
TestBookmarkPositions expected_positions = query.positions_per_match[i];
EXPECT_EQ(actual_positions, expected_positions)
<< "EXPECTED: " << TestBookmarkPositionsAsString(expected_positions)
<< "ACTUAL: " << TestBookmarkPositionsAsString(actual_positions)
<< " for query: '" << query.query << "'.";
}
}
}
TEST_F(BookmarkProviderTest, Rankings) {
// Simulate searches.
struct QueryData {
const std::string query;
// |match_count| must match the number of elements in the following
// |matches| array.
const size_t match_count;
// |matches| specifies the titles for all bookmarks expected to be matched
// by the |query|
const std::array<std::string, 3> matches;
} query_datas[] = {
// Basic ranking test.
{"abc",
3,
{"abcde", // Most complete match.
"abcdef", "abc def"}}, // Least complete match.
{"ghi",
2,
{"ghi jkl", // Matched earlier.
"jkl ghi", // Matched later.
""}},
// Rankings of exact-word matches with different URLs.
{"achlorhydric",
3,
{"achlorhydric mockingbirds resuscitates featherhead",
"achlorhydric featherheads resuscitates mockingbirds",
"featherhead resuscitates achlorhydric mockingbirds"}},
{"achlorhydric featherheads",
2,
{"achlorhydric featherheads resuscitates mockingbirds",
"mockingbirds resuscitates featherheads achlorhydric", ""}},
{"mockingbirds resuscitates",
3,
{"mockingbirds resuscitates featherheads achlorhydric",
"achlorhydric mockingbirds resuscitates featherhead",
"featherhead resuscitates achlorhydric mockingbirds"}},
// Ranking of exact-word matches with URL boosts.
{"worms",
2,
{"burning worms #1", // boosted
"burning worms #2", // not boosted
""}},
// Ranking of prefix matches with URL boost.
{"burn worm",
3,
{"burning worms #1", // boosted
"worming burns #10", // boosted but longer title
"burning worms #2"}}, // not boosted
// A query of "worm burn" will have the same results.
{"worm burn",
3,
{"burning worms #1", // boosted
"worming burns #10", // boosted but longer title
"burning worms #2"}}, // not boosted
};
for (auto& query_data : query_datas) {
AutocompleteInput input(base::ASCIIToUTF16(query_data.query),
metrics::OmniboxEventProto::OTHER,
TestSchemeClassifier());
provider_->Start(input, /*minimal_changes=*/false);
const ACMatches& matches(provider_->matches());
// Validate number and content of results is as expected.
for (size_t j = 0; j < std::max(query_data.match_count, matches.size());
++j) {
EXPECT_LT(j, query_data.match_count)
<< " Unexpected match '"
<< base::UTF16ToUTF8(matches[j].description) << "' for query: '"
<< query_data.query << "'.";
if (j >= query_data.match_count)
continue;
EXPECT_LT(j, matches.size())
<< " Missing match '" << query_data.matches[j] << "' for query: '"
<< query_data.query << "'.";
if (j >= matches.size())
continue;
EXPECT_EQ(query_data.matches[j],
base::UTF16ToUTF8(matches[j].description))
<< " Mismatch at [" << base::NumberToString(j) << "] for query '"
<< query_data.query << "'.";
}
}
}
TEST_F(BookmarkProviderTest, InlineAutocompletion) {
// Simulate searches.
struct QueryData {
const std::string query;
const std::string url;
const bool allowed_to_be_default_match;
const std::string inline_autocompletion;
};
auto query_data = std::to_array<QueryData>({
{"bla", "http://blah.com/", true, "h.com"},
{"blah ", "http://blah.com/", false, ".com"},
{"http://bl", "http://blah.com/", true, "ah.com"},
{"fiddle.c", "http://fiddle.com/", true, "om"},
{"www", "http://www.www.com/", true, ".com"},
{"chro", "chrome://version", true, "me://version"},
{"chrome://ve", "chrome://version", true, "rsion"},
{"chrome ver", "chrome://version", false, ""},
{"versi", "chrome://version", false, ""},
{"abou", "chrome://omnibox", false, ""},
{"about:om", "chrome://omnibox", true, "nibox"}
// Note: when adding a new URL to this test, be sure to add it to the list
// of bookmarks at the top of the file as well. All items in this list
// need to be in the bookmarks list because BookmarkProvider's
// TitleMatchToACMatch() has an assertion that verifies the URL is
// actually bookmarked.
});
for (size_t i = 0; i < std::size(query_data); ++i) {
const std::string description =
"for query=" + query_data[i].query + " and url=" + query_data[i].url;
AutocompleteInput input(base::ASCIIToUTF16(query_data[i].query),
metrics::OmniboxEventProto::OTHER,
TestSchemeClassifier());
const std::u16string fixed_up_input(
provider_->FixupUserInput(input).second);
BookmarkNode node(/*id=*/0, base::Uuid::GenerateRandomV4(),
GURL(query_data[i].url));
node.SetTitle(base::ASCIIToUTF16(query_data[i].url));
TitledUrlMatch bookmark_match;
bookmark_match.node = &node;
auto relevance_and_bookmark_count =
provider_->CalculateBookmarkMatchRelevance(bookmark_match);
const AutocompleteMatch& ac_match = TitledUrlMatchToAutocompleteMatch(
bookmark_match, AutocompleteMatchType::BOOKMARK_TITLE,
relevance_and_bookmark_count.first, relevance_and_bookmark_count.second,
provider_.get(), classifier_, input, fixed_up_input);
EXPECT_EQ(query_data[i].allowed_to_be_default_match,
ac_match.allowed_to_be_default_match)
<< description;
EXPECT_EQ(base::ASCIIToUTF16(query_data[i].inline_autocompletion),
ac_match.inline_autocompletion)
<< description;
}
}
TEST_F(BookmarkProviderTest, StripHttpAndAdjustOffsets) {
// Simulate searches.
struct QueryData {
const std::string query;
const std::string expected_contents;
// |expected_contents_class| is in format offset:style,offset:style,...
const std::string expected_contents_class;
};
auto query_data = std::to_array<QueryData>({
// clang-format off
{ "foo", "foobar.com", "0:3,3:1" },
{ "www foo", "www.foobar.com", "0:3,3:1,4:3,7:1" },
{ "foo www", "www.foobar.com", "0:3,3:1,4:3,7:1" },
{ "foo http", "http://foobar.com", "0:3,4:1,7:3,10:1" },
{ "blah", "blah.com", "0:3,4:1" },
{ "http blah", "http://blah.com", "0:3,4:1,7:3,11:1" },
{ "dom", "domain.com/http/", "0:3,3:1" },
{ "dom http", "http://domain.com/http/", "0:3,4:1,7:3,10:1,18:3,22:1" },
{ "rep", "repeat.com/1/repeat/2/", "0:3,3:1" },
{ "versi", "chrome://version", "0:1,9:3,14:1" },
// clang-format on
});
for (size_t i = 0; i < std::size(query_data); ++i) {
std::string description = "for query=" + query_data[i].query;
AutocompleteInput input(base::ASCIIToUTF16(query_data[i].query),
metrics::OmniboxEventProto::OTHER,
TestSchemeClassifier());
provider_->Start(input, /*minimal_changes=*/false);
const ACMatches& matches(provider_->matches());
ASSERT_EQ(1U, matches.size()) << description;
const AutocompleteMatch& match = matches[0];
description +=
"\n EXPECTED classes: " + query_data[i].expected_contents_class;
description += "\n ACTUAL classes: ";
for (auto x : match.contents_class) {
description += base::NumberToString(x.offset) + ":" +
base::NumberToString(x.style) + ",";
}
EXPECT_EQ(base::ASCIIToUTF16(query_data[i].expected_contents),
match.contents)
<< description;
std::vector<std::string> class_strings =
base::SplitString(query_data[i].expected_contents_class, ",",
base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
ASSERT_EQ(class_strings.size(), match.contents_class.size()) << description;
for (size_t j = 0; j < class_strings.size(); ++j) {
std::vector<std::string> chunks = base::SplitString(
class_strings[j], ":", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
ASSERT_EQ(2U, chunks.size()) << description;
size_t offset;
EXPECT_TRUE(base::StringToSizeT(chunks[0], &offset)) << description;
EXPECT_EQ(offset, match.contents_class[j].offset) << description;
int style;
EXPECT_TRUE(base::StringToInt(chunks[1], &style)) << description;
EXPECT_EQ(style, match.contents_class[j].style) << description;
}
}
}
TEST_F(BookmarkProviderTest, DoesNotProvideMatchesOnFocus) {
AutocompleteInput input(u"foo", metrics::OmniboxEventProto::OTHER,
TestSchemeClassifier());
input.set_focus_type(metrics::OmniboxFocusType::INTERACTION_FOCUS);
provider_->Start(input, /*minimal_changes=*/false);
EXPECT_TRUE(provider_->matches().empty());
}
TEST_F(BookmarkProviderTest, ShortBookmarks) {
// Test the 2 short bookmark features that determine when short inputs should
// be allowed to prefix match. These tests are trying to match the mock
// bookmark "testing short bookmarks".
EXPECT_EQ(GetNumMatches("te"), 0u);
EXPECT_EQ(GetNumMatches("te "), 1u);
EXPECT_EQ(GetNumMatches("tes"), 1u);
EXPECT_EQ(GetNumMatches("te sh bo"), 1u);
}
TEST_F(BookmarkProviderTest, GetMatchesWithBookmarkPaths) {
// Should return path matched bookmark.
SCOPED_TRACE("feature enabled without counterfactual");
EXPECT_EQ(GetNumMatches("carefully other"), 1u);
}
// Make sure that user input is trimmed correctly for starter pack keyword mode.
// In this mode, suggestions should be provided for only the user input after
// the keyword, i.e. "@bookmarks domain" should only match "domain".
TEST_F(BookmarkProviderTest, KeywordModeExtractUserInput) {
// Populate template URL with starter pack entries
std::vector<std::unique_ptr<TemplateURLData>> turls =
template_url_starter_pack_data::GetStarterPackEngines();
for (auto& turl : turls) {
provider_client_->GetTemplateURLService()->Add(
std::make_unique<TemplateURL>(std::move(*turl)));
}
// Test result for user text "domain", we should get back a result for domain.
AutocompleteInput input(u"domain", metrics::OmniboxEventProto::OTHER,
TestSchemeClassifier());
provider_->Start(input, /*minimal_changes=*/false);
ACMatches matches = provider_->matches();
ASSERT_GT(matches.size(), 0u);
EXPECT_EQ(matches[0].description, u"domain");
// Test result for "@bookmarks" while NOT in keyword mode, we shouldn't get a
// result because the input starts with "@".
AutocompleteInput input2(u"@bookmarks", metrics::OmniboxEventProto::OTHER,
TestSchemeClassifier());
provider_->Start(input2, /*minimal_changes=*/false);
EXPECT_TRUE(provider_->matches().empty());
// Test result for "domain @bookmarks" while NOT in keyword mode, we should
// get a result. Although the input contains "@", it doesn't start with it.
AutocompleteInput input3(u"domain @bookmarks",
metrics::OmniboxEventProto::OTHER,
TestSchemeClassifier());
provider_->Start(input3, /*minimal_changes=*/false);
EXPECT_EQ(provider_->matches().size(), 1u);
EXPECT_EQ(matches[0].description, u"domain");
// In keyword mode, "@bookmarks domain" should match since we're only trying
// to match "domain".
AutocompleteInput input4(u"@bookmarks domain",
metrics::OmniboxEventProto::OTHER,
TestSchemeClassifier());
input4.set_prefer_keyword(true);
input4.set_keyword_mode_entry_method(
metrics::OmniboxEventProto_KeywordModeEntryMethod_TAB);
provider_->Start(input4, /*minimal_changes=*/false);
matches = provider_->matches();
ASSERT_EQ(matches.size(), 1u);
EXPECT_EQ(matches[0].description, u"domain");
// Ensure keyword and transition are set properly to keep user in keyword
// mode.
EXPECT_TRUE(matches[0].from_keyword);
EXPECT_EQ(matches[0].keyword, u"@bookmarks");
EXPECT_TRUE(PageTransitionCoreTypeIs(matches[0].transition,
ui::PAGE_TRANSITION_KEYWORD));
}
TEST_F(BookmarkProviderTest, MaxMatches) {
// Keyword mode is off. We should only get provider_max_matches_ matches.
AutocompleteInput input(u"zyx", metrics::OmniboxEventProto::OTHER,
TestSchemeClassifier());
provider_->Start(input, /*minimal_changes=*/false);
ACMatches matches = provider_->matches();
EXPECT_EQ(matches.size(), provider_->provider_max_matches());
// Turn keyword mode on. we should be able to get more matches now.
input.set_keyword_mode_entry_method(
metrics::OmniboxEventProto_KeywordModeEntryMethod_TAB);
input.set_prefer_keyword(true);
provider_->Start(input, /*minimal_changes=*/false);
matches = provider_->matches();
EXPECT_EQ(matches.size(), provider_->provider_max_matches_in_keyword_mode());
// The provider should not limit the number of suggestions when ML scoring
// w/increased candidates is enabled. Any matches beyond the limit should be
// marked as culled_by_provider and have a relevance of 0.
input.set_keyword_mode_entry_method(
metrics::OmniboxEventProto_KeywordModeEntryMethod_INVALID);
input.set_prefer_keyword(false);
base::test::ScopedFeatureList scoped_feature_list;
scoped_feature_list.InitWithFeaturesAndParameters(
/*enabled_features=*/
{{omnibox::kUrlScoringModel, {}},
{omnibox::kMlUrlScoring,
{{"MlUrlScoringUnlimitedNumCandidates", "true"}}}},
/*disabled_features=*/{});
OmniboxFieldTrial::ScopedMLConfigForTesting scoped_ml_config;
provider_->Start(input, false);
matches = provider_->matches();
EXPECT_EQ(matches.size(), 9u);
// Matches below the `max_matches` limit.
for (size_t i = 0; i < provider_->provider_max_matches(); i++) {
EXPECT_FALSE(matches[i].culled_by_provider);
EXPECT_GT(matches[i].relevance, 0);
}
// "Extra" matches above the `max_matches` limit. Should have 0 relevance and
// be marked as `culled_by_provider`.
for (size_t i = provider_->provider_max_matches(); i < matches.size(); i++) {
EXPECT_TRUE(matches[i].culled_by_provider);
EXPECT_EQ(matches[i].relevance, 0);
}
// Unlimited matches should ignore the provider max matches, even if the
// `kMlUrlScoringMaxMatchesByProvider` param is set.
scoped_ml_config.GetMLConfig().ml_url_scoring_max_matches_by_provider = "*:6";
provider_->Start(input, false);
matches = provider_->matches();
EXPECT_EQ(matches.size(), 9u);
}
TEST_F(BookmarkProviderTest, SetsGroupForHubSearch) {
AutocompleteInput input(u"foo", metrics::OmniboxEventProto::ANDROID_HUB,
TestSchemeClassifier());
provider_->Start(input, /*minimal_changes=*/false);
EXPECT_FALSE(provider_->matches().empty());
EXPECT_EQ(omnibox::GROUP_MOBILE_BOOKMARKS,
provider_->matches()[0].suggestion_group_id);
}
TEST_F(BookmarkProviderTest, NoMaxMatchesForHubSearch) {
AutocompleteInput input(u"zyx", metrics::OmniboxEventProto::ANDROID_HUB,
TestSchemeClassifier());
provider_->Start(input, /*minimal_changes=*/false);
EXPECT_EQ(3u, provider_->provider_max_matches());
EXPECT_FALSE(provider_->matches().empty());
EXPECT_GT(provider_->matches().size(), 3u);
}
TEST_F(BookmarkProviderTest, MatchingAlgorithmForHubSearch) {
AutocompleteInput input(u"foo", metrics::OmniboxEventProto::ANDROID_HUB,
TestSchemeClassifier());
EXPECT_EQ(query_parser::MatchingAlgorithm::ALWAYS_PREFIX_SEARCH,
provider_->GetMatchingAlgorithm(input));
}