src/chrome/browser/history/in_memory_url_index_types_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/strings/string16.h"
   8 #include "base/strings/utf_string_conversions.h"
   9 #include "chrome/browser/history/in_memory_url_index_types.h"
  10 #include "testing/gtest/include/gtest/gtest.h"
  11
  12 using base::UTF8ToUTF16;
  13
  14 namespace history {
  15
  16 // Helper function for verifying that the contents of a C++ iterable container
  17 // of ints matches a C array ints.
  18 template <typename T>
  19 bool IntArraysEqual(const size_t* expected,
  20                     size_t expected_size,
  21                     const T& actual) {
  22   if (expected_size != actual.size())
  23     return false;
  24   for (size_t i = 0; i < expected_size; ++i)
  25     if (expected[i] != actual[i])
  26       return false;
  27   return true;
  28 }
  29
  30 class InMemoryURLIndexTypesTest : public testing::Test {
  31 };
  32
  33 TEST_F(InMemoryURLIndexTypesTest, StaticFunctions) {
  34   // Test String16VectorFromString16
  35   base::string16 string_a(
  36       base::UTF8ToUTF16("http://www.google.com/ frammy  the brammy"));
  37   WordStarts actual_starts_a;
  38   String16Vector string_vec =
  39       String16VectorFromString16(string_a, false, &actual_starts_a);
  40   ASSERT_EQ(7U, string_vec.size());
  41   // See if we got the words we expected.
  42   EXPECT_EQ(UTF8ToUTF16("http"), string_vec[0]);
  43   EXPECT_EQ(UTF8ToUTF16("www"), string_vec[1]);
  44   EXPECT_EQ(UTF8ToUTF16("google"), string_vec[2]);
  45   EXPECT_EQ(UTF8ToUTF16("com"), string_vec[3]);
  46   EXPECT_EQ(UTF8ToUTF16("frammy"), string_vec[4]);
  47   EXPECT_EQ(UTF8ToUTF16("the"), string_vec[5]);
  48   EXPECT_EQ(UTF8ToUTF16("brammy"), string_vec[6]);
  49   // Verify the word starts.
  50   size_t expected_starts_a[] = {0, 7, 11, 18, 23, 31, 35};
  51   EXPECT_TRUE(IntArraysEqual(expected_starts_a, arraysize(expected_starts_a),
  52                              actual_starts_a));
  53
  54   WordStarts actual_starts_b;
  55   string_vec = String16VectorFromString16(string_a, true, &actual_starts_b);
  56   ASSERT_EQ(5U, string_vec.size());
  57   EXPECT_EQ(UTF8ToUTF16("http://"), string_vec[0]);
  58   EXPECT_EQ(UTF8ToUTF16("www.google.com/"), string_vec[1]);
  59   EXPECT_EQ(UTF8ToUTF16("frammy"), string_vec[2]);
  60   EXPECT_EQ(UTF8ToUTF16("the"), string_vec[3]);
  61   EXPECT_EQ(UTF8ToUTF16("brammy"), string_vec[4]);
  62   size_t expected_starts_b[] = {0, 7, 23, 31, 35};
  63   EXPECT_TRUE(IntArraysEqual(expected_starts_b, arraysize(expected_starts_b),
  64                              actual_starts_b));
  65
  66   base::string16 string_c(base::ASCIIToUTF16(
  67       " funky%20string-with=@strange   sequences, intended(to exceed)"));
  68   WordStarts actual_starts_c;
  69   string_vec = String16VectorFromString16(string_c, false, &actual_starts_c);
  70   ASSERT_EQ(8U, string_vec.size());
  71   // Note that we stop collecting words and word starts at kMaxSignificantChars.
  72   size_t expected_starts_c[] = {1, 7, 16, 22, 32, 43, 52, 55};
  73   EXPECT_TRUE(IntArraysEqual(expected_starts_c, arraysize(expected_starts_c),
  74                              actual_starts_c));
  75
  76   // Test String16SetFromString16
  77   base::string16 string_d(base::ASCIIToUTF16(
  78       "http://web.google.com/search Google Web Search"));
  79   WordStarts actual_starts_d;
  80   String16Set string_set = String16SetFromString16(string_d, &actual_starts_d);
  81   EXPECT_EQ(5U, string_set.size());
  82   // See if we got the words we expected.
  83   EXPECT_TRUE(string_set.find(UTF8ToUTF16("com")) != string_set.end());
  84   EXPECT_TRUE(string_set.find(UTF8ToUTF16("google")) != string_set.end());
  85   EXPECT_TRUE(string_set.find(UTF8ToUTF16("http")) != string_set.end());
  86   EXPECT_TRUE(string_set.find(UTF8ToUTF16("search")) != string_set.end());
  87   EXPECT_TRUE(string_set.find(UTF8ToUTF16("web")) != string_set.end());
  88   size_t expected_starts_d[] = {0, 7, 11, 18, 22, 29, 36, 40};
  89   EXPECT_TRUE(IntArraysEqual(expected_starts_d, arraysize(expected_starts_d),
  90                              actual_starts_d));
  91
  92   // Test SortAndDeoverlapMatches
  93   TermMatches matches_e;
  94   matches_e.push_back(TermMatch(1, 13, 10));
  95   matches_e.push_back(TermMatch(2, 23, 10));
  96   matches_e.push_back(TermMatch(3, 3, 10));
  97   matches_e.push_back(TermMatch(4, 40, 5));
  98   TermMatches matches_f = SortAndDeoverlapMatches(matches_e);
  99   // Nothing should have been eliminated.
 100   EXPECT_EQ(matches_e.size(), matches_f.size());
 101   // The order should now be 3, 1, 2, 4.
 102   EXPECT_EQ(3, matches_f[0].term_num);
 103   EXPECT_EQ(1, matches_f[1].term_num);
 104   EXPECT_EQ(2, matches_f[2].term_num);
 105   EXPECT_EQ(4, matches_f[3].term_num);
 106   matches_e.push_back(TermMatch(5, 18, 10));
 107   matches_e.push_back(TermMatch(6, 38, 5));
 108   matches_f = SortAndDeoverlapMatches(matches_e);
 109   // Two matches should have been eliminated.
 110   EXPECT_EQ(matches_e.size() - 2, matches_f.size());
 111   // The order should now be 3, 1, 2, 6.
 112   EXPECT_EQ(3, matches_f[0].term_num);
 113   EXPECT_EQ(1, matches_f[1].term_num);
 114   EXPECT_EQ(2, matches_f[2].term_num);
 115   EXPECT_EQ(6, matches_f[3].term_num);
 116
 117   // Test MatchTermInString
 118   TermMatches matches_g = MatchTermInString(
 119       UTF8ToUTF16("x"), UTF8ToUTF16("axbxcxdxex fxgx/hxixjx.kx"), 123);
 120   const size_t expected_offsets[] = { 1, 3, 5, 7, 9, 12, 14, 17, 19, 21, 24 };
 121   ASSERT_EQ(arraysize(expected_offsets), matches_g.size());
 122   for (size_t i = 0; i < arraysize(expected_offsets); ++i)
 123     EXPECT_EQ(expected_offsets[i], matches_g[i].offset);
 124 }
 125
 126 TEST_F(InMemoryURLIndexTypesTest, OffsetsAndTermMatches) {
 127   // Test OffsetsFromTermMatches
 128   history::TermMatches matches_a;
 129   matches_a.push_back(history::TermMatch(1, 1, 2));
 130   matches_a.push_back(history::TermMatch(2, 4, 3));
 131   matches_a.push_back(history::TermMatch(3, 9, 1));
 132   matches_a.push_back(history::TermMatch(3, 10, 1));
 133   matches_a.push_back(history::TermMatch(4, 14, 5));
 134   std::vector<size_t> offsets = OffsetsFromTermMatches(matches_a);
 135   const size_t expected_offsets_a[] = {1, 3, 4, 7, 9, 10, 10, 11, 14, 19};
 136   ASSERT_EQ(offsets.size(), arraysize(expected_offsets_a));
 137   for (size_t i = 0; i < offsets.size(); ++i)
 138     EXPECT_EQ(expected_offsets_a[i], offsets[i]);
 139
 140   // Test ReplaceOffsetsInTermMatches
 141   offsets[4] = base::string16::npos;  // offset of third term
 142   history::TermMatches matches_b =
 143       ReplaceOffsetsInTermMatches(matches_a, offsets);
 144   const size_t expected_offsets_b[] = {1, 4, 10, 14};
 145   ASSERT_EQ(arraysize(expected_offsets_b), matches_b.size());
 146   for (size_t i = 0; i < matches_b.size(); ++i)
 147     EXPECT_EQ(expected_offsets_b[i], matches_b[i].offset);
 148 }
 149
 150 }  // namespace history