src/chrome/browser/history/scored_history_match_unittest.cc

   1 // Copyright (c) 2012 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 <algorithm>
   6
   7 #include "base/auto_reset.h"
   8 #include "base/strings/string16.h"
   9 #include "base/strings/utf_string_conversions.h"
  10 #include "chrome/browser/history/scored_history_match.h"
  11 #include "components/history/core/test/history_client_fake_bookmarks.h"
  12 #include "testing/gtest/include/gtest/gtest.h"
  13
  14 using base::ASCIIToUTF16;
  15
  16 namespace history {
  17
  18 // Returns a VisitInfoVector that includes |num_visits| spread over the
  19 // last |frequency|*|num_visits| days (relative to |now|).  A frequency of
  20 // one means one visit each day, two means every other day, etc.
  21 VisitInfoVector CreateVisitInfoVector(int num_visits,
  22                                       int frequency,
  23                                       base::Time now) {
  24   VisitInfoVector visits;
  25   for (int i = 0; i < num_visits; ++i) {
  26     visits.push_back(
  27         std::make_pair(now - base::TimeDelta::FromDays(i * frequency),
  28                        ui::PAGE_TRANSITION_LINK));
  29   }
  30   return visits;
  31 }
  32
  33 class ScoredHistoryMatchTest : public testing::Test {
  34  protected:
  35   // Convenience function to create a URLRow with basic data for |url|, |title|,
  36   // |visit_count|, and |typed_count|. |days_since_last_visit| gives the number
  37   // of days ago to which to set the URL's last_visit.
  38   URLRow MakeURLRow(const char* url,
  39                     const char* title,
  40                     int visit_count,
  41                     int days_since_last_visit,
  42                     int typed_count);
  43
  44   // Convenience function to set the word starts information from a URLRow's
  45   // URL and title.
  46   void PopulateWordStarts(const URLRow& url_row, RowWordStarts* word_starts);
  47
  48   // Convenience functions for easily creating vectors of search terms.
  49   String16Vector Make1Term(const char* term) const;
  50   String16Vector Make2Terms(const char* term_1, const char* term_2) const;
  51
  52   // Convenience function for GetTopicalityScore() that builds the
  53   // term match and word break information automatically that are needed
  54   // to call GetTopicalityScore().  It only works for scoring a single term,
  55   // not multiple terms.
  56   float GetTopicalityScoreOfTermAgainstURLAndTitle(const base::string16& term,
  57                                                    const base::string16& url,
  58                                                    const base::string16& title);
  59 };
  60
  61 URLRow ScoredHistoryMatchTest::MakeURLRow(const char* url,
  62                                           const char* title,
  63                                           int visit_count,
  64                                           int days_since_last_visit,
  65                                           int typed_count) {
  66   URLRow row(GURL(url), 0);
  67   row.set_title(ASCIIToUTF16(title));
  68   row.set_visit_count(visit_count);
  69   row.set_typed_count(typed_count);
  70   row.set_last_visit(base::Time::NowFromSystemTime() -
  71                      base::TimeDelta::FromDays(days_since_last_visit));
  72   return row;
  73 }
  74
  75 void ScoredHistoryMatchTest::PopulateWordStarts(
  76     const URLRow& url_row, RowWordStarts* word_starts) {
  77   String16SetFromString16(ASCIIToUTF16(url_row.url().spec()),
  78                           &word_starts->url_word_starts_);
  79   String16SetFromString16(url_row.title(), &word_starts->title_word_starts_);
  80 }
  81
  82
  83 String16Vector ScoredHistoryMatchTest::Make1Term(const char* term) const {
  84   String16Vector original_terms;
  85   original_terms.push_back(ASCIIToUTF16(term));
  86   return original_terms;
  87 }
  88
  89 String16Vector ScoredHistoryMatchTest::Make2Terms(const char* term_1,
  90                                                   const char* term_2) const {
  91   String16Vector original_terms;
  92   original_terms.push_back(ASCIIToUTF16(term_1));
  93   original_terms.push_back(ASCIIToUTF16(term_2));
  94   return original_terms;
  95 }
  96
  97 float ScoredHistoryMatchTest::GetTopicalityScoreOfTermAgainstURLAndTitle(
  98     const base::string16& term,
  99     const base::string16& url,
 100     const base::string16& title) {
 101   // Make an empty match and simply populate the fields we need in order
 102   // to call GetTopicalityScore().
 103   ScoredHistoryMatch scored_match;
 104   scored_match.url_matches_ = MatchTermInString(term, url, 0);
 105   scored_match.title_matches_ = MatchTermInString(term, title, 0);
 106   RowWordStarts word_starts;
 107   String16SetFromString16(url, &word_starts.url_word_starts_);
 108   String16SetFromString16(title, &word_starts.title_word_starts_);
 109   WordStarts one_word_no_offset(1, 0u);
 110   return scored_match.GetTopicalityScore(1, url, one_word_no_offset,
 111                                          word_starts);
 112 }
 113
 114 TEST_F(ScoredHistoryMatchTest, Scoring) {
 115   // We use NowFromSystemTime() because MakeURLRow uses the same function
 116   // to calculate last visit time when building a row.
 117   base::Time now = base::Time::NowFromSystemTime();
 118
 119   URLRow row_a(MakeURLRow("http://fedcba", "abcd bcd", 3, 30, 1));
 120   RowWordStarts word_starts_a;
 121   PopulateWordStarts(row_a, &word_starts_a);
 122   WordStarts one_word_no_offset(1, 0u);
 123   VisitInfoVector visits_a = CreateVisitInfoVector(3, 30, now);
 124   // Mark one visit as typed.
 125   visits_a[0].second = ui::PAGE_TRANSITION_TYPED;
 126   ScoredHistoryMatch scored_a(row_a, visits_a, std::string(),
 127                               ASCIIToUTF16("abc"), Make1Term("abc"),
 128                               one_word_no_offset, word_starts_a, now, NULL);
 129
 130   // Test scores based on visit_count.
 131   URLRow row_b(MakeURLRow("http://abcdef", "abcd bcd", 10, 30, 1));
 132   RowWordStarts word_starts_b;
 133   PopulateWordStarts(row_b, &word_starts_b);
 134   VisitInfoVector visits_b = CreateVisitInfoVector(10, 30, now);
 135   visits_b[0].second = ui::PAGE_TRANSITION_TYPED;
 136   ScoredHistoryMatch scored_b(row_b, visits_b, std::string(),
 137                               ASCIIToUTF16("abc"), Make1Term("abc"),
 138                               one_word_no_offset, word_starts_b, now, NULL);
 139   EXPECT_GT(scored_b.raw_score(), scored_a.raw_score());
 140
 141   // Test scores based on last_visit.
 142   URLRow row_c(MakeURLRow("http://abcdef", "abcd bcd", 3, 10, 1));
 143   RowWordStarts word_starts_c;
 144   PopulateWordStarts(row_c, &word_starts_c);
 145   VisitInfoVector visits_c = CreateVisitInfoVector(3, 10, now);
 146   visits_c[0].second = ui::PAGE_TRANSITION_TYPED;
 147   ScoredHistoryMatch scored_c(row_c, visits_c, std::string(),
 148                               ASCIIToUTF16("abc"), Make1Term("abc"),
 149                               one_word_no_offset, word_starts_c, now, NULL);
 150   EXPECT_GT(scored_c.raw_score(), scored_a.raw_score());
 151
 152   // Test scores based on typed_count.
 153   URLRow row_d(MakeURLRow("http://abcdef", "abcd bcd", 3, 30, 3));
 154   RowWordStarts word_starts_d;
 155   PopulateWordStarts(row_d, &word_starts_d);
 156   VisitInfoVector visits_d = CreateVisitInfoVector(3, 30, now);
 157   visits_d[0].second = ui::PAGE_TRANSITION_TYPED;
 158   visits_d[1].second = ui::PAGE_TRANSITION_TYPED;
 159   visits_d[2].second = ui::PAGE_TRANSITION_TYPED;
 160   ScoredHistoryMatch scored_d(row_d, visits_d, std::string(),
 161                               ASCIIToUTF16("abc"), Make1Term("abc"),
 162                               one_word_no_offset, word_starts_d, now, NULL);
 163   EXPECT_GT(scored_d.raw_score(), scored_a.raw_score());
 164
 165   // Test scores based on a terms appearing multiple times.
 166   URLRow row_e(MakeURLRow("http://csi.csi.csi/csi_csi",
 167       "CSI Guide to CSI Las Vegas, CSI New York, CSI Provo", 3, 30, 3));
 168   RowWordStarts word_starts_e;
 169   PopulateWordStarts(row_e, &word_starts_e);
 170   const VisitInfoVector visits_e = visits_d;
 171   ScoredHistoryMatch scored_e(row_e, visits_e, std::string(),
 172                               ASCIIToUTF16("csi"), Make1Term("csi"),
 173                               one_word_no_offset, word_starts_e, now, NULL);
 174   EXPECT_LT(scored_e.raw_score(), 1400);
 175
 176   // Test that a result with only a mid-term match (i.e., not at a word
 177   // boundary) scores 0.
 178   ScoredHistoryMatch scored_f(row_a, visits_a, std::string(),
 179                               ASCIIToUTF16("cd"), Make1Term("cd"),
 180                               one_word_no_offset, word_starts_a, now, NULL);
 181   EXPECT_EQ(scored_f.raw_score(), 0);
 182 }
 183
 184 TEST_F(ScoredHistoryMatchTest, ScoringBookmarks) {
 185   // We use NowFromSystemTime() because MakeURLRow uses the same function
 186   // to calculate last visit time when building a row.
 187   base::Time now = base::Time::NowFromSystemTime();
 188
 189   std::string url_string("http://fedcba");
 190   const GURL url(url_string);
 191   URLRow row(MakeURLRow(url_string.c_str(), "abcd bcd", 8, 3, 1));
 192   RowWordStarts word_starts;
 193   PopulateWordStarts(row, &word_starts);
 194   WordStarts one_word_no_offset(1, 0u);
 195   VisitInfoVector visits = CreateVisitInfoVector(8, 3, now);
 196   ScoredHistoryMatch scored(row, visits, std::string(),
 197                             ASCIIToUTF16("abc"), Make1Term("abc"),
 198                             one_word_no_offset, word_starts, now, NULL);
 199   // Now bookmark that URL and make sure its score increases.
 200   base::AutoReset<int> reset(&ScoredHistoryMatch::bookmark_value_, 5);
 201   history::HistoryClientFakeBookmarks history_client;
 202   history_client.AddBookmark(url);
 203   ScoredHistoryMatch scored_with_bookmark(
 204       row, visits, std::string(), ASCIIToUTF16("abc"), Make1Term("abc"),
 205       one_word_no_offset, word_starts, now, &history_client);
 206   EXPECT_GT(scored_with_bookmark.raw_score(), scored.raw_score());
 207 }
 208
 209 TEST_F(ScoredHistoryMatchTest, ScoringTLD) {
 210   // We use NowFromSystemTime() because MakeURLRow uses the same function
 211   // to calculate last visit time when building a row.
 212   base::Time now = base::Time::NowFromSystemTime();
 213
 214   // By default the URL should not be returned for a query that includes "com".
 215   std::string url_string("http://fedcba.com/");
 216   const GURL url(url_string);
 217   URLRow row(MakeURLRow(url_string.c_str(), "", 8, 3, 1));
 218   RowWordStarts word_starts;
 219   PopulateWordStarts(row, &word_starts);
 220   WordStarts two_words_no_offsets(2, 0u);
 221   VisitInfoVector visits = CreateVisitInfoVector(8, 3, now);
 222   ScoredHistoryMatch scored(row, visits, std::string(),
 223                             ASCIIToUTF16("fed com"), Make2Terms("fed", "com"),
 224                             two_words_no_offsets, word_starts, now, NULL);
 225   EXPECT_EQ(0, scored.raw_score());
 226
 227   // Now allow credit for the match in the TLD.
 228   base::AutoReset<bool> reset(&ScoredHistoryMatch::allow_tld_matches_, true);
 229   ScoredHistoryMatch scored_with_tld(
 230       row, visits, std::string(), ASCIIToUTF16("fed com"),
 231       Make2Terms("fed", "com"), two_words_no_offsets, word_starts, now, NULL);
 232   EXPECT_GT(scored_with_tld.raw_score(), 0);
 233 }
 234
 235 TEST_F(ScoredHistoryMatchTest, ScoringScheme) {
 236   // We use NowFromSystemTime() because MakeURLRow uses the same function
 237   // to calculate last visit time when building a row.
 238   base::Time now = base::Time::NowFromSystemTime();
 239
 240   // By default the URL should not be returned for a query that includes "http".
 241   std::string url_string("http://fedcba/");
 242   const GURL url(url_string);
 243   URLRow row(MakeURLRow(url_string.c_str(), "", 8, 3, 1));
 244   RowWordStarts word_starts;
 245   PopulateWordStarts(row, &word_starts);
 246   WordStarts two_words_no_offsets(2, 0u);
 247   VisitInfoVector visits = CreateVisitInfoVector(8, 3, now);
 248   ScoredHistoryMatch scored(row, visits, std::string(),
 249                             ASCIIToUTF16("fed http"), Make2Terms("fed", "http"),
 250                             two_words_no_offsets, word_starts, now, NULL);
 251   EXPECT_EQ(0, scored.raw_score());
 252
 253   // Now allow credit for the match in the scheme.
 254   base::AutoReset<bool> reset(&ScoredHistoryMatch::allow_scheme_matches_, true);
 255   ScoredHistoryMatch scored_with_scheme(
 256       row, visits, std::string(), ASCIIToUTF16("fed http"),
 257       Make2Terms("fed", "http"), two_words_no_offsets, word_starts, now, NULL);
 258   EXPECT_GT(scored_with_scheme.raw_score(), 0);
 259 }
 260
 261 TEST_F(ScoredHistoryMatchTest, Inlining) {
 262   // We use NowFromSystemTime() because MakeURLRow uses the same function
 263   // to calculate last visit time when building a row.
 264   base::Time now = base::Time::NowFromSystemTime();
 265   RowWordStarts word_starts;
 266   WordStarts one_word_no_offset(1, 0u);
 267   VisitInfoVector visits;
 268
 269   {
 270     URLRow row(MakeURLRow("http://www.google.com", "abcdef", 3, 30, 1));
 271     PopulateWordStarts(row, &word_starts);
 272     ScoredHistoryMatch scored_a(row, visits, std::string(),
 273                                 ASCIIToUTF16("g"), Make1Term("g"),
 274                                 one_word_no_offset, word_starts, now, NULL);
 275     EXPECT_TRUE(scored_a.can_inline());
 276     EXPECT_FALSE(scored_a.match_in_scheme);
 277     ScoredHistoryMatch scored_b(row, visits, std::string(),
 278                                 ASCIIToUTF16("w"), Make1Term("w"),
 279                                 one_word_no_offset, word_starts, now, NULL);
 280     EXPECT_TRUE(scored_b.can_inline());
 281     EXPECT_FALSE(scored_b.match_in_scheme);
 282     ScoredHistoryMatch scored_c(row, visits, std::string(),
 283                                 ASCIIToUTF16("h"), Make1Term("h"),
 284                                 one_word_no_offset, word_starts, now, NULL);
 285     EXPECT_TRUE(scored_c.can_inline());
 286     EXPECT_TRUE(scored_c.match_in_scheme);
 287     ScoredHistoryMatch scored_d(row, visits, std::string(),
 288                                 ASCIIToUTF16("o"), Make1Term("o"),
 289                                 one_word_no_offset, word_starts, now, NULL);
 290     EXPECT_FALSE(scored_d.can_inline());
 291     EXPECT_FALSE(scored_d.match_in_scheme);
 292   }
 293
 294   {
 295     URLRow row(MakeURLRow("http://teams.foo.com", "abcdef", 3, 30, 1));
 296     PopulateWordStarts(row, &word_starts);
 297     ScoredHistoryMatch scored_a(row, visits, std::string(),
 298                                 ASCIIToUTF16("t"), Make1Term("t"),
 299                                 one_word_no_offset, word_starts, now, NULL);
 300     EXPECT_TRUE(scored_a.can_inline());
 301     EXPECT_FALSE(scored_a.match_in_scheme);
 302     ScoredHistoryMatch scored_b(row, visits, std::string(),
 303                                 ASCIIToUTF16("f"), Make1Term("f"),
 304                                 one_word_no_offset, word_starts, now, NULL);
 305     EXPECT_FALSE(scored_b.can_inline());
 306     EXPECT_FALSE(scored_b.match_in_scheme);
 307     ScoredHistoryMatch scored_c(row, visits, std::string(),
 308                                 ASCIIToUTF16("o"), Make1Term("o"),
 309                                 one_word_no_offset, word_starts, now, NULL);
 310     EXPECT_FALSE(scored_c.can_inline());
 311     EXPECT_FALSE(scored_c.match_in_scheme);
 312   }
 313
 314   {
 315     URLRow row(MakeURLRow("https://www.testing.com", "abcdef", 3, 30, 1));
 316     PopulateWordStarts(row, &word_starts);
 317     ScoredHistoryMatch scored_a(row, visits, std::string(),
 318                                 ASCIIToUTF16("t"), Make1Term("t"),
 319                                 one_word_no_offset, word_starts, now, NULL);
 320     EXPECT_TRUE(scored_a.can_inline());
 321     EXPECT_FALSE(scored_a.match_in_scheme);
 322     ScoredHistoryMatch scored_b(row, visits, std::string(),
 323                                 ASCIIToUTF16("h"), Make1Term("h"),
 324                                 one_word_no_offset, word_starts, now, NULL);
 325     EXPECT_TRUE(scored_b.can_inline());
 326     EXPECT_TRUE(scored_b.match_in_scheme);
 327     ScoredHistoryMatch scored_c(row, visits, std::string(),
 328                                 ASCIIToUTF16("w"), Make1Term("w"),
 329                                 one_word_no_offset, word_starts, now, NULL);
 330     EXPECT_TRUE(scored_c.can_inline());
 331     EXPECT_FALSE(scored_c.match_in_scheme);
 332   }
 333 }
 334
 335 TEST_F(ScoredHistoryMatchTest, GetTopicalityScoreTrailingSlash) {
 336   const float hostname = GetTopicalityScoreOfTermAgainstURLAndTitle(
 337       ASCIIToUTF16("def"),
 338       ASCIIToUTF16("http://abc.def.com/"),
 339       ASCIIToUTF16("Non-Matching Title"));
 340   const float hostname_no_slash = GetTopicalityScoreOfTermAgainstURLAndTitle(
 341       ASCIIToUTF16("def"),
 342       ASCIIToUTF16("http://abc.def.com"),
 343       ASCIIToUTF16("Non-Matching Title"));
 344   EXPECT_EQ(hostname_no_slash, hostname);
 345 }
 346
 347 // This function only tests scoring of single terms that match exactly
 348 // once somewhere in the URL or title.
 349 TEST_F(ScoredHistoryMatchTest, GetTopicalityScore) {
 350   base::string16 url = ASCIIToUTF16("http://abc.def.com/path1/path2?"
 351       "arg1=val1&arg2=val2#hash_component");
 352   base::string16 title = ASCIIToUTF16("here is a title");
 353   const float hostname_score =
 354       GetTopicalityScoreOfTermAgainstURLAndTitle(
 355           ASCIIToUTF16("abc"), url, title);
 356   const float hostname_mid_word_score =
 357       GetTopicalityScoreOfTermAgainstURLAndTitle(
 358           ASCIIToUTF16("bc"), url, title);
 359   const float domain_name_score =
 360       GetTopicalityScoreOfTermAgainstURLAndTitle(
 361           ASCIIToUTF16("def"), url, title);
 362   const float domain_name_mid_word_score =
 363       GetTopicalityScoreOfTermAgainstURLAndTitle(
 364           ASCIIToUTF16("ef"), url, title);
 365   const float tld_score =
 366       GetTopicalityScoreOfTermAgainstURLAndTitle(
 367           ASCIIToUTF16("com"), url, title);
 368   const float tld_mid_word_score =
 369       GetTopicalityScoreOfTermAgainstURLAndTitle(
 370           ASCIIToUTF16("om"), url, title);
 371   const float path_score =
 372       GetTopicalityScoreOfTermAgainstURLAndTitle(
 373           ASCIIToUTF16("path1"), url, title);
 374   const float path_mid_word_score =
 375       GetTopicalityScoreOfTermAgainstURLAndTitle(
 376           ASCIIToUTF16("ath1"), url, title);
 377   const float arg_score =
 378       GetTopicalityScoreOfTermAgainstURLAndTitle(
 379           ASCIIToUTF16("arg2"), url, title);
 380   const float arg_mid_word_score =
 381       GetTopicalityScoreOfTermAgainstURLAndTitle(
 382           ASCIIToUTF16("rg2"), url, title);
 383   const float protocol_score =
 384       GetTopicalityScoreOfTermAgainstURLAndTitle(
 385           ASCIIToUTF16("htt"), url, title);
 386   const float protocol_mid_word_score =
 387       GetTopicalityScoreOfTermAgainstURLAndTitle(
 388           ASCIIToUTF16("tt"), url, title);
 389   const float title_score =
 390       GetTopicalityScoreOfTermAgainstURLAndTitle(
 391           ASCIIToUTF16("her"), url, title);
 392   const float title_mid_word_score =
 393       GetTopicalityScoreOfTermAgainstURLAndTitle(
 394           ASCIIToUTF16("er"), url, title);
 395   // Verify hostname and domain name > path > arg.
 396   EXPECT_GT(hostname_score, path_score);
 397   EXPECT_GT(domain_name_score, path_score);
 398   EXPECT_GT(path_score, arg_score);
 399   // Verify that domain name > path and domain name > arg for non-word
 400   // boundaries.
 401   EXPECT_GT(hostname_mid_word_score, path_mid_word_score);
 402   EXPECT_GT(domain_name_mid_word_score, path_mid_word_score);
 403   EXPECT_GT(domain_name_mid_word_score, arg_mid_word_score);
 404   EXPECT_GT(hostname_mid_word_score, arg_mid_word_score);
 405   // Also verify that the matches at non-word-boundaries all score
 406   // worse than the matches at word boundaries.  These three sets suffice.
 407   EXPECT_GT(arg_score, hostname_mid_word_score);
 408   EXPECT_GT(arg_score, domain_name_mid_word_score);
 409   EXPECT_GT(title_score, title_mid_word_score);
 410   // Check that title matches fit somewhere reasonable compared to the
 411   // various types of URL matches.
 412   EXPECT_GT(title_score, arg_score);
 413   EXPECT_GT(arg_score, title_mid_word_score);
 414   // Finally, verify that protocol matches and top level domain name
 415   // matches (.com, .net, etc.) score worse than some of the mid-word
 416   // matches that actually count.
 417   EXPECT_GT(hostname_mid_word_score, protocol_score);
 418   EXPECT_GT(hostname_mid_word_score, protocol_mid_word_score);
 419   EXPECT_GT(hostname_mid_word_score, tld_score);
 420   EXPECT_GT(hostname_mid_word_score, tld_mid_word_score);
 421 }
 422
 423 }  // namespace history