Make Omnibox HistoryURL Provider always aggressive.

chrome/browser/autocomplete/history_url_provider_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/autocomplete/history_url_provider.h"
 
 #include <algorithm>
 
 #include "base/file_util.h"
 #include "base/message_loop.h"
@@ skipping 538 matching lines @@
     MessageLoop::current()->Run();
 
   // None of the matches should attempt to autocomplete.
   matches_ = autocomplete_->matches();
   for (size_t i = 0; i < matches_.size(); ++i)
     EXPECT_EQ(string16::npos, matches_[i].inline_autocomplete_offset);
 }
 
 TEST_F(HistoryURLProviderTest, TreatEmailsAsSearches) {
   // Visiting foo.com should not make this string be treated as a navigation.
-  // That means the result should be scored at 1200 ("what you typed") and not
-  // 1400+.
+  // That means the result should be scored around 1200 ("what you typed")
+  // and not 1400+.
   const std::string expected[] = {"http://user@foo.com/"};
   ASSERT_NO_FATAL_FAILURE(RunTest(ASCIIToUTF16("user@foo.com"), string16(),
                                   false, expected, arraysize(expected)));
-  EXPECT_EQ(1200, matches_[0].relevance);
+  EXPECT_LE(1200, matches_[0].relevance);
+  EXPECT_LT(matches_[0].relevance, 1210);
 }
 
 TEST_F(HistoryURLProviderTest, IntranetURLsWithPaths) {
   struct TestCase {
     const char* input;
     int relevance;
   } test_cases[] = {
     { "fooey", 0 },
     { "fooey/", 1200 },     // 1200 for URL would still navigate by default.
     { "fooey/a", 1200 },    // 1200 for UNKNOWN would not.
     { "fooey/a b", 1200 },  // Also UNKNOWN.
     { "gooey", 1410 },
     { "gooey/", 1410 },
     { "gooey/a", 1400 },
     { "gooey/a b", 1400 },
   };
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_cases); ++i) {
     SCOPED_TRACE(test_cases[i].input);
     if (test_cases[i].relevance == 0) {
       RunTest(ASCIIToUTF16(test_cases[i].input), string16(), false, NULL, 0);
     } else {
       const std::string output[] = {
         URLFixerUpper::FixupURL(test_cases[i].input, std::string()).spec()
       };
       ASSERT_NO_FATAL_FAILURE(RunTest(ASCIIToUTF16(test_cases[i].input),
                               string16(), false, output, arraysize(output)));
-      EXPECT_EQ(test_cases[i].relevance, matches_[0].relevance);
+      // Actual relevance should be at least what test_cases expects and
+      // and no more than 10 more.
+      EXPECT_LE(test_cases[i].relevance, matches_[0].relevance);
+      EXPECT_LT(matches_[0].relevance, test_cases[i].relevance + 10);
     }
   }
 }
 
 // Makes sure autocompletion happens for intranet sites that have been
 // previoulsy visited.
 TEST_F(HistoryURLProviderTest, IntranetURLCompletion) {
   sort_matches_ = true;
 
   const std::string expected1[] = {
     "http://intra/three",
     "http://intra/two",
   };
   ASSERT_NO_FATAL_FAILURE(RunTest(ASCIIToUTF16("intra/t"), string16(), false,
                                   expected1, arraysize(expected1)));
-  EXPECT_EQ(1410, matches_[0].relevance);
-  EXPECT_EQ(900, matches_[1].relevance);
+  EXPECT_LE(1410, matches_[0].relevance);
+  EXPECT_LT(matches_[0].relevance, 1420);
+  EXPECT_EQ(matches_[0].relevance - 1, matches_[1].relevance);
 
   const std::string expected2[] = {
     "http://moo/b",
     "http://moo/bar",
   };
   ASSERT_NO_FATAL_FAILURE(RunTest(ASCIIToUTF16("moo/b"), string16(), false,
                                   expected2, arraysize(expected2)));
-  // The what you typed match should be 1400, otherwise the search what you
-  // typed match is going to be first.
-  EXPECT_EQ(1400, matches_[0].relevance);
+  // The url what you typed match should be around 1400, otherwise the
+  // search what you typed match is going to be first.
+  EXPECT_LE(1400, matches_[0].relevance);
+  EXPECT_LT(matches_[0].relevance, 1410);
 
   const std::string expected3[] = {
     "http://intra/one",
     "http://intra/three",
     "http://intra/two",
   };
   RunTest(ASCIIToUTF16("intra"), string16(), false, expected3,
           arraysize(expected3));
 
   const std::string expected4[] = {
     "http://intra/one",
     "http://intra/three",
     "http://intra/two",
   };
   RunTest(ASCIIToUTF16("intra/"), string16(), false, expected4,
           arraysize(expected4));
 
   const std::string expected5[] = {
     "http://intra/one",
   };
   ASSERT_NO_FATAL_FAILURE(RunTest(ASCIIToUTF16("intra/o"), string16(), false,
                                   expected5, arraysize(expected5)));
-  EXPECT_EQ(1410, matches_[0].relevance);
+  EXPECT_LE(1410, matches_[0].relevance);
+  EXPECT_LT(matches_[0].relevance, 1420);
 
   const std::string expected6[] = {
     "http://intra/x",
   };
   ASSERT_NO_FATAL_FAILURE(RunTest(ASCIIToUTF16("intra/x"), string16(), false,
                                   expected6, arraysize(expected6)));
-  EXPECT_EQ(1400, matches_[0].relevance);
+  EXPECT_LE(1400, matches_[0].relevance);
+  EXPECT_LT(matches_[0].relevance, 1410);
 
   const std::string expected7[] = {
     "http://typedhost/untypedpath",
   };
   ASSERT_NO_FATAL_FAILURE(RunTest(ASCIIToUTF16("typedhost/untypedpath"),
       string16(), false, expected7, arraysize(expected7)));
-  EXPECT_EQ(1400, matches_[0].relevance);
+  EXPECT_LE(1400, matches_[0].relevance);
+  EXPECT_LT(matches_[0].relevance, 1410);
 }
 
 TEST_F(HistoryURLProviderTest, CrashDueToFixup) {
   // This test passes if we don't crash.  The results don't matter.
   const char* const test_cases[] = {
     "//c",
     "\\@st"
   };
   for (size_t i = 0; i < arraysize(test_cases); ++i) {
     AutocompleteInput input(ASCIIToUTF16(test_cases[i]), string16(), false,
                             false, true, AutocompleteInput::ALL_MATCHES);
     autocomplete_->Start(input, false);
     if (!autocomplete_->done())
       MessageLoop::current()->Run();
   }
 }