Omnibox: Make the Controller Reorder Matches for Inlining

chrome/browser/autocomplete/keyword_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 "base/command_line.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/autocomplete/autocomplete_match.h"
 #include "chrome/browser/autocomplete/keyword_provider.h"
 #include "chrome/browser/search_engines/template_url.h"
 #include "chrome/browser/search_engines/template_url_service.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/test/base/testing_browser_process.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 class KeywordProviderTest : public testing::Test {
  protected:
   template<class ResultType>
-  struct test_data {
+  struct MatchType {
+    const ResultType member;
+    bool allowed_to_be_default_match;
+  };
+
+  template<class ResultType>
+  struct TestData {
     const string16 input;
     const size_t num_results;
-    const ResultType output[3];
+    const MatchType<ResultType> output[3];
   };
 
   KeywordProviderTest() : kw_provider_(NULL) { }
   virtual ~KeywordProviderTest() { }
 
   virtual void SetUp();
   virtual void TearDown();
 
   template<class ResultType>
-  void RunTest(test_data<ResultType>* keyword_cases,
+  void RunTest(TestData<ResultType>* keyword_cases,
                int num_cases,
                ResultType AutocompleteMatch::* member);
 
  protected:
   static const TemplateURLService::Initializer kTestData[];
 
   scoped_refptr<KeywordProvider> kw_provider_;
   scoped_ptr<TemplateURLService> model_;
 };
 
@@ skipping 13 matching lines @@
   kw_provider_ = new KeywordProvider(NULL, model_.get());
 }
 
 void KeywordProviderTest::TearDown() {
   model_.reset();
   kw_provider_ = NULL;
 }
 
 template<class ResultType>
 void KeywordProviderTest::RunTest(
-    test_data<ResultType>* keyword_cases,
+    TestData<ResultType>* keyword_cases,
     int num_cases,
     ResultType AutocompleteMatch::* member) {
   ACMatches matches;
   for (int i = 0; i < num_cases; ++i) {
+    SCOPED_TRACE(keyword_cases[i].input);
     AutocompleteInput input(keyword_cases[i].input, string16::npos, string16(),
                             GURL(), AutocompleteInput::INVALID_SPEC, true,
                             false, true, AutocompleteInput::ALL_MATCHES);
     kw_provider_->Start(input, false);
     EXPECT_TRUE(kw_provider_->done());
     matches = kw_provider_->matches();
-    EXPECT_EQ(keyword_cases[i].num_results, matches.size()) <<
-                ASCIIToUTF16("Input was: ") + keyword_cases[i].input;
-    if (matches.size() == keyword_cases[i].num_results) {
-      for (size_t j = 0; j < keyword_cases[i].num_results; ++j) {
-        EXPECT_EQ(keyword_cases[i].output[j], matches[j].*member);
-      }
+    ASSERT_EQ(keyword_cases[i].num_results, matches.size());
+    for (size_t j = 0; j < matches.size(); ++j) {
+      EXPECT_EQ(keyword_cases[i].output[j].member, matches[j].*member);
+      EXPECT_EQ(keyword_cases[i].output[j].allowed_to_be_default_match,
+                matches[j].allowed_to_be_default_match);
     }
   }
 }
 
 TEST_F(KeywordProviderTest, Edit) {
-  test_data<string16> edit_cases[] = {
+  const MatchType<string16> kEmptyMatch = { string16(), false };
+  TestData<string16> edit_cases[] = {
     // Searching for a nonexistent prefix should give nothing.
-    {ASCIIToUTF16("Not Found"),       0, {}},
-    {ASCIIToUTF16("aaaaaNot Found"),  0, {}},
+    { ASCIIToUTF16("Not Found"), 0,
+      { kEmptyMatch, kEmptyMatch, kEmptyMatch } },
+    { ASCIIToUTF16("aaaaaNot Found"), 0,
+      { kEmptyMatch, kEmptyMatch, kEmptyMatch } },
 
     // Check that tokenization only collapses whitespace between first tokens,
     // no-query-input cases have a space appended, and action is not escaped.
-    {ASCIIToUTF16("z"),               1, {ASCIIToUTF16("z ")}},
-    {ASCIIToUTF16("z    \t"),         1, {ASCIIToUTF16("z ")}},
+    { ASCIIToUTF16("z"), 1,
+      { { ASCIIToUTF16("z "), true }, kEmptyMatch, kEmptyMatch } },
+    { ASCIIToUTF16("z    \t"), 1,
+      { { ASCIIToUTF16("z "), true }, kEmptyMatch, kEmptyMatch } },
 
     // Check that exact, substituting keywords with a verbatim search term
     // don't generate a result.  (These are handled by SearchProvider.)
-    {ASCIIToUTF16("z foo"),           0, {}},
-    {ASCIIToUTF16("z   a   b   c++"), 0, {}},
+    { ASCIIToUTF16("z foo"), 0,
+      { kEmptyMatch, kEmptyMatch, kEmptyMatch } },
+    { ASCIIToUTF16("z   a   b   c++"), 0,
+      { kEmptyMatch, kEmptyMatch, kEmptyMatch } },
 
     // Matches should be limited to three, and sorted in quality order, not
     // alphabetical.
-    {ASCIIToUTF16("aaa"),             2, {ASCIIToUTF16("aaaa "),
-                                          ASCIIToUTF16("aaaaa ")}},
-    {ASCIIToUTF16("a 1 2 3"),         3, {ASCIIToUTF16("aa 1 2 3"),
-                                          ASCIIToUTF16("ab 1 2 3"),
-                                          ASCIIToUTF16("aaaa 1 2 3")}},
-    {ASCIIToUTF16("www.a"),           3, {ASCIIToUTF16("aa "),
-                                          ASCIIToUTF16("ab "),
-                                          ASCIIToUTF16("aaaa ")}},
+    { ASCIIToUTF16("aaa"), 2,
+      { { ASCIIToUTF16("aaaa "), false },
+        { ASCIIToUTF16("aaaaa "), false },
+        kEmptyMatch } },
+    { ASCIIToUTF16("a 1 2 3"), 3,
+     { { ASCIIToUTF16("aa 1 2 3"), false },
+       { ASCIIToUTF16("ab 1 2 3"), false },
+       { ASCIIToUTF16("aaaa 1 2 3"), false } } },
+    { ASCIIToUTF16("www.a"), 3,
+      { { ASCIIToUTF16("aa "), false },
+        { ASCIIToUTF16("ab "), false },
+        { ASCIIToUTF16("aaaa "), false } } },
     // Exact matches should prevent returning inexact matches.  Also, the
     // verbatim query for this keyword match should not be returned.  (It's
     // returned by SearchProvider.)
-    {ASCIIToUTF16("aaaa foo"),        0, {}},
-    {ASCIIToUTF16("www.aaaa foo"),    0, {}},
+    { ASCIIToUTF16("aaaa foo"), 0,
+      { kEmptyMatch, kEmptyMatch, kEmptyMatch } },
+    { ASCIIToUTF16("www.aaaa foo"), 0,
+      { kEmptyMatch, kEmptyMatch, kEmptyMatch } },
 
     // Clean up keyword input properly.  "http" and "https" are the only
     // allowed schemes.
-    {ASCIIToUTF16("www"),             1, {ASCIIToUTF16("www ")}},
-    {ASCIIToUTF16("www."),            0, {}},
-    {ASCIIToUTF16("www.w w"),         2, {ASCIIToUTF16("www w"),
-                                          ASCIIToUTF16("weasel w")}},
-    {ASCIIToUTF16("http://www"),      1, {ASCIIToUTF16("www ")}},
-    {ASCIIToUTF16("http://www."),     0, {}},
-    {ASCIIToUTF16("ftp: blah"),       0, {}},
-    {ASCIIToUTF16("mailto:z"),        0, {}},
-    {ASCIIToUTF16("ftp://z"),         0, {}},
-    {ASCIIToUTF16("https://z"),       1, {ASCIIToUTF16("z ")}},
+    { ASCIIToUTF16("www"), 1,
+      { { ASCIIToUTF16("www "), true }, kEmptyMatch, kEmptyMatch }},
+    { ASCIIToUTF16("www."), 0,
+      { kEmptyMatch, kEmptyMatch, kEmptyMatch } },
+    { ASCIIToUTF16("www.w w"), 2,
+      { { ASCIIToUTF16("www w"), false },
+        { ASCIIToUTF16("weasel w"), false },
+        kEmptyMatch } },
+    { ASCIIToUTF16("http://www"), 1,
+      { { ASCIIToUTF16("www "), true }, kEmptyMatch, kEmptyMatch } },
+    { ASCIIToUTF16("http://www."), 0,
+      { kEmptyMatch, kEmptyMatch, kEmptyMatch } },
+    { ASCIIToUTF16("ftp: blah"), 0,
+      { kEmptyMatch, kEmptyMatch, kEmptyMatch } },
+    { ASCIIToUTF16("mailto:z"), 0,
+      { kEmptyMatch, kEmptyMatch, kEmptyMatch } },
+    { ASCIIToUTF16("ftp://z"), 0,
+      { kEmptyMatch, kEmptyMatch, kEmptyMatch } },
+    { ASCIIToUTF16("https://z"), 1,
+      { { ASCIIToUTF16("z "), true }, kEmptyMatch, kEmptyMatch } },
   };
 
   RunTest<string16>(edit_cases, arraysize(edit_cases),
                     &AutocompleteMatch::fill_into_edit);
 }
 
 TEST_F(KeywordProviderTest, URL) {
-  test_data<GURL> url_cases[] = {
+  const MatchType<GURL> kEmptyMatch = { GURL(), false };
+  TestData<GURL> url_cases[] = {
     // No query input -> empty destination URL.
-    {ASCIIToUTF16("z"),           1, {GURL()}},
-    {ASCIIToUTF16("z    \t"),     1, {GURL()}},
+    { ASCIIToUTF16("z"), 1,
+      { { GURL(), true }, kEmptyMatch, kEmptyMatch } },
+    { ASCIIToUTF16("z    \t"), 1,
+      { { GURL(), true }, kEmptyMatch, kEmptyMatch } },
 
     // Check that tokenization only collapses whitespace between first tokens
     // and query input, but not rest of URL, is escaped.
-    {ASCIIToUTF16("w  bar +baz"), 2, {GURL(" +%2B?=bar+%2Bbazfoo "),
-                                      GURL("bar+%2Bbaz=z")}},
+    { ASCIIToUTF16("w  bar +baz"), 2,
+      { { GURL(" +%2B?=bar+%2Bbazfoo "), false },
+        { GURL("bar+%2Bbaz=z"), false },
+        kEmptyMatch } },
 
     // Substitution should work with various locations of the "%s".
-    {ASCIIToUTF16("aaa 1a2b"),    2, {GURL("http://aaaa/?aaaa=1&b=1a2b&c"),
-                                      GURL("1a2b")}},
-    {ASCIIToUTF16("a 1 2 3"),     3, {GURL("aa.com?foo=1+2+3"),
-                                      GURL("bogus URL 1+2+3"),
-                                      GURL("http://aaaa/?aaaa=1&b=1+2+3&c")}},
-    {ASCIIToUTF16("www.w w"),     2, {GURL(" +%2B?=wfoo "),
-                                      GURL("weaselwweasel")}},
+    { ASCIIToUTF16("aaa 1a2b"), 2,
+      { { GURL("http://aaaa/?aaaa=1&b=1a2b&c"), false },
+        { GURL("1a2b"), false },
+        kEmptyMatch } },
+    { ASCIIToUTF16("a 1 2 3"), 3,
+      { { GURL("aa.com?foo=1+2+3"), false },
+        { GURL("bogus URL 1+2+3"), false },
+        { GURL("http://aaaa/?aaaa=1&b=1+2+3&c"), false } } },
+    { ASCIIToUTF16("www.w w"), 2,
+      { { GURL(" +%2B?=wfoo "), false },
+        { GURL("weaselwweasel"), false },
+        kEmptyMatch } },
   };
 
   RunTest<GURL>(url_cases, arraysize(url_cases),
                 &AutocompleteMatch::destination_url);
 }
 
 TEST_F(KeywordProviderTest, Contents) {
-  test_data<string16> contents_cases[] = {
+  const MatchType<string16> kEmptyMatch = { string16(), false };
+  TestData<string16> contents_cases[] = {
     // No query input -> substitute "<enter query>" into contents.
-    {ASCIIToUTF16("z"),               1,
-        {ASCIIToUTF16("Search z for <enter query>")}},
-    {ASCIIToUTF16("z    \t"),         1,
-        {ASCIIToUTF16("Search z for <enter query>")}},
+    { ASCIIToUTF16("z"), 1,
+      { { ASCIIToUTF16("Search z for <enter query>"), true },
+        kEmptyMatch,

[msw, 2013/08/10 17:32:18]

nit: I think these empties could be combined too (and lines 212-213)

[Mark P, 2013/08/11 03:22:48]

Done.

+        kEmptyMatch } },
+    { ASCIIToUTF16("z    \t"), 1,
+      { { ASCIIToUTF16("Search z for <enter query>"), true },
+        kEmptyMatch,
+        kEmptyMatch } },
 
     // Exact keyword matches with remaining text should return nothing.
-    {ASCIIToUTF16("www.www www"),     0, {}},
-    {ASCIIToUTF16("z   a   b   c++"), 0, {}},
+    { ASCIIToUTF16("www.www www"), 0,
+      { kEmptyMatch, kEmptyMatch, kEmptyMatch } },
+    { ASCIIToUTF16("z   a   b   c++"), 0,
+      { kEmptyMatch, kEmptyMatch, kEmptyMatch } },
 
     // Exact keyword matches with remaining text when the keyword is an
     // extension keyword should return something.  This is tested in
     // chrome/browser/extensions/api/omnibox/omnibox_apitest.cc's
     // in OmniboxApiTest's Basic test.
 
     // Substitution should work with various locations of the "%s".
-    {ASCIIToUTF16("aaa"),             2,
-        {ASCIIToUTF16("Search aaaa for <enter query>"),
-         ASCIIToUTF16("Search aaaaa for <enter query>")}},
-    {ASCIIToUTF16("www.w w"),         2,
-        {ASCIIToUTF16("Search www for w"),
-         ASCIIToUTF16("Search weasel for w")}},
+    { ASCIIToUTF16("aaa"), 2,
+      { { ASCIIToUTF16("Search aaaa for <enter query>"), false },
+        { ASCIIToUTF16("Search aaaaa for <enter query>"), false },
+        kEmptyMatch} },
+    { ASCIIToUTF16("www.w w"), 2,
+      { { ASCIIToUTF16("Search www for w"), false },
+        { ASCIIToUTF16("Search weasel for w"), false },
+        kEmptyMatch } },
     // Also, check that tokenization only collapses whitespace between first
     // tokens and contents are not escaped or unescaped.
-    {ASCIIToUTF16("a   1 2+ 3"),      3,
-        {ASCIIToUTF16("Search aa for 1 2+ 3"),
-         ASCIIToUTF16("Search ab for 1 2+ 3"),
-         ASCIIToUTF16("Search aaaa for 1 2+ 3")}},
+    { ASCIIToUTF16("a   1 2+ 3"), 3,
+      { { ASCIIToUTF16("Search aa for 1 2+ 3"), false },
+        { ASCIIToUTF16("Search ab for 1 2+ 3"), false },
+        { ASCIIToUTF16("Search aaaa for 1 2+ 3"), false } } },
   };
 
   RunTest<string16>(contents_cases, arraysize(contents_cases),
                     &AutocompleteMatch::contents);
 }
 
 TEST_F(KeywordProviderTest, AddKeyword) {
   TemplateURLData data;
   data.short_name = ASCIIToUTF16("Test");
   string16 keyword(ASCIIToUTF16("foo"));
@@ skipping 76 matching lines @@
     EXPECT_EQ(cases[i].updated_cursor_position, input.cursor_position());
   }
 }
 
 // If extra query params are specified on the command line, they should be
 // reflected (only) in the default search provider's destination URL.
 TEST_F(KeywordProviderTest, ExtraQueryParams) {
   CommandLine::ForCurrentProcess()->AppendSwitchASCII(
       switches::kExtraSearchQueryParams, "a=b");
 
-  test_data<GURL> url_cases[] = {
-    {ASCIIToUTF16("a 1 2 3"), 3, {GURL("aa.com?a=b&foo=1+2+3"),
-                                  GURL("bogus URL 1+2+3"),
-                                  GURL("http://aaaa/?aaaa=1&b=1+2+3&c")}},
+  TestData<GURL> url_cases[] = {
+    { ASCIIToUTF16("a 1 2 3"), 3,
+      { { GURL("aa.com?a=b&foo=1+2+3"), false },
+        { GURL("bogus URL 1+2+3"), false },
+        { GURL("http://aaaa/?aaaa=1&b=1+2+3&c"), false } } },
   };
 
   RunTest<GURL>(url_cases, arraysize(url_cases),
                 &AutocompleteMatch::destination_url);
 }