chrome/browser/spellchecker/feedback_unittest.cc

   1 // Copyright (c) 2013 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 // Unit tests for |Feedback| object.
   6
   7 #include "chrome/browser/spellchecker/feedback.h"
   8
   9 #include "base/strings/utf_string_conversions.h"
  10 #include "testing/gtest/include/gtest/gtest.h"
  11
  12 using base::ASCIIToUTF16;
  13
  14 namespace spellcheck {
  15
  16 namespace {
  17
  18 // Identifier for a renderer process.
  19 const int kRendererProcessId = 7;
  20
  21 // Hash identifier for a misspelling.
  22 const uint32 kMisspellingHash = 42;
  23
  24 }  // namespace
  25
  26 // A test fixture to help keep the tests simple.
  27 class FeedbackTest : public testing::Test {
  28  public:
  29   FeedbackTest() {}
  30   ~FeedbackTest() override {}
  31
  32  protected:
  33   void AddMisspelling(int renderer_process_id, uint32 hash) {
  34     Misspelling misspelling;
  35     misspelling.hash = hash;
  36     feedback_.AddMisspelling(renderer_process_id, misspelling);
  37   }
  38
  39   spellcheck::Feedback feedback_;
  40 };
  41
  42 // Should be able to retrieve misspelling after it's added.
  43 TEST_F(FeedbackTest, RetreiveMisspelling) {
  44   EXPECT_EQ(NULL, feedback_.GetMisspelling(kMisspellingHash));
  45   AddMisspelling(kRendererProcessId, kMisspellingHash);
  46   Misspelling* result = feedback_.GetMisspelling(kMisspellingHash);
  47   EXPECT_NE(static_cast<Misspelling*>(NULL), result);
  48   EXPECT_EQ(kMisspellingHash, result->hash);
  49 }
  50
  51 // Removed misspellings should be finalized.
  52 TEST_F(FeedbackTest, FinalizeRemovedMisspellings) {
  53   static const int kRemovedMisspellingHash = 1;
  54   static const int kRemainingMisspellingHash = 2;
  55   AddMisspelling(kRendererProcessId, kRemovedMisspellingHash);
  56   AddMisspelling(kRendererProcessId, kRemainingMisspellingHash);
  57   std::vector<uint32> remaining_markers(1, kRemainingMisspellingHash);
  58   feedback_.FinalizeRemovedMisspellings(kRendererProcessId, remaining_markers);
  59   Misspelling* removed_misspelling =
  60       feedback_.GetMisspelling(kRemovedMisspellingHash);
  61   EXPECT_NE(static_cast<Misspelling*>(NULL), removed_misspelling);
  62   EXPECT_TRUE(removed_misspelling->action.IsFinal());
  63   Misspelling* remaining_misspelling =
  64       feedback_.GetMisspelling(kRemainingMisspellingHash);
  65   EXPECT_NE(static_cast<Misspelling*>(NULL), remaining_misspelling);
  66   EXPECT_FALSE(remaining_misspelling->action.IsFinal());
  67 }
  68
  69 // Duplicate misspellings should not be finalized.
  70 TEST_F(FeedbackTest, DuplicateMisspellingFinalization) {
  71   AddMisspelling(kRendererProcessId, kMisspellingHash);
  72   AddMisspelling(kRendererProcessId, kMisspellingHash);
  73   std::vector<uint32> remaining_markers(1, kMisspellingHash);
  74   feedback_.FinalizeRemovedMisspellings(kRendererProcessId, remaining_markers);
  75   std::vector<Misspelling> misspellings = feedback_.GetAllMisspellings();
  76   EXPECT_EQ(static_cast<size_t>(1), misspellings.size());
  77   EXPECT_FALSE(misspellings[0].action.IsFinal());
  78 }
  79
  80 // Misspellings should be associated with a renderer.
  81 TEST_F(FeedbackTest, RendererHasMisspellings) {
  82   EXPECT_FALSE(feedback_.RendererHasMisspellings(kRendererProcessId));
  83   AddMisspelling(kRendererProcessId, kMisspellingHash);
  84   EXPECT_TRUE(feedback_.RendererHasMisspellings(kRendererProcessId));
  85 }
  86
  87 // Should be able to retrieve misspellings in renderer.
  88 TEST_F(FeedbackTest, GetMisspellingsInRenderer) {
  89   AddMisspelling(kRendererProcessId, kMisspellingHash);
  90   const std::vector<Misspelling>& renderer_with_misspellings =
  91       feedback_.GetMisspellingsInRenderer(kRendererProcessId);
  92   EXPECT_EQ(static_cast<size_t>(1), renderer_with_misspellings.size());
  93   EXPECT_EQ(kMisspellingHash, renderer_with_misspellings[0].hash);
  94   const std::vector<Misspelling>& renderer_without_misspellings =
  95       feedback_.GetMisspellingsInRenderer(kRendererProcessId + 1);
  96   EXPECT_EQ(static_cast<size_t>(0), renderer_without_misspellings.size());
  97 }
  98
  99 // Finalized misspellings should be erased.
 100 TEST_F(FeedbackTest, EraseFinalizedMisspellings) {
 101   AddMisspelling(kRendererProcessId, kMisspellingHash);
 102   feedback_.FinalizeRemovedMisspellings(kRendererProcessId,
 103                                         std::vector<uint32>());
 104   EXPECT_TRUE(feedback_.RendererHasMisspellings(kRendererProcessId));
 105   feedback_.EraseFinalizedMisspellings(kRendererProcessId);
 106   EXPECT_FALSE(feedback_.RendererHasMisspellings(kRendererProcessId));
 107   EXPECT_TRUE(feedback_.GetMisspellingsInRenderer(kRendererProcessId).empty());
 108 }
 109
 110 // Should be able to check for misspelling existence.
 111 TEST_F(FeedbackTest, HasMisspelling) {
 112   EXPECT_FALSE(feedback_.HasMisspelling(kMisspellingHash));
 113   AddMisspelling(kRendererProcessId, kMisspellingHash);
 114   EXPECT_TRUE(feedback_.HasMisspelling(kMisspellingHash));
 115 }
 116
 117 // Should be able to check for feedback data presence.
 118 TEST_F(FeedbackTest, EmptyFeedback) {
 119   EXPECT_TRUE(feedback_.Empty());
 120   AddMisspelling(kRendererProcessId, kMisspellingHash);
 121   EXPECT_FALSE(feedback_.Empty());
 122 }
 123
 124 // Should be able to retrieve a list of all renderers with misspellings.
 125 TEST_F(FeedbackTest, GetRendersWithMisspellings) {
 126   EXPECT_TRUE(feedback_.GetRendersWithMisspellings().empty());
 127   AddMisspelling(kRendererProcessId, kMisspellingHash);
 128   AddMisspelling(kRendererProcessId + 1, kMisspellingHash + 1);
 129   std::vector<int> result = feedback_.GetRendersWithMisspellings();
 130   EXPECT_EQ(static_cast<size_t>(2), result.size());
 131   EXPECT_NE(result[0], result[1]);
 132   EXPECT_TRUE(result[0] == kRendererProcessId ||
 133               result[0] == kRendererProcessId + 1);
 134   EXPECT_TRUE(result[1] == kRendererProcessId ||
 135               result[1] == kRendererProcessId + 1);
 136 }
 137
 138 // Should be able to finalize all misspellings.
 139 TEST_F(FeedbackTest, FinalizeAllMisspellings) {
 140   AddMisspelling(kRendererProcessId, kMisspellingHash);
 141   AddMisspelling(kRendererProcessId + 1, kMisspellingHash + 1);
 142   {
 143     std::vector<Misspelling> pending = feedback_.GetAllMisspellings();
 144     for (std::vector<Misspelling>::const_iterator it = pending.begin();
 145          it != pending.end();
 146          ++it) {
 147       EXPECT_FALSE(it->action.IsFinal());
 148     }
 149   }
 150   feedback_.FinalizeAllMisspellings();
 151   {
 152     std::vector<Misspelling> final = feedback_.GetAllMisspellings();
 153     for (std::vector<Misspelling>::const_iterator it = final.begin();
 154          it != final.end();
 155          ++it) {
 156       EXPECT_TRUE(it->action.IsFinal());
 157     }
 158   }
 159 }
 160
 161 // Should be able to retrieve a copy of all misspellings.
 162 TEST_F(FeedbackTest, GetAllMisspellings) {
 163   EXPECT_TRUE(feedback_.GetAllMisspellings().empty());
 164   AddMisspelling(kRendererProcessId, kMisspellingHash);
 165   AddMisspelling(kRendererProcessId + 1, kMisspellingHash + 1);
 166   const std::vector<Misspelling>& result = feedback_.GetAllMisspellings();
 167   EXPECT_EQ(static_cast<size_t>(2), result.size());
 168   EXPECT_NE(result[0].hash, result[1].hash);
 169   EXPECT_TRUE(result[0].hash == kMisspellingHash ||
 170               result[0].hash == kMisspellingHash + 1);
 171   EXPECT_TRUE(result[1].hash == kMisspellingHash ||
 172               result[1].hash == kMisspellingHash + 1);
 173 }
 174
 175 // Should be able to clear all misspellings.
 176 TEST_F(FeedbackTest, ClearFeedback) {
 177   AddMisspelling(kRendererProcessId, kMisspellingHash);
 178   AddMisspelling(kRendererProcessId + 1, kMisspellingHash + 1);
 179   EXPECT_FALSE(feedback_.Empty());
 180   feedback_.Clear();
 181   EXPECT_TRUE(feedback_.Empty());
 182 }
 183
 184 // Should be able to find misspellings by misspelled word.
 185 TEST_F(FeedbackTest, FindMisspellingsByText) {
 186   static const base::string16 kMisspelledText =
 187       ASCIIToUTF16("Helllo world. Helllo world");
 188   static const base::string16 kSuggestion = ASCIIToUTF16("Hello");
 189   static const int kMisspellingStart = 0;
 190   static const int kMisspellingLength = 6;
 191   static const int kSentenceLength = 14;
 192   static const int kNumberOfSentences = 2;
 193   static const int kNumberOfRenderers = 2;
 194   uint32 hash = kMisspellingHash;
 195   for (int renderer_process_id = kRendererProcessId;
 196        renderer_process_id < kRendererProcessId + kNumberOfRenderers;
 197        ++renderer_process_id) {
 198     for (int j = 0; j < kNumberOfSentences; ++j) {
 199       feedback_.AddMisspelling(
 200           renderer_process_id,
 201           Misspelling(kMisspelledText,
 202                       kMisspellingStart + j * kSentenceLength,
 203                       kMisspellingLength,
 204                       std::vector<base::string16>(1, kSuggestion),
 205                       ++hash));
 206     }
 207   }
 208
 209   static const base::string16 kOtherMisspelledText =
 210       ASCIIToUTF16("Somethign else");
 211   static const base::string16 kOtherSuggestion = ASCIIToUTF16("Something");
 212   static const int kOtherMisspellingStart = 0;
 213   static const int kOtherMisspellingLength = 9;
 214   feedback_.AddMisspelling(
 215       kRendererProcessId,
 216       Misspelling(kOtherMisspelledText,
 217                   kOtherMisspellingStart,
 218                   kOtherMisspellingLength,
 219                   std::vector<base::string16>(1, kOtherSuggestion),
 220                   hash + 1));
 221
 222   static const base::string16 kMisspelledWord = ASCIIToUTF16("Helllo");
 223   const std::set<uint32>& misspellings =
 224       feedback_.FindMisspellings(kMisspelledWord);
 225   EXPECT_EQ(static_cast<size_t>(kNumberOfSentences * kNumberOfRenderers),
 226             misspellings.size());
 227
 228   for (std::set<uint32>::const_iterator it = misspellings.begin();
 229        it != misspellings.end();
 230       ++it) {
 231     Misspelling* misspelling = feedback_.GetMisspelling(*it);
 232     EXPECT_NE(static_cast<Misspelling*>(NULL), misspelling);
 233     EXPECT_TRUE(misspelling->hash >= kMisspellingHash &&
 234                 misspelling->hash <= hash);
 235     EXPECT_EQ(kMisspelledWord, misspelling->GetMisspelledString());
 236   }
 237 }
 238
 239 // Should not be able to find misspellings by misspelled word after they have
 240 // been removed.
 241 TEST_F(FeedbackTest, CannotFindMisspellingsByTextAfterErased) {
 242   static const base::string16 kMisspelledText = ASCIIToUTF16("Helllo world");
 243   static const base::string16 kMisspelledWord = ASCIIToUTF16("Helllo");
 244   static const base::string16 kSuggestion = ASCIIToUTF16("Hello");
 245   static const int kMisspellingStart = 0;
 246   static const int kMisspellingLength = 6;
 247   feedback_.AddMisspelling(
 248       kRendererProcessId,
 249       Misspelling(kMisspelledText,
 250                   kMisspellingStart,
 251                   kMisspellingLength,
 252                   std::vector<base::string16>(1, kSuggestion),
 253                   kMisspellingHash));
 254   feedback_.GetMisspelling(kMisspellingHash)->action.Finalize();
 255   feedback_.EraseFinalizedMisspellings(kRendererProcessId);
 256   EXPECT_TRUE(feedback_.FindMisspellings(kMisspelledWord).empty());
 257 }
 258
 259 }  // namespace spellcheck