[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);
 }
 
+#if defined(OS_MACOSX)
+// FIXME(pritam.nikam): Flaky on mac trybots: C++11 error about initializing
+// explicit constructor with {}.
+#define MAX_TERMS 2
+typedef size_t SizeVector[MAX_TERMS];
+#else
+typedef std::vector<size_t> SizeVector;
+#endif
+
+TEST_F(InMemoryURLIndexTest, AddHistoryMatch) {
+  const struct {
+    const char* search_string;
+    size_t cursor_position;
+    const SizeVector expected_word_starts_offsets;

[Mark P, 2015/06/10 16:53:01]

Instead of this approach, just use a fixed size array, e.g.,
const size_t expected_word_starts_offsets[4]
and use an invalid value (e.g., -1) for the entries that don't need to exist.
This is the usual technique used in unit tests.

Sorry I didn't notice this earlier.

[Pritam Nikam, 2015/06/11 03:06:09]

Done.

+  } test_cases[] = {
+    /* No punctuations, only cursor position change. */
+    { "ABCD", base::string16::npos, {0} },
+    { "abcd", 0,                    {0} },
+    { "AbcD", 1,                    {0, 0} },
+    { "abcd", 4,                    {0} },
+
+    /* Starting with punctuation. */
+    { ".abcd",  base::string16::npos, {1} },
+    { ".abcd",  0,                    {1} },
+    { "!abcd",  1,                    {1, 0} },
+    { "::abcd", 1,                    {1, 1} },
+    { ":abcd",  5,                    {1} },
+
+    /* Ending with punctuation. */
+    { "abcd://", base::string16::npos, {0} },
+    { "ABCD://", 0,                    {0} },
+    { "abcd://", 1,                    {0, 0} },
+    { "abcd://", 4,                    {0, 3} },
+    { "abcd://", 7,                    {0} },
+
+    /* Punctuation in the middle. */
+    { "ab.cd", base::string16::npos, {0} },
+    { "ab.cd", 0,                    {0} },
+    { "ab!cd", 1,                    {0, 0} },
+    { "AB.cd", 2,                    {0, 1} },
+    { "AB.cd", 3,                    {0, 0} },
+    { "ab:cd", 5,                    {0} },
+
+    /* Hyphenation */
+    { "Ab-cd", base::string16::npos, {0} },
+    { "ab-cd", 0,                    {0} },
+    { "-abcd", 0,                    {1} },
+    { "-abcd", 1,                    {1, 0} },
+    { "abcd-", 2,                    {0, 0} },
+    { "abcd-", 4,                    {0, 1} },
+    { "ab-cd", 5,                    {0} }
+  };
+
+  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.
+#if defined(OS_MACOSX)
+    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]);
+    }
+#else
+    EXPECT_EQ(test_cases[i].expected_word_starts_offsets,
+              match.lower_terms_to_word_starts_offsets_);
+#endif
+  }
+}
+
 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());
 }