// Copyright 2014 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/autocomplete_match.h"

#include <stddef.h>

#include <utility>

#include "base/strings/utf_string_conversions.h"
#include "base/test/scoped_feature_list.h"
#include "components/omnibox/browser/actions/omnibox_action.h"
#include "components/omnibox/browser/actions/omnibox_action_in_suggest.h"
#include "components/omnibox/browser/actions/omnibox_answer_action.h"
#include "components/omnibox/browser/actions/omnibox_pedal.h"
#include "components/omnibox/browser/actions/omnibox_pedal_concepts.h"
#include "components/omnibox/browser/autocomplete_match_type.h"
#include "components/omnibox/browser/autocomplete_provider.h"
#include "components/omnibox/browser/fake_autocomplete_provider.h"
#include "components/omnibox/browser/omnibox_field_trial.h"
#include "components/omnibox/browser/test_scheme_classifier.h"
#include "components/omnibox/common/omnibox_features.h"
#include "components/search_engines/template_url.h"
#include "components/search_engines/template_url_data.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_scoring_signals.pb.h"
#include "third_party/omnibox_proto/entity_info.pb.h"
#include "third_party/omnibox_proto/suggest_template_info.pb.h"
#include "ui/gfx/vector_icon_types.h"
#include "url/gurl.h"

using ScoringSignals = ::metrics::OmniboxScoringSignals;

namespace {

class FakeOmniboxAction : public OmniboxAction {
 public:
  explicit FakeOmniboxAction(OmniboxActionId id)
      : OmniboxAction(LabelStrings(u"", u"", u"", u""), GURL{}), id_(id) {}
  OmniboxActionId ActionId() const override { return id_; }

 private:
  ~FakeOmniboxAction() override = default;
  OmniboxActionId id_{};
};

void TestSetAllowedToBeDefault(int caseI,
                               const std::string input_text,
                               bool input_prevent_inline_autocomplete,
                               const std::string match_inline_autocompletion,
                               const std::string expected_inline_autocompletion,
                               bool expected_allowed_to_be_default_match) {
  AutocompleteInput input(base::UTF8ToUTF16(input_text),
                          metrics::OmniboxEventProto::OTHER,
                          TestSchemeClassifier());
  input.set_prevent_inline_autocomplete(input_prevent_inline_autocomplete);

  AutocompleteMatch match;
  match.inline_autocompletion = base::UTF8ToUTF16(match_inline_autocompletion);

  match.SetAllowedToBeDefault(input);

  EXPECT_EQ(base::UTF16ToUTF8(match.inline_autocompletion).c_str(),
            expected_inline_autocompletion)
      << "case " << caseI;
  EXPECT_EQ(match.allowed_to_be_default_match,
            expected_allowed_to_be_default_match)
      << "case " << caseI;
}

AutocompleteMatch CreateACMatchWithScoringSignals(
    int typed_count,
    int visit_count,
    int elapsed_time_last_visit_secs,
    int shortcut_visit_count,
    int shortest_shortcut_len,
    bool is_host_only,
    int num_bookmarks_of_url,
    int first_bookmark_title_match_position,
    int total_bookmark_title_match_length,
    int num_input_terms_matched_by_bookmark_title,
    int first_url_match_position,
    int total_url_match_length,
    bool host_match_at_word_boundary,
    int total_path_match_length,
    int total_query_or_ref_match_length,
    int total_title_match_length,
    bool has_non_scheme_www_match,
    int num_input_terms_matched_by_title,
    int num_input_terms_matched_by_url,
    int length_of_url,
    float site_engagement,
    bool allowed_to_be_default_match) {
  AutocompleteMatch match;
  match.scoring_signals = std::make_optional<ScoringSignals>();
  match.scoring_signals->set_typed_count(typed_count);
  match.scoring_signals->set_visit_count(visit_count);
  match.scoring_signals->set_elapsed_time_last_visit_secs(
      elapsed_time_last_visit_secs);
  match.scoring_signals->set_shortcut_visit_count(shortcut_visit_count);
  match.scoring_signals->set_shortest_shortcut_len(shortest_shortcut_len);
  match.scoring_signals->set_is_host_only(is_host_only);
  match.scoring_signals->set_num_bookmarks_of_url(num_bookmarks_of_url);
  match.scoring_signals->set_first_bookmark_title_match_position(
      first_bookmark_title_match_position);
  match.scoring_signals->set_total_bookmark_title_match_length(
      total_bookmark_title_match_length);
  match.scoring_signals->set_num_input_terms_matched_by_bookmark_title(
      num_input_terms_matched_by_bookmark_title);
  match.scoring_signals->set_first_url_match_position(first_url_match_position);
  match.scoring_signals->set_total_url_match_length(total_url_match_length);
  match.scoring_signals->set_host_match_at_word_boundary(
      host_match_at_word_boundary);
  match.scoring_signals->set_total_path_match_length(total_path_match_length);
  match.scoring_signals->set_total_query_or_ref_match_length(
      total_query_or_ref_match_length);
  match.scoring_signals->set_total_title_match_length(total_title_match_length);
  match.scoring_signals->set_has_non_scheme_www_match(has_non_scheme_www_match);
  match.scoring_signals->set_num_input_terms_matched_by_title(
      num_input_terms_matched_by_title);
  match.scoring_signals->set_num_input_terms_matched_by_url(
      num_input_terms_matched_by_url);
  match.scoring_signals->set_length_of_url(length_of_url);
  match.scoring_signals->set_site_engagement(site_engagement);
  match.scoring_signals->set_allowed_to_be_default_match(
      allowed_to_be_default_match);

  return match;
}

// Use a test fixture to ensure that any scoped settings that are set during the
// test are cleared after the test is terminated.
class AutocompleteMatchTest : public testing::Test {
 protected:
  void TearDown() override {
    RichAutocompletionParams::ClearParamsForTesting();
  }
};

}  // namespace

TEST_F(AutocompleteMatchTest, MoreRelevant) {
  struct RelevantCases {
    int r1;
    int r2;
    bool expected_result;
  } cases[] = {
      {10, 0, true},  {10, -5, true},   {-5, 10, false},
      {0, 10, false}, {-10, -5, false}, {-5, -10, true},
  };

  AutocompleteMatch m1(nullptr, 0, false,
                       AutocompleteMatchType::URL_WHAT_YOU_TYPED);
  AutocompleteMatch m2(nullptr, 0, false,
                       AutocompleteMatchType::URL_WHAT_YOU_TYPED);

  for (const auto& caseI : cases) {
    m1.relevance = caseI.r1;
    m2.relevance = caseI.r2;
    EXPECT_EQ(caseI.expected_result, AutocompleteMatch::MoreRelevant(m1, m2));
  }
}

TEST_F(AutocompleteMatchTest, MergeClassifications) {
  // Merging two empty vectors should result in an empty vector.
  EXPECT_EQ(std::string(),
            AutocompleteMatch::ClassificationsToString(
                AutocompleteMatch::MergeClassifications(
                    AutocompleteMatch::ACMatchClassifications(),
                    AutocompleteMatch::ACMatchClassifications())));

  // If one vector is empty and the other is "trivial" but non-empty (i.e. (0,
  // NONE)), the non-empty vector should be returned.
  EXPECT_EQ("0,0", AutocompleteMatch::ClassificationsToString(
                       AutocompleteMatch::MergeClassifications(
                           AutocompleteMatch::ClassificationsFromString("0,0"),
                           AutocompleteMatch::ACMatchClassifications())));
  EXPECT_EQ("0,0",
            AutocompleteMatch::ClassificationsToString(
                AutocompleteMatch::MergeClassifications(
                    AutocompleteMatch::ACMatchClassifications(),
                    AutocompleteMatch::ClassificationsFromString("0,0"))));

  // Ditto if the one-entry vector is non-trivial.
  EXPECT_EQ("0,1", AutocompleteMatch::ClassificationsToString(
                       AutocompleteMatch::MergeClassifications(
                           AutocompleteMatch::ClassificationsFromString("0,1"),
                           AutocompleteMatch::ACMatchClassifications())));
  EXPECT_EQ("0,1",
            AutocompleteMatch::ClassificationsToString(
                AutocompleteMatch::MergeClassifications(
                    AutocompleteMatch::ACMatchClassifications(),
                    AutocompleteMatch::ClassificationsFromString("0,1"))));

  // Merge an unstyled one-entry vector with a styled one-entry vector.
  EXPECT_EQ("0,1",
            AutocompleteMatch::ClassificationsToString(
                AutocompleteMatch::MergeClassifications(
                    AutocompleteMatch::ClassificationsFromString("0,0"),
                    AutocompleteMatch::ClassificationsFromString("0,1"))));

  // Test simple cases of overlap.
  EXPECT_EQ(
      "0,3,"
      "1,2",
      AutocompleteMatch::ClassificationsToString(
          AutocompleteMatch::MergeClassifications(
              AutocompleteMatch::ClassificationsFromString("0,1,"
                                                           "1,0"),
              AutocompleteMatch::ClassificationsFromString("0,2"))));
  EXPECT_EQ(
      "0,3,"
      "1,2",
      AutocompleteMatch::ClassificationsToString(
          AutocompleteMatch::MergeClassifications(
              AutocompleteMatch::ClassificationsFromString("0,2"),
              AutocompleteMatch::ClassificationsFromString("0,1,"
                                                           "1,0"))));

  // Test the case where both vectors have classifications at the same
  // positions.
  EXPECT_EQ("0,3",
            AutocompleteMatch::ClassificationsToString(
                AutocompleteMatch::MergeClassifications(
                    AutocompleteMatch::ClassificationsFromString("0,1,"
                                                                 "1,2"),
                    AutocompleteMatch::ClassificationsFromString("0,2,"
                                                                 "1,1"))));

  // Test an arbitrary complicated case.
  EXPECT_EQ(
      "0,2,"
      "1,0,"
      "2,1,"
      "4,3,"
      "5,7,"
      "6,3,"
      "7,7,"
      "15,1,"
      "17,0",
      AutocompleteMatch::ClassificationsToString(
          AutocompleteMatch::MergeClassifications(
              AutocompleteMatch::ClassificationsFromString("0,0,"
                                                           "2,1,"
                                                           "4,3,"
                                                           "7,7,"
                                                           "10,6,"
                                                           "15,0"),
              AutocompleteMatch::ClassificationsFromString("0,2,"
                                                           "1,0,"
                                                           "5,7,"
                                                           "6,1,"
                                                           "17,0"))));
}

TEST_F(AutocompleteMatchTest, GetMatchComponents) {
  struct MatchComponentsTestData {
    const std::string url;
    std::vector<std::string> input_terms;
    bool expected_match_in_scheme;
    bool expected_match_in_subdomain;
  };

  MatchComponentsTestData test_cases[] = {
      // Match in scheme.
      {"http://www.google.com", {"ht"}, true, false},
      // Match within the scheme, but not starting at the beginning, i.e. "ttp".
      {"http://www.google.com", {"tp"}, false, false},
      // Sanity check that HTTPS still works.
      {"https://www.google.com", {"http"}, true, false},

      // Match within the subdomain.
      {"http://www.google.com", {"www"}, false, true},
      {"http://www.google.com", {"www."}, false, true},
      // Don't consider matches on the '.' delimiter as a match_in_subdomain.
      {"http://www.google.com", {"."}, false, false},
      {"http://www.google.com", {".goo"}, false, false},
      // Matches within the domain.
      {"http://www.google.com", {"goo"}, false, false},
      // Verify that in private registries, we detect matches in subdomains.
      {"http://www.appspot.com", {"www"}, false, true},

      // Matches spanning the scheme, subdomain, and domain.
      {"http://www.google.com", {"http://www.goo"}, true, true},
      {"http://www.google.com", {"ht", "www"}, true, true},
      // But we should not flag match_in_subdomain if there is no subdomain.
      {"http://google.com", {"http://goo"}, true, false},

      // Matches spanning the subdomain and path.
      {"http://www.google.com/abc", {"www.google.com/ab"}, false, true},
      {"http://www.google.com/abc", {"www", "ab"}, false, true},

      // Matches spanning the scheme, subdomain, and path.
      {"http://www.google.com/abc", {"http://www.google.com/ab"}, true, true},
      {"http://www.google.com/abc", {"ht", "ww", "ab"}, true, true},

      // Intranet sites.
      {"http://foobar/biz", {"foobar"}, false, false},
      {"http://foobar/biz", {"biz"}, false, false},

      // Ensure something sane happens when the URL input is invalid.
      {"", {""}, false, false},
      {"foobar", {"bar"}, false, false},
  };
  for (auto& test_case : test_cases) {
    SCOPED_TRACE(testing::Message()
                 << " url=" << test_case.url << " first input term="
                 << test_case.input_terms[0] << " expected_match_in_scheme="
                 << test_case.expected_match_in_scheme
                 << " expected_match_in_subdomain="
                 << test_case.expected_match_in_subdomain);
    bool match_in_scheme = false;
    bool match_in_subdomain = false;
    std::vector<AutocompleteMatch::MatchPosition> match_positions;
    for (auto& term : test_case.input_terms) {
      size_t start = test_case.url.find(term);
      ASSERT_NE(std::string::npos, start);
      size_t end = start + term.size();
      match_positions.push_back(std::make_pair(start, end));
    }
    AutocompleteMatch::GetMatchComponents(GURL(test_case.url), match_positions,
                                          &match_in_scheme,
                                          &match_in_subdomain);
    EXPECT_EQ(test_case.expected_match_in_scheme, match_in_scheme);
    EXPECT_EQ(test_case.expected_match_in_subdomain, match_in_subdomain);
  }
}

TEST_F(AutocompleteMatchTest, FormatUrlForSuggestionDisplay) {
  // This test does not need to verify url_formatter's functionality in-depth,
  // since url_formatter has its own unit tests. This test is to validate that
  // flipping feature flags and varying the trim_scheme parameter toggles the
  // correct behavior within AutocompleteMatch::GetFormatTypes.
  struct FormatUrlTestData {
    const std::string url;
    bool preserve_scheme;
    bool preserve_subdomain;
    const wchar_t* expected_result;

    void Validate() {
      SCOPED_TRACE(testing::Message()
                   << " url=" << url << " preserve_scheme=" << preserve_scheme
                   << " preserve_subdomain=" << preserve_subdomain
                   << " expected_result=" << expected_result);
      auto format_types = AutocompleteMatch::GetFormatTypes(preserve_scheme,
                                                            preserve_subdomain);
      EXPECT_EQ(base::WideToUTF16(expected_result),
                url_formatter::FormatUrl(GURL(url), format_types,
                                         base::UnescapeRule::SPACES, nullptr,
                                         nullptr, nullptr));
    }
  };

  FormatUrlTestData normal_cases[] = {
      // Test the |preserve_scheme| parameter.
      {"http://google.com", false, false, L"google.com"},
      {"https://google.com", false, false, L"google.com"},
      {"http://google.com", true, false, L"http://google.com"},
      {"https://google.com", true, false, L"https://google.com"},

      // Test the |preserve_subdomain| parameter.
      {"http://www.google.com", false, false, L"google.com"},
      {"http://www.google.com", false, true, L"www.google.com"},

      // Test that paths are preserved in the default case.
      {"http://google.com/foobar", false, false, L"google.com/foobar"},
  };
  for (FormatUrlTestData& test_case : normal_cases)
    test_case.Validate();
}

TEST_F(AutocompleteMatchTest, SupportsDeletion) {
  // A non-deletable match with no duplicates.
  AutocompleteMatch m(nullptr, 0, false,
                      AutocompleteMatchType::URL_WHAT_YOU_TYPED);
  EXPECT_FALSE(m.SupportsDeletion());

  // A deletable match with no duplicates.
  AutocompleteMatch m1(nullptr, 0, true,
                       AutocompleteMatchType::URL_WHAT_YOU_TYPED);
  EXPECT_TRUE(m1.SupportsDeletion());

  // A non-deletable match, with non-deletable duplicates.
  m.duplicate_matches.push_back(AutocompleteMatch(
      nullptr, 0, false, AutocompleteMatchType::URL_WHAT_YOU_TYPED));
  m.duplicate_matches.push_back(AutocompleteMatch(
      nullptr, 0, false, AutocompleteMatchType::URL_WHAT_YOU_TYPED));
  EXPECT_FALSE(m.SupportsDeletion());

  // A non-deletable match, with at least one deletable duplicate.
  m.duplicate_matches.push_back(AutocompleteMatch(
      nullptr, 0, true, AutocompleteMatchType::URL_WHAT_YOU_TYPED));
  EXPECT_TRUE(m.SupportsDeletion());
}

TEST_F(AutocompleteMatchTest, GURLToStrippedGURL) {
  struct {
    const char* url1;
    const char* url2;
    const char* input;
    bool equal;
  } test_cases[] = {
      // Sanity check cases.
      {"http://google.com", "http://google.com", "", true},
      {"http://google.com", "http://www.google.com", "", true},
      {"http://google.com", "http://facebook.com", "", false},
      {"http://google.com", "https://google.com", "", true},
      // Because we provided scheme, must match in scheme.
      {"http://google.com", "https://google.com", "http://google.com", false},
      {"https://www.apple.com/", "http://www.apple.com/",
       "https://www.apple.com/", false},
      {"https://www.apple.com/", "https://www.apple.com/",
       "https://www.apple.com/", true},
      // Ignore ref if not in input.
      {"http://drive.google.com/doc/blablabla#page=10",
       "http://drive.google.com/doc/blablabla#page=111", "", true},
      {"http://drive.google.com/doc/blablabla#page=10",
       "http://drive.google.com/doc/blablabla#page=111",
       "http://drive.google.com/doc/blablabla", true},
      {"file:///usr/local/bin/tuxpenguin#ref1",
       "file:///usr/local/bin/tuxpenguin#ref2", "", true},
      {"file:///usr/local/bin/tuxpenguin#ref1",
       "file:///usr/local/bin/tuxpenguin#ref2",
       "file:///usr/local/bin/tuxpenguin", true},
      // Do not ignore ref if in input.
      {"http://drive.google.com/doc/blablabla#page=10",
       "http://drive.google.com/doc/blablabla#page=111",
       "http://drive.google.com/doc/blablabla#p", false},
      {"file:///usr/local/bin/tuxpenguin#ref1",
       "file:///usr/local/bin/tuxpenguin#ref2",
       "file:///usr/local/bin/tuxpenguin#r", false}};

  for (const auto& test_case : test_cases) {
    SCOPED_TRACE(std::string(test_case.url1) + " vs " + test_case.url2 +
                 ", input '" + test_case.input + "'");
    AutocompleteInput input(base::ASCIIToUTF16(test_case.input),
                            test_case.input[0]
                                ? metrics::OmniboxEventProto::OTHER
                                : metrics::OmniboxEventProto::BLANK,
                            TestSchemeClassifier());
    const auto stripped_url1 = AutocompleteMatch::GURLToStrippedGURL(
        /*url=*/GURL(test_case.url1),
        /*input=*/input,
        /*template_url=*/nullptr,
        /*search_terms=*/std::u16string(),
        /*keep_search_intent_params=*/false);
    const auto stripped_url2 = AutocompleteMatch::GURLToStrippedGURL(
        /*url=*/GURL(test_case.url2),
        /*input=*/input,
        /*template_url=*/nullptr,
        /*search_terms=*/std::u16string(),
        /*keep_search_intent_params=*/false);
    EXPECT_EQ(test_case.equal, stripped_url1 == stripped_url2);
  }
}

// Structure containing URL pairs for deduping-related tests.
struct DuplicateCase {
  const wchar_t* input;
  const std::string url1;
  const std::string url2;
  const bool expected_duplicate;
};

// Runs deduping logic against URLs in |duplicate_case| and makes sure they are
// unique or matched as duplicates as expected.
void CheckDuplicateCase(const DuplicateCase& duplicate_case) {
  SCOPED_TRACE("input=" + base::WideToUTF8(duplicate_case.input) +
               " url1=" + duplicate_case.url1 + " url2=" + duplicate_case.url2);
  AutocompleteInput input(base::WideToUTF16(duplicate_case.input),
                          metrics::OmniboxEventProto::OTHER,
                          TestSchemeClassifier());
  AutocompleteMatch m1(nullptr, 100, false,
                       AutocompleteMatchType::URL_WHAT_YOU_TYPED);
  m1.destination_url = GURL(duplicate_case.url1);
  m1.ComputeStrippedDestinationURL(input, nullptr);
  AutocompleteMatch m2(nullptr, 100, false,
                       AutocompleteMatchType::URL_WHAT_YOU_TYPED);
  m2.destination_url = GURL(duplicate_case.url2);
  m2.ComputeStrippedDestinationURL(input, nullptr);
  EXPECT_EQ(duplicate_case.expected_duplicate,
            m1.stripped_destination_url == m2.stripped_destination_url);
  EXPECT_TRUE(m1.stripped_destination_url.is_valid());
  EXPECT_TRUE(m2.stripped_destination_url.is_valid());
}

TEST_F(AutocompleteMatchTest, Duplicates) {
  DuplicateCase cases[] = {
      {L"g", "http://www.google.com/", "https://www.google.com/", true},
      {L"g", "http://www.google.com/", "http://www.google.com", true},
      {L"g", "http://google.com/", "http://www.google.com/", true},
      {L"g", "http://www.google.com/", "HTTP://www.GOOGLE.com/", true},
      {L"g", "http://www.google.com/", "http://www.google.com", true},
      {L"g", "https://www.google.com/", "http://google.com", true},
      {L"g", "http://www.google.com/", "wss://www.google.com/", false},
      {L"g", "http://www.google.com/1", "http://www.google.com/1/", false},
      {L"g", "http://www.google.com/", "http://www.google.com/1", false},
      {L"g", "http://www.google.com/", "http://www.goo.com/", false},
      {L"g", "http://www.google.com/", "http://w2.google.com/", false},
      {L"g", "http://www.google.com/", "http://m.google.com/", false},
      {L"g", "http://www.google.com/", "http://www.google.com/?foo", false},

      // Don't allow URLs with different schemes to be considered duplicates for
      // certain inputs.
      {L"http://g", "http://google.com/", "https://google.com/", false},
      {L"http://g", "http://blah.com/", "https://blah.com/", true},
      {L"http://g", "http://google.com/1", "https://google.com/1", false},
      {L"http://g hello", "http://google.com/", "https://google.com/", false},
      {L"hello http://g", "http://google.com/", "https://google.com/", false},
      {L"hello http://g", "http://blah.com/", "https://blah.com/", true},
      {L"http://b http://g", "http://google.com/", "https://google.com/",
       false},
      {L"http://b http://g", "http://blah.com/", "https://blah.com/", false},

      // If the user types unicode that matches the beginning of a
      // punycode-encoded hostname then consider that a match.
      {L"x", "http://xn--1lq90ic7f1rc.cn/", "https://xn--1lq90ic7f1rc.cn/",
       true},
      {L"http://\x5317 x", "http://xn--1lq90ic7f1rc.cn/",
       "https://xn--1lq90ic7f1rc.cn/", false},
      {L"http://\x89c6 x", "http://xn--1lq90ic7f1rc.cn/",
       "https://xn--1lq90ic7f1rc.cn/", true},

      // URLs with hosts containing only `www.` should produce valid stripped
      // urls
      {L"http://www./", "http://www./", "http://google.com/", false},
  };

  for (const auto& caseI : cases)
    CheckDuplicateCase(caseI);
}

TEST_F(AutocompleteMatchTest, DedupeDriveURLs) {
  DuplicateCase cases[] = {
      // Document URLs pointing to the same document, perhaps with different
      // /edit points, hashes, or cgiargs, are deduped.
      {L"docs", "https://docs.google.com/spreadsheets/d/the_doc-id/preview?x=1",
       "https://docs.google.com/spreadsheets/d/the_doc-id/edit?x=2#y=3", true},
      {L"report", "https://drive.google.com/open?id=the-doc-id",
       "https://docs.google.com/spreadsheets/d/the-doc-id/edit?x=2#y=3", true},
      // Similar but different URLs should not be deduped.
      {L"docs", "https://docs.google.com/spreadsheets/d/the_doc-id/preview",
       "https://docs.google.com/spreadsheets/d/another_doc-id/preview", false},
      {L"report", "https://drive.google.com/open?id=the-doc-id",
       "https://drive.google.com/open?id=another-doc-id", false},
  };

  for (const auto& caseI : cases)
    CheckDuplicateCase(caseI);
}

TEST_F(AutocompleteMatchTest, UpgradeMatchWithPropertiesFrom) {
  scoped_refptr<FakeAutocompleteProvider> bookmark_provider =
      new FakeAutocompleteProvider(AutocompleteProvider::Type::TYPE_BOOKMARK);
  scoped_refptr<FakeAutocompleteProvider> history_provider =
      new FakeAutocompleteProvider(
          AutocompleteProvider::Type::TYPE_HISTORY_QUICK);
  scoped_refptr<FakeAutocompleteProvider> search_provider =
      new FakeAutocompleteProvider(AutocompleteProvider::Type::TYPE_SEARCH);

  AutocompleteMatch search_history_match(search_provider.get(), 500, true,
                                         AutocompleteMatchType::SEARCH_HISTORY);

  // Entity match should get the increased score, but not change types.
  AutocompleteMatch entity_match(search_provider.get(), 400, false,
                                 AutocompleteMatchType::SEARCH_SUGGEST_ENTITY);
  entity_match.UpgradeMatchWithPropertiesFrom(search_history_match);
  EXPECT_EQ(entity_match.relevance, 500);
  EXPECT_EQ(entity_match.type, AutocompleteMatchType::SEARCH_SUGGEST_ENTITY);

  // Suggest and search-what-typed matches should get the search history type.
  AutocompleteMatch suggest_match(search_provider.get(), 400, true,
                                  AutocompleteMatchType::SEARCH_SUGGEST);
  AutocompleteMatch search_what_you_typed(
      search_provider.get(), 400, true,
      AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED);
  suggest_match.UpgradeMatchWithPropertiesFrom(search_history_match);
  search_what_you_typed.UpgradeMatchWithPropertiesFrom(search_history_match);
  EXPECT_EQ(suggest_match.relevance, 500);
  EXPECT_EQ(search_what_you_typed.relevance, 500);
  EXPECT_EQ(suggest_match.type, AutocompleteMatchType::SEARCH_HISTORY);
  EXPECT_EQ(search_what_you_typed.type, AutocompleteMatchType::SEARCH_HISTORY);

  // Some providers should bestow their suggestion texts even if not the primary
  // duplicate.
  AutocompleteMatch history_match(history_provider.get(), 800, true,
                                  AutocompleteMatchType::HISTORY_TITLE);
  AutocompleteMatch bookmark_match(bookmark_provider.get(), 400, true,
                                   AutocompleteMatchType::BOOKMARK_TITLE);
  history_match.contents = u"overwrite";
  history_match.inline_autocompletion = u"preserve";
  bookmark_match.contents = u"propagate";
  bookmark_match.inline_autocompletion = u"discard";
  history_match.UpgradeMatchWithPropertiesFrom(bookmark_match);
  EXPECT_EQ(history_match.type, AutocompleteMatchType::HISTORY_TITLE);
  EXPECT_EQ(history_match.contents, u"propagate");
  EXPECT_EQ(history_match.inline_autocompletion, u"preserve");

  omnibox::RichAnswerTemplate answer_template;
  omnibox::SuggestionEnhancement* enhancement =
      answer_template.mutable_enhancements()->add_enhancements();
  enhancement->set_display_text("Similar and opposite words");
  AutocompleteMatch match_with_answer_actions(
      search_provider.get(), 400, true, AutocompleteMatchType::SEARCH_SUGGEST);
  match_with_answer_actions.actions.push_back(
      base::MakeRefCounted<OmniboxAnswerAction>(
          std::move(*enhancement), TemplateURLRef::SearchTermsArgs(),
          omnibox::ANSWER_TYPE_DICTIONARY));
  AutocompleteMatch match_with_no_answer_actions(
      search_provider.get(), 400, true,
      AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED);
  match_with_no_answer_actions.UpgradeMatchWithPropertiesFrom(
      match_with_answer_actions);
  EXPECT_EQ(0u, match_with_no_answer_actions.actions.size());
}

TEST_F(AutocompleteMatchTest, MergeScoringSignals) {
  AutocompleteMatch match = CreateACMatchWithScoringSignals(
      /*typed_count*/ 3, /*visit_count*/ 10,
      /*elapsed_time_last_visit_secs*/ 100, /*shortcut_visit_count*/ 5,
      /*shortest_shortcut_len*/ 3, /*is_host_only*/ true,
      /*num_bookmarks_of_url*/ 5, /*first_bookmark_title_match_position*/ 1,
      /*total_bookmark_title_match_length*/ 8,
      /*num_input_terms_matched_by_bookmark_title*/ 2,
      /*first_url_match_position*/ 2, /*total_url_match_length*/ 5,
      /*host_match_at_word_boundary*/ true, /*total_path_match_length*/ 0,
      /*total_query_or_ref_match_length*/ 0,
      /*total_title_match_length*/ 5, /*has_non_scheme_www_match*/ true,
      /*num_input_terms_matched_by_title*/ 2,
      /*num_input_terms_matched_by_url*/ 2, /*length_of_url*/ 10,
      /*site_engagement*/ 0.6, /*allowed_to_be_default_match*/ true);

  AutocompleteMatch other_match = CreateACMatchWithScoringSignals(
      /*typed_count*/ 1, /*visit_count*/ 2, /*elapsed_time_last_visit_secs*/ 50,
      /*shortcut_visit_count*/ 1,
      /*shortest_shortcut_len*/ 2, /*is_host_only*/ false,
      /*num_bookmarks_of_url*/ 1, /*first_bookmark_title_match_position*/ 2,
      /*total_bookmark_title_match_length*/ 6,
      /*num_input_terms_matched_by_bookmark_title*/ 3,
      /*first_url_match_position*/ 5, /*total_url_match_length*/ 3,
      /*host_match_at_word_boundary*/ false, /*total_path_match_length*/ 1,
      /*total_query_or_ref_match_length*/ 2,
      /*total_title_match_length*/ 3, /*has_non_scheme_www_match*/ false,
      /*num_input_terms_matched_by_title*/ 0,
      /*num_input_terms_matched_by_url*/ 1, /*length_of_url*/ 12,
      /*site_engagement*/ 0.5, /*allowed_to_be_default_match*/ false);

  match.MergeScoringSignals(other_match);

  EXPECT_EQ(match.scoring_signals->typed_count(), 3);
  EXPECT_EQ(match.scoring_signals->visit_count(), 10);
  EXPECT_EQ(match.scoring_signals->elapsed_time_last_visit_secs(), 50);
  EXPECT_EQ(match.scoring_signals->shortcut_visit_count(), 5);
  EXPECT_EQ(match.scoring_signals->shortest_shortcut_len(), 2);
  EXPECT_TRUE(match.scoring_signals->is_host_only());
  EXPECT_EQ(match.scoring_signals->num_bookmarks_of_url(), 5);
  EXPECT_EQ(match.scoring_signals->first_bookmark_title_match_position(), 1);
  EXPECT_EQ(match.scoring_signals->total_bookmark_title_match_length(), 8);
  EXPECT_EQ(match.scoring_signals->num_input_terms_matched_by_bookmark_title(),
            3);
  EXPECT_EQ(match.scoring_signals->first_url_match_position(), 2);
  EXPECT_EQ(match.scoring_signals->total_url_match_length(), 5);
  EXPECT_TRUE(match.scoring_signals->host_match_at_word_boundary());
  EXPECT_EQ(match.scoring_signals->total_path_match_length(), 1);
  EXPECT_EQ(match.scoring_signals->total_query_or_ref_match_length(), 2);
  EXPECT_EQ(match.scoring_signals->total_title_match_length(), 5);
  EXPECT_TRUE(match.scoring_signals->has_non_scheme_www_match());
  EXPECT_EQ(match.scoring_signals->num_input_terms_matched_by_title(), 2);
  EXPECT_EQ(match.scoring_signals->num_input_terms_matched_by_url(), 2);
  EXPECT_EQ(match.scoring_signals->length_of_url(), 10);
  EXPECT_EQ(match.scoring_signals->site_engagement(), 0.6f);
  EXPECT_TRUE(match.scoring_signals->allowed_to_be_default_match());
}

TEST_F(AutocompleteMatchTest, SetAllowedToBeDefault) {
  // Test all combinations of:
  // 1) input text in ["goo", "goo ", "goo  "]
  // 2) input prevent_inline_autocomplete in [false, true]
  // 3) match inline_autocompletion in ["", "gle.com", " gle.com", "  gle.com"]
  TestSetAllowedToBeDefault(1, "goo", false, "", "", true);
  TestSetAllowedToBeDefault(2, "goo", false, "gle.com", "gle.com", true);
  TestSetAllowedToBeDefault(3, "goo", false, " gle.com", " gle.com", true);
  TestSetAllowedToBeDefault(4, "goo", false, "  gle.com", "  gle.com", true);
  TestSetAllowedToBeDefault(5, "goo ", false, "", "", true);
  TestSetAllowedToBeDefault(6, "goo ", false, "gle.com", "gle.com", false);
  TestSetAllowedToBeDefault(7, "goo ", false, " gle.com", "gle.com", true);
  TestSetAllowedToBeDefault(8, "goo ", false, "  gle.com", " gle.com", true);
  TestSetAllowedToBeDefault(9, "goo  ", false, "", "", true);
  TestSetAllowedToBeDefault(10, "goo  ", false, "gle.com", "gle.com", false);
  TestSetAllowedToBeDefault(11, "goo  ", false, " gle.com", " gle.com", false);
  TestSetAllowedToBeDefault(12, "goo  ", false, "  gle.com", "gle.com", true);
  TestSetAllowedToBeDefault(13, "goo", true, "", "", true);
  TestSetAllowedToBeDefault(14, "goo", true, "gle.com", "gle.com", false);
  TestSetAllowedToBeDefault(15, "goo", true, " gle.com", " gle.com", false);
  TestSetAllowedToBeDefault(16, "goo", true, "  gle.com", "  gle.com", false);
  TestSetAllowedToBeDefault(17, "goo ", true, "", "", true);
  TestSetAllowedToBeDefault(18, "goo ", true, "gle.com", "gle.com", false);
  TestSetAllowedToBeDefault(19, "goo ", true, " gle.com", " gle.com", false);
  TestSetAllowedToBeDefault(20, "goo ", true, "  gle.com", "  gle.com", false);
  TestSetAllowedToBeDefault(21, "goo  ", true, "", "", true);
  TestSetAllowedToBeDefault(22, "goo  ", true, "gle.com", "gle.com", false);
  TestSetAllowedToBeDefault(23, "goo  ", true, " gle.com", " gle.com", false);
  TestSetAllowedToBeDefault(24, "goo  ", true, "  gle.com", "  gle.com", false);
}

TEST_F(AutocompleteMatchTest, TryRichAutocompletion) {
  auto test = [](const std::string input_text,
                 bool input_prevent_inline_autocomplete,
                 const std::string primary_text,
                 const std::string secondary_text,
                 const std::string shortcut_text, bool expected_return,
                 AutocompleteMatch::RichAutocompletionType
                     expected_rich_autocompletion_triggered,
                 const std::string expected_inline_autocompletion,
                 const std::string expected_additional_text,
                 bool expected_allowed_to_be_default_match) {
    AutocompleteInput input(base::UTF8ToUTF16(input_text),
                            metrics::OmniboxEventProto::OTHER,
                            TestSchemeClassifier());
    input.set_prevent_inline_autocomplete(input_prevent_inline_autocomplete);

    AutocompleteMatch match;
    EXPECT_EQ(
        match.TryRichAutocompletion(input, base::UTF8ToUTF16(primary_text),
                                    base::UTF8ToUTF16(secondary_text),
                                    base::UTF8ToUTF16(shortcut_text)),
        expected_return);

    EXPECT_EQ(match.rich_autocompletion_triggered,
              expected_rich_autocompletion_triggered);

    EXPECT_EQ(base::UTF16ToUTF8(match.inline_autocompletion).c_str(),
              expected_inline_autocompletion);
    EXPECT_EQ(base::UTF16ToUTF8(match.additional_text).c_str(),
              expected_additional_text);
    EXPECT_EQ(match.allowed_to_be_default_match,
              expected_allowed_to_be_default_match);
  };

  {
    base::test::ScopedFeatureList feature_list;
    feature_list.InitAndEnableFeatureWithParameters(
        omnibox::kRichAutocompletion,
        {
            {"RichAutocompletionAutocompleteTitlesMinChar", "0"},
            {"RichAutocompletionAutocompleteShortcutTextMinChar", "0"},
        });
    RichAutocompletionParams::ClearParamsForTesting();

    // The combinations that are allowed to be autocompleted, in order of
    // preference:
    // - Non-shortcut, prefix,     primary   - autocomplete
    // - Non-shortcut, prefix,     secondary - no
    // - Non-shortcut, non-prefix, primary   - no
    // - Non-shortcut, non-prefix, secondary - no
    // - Shortcut,     prefix,     primary   - autocomplete
    // - Shortcut,     prefix,     secondary - autocomplete
    // - Shortcut,     prefix,     shortcut  - autocomplete
    // - Shortcut,     non-prefix, primary   - no
    // - Shortcut,     non-prefix, secondary - no

    {
      SCOPED_TRACE("non-shortcut, prefix, primary text");
      // This case shouldn't set `rich_autocompletion_triggered`.
      test("x", false, "x_mixd_x_primary", "x_mixd_x_secondary", "", true,
           AutocompleteMatch::RichAutocompletionType::kNone, "_mixd_x_primary",
           "", true);
    }

    {
      SCOPED_TRACE("non-shortcut, all other cases text");
      test("x", false, "y_mixd_x_primary", "x_mixd_x_secondary", "", false,
           AutocompleteMatch::RichAutocompletionType::kNone, "", "", false);
    }

    {
      SCOPED_TRACE("shortcut, prefix, primary text");
      test("x", false, "x_mixd_x_primary", "x_mixd_x_secondary",
           "x_mixd_x_shortcut", true,
           AutocompleteMatch::RichAutocompletionType::kNone, "_mixd_x_primary",
           "", true);
    }

    {
      SCOPED_TRACE("shortcut, prefix, secondary text");
      test("x", false, "y_mixd_x_primary", "x_mixd_x_secondary",
           "x_mixd_x_shortcut", true,
           AutocompleteMatch::RichAutocompletionType::kTitlePrefix,
           "_mixd_x_secondary", "y_mixd_x_primary", true);
    }

    {
      SCOPED_TRACE("shortcut, prefix, shortcut text");
      test("x", false, "y_mixd_x_primary", "y_mixd_x_secondary",
           "x_mixd_x_shortcut", true,
           AutocompleteMatch::RichAutocompletionType::kShortcutTextPrefix,
           "_mixd_x_shortcut", "y_mixd_x_primary", true);
    }

    {
      SCOPED_TRACE("shortcut, all other cases");
      test("x", false, "y_mixd_x_primary", "y_mixd_x_secondary",
           "y_mixd_x_shortcut", false,
           AutocompleteMatch::RichAutocompletionType::kNone, "", "", false);
    }

    {
      SCOPED_TRACE("Autocomplete input with spaces");
      test("x x", false, "primary", "x x secondary", "x x shortcut", true,
           AutocompleteMatch::RichAutocompletionType::kTitlePrefix,
           " secondary", "primary", true);
    }
  }

  {
    base::test::ScopedFeatureList feature_list;
    feature_list.InitAndEnableFeatureWithParameters(
        omnibox::kRichAutocompletion,
        {
            {"RichAutocompletionAutocompleteTitlesMinChar", "3"},
            {"RichAutocompletionAutocompleteShortcutTextMinChar", "3"},
        });
    RichAutocompletionParams::ClearParamsForTesting();

    {
      SCOPED_TRACE("Do autocomplete title if input is greater than limits");
      test("x_mixd", false, "y_mixd_x_primary", "x_mixd_x_secondary",
           "x_mixd_x_shortcut", true,
           AutocompleteMatch::RichAutocompletionType::kTitlePrefix,
           "_x_secondary", "y_mixd_x_primary", true);
    }

    {
      SCOPED_TRACE("Do autocomplete shortcut if input is greater than limits");
      test("x_mixd", false, "y_mixd_x_primary", "y_mixd_x_secondary",
           "x_mixd_x_shortcut", true,
           AutocompleteMatch::RichAutocompletionType::kShortcutTextPrefix,
           "_x_shortcut", "y_mixd_x_primary", true);
    }

    {
      SCOPED_TRACE(
          "Don't autocomplete title or shortcut if input is shorter than "
          "limits");
      test("x", false, "y_mixd_x_primary", "y_mixd_x_secondary",
           "x_mixd_x_shortcut", false,
           AutocompleteMatch::RichAutocompletionType::kNone, "", "", false);
    }
  }
}

TEST_F(AutocompleteMatchTest, BetterDuplicate) {
  const auto create_match = [](scoped_refptr<FakeAutocompleteProvider> provider,
                               int relevance,
                               AutocompleteMatchType::Type match_type =
                                   AutocompleteMatchType::URL_WHAT_YOU_TYPED) {
    return AutocompleteMatch{provider.get(), relevance, false, match_type};
  };

  scoped_refptr<FakeAutocompleteProvider> document_provider =
      new FakeAutocompleteProvider(AutocompleteProvider::Type::TYPE_DOCUMENT);

  scoped_refptr<FakeAutocompleteProvider> bookmark_provider =
      new FakeAutocompleteProvider(AutocompleteProvider::Type::TYPE_BOOKMARK);

  scoped_refptr<FakeAutocompleteProvider> history_provider =
      new FakeAutocompleteProvider(
          AutocompleteProvider::Type::TYPE_HISTORY_QUICK);

  scoped_refptr<FakeAutocompleteProvider> shortcuts_provider =
      new FakeAutocompleteProvider(AutocompleteProvider::Type::TYPE_SHORTCUTS);

  scoped_refptr<FakeAutocompleteProvider> featured_search_provider =
      new FakeAutocompleteProvider(
          AutocompleteProvider::Type::TYPE_FEATURED_SEARCH);

  // Prefer document provider matches over other providers, even if scored
  // lower.
  EXPECT_TRUE(
      AutocompleteMatch::BetterDuplicate(create_match(document_provider, 0),
                                         create_match(history_provider, 1000)));

  // Prefer bookmark provider matches over other providers, even if scored
  // lower.
  EXPECT_TRUE(
      AutocompleteMatch::BetterDuplicate(create_match(bookmark_provider, 0),
                                         create_match(history_provider, 1000)));

  // Prefer document provider matches over bookmark provider matches.
  EXPECT_TRUE(AutocompleteMatch::BetterDuplicate(
      create_match(document_provider, 0),
      create_match(bookmark_provider, 1000)));

#if !BUILDFLAG(IS_ANDROID) && !BUILDFLAG(IS_IOS)
  // Prefer non-shortcuts provider matches over shortcuts provider matches.
  EXPECT_TRUE(AutocompleteMatch::BetterDuplicate(
      create_match(history_provider, 0),
      create_match(shortcuts_provider, 1000)));

  // Prefer featured enterprise search over other matches.
  EXPECT_TRUE(AutocompleteMatch::BetterDuplicate(
      create_match(featured_search_provider, 100,
                   AutocompleteMatchType::FEATURED_ENTERPRISE_SEARCH),
      create_match(featured_search_provider, 500,
                   AutocompleteMatchType::STARTER_PACK)));

  EXPECT_FALSE(AutocompleteMatch::BetterDuplicate(
      create_match(featured_search_provider, 500,
                   AutocompleteMatchType::STARTER_PACK),
      create_match(featured_search_provider, 100,
                   AutocompleteMatchType::FEATURED_ENTERPRISE_SEARCH)));

  EXPECT_TRUE(AutocompleteMatch::BetterDuplicate(
      create_match(featured_search_provider, 100,
                   AutocompleteMatchType::FEATURED_ENTERPRISE_SEARCH),
      create_match(bookmark_provider, 500)));

  EXPECT_FALSE(AutocompleteMatch::BetterDuplicate(
      create_match(bookmark_provider, 500),
      create_match(featured_search_provider, 100,
                   AutocompleteMatchType::FEATURED_ENTERPRISE_SEARCH)));

  // Prefer stater pack matches over other matches.
  EXPECT_TRUE(AutocompleteMatch::BetterDuplicate(
      create_match(featured_search_provider, 100,
                   AutocompleteMatchType::STARTER_PACK),
      create_match(bookmark_provider, 500)));

  EXPECT_FALSE(AutocompleteMatch::BetterDuplicate(
      create_match(bookmark_provider, 500),
      create_match(featured_search_provider, 100,
                   AutocompleteMatchType::STARTER_PACK)));
#endif  // !BUILDFLAG(IS_ANDROID) && !BUILDFLAG(IS_IOS)

  // Prefer more relevant matches.
  EXPECT_FALSE(
      AutocompleteMatch::BetterDuplicate(create_match(history_provider, 500),
                                         create_match(history_provider, 510)));
}

TEST_F(AutocompleteMatchTest, FilterOmniboxActions) {
  scoped_refptr<FakeAutocompleteProvider> provider =
      new FakeAutocompleteProvider(AutocompleteProvider::Type::TYPE_SEARCH);
  const OmniboxAction::LabelStrings dummy_labels(u"", u"", u"", u"");

  using OmniboxActionId::ACTION_IN_SUGGEST;
  using OmniboxActionId::HISTORY_CLUSTERS;
  using OmniboxActionId::PEDAL;

  struct FilterOmniboxActionsTestData {
    std::string test_name;
    // This is what will get added to the AutocompleteMatch.
    std::vector<OmniboxActionId> actions_attached_to_match;
    // This is the filter. Order of elements specifies the preference.
    std::vector<OmniboxActionId> allowed_actions;
    // This is the expected result.
    std::vector<OmniboxActionId> resulting_actions;
  } test_cases[]{
      {"have nothing, want nothing", {}, {}, {}},
      {"have nothing, want Pedals", {}, {PEDAL}, {}},
      {"have Pedals, want nothing", {PEDAL}, {}, {}},
      {"have Pedals, want Pedals", {PEDAL}, {PEDAL}, {PEDAL}},
      {"have Pedals, want History Clusters", {PEDAL}, {HISTORY_CLUSTERS}, {}},
      {"have Pedals, want History Clusters, then Pedals",
       {PEDAL},
       {HISTORY_CLUSTERS, PEDAL},
       {PEDAL}},
      {"have Pedals and History Clusters, want History Clusters, then Pedals",
       {PEDAL, HISTORY_CLUSTERS},
       {HISTORY_CLUSTERS, PEDAL},
       {HISTORY_CLUSTERS}},
      {"have Pedals and History Clusters, want Pedals, then History Clusters",
       {PEDAL, HISTORY_CLUSTERS},
       {PEDAL, HISTORY_CLUSTERS},
       {PEDAL}},
      {"have Pedals and History Clusters, want Actions in Suggest",
       {PEDAL, HISTORY_CLUSTERS},
       {ACTION_IN_SUGGEST},
       {}},
      {"have Pedals and History Clusters, want Actions in Suggest, then Pedals",
       {PEDAL, HISTORY_CLUSTERS},
       {ACTION_IN_SUGGEST, PEDAL},
       {PEDAL}},
      {"have Pedals, Actions and History Clusters, want Pedals",
       {ACTION_IN_SUGGEST, PEDAL, HISTORY_CLUSTERS},
       {PEDAL},
       {PEDAL}},
      {"have multiple, want Actions, then History Clusters, then Pedals",
       // Mix: 4 pedals, 3 history clusters, 2 actions.
       {PEDAL, ACTION_IN_SUGGEST, HISTORY_CLUSTERS, PEDAL, ACTION_IN_SUGGEST,
        HISTORY_CLUSTERS, PEDAL, HISTORY_CLUSTERS, PEDAL},
       {ACTION_IN_SUGGEST, HISTORY_CLUSTERS, PEDAL},
       {ACTION_IN_SUGGEST, ACTION_IN_SUGGEST}},
      {"have multiple, want History Clusters, then Actions, then Pedals",
       // Mix: 4 pedals, 3 history clusters, 2 actions.
       {PEDAL, ACTION_IN_SUGGEST, HISTORY_CLUSTERS, PEDAL, ACTION_IN_SUGGEST,
        HISTORY_CLUSTERS, PEDAL, HISTORY_CLUSTERS, PEDAL},
       {HISTORY_CLUSTERS, ACTION_IN_SUGGEST, PEDAL},
       {HISTORY_CLUSTERS, HISTORY_CLUSTERS, HISTORY_CLUSTERS}},
      {"have multiple, want Pedals, then History Clusters, then Actions",
       // Mix: 4 pedals, 3 history clusters, 2 actions.
       {PEDAL, ACTION_IN_SUGGEST, HISTORY_CLUSTERS, PEDAL, ACTION_IN_SUGGEST,
        HISTORY_CLUSTERS, PEDAL, HISTORY_CLUSTERS, PEDAL},
       {PEDAL, HISTORY_CLUSTERS, ACTION_IN_SUGGEST},
       {PEDAL, PEDAL, PEDAL, PEDAL}},
      {"have multiple, want nothing",
       // Mix: 4 pedals, 3 history clusters, 2 actions.
       {PEDAL, ACTION_IN_SUGGEST, HISTORY_CLUSTERS, PEDAL, ACTION_IN_SUGGEST,
        HISTORY_CLUSTERS, PEDAL, HISTORY_CLUSTERS, PEDAL},
       {},
       {}}};

  for (const auto& test_case : test_cases) {
    AutocompleteMatch match(provider.get(), 1, false,
                            AutocompleteMatchType::SEARCH_SUGGEST_ENTITY);

    // Populate match with requested actions.
    for (auto& action_id : test_case.actions_attached_to_match) {
      match.actions.push_back(
          base::MakeRefCounted<FakeOmniboxAction>(action_id));
    }

    match.FilterOmniboxActions(test_case.allowed_actions);
    EXPECT_EQ(match.actions.size(), test_case.resulting_actions.size())
        << "while testing variant: " << test_case.test_name;

    for (size_t index = 0u; index < match.actions.size(); ++index) {
      EXPECT_EQ(match.actions[index]->ActionId(),
                test_case.resulting_actions[index])
          << "while testing variant: " << test_case.test_name;
    }
  }
}

TEST_F(AutocompleteMatchTest, RearrangeActionsInSuggest) {
  scoped_refptr<FakeAutocompleteProvider> provider =
      new FakeAutocompleteProvider(AutocompleteProvider::Type::TYPE_SEARCH);
  const OmniboxAction::LabelStrings dummy_labels(u"", u"", u"", u"");

  using ActionType = omnibox::ActionInfo::ActionType;
  constexpr auto CALL = omnibox::ActionInfo_ActionType_CALL;
  constexpr auto NAV = omnibox::ActionInfo_ActionType_DIRECTIONS;
  constexpr auto REVS = omnibox::ActionInfo_ActionType_REVIEWS;

  struct FilterOmniboxActionsTestData {
    std::string test_name;
    // This is what will get added to the AutocompleteMatch.
    std::vector<ActionType> types_to_add;
    // This is the expected result (and order).
    std::vector<ActionType> types_to_expect;
  } test_cases[]{
      // clang-format off
      // Retain all
      {"retain all - no actions, promote calls", {}, {}},
      {"retain all - have no reviews, promote reviews",
       {CALL, CALL, CALL}, {CALL, CALL, CALL}},
      {"retain all - have reviews",
       {CALL, CALL, REVS}, {CALL, CALL, REVS}},
      {"retain all - have all types",
       {CALL, NAV, REVS}, {CALL, NAV, REVS}},
      {"retain all - have all types, sort",
       {REVS, CALL, NAV}, {CALL, NAV, REVS}},
      {"retain all - have multiple reviews, sort",
       {REVS, NAV, REVS}, {NAV, REVS, REVS}},

      // clang-format on
  };

  for (const auto& test_case : test_cases) {
    AutocompleteMatch match(provider.get(), 1, false,
                            AutocompleteMatchType::SEARCH_SUGGEST_ENTITY);

    // Populate match with requested actions.
    for (auto& action_type : test_case.types_to_add) {
      omnibox::ActionInfo info;
      info.set_action_type(action_type);
      match.actions.push_back(base::MakeRefCounted<OmniboxActionInSuggest>(
          std::move(info), std::nullopt));
    }

    match.FilterAndSortActionsInSuggest();

    EXPECT_EQ(match.actions.size(), test_case.types_to_expect.size())
        << "while testing variant: " << test_case.test_name;

    for (size_t index = 0u; index < match.actions.size(); ++index) {
      const auto* action =
          OmniboxActionInSuggest::FromAction(match.actions[index].get());
      EXPECT_NE(nullptr, action)
          << "while testing variant: " << test_case.test_name;

      EXPECT_EQ(action->Type(), test_case.types_to_expect[index])
          << "at position " << index
          << " while testing variant: " << test_case.test_name;
    }
  }
}

#if (!BUILDFLAG(IS_ANDROID) || BUILDFLAG(ENABLE_VR)) && !BUILDFLAG(IS_IOS)
TEST_F(AutocompleteMatchTest, ValidateGetVectorIcons) {
  AutocompleteMatch match;

  // Irrespective of match type, bookmark suggestions should have a non-empty
  // icon.
  EXPECT_FALSE(match.GetVectorIcon(/*is_bookmark=*/true).is_empty());

  for (int type = AutocompleteMatchType::URL_WHAT_YOU_TYPED;
       type != AutocompleteMatchType::NUM_TYPES; type++) {
    match.type = static_cast<AutocompleteMatchType::Type>(type);

    if (match.type == AutocompleteMatchType::STARTER_PACK) {
      // All STARTER_PACK suggestions should have non-empty vector icons.
      for (int starter_pack_id = template_url_starter_pack_data::kBookmarks;
           starter_pack_id != template_url_starter_pack_data::kMaxStarterPackId;
           starter_pack_id++) {
        TemplateURLData turl_data;
        turl_data.starter_pack_id = starter_pack_id;
        TemplateURL turl(turl_data);
        EXPECT_FALSE(
            match.GetVectorIcon(/*is_bookmark=*/false, &turl).is_empty());
      }
    } else if (match.type == AutocompleteMatchType::SEARCH_SUGGEST_TAIL ||
               match.type == AutocompleteMatchType::HISTORY_EMBEDDINGS_ANSWER ||
               (match.type == AutocompleteMatchType::NULL_RESULT_MESSAGE &&
                !match.IsIphSuggestion())) {
      // SEARCH_SUGGEST_TAIL and non-IPH NULL_RESULT_MESSAGE suggestions use an
      // empty vector icon.
      EXPECT_TRUE(match.GetVectorIcon(/*is_bookmark=*/false).is_empty());
    } else {
      // All other suggestion types should result in non-empty vector icons.
      EXPECT_FALSE(match.GetVectorIcon(/*is_bookmark=*/false).is_empty());
    }
  }

  // When the match has a SuggestTemplateInfo, its icon should be set.
  // This checks the full range to ensure any new additions get mapped.
  match.suggest_template = omnibox::SuggestTemplateInfo();
  for (int i = omnibox::SuggestTemplateInfo::IconType_MIN;
       i <= omnibox::SuggestTemplateInfo::IconType_MAX; i++) {
    match.suggest_template->set_type_icon(
        static_cast<omnibox::SuggestTemplateInfo::IconType>(i));
    EXPECT_FALSE(match.GetVectorIcon(false).is_empty());
  }
}
#endif

TEST_F(AutocompleteMatchTest, IsClipboardType) {
  std::set<int> clipboard_types{AutocompleteMatchType::CLIPBOARD_TEXT,
                                AutocompleteMatchType::CLIPBOARD_URL,
                                AutocompleteMatchType::CLIPBOARD_IMAGE};

  for (int type = 0; type < AutocompleteMatchType::NUM_TYPES; type++) {
    EXPECT_EQ(
        AutocompleteMatch::IsClipboardType((AutocompleteMatchType::Type)type),
        clipboard_types.contains(type));
  }
}