[Omnibox] Changing scheme from https:// to http:// results in DCHECK (Always).

chrome/browser/autocomplete/in_memory_url_index_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 <algorithm>
 #include <fstream>
 
 #include "base/auto_reset.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
+#include "base/i18n/case_conversion.h"
 #include "base/path_service.h"
 #include "base/run_loop.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/autocomplete/in_memory_url_index.h"
 #include "chrome/browser/autocomplete/in_memory_url_index_types.h"
 #include "chrome/browser/autocomplete/url_index_private_data.h"
 #include "chrome/browser/bookmarks/bookmark_model_factory.h"
 #include "chrome/browser/history/history_service_factory.h"
@@ skipping 17 matching lines @@
 // number specifying the number of days relative to 'today' to which the
 // absolute time should be set during the test setup stage.
 //
 // The format of the test database text file is of a SQLite .dump file.
 // Note that only lines whose first character is an upper-case letter are
 // processed when creating the test database.
 
 namespace {
 const size_t kMaxMatches = 3;
 const char kTestLanguages[] = "en,ja,hi,zh";
+
+// Helper function to set lower case |lower_string| and |lower_terms| (words
+// list) based on supplied |search_string| and |cursor_position|. If
+// |cursor_position| is set and useful (not at either end of the string), allow
+// the |search_string| to be broken at |cursor_position|. We do this by
+// pretending there's a space where the cursor is. |lower_terms| are obtained by
+// splitting the |lower_string| on whitespace into tokens.
+void StringToTerms(const char* search_string,
+                   size_t cursor_position,
+                   base::string16* lower_string,
+                   String16Vector* lower_terms) {
+  *lower_string = base::i18n::ToLower(ASCIIToUTF16(search_string));
+  if ((cursor_position != base::string16::npos) &&
+      (cursor_position < lower_string->length()) && (cursor_position > 0)) {
+    lower_string->insert(cursor_position, base::ASCIIToUTF16(" "));
+  }
+
+  Tokenize(*lower_string, base::kWhitespaceUTF16, lower_terms);
+}
+
 }  // namespace
 
 // -----------------------------------------------------------------------------
 
 // Observer class so the unit tests can wait while the cache is being saved.
 class CacheFileSaverObserver : public InMemoryURLIndex::SaveCacheObserver {
  public:
   explicit CacheFileSaverObserver(const base::Closure& task);
 
   bool succeeded() { return succeeded_; }
@@ skipping 1127 matching lines @@
   // Make sure the data we have was rebuilt from history.  (Version 0
   // means rebuilt from history; anything else means restored from
   // a cache version.)
   EXPECT_EQ(0, new_data.restored_cache_version_);
   EXPECT_NE(fake_rebuild_time, new_data.last_time_rebuilt_from_history_);
 
   // Compare the captured and restored for equality.
   ExpectPrivateDataEqual(*old_data.get(), new_data);
 }
 
+TEST_F(InMemoryURLIndexTest, AddHistoryMatch) {
+  const struct {
+    const char* search_string;
+    size_t cursor_position;
+    const size_t expected_word_starts_offsets[4];
+  } test_cases[] = {
+    /* No punctuations, only cursor position change. */
+    { "ABCD", base::string16::npos, {0, -1, -1, -1} },
+    { "abcd", 0,                    {0, -1, -1, -1} },
+    { "AbcD", 1,                    {0, 0, -1, -1} },
+    { "abcd", 4,                    {0, -1, -1, -1} },
+
+    /* Starting with punctuation. */
+    { ".abcd",  base::string16::npos, {1, -1, -1, -1} },
+    { ".abcd",  0,                    {1, -1, -1, -1} },
+    { "!abcd",  1,                    {1, 0, -1, -1} },
+    { "::abcd", 1,                    {1, 1, -1, -1} },
+    { ":abcd",  5,                    {1, -1, -1, -1} },
+
+    /* Ending with punctuation. */
+    { "abcd://", base::string16::npos, {0, -1, -1, -1} },
+    { "ABCD://", 0,                    {0, -1, -1, -1} },
+    { "abcd://", 1,                    {0, 0, -1, -1} },
+    { "abcd://", 4,                    {0, 3, -1, -1} },
+    { "abcd://", 7,                    {0, -1, -1, -1} },
+
+    /* Punctuation in the middle. */
+    { "ab.cd", base::string16::npos, {0, -1, -1, -1} },
+    { "ab.cd", 0,                    {0, -1, -1, -1} },
+    { "ab!cd", 1,                    {0, 0, -1, -1} },
+    { "AB.cd", 2,                    {0, 1, -1, -1} },
+    { "AB.cd", 3,                    {0, 0, -1, -1} },
+    { "ab:cd", 5,                    {0, -1, -1, -1} },
+
+    /* Hyphenation */
+    { "Ab-cd", base::string16::npos, {0, -1, -1, -1} },
+    { "ab-cd", 0,                    {0, -1, -1, -1} },
+    { "-abcd", 0,                    {1, -1, -1, -1} },
+    { "-abcd", 1,                    {1, 0, -1, -1} },
+    { "abcd-", 2,                    {0, 0, -1, -1} },
+    { "abcd-", 4,                    {0, 1, -1, -1} },
+    { "ab-cd", 5,                    {0, -1, -1, -1} },
+
+    /* Whitespace */
+    { "Ab cd", base::string16::npos, {0, 0, -1, -1} },
+    { "ab cd", 0,                    {0, 0, -1, -1} },
+    { " abcd", 0,                    {0, -1, -1, -1} },
+    { " abcd", 1,                    {0, 0, -1, -1} },
+    { "abcd ", 2,                    {0, 0, -1, -1} },
+    { "abcd :", 4,                   {0, 1, -1, -1} },
+    { "abcd :", 5,                   {0, 1, -1, -1} },
+    { "abcd :", 2,                   {0, 0, 1, -1} }
+  };
+
+  for (size_t i = 0; i < arraysize(test_cases); ++i) {
+    SCOPED_TRACE(testing::Message()
+                 << "search_string = " << test_cases[i].search_string
+                 << ", cursor_position = " << test_cases[i].cursor_position);
+
+    base::string16 lower_string;
+    String16Vector lower_terms;
+    StringToTerms(test_cases[i].search_string, test_cases[i].cursor_position,
+                  &lower_string, &lower_terms);
+    URLIndexPrivateData::AddHistoryMatch match(nullptr, *GetPrivateData(),
+                                               kTestLanguages, lower_string,
+                                               lower_terms, base::Time::Now());
+
+    // Verify against expectations.
+    for (size_t j = 0; j < match.lower_terms_to_word_starts_offsets_.size();
+         ++j) {
+      EXPECT_EQ(test_cases[i].expected_word_starts_offsets[j],
+                match.lower_terms_to_word_starts_offsets_[j]);
+    }

[Mark P, 2015/06/11 18:37:06]

You should either check that match.lower_terms_to_word_starts_offsets_.size() is
the expected length or (equivalently) test that everything from j where the
above loop ends to 4 all have values of -1.

(Otherwise a function that always returns an empty
lower_terms_to_word_starts_offsets_ list will always pass this test.)

[Pritam Nikam, 2015/06/12 06:09:50]

Done.

Now, I'm matching match.lower_terms_to_word_starts_offsets_.size() against
expected length (expected_word_starts_offsets_size).

+  }
+}
+
 class InMemoryURLIndexCacheTest : public testing::Test {
  public:
   InMemoryURLIndexCacheTest() {}
 
  protected:
   void SetUp() override;
   void TearDown() override;
 
   // Pass-through functions to simplify our friendship with InMemoryURLIndex.
   void set_history_dir(const base::FilePath& dir_path);
@@ skipping 36 matching lines @@
   ASSERT_TRUE(GetCacheFilePath(&full_file_path));
   std::vector<base::FilePath::StringType> actual_parts;
   full_file_path.GetComponents(&actual_parts);
   ASSERT_EQ(expected_parts.size(), actual_parts.size());
   size_t count = expected_parts.size();
   for (size_t i = 0; i < count; ++i)
     EXPECT_EQ(expected_parts[i], actual_parts[i]);
   // Must clear the history_dir_ to satisfy the dtor's DCHECK.
   set_history_dir(base::FilePath());
 }