Add HasWord(string) method to SpellcheckCustomDictionary

chrome/browser/spellchecker/spellcheck_custom_dictionary_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 <vector>
 
 #include "base/file_util.h"
 #include "base/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/histogram_samples.h"
@@ skipping 13 matching lines @@
 #include "sync/api/sync_error_factory_mock.h"
 #include "sync/protocol/sync.pb.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::HistogramBase;
 using base::HistogramSamples;
 using base::StatisticsRecorder;
 using content::BrowserThread;
 using chrome::spellcheck_common::WordList;
+using chrome::spellcheck_common::WordSet;
 
 namespace {
 
 // Get all sync data for the custom dictionary without limiting to maximum
 // number of syncable words.
 syncer::SyncDataList GetAllSyncDataNoLimit(
     const SpellcheckCustomDictionary* dictionary) {
   syncer::SyncDataList data;
   std::string word;
-  for (WordList::const_iterator it = dictionary->GetWords().begin();
-       it != dictionary->GetWords().end();
-       ++it) {
+  const WordSet& words = dictionary->GetWords();
+  for (WordSet::const_iterator it = words.begin(); it != words.end(); ++it) {
     word = *it;
     sync_pb::EntitySpecifics specifics;
     specifics.mutable_dictionary()->set_word(word);
     data.push_back(syncer::SyncData::CreateLocalData(word, word, specifics));
   }
   return data;
 }
 
 }  // namespace
 
@@ skipping 162 matching lines @@
   SpellcheckCustomDictionary* custom_dictionary =
       spellcheck_service->GetCustomDictionary();
   TestingProfile profile2;
   SpellcheckService* spellcheck_service2 =
       static_cast<SpellcheckService*>(
           SpellcheckServiceFactory::GetInstance()->SetTestingFactoryAndUse(
               &profile2, &BuildSpellcheckService));
   SpellcheckCustomDictionary* custom_dictionary2 =
       spellcheck_service2->GetCustomDictionary();
 
-  WordList expected1;
-  WordList expected2;
+  WordSet expected1;
+  WordSet expected2;
 
   custom_dictionary->AddWord("foo");
   custom_dictionary->AddWord("bar");
-  expected1.push_back("foo");
-  expected1.push_back("bar");
+  expected1.insert("foo");
+  expected1.insert("bar");
 
   custom_dictionary2->AddWord("hoge");
   custom_dictionary2->AddWord("fuga");
-  expected2.push_back("hoge");
-  expected2.push_back("fuga");
+  expected2.insert("hoge");
+  expected2.insert("fuga");
 
-  WordList actual1 = custom_dictionary->GetWords();
-  std::sort(actual1.begin(), actual1.end());
-  std::sort(expected1.begin(), expected1.end());
+  WordSet actual1 = custom_dictionary->GetWords();
   EXPECT_EQ(actual1, expected1);
 
-  WordList actual2 = custom_dictionary2->GetWords();
-  std::sort(actual2.begin(), actual2.end());
-  std::sort(expected2.begin(), expected2.end());
+  WordSet actual2 = custom_dictionary2->GetWords();
   EXPECT_EQ(actual2, expected2);
 }
 
 // Legacy empty dictionary should be converted to new format empty dictionary.
 TEST_F(SpellcheckCustomDictionaryTest, LegacyEmptyDictionaryShouldBeConverted) {
   base::FilePath path =
       profile_->GetPath().Append(chrome::kCustomDictionaryFileName);
 
   std::string content;
   file_util::WriteFile(path, content.c_str(), content.length());
@@ skipping 64 matching lines @@
 
 TEST_F(SpellcheckCustomDictionaryTest,
        GetAllSyncDataAccuratelyReflectsDictionaryState) {
   SpellcheckCustomDictionary* dictionary =
       SpellcheckServiceFactory::GetForProfile(
           profile_.get())->GetCustomDictionary();
 
   syncer::SyncDataList data = dictionary->GetAllSyncData(syncer::DICTIONARY);
   EXPECT_TRUE(data.empty());
 
+  EXPECT_TRUE(dictionary->AddWord("bar"));
   EXPECT_TRUE(dictionary->AddWord("foo"));
-  EXPECT_TRUE(dictionary->AddWord("bar"));
 
   data = dictionary->GetAllSyncData(syncer::DICTIONARY);
   EXPECT_EQ(2UL, data.size());
   std::vector<std::string> words;
+  words.push_back("bar");
   words.push_back("foo");
-  words.push_back("bar");
   for (size_t i = 0; i < data.size(); i++) {
     EXPECT_TRUE(data[i].GetSpecifics().has_dictionary());
     EXPECT_EQ(syncer::DICTIONARY, data[i].GetDataType());
     EXPECT_EQ(words[i], data[i].GetTag());
     EXPECT_EQ(words[i], data[i].GetSpecifics().dictionary().word());
   }
 
+  EXPECT_TRUE(dictionary->RemoveWord("bar"));
   EXPECT_TRUE(dictionary->RemoveWord("foo"));
-  EXPECT_TRUE(dictionary->RemoveWord("bar"));
 
   data = dictionary->GetAllSyncData(syncer::DICTIONARY);
   EXPECT_TRUE(data.empty());
 }
 
 TEST_F(SpellcheckCustomDictionaryTest, GetAllSyncDataHasLimit) {
   SpellcheckCustomDictionary* dictionary =
       SpellcheckServiceFactory::GetForProfile(
           profile_.get())->GetCustomDictionary();
 
@@ skipping 85 matching lines @@
     sync_pb::EntitySpecifics specifics;
     specifics.mutable_dictionary()->set_word(word);
     changes.push_back(syncer::SyncChange(
         FROM_HERE,
         syncer::SyncChange::ACTION_DELETE,
         syncer::SyncData::CreateLocalData(word, word, specifics)));
   }
 
   EXPECT_FALSE(dictionary->ProcessSyncChanges(FROM_HERE, changes).IsSet());
 
-  const chrome::spellcheck_common::WordList& words = dictionary->GetWords();
+  const WordSet& words = dictionary->GetWords();
   EXPECT_EQ(2UL, words.size());
-  EXPECT_EQ(words.end(), std::find(words.begin(), words.end(), "bar"));
-  EXPECT_NE(words.end(), std::find(words.begin(), words.end(), "foo"));
-  EXPECT_NE(words.end(), std::find(words.begin(), words.end(), "baz"));
+  EXPECT_EQ(0UL, words.count("bar"));
+  EXPECT_EQ(1UL, words.count("foo"));
+  EXPECT_EQ(1UL, words.count("baz"));
 }
 
 TEST_F(SpellcheckCustomDictionaryTest, MergeDataAndStartSyncing) {
   SpellcheckService* spellcheck_service =
       SpellcheckServiceFactory::GetForProfile(profile_.get());
   SpellcheckCustomDictionary* custom_dictionary =
       spellcheck_service->GetCustomDictionary();
   TestingProfile profile2;
   SpellcheckService* spellcheck_service2 =
       static_cast<SpellcheckService*>(
@@ skipping 22 matching lines @@
   EXPECT_FALSE(custom_dictionary->MergeDataAndStartSyncing(
       syncer::DICTIONARY,
       custom_dictionary2->GetAllSyncData(syncer::DICTIONARY),
       scoped_ptr<syncer::SyncChangeProcessor>(
           new SyncChangeProcessorDelegate(custom_dictionary2)),
       scoped_ptr<syncer::SyncErrorFactory>(
           new SyncErrorFactoryStub(&error_counter))).error().IsSet());
   EXPECT_EQ(0, error_counter);
   EXPECT_TRUE(custom_dictionary->IsSyncing());
 
-  WordList words = custom_dictionary->GetWords();
-  WordList words2 = custom_dictionary2->GetWords();
+  WordSet words = custom_dictionary->GetWords();
+  WordSet words2 = custom_dictionary2->GetWords();
   EXPECT_EQ(words.size(), words2.size());
-
-  std::sort(words.begin(), words.end());
-  std::sort(words2.begin(), words2.end());
   EXPECT_EQ(words, words2);
 }
 
 TEST_F(SpellcheckCustomDictionaryTest, DictionaryTooBigBeforeSyncing) {
   SpellcheckService* spellcheck_service =
       SpellcheckServiceFactory::GetForProfile(profile_.get());
   SpellcheckCustomDictionary* custom_dictionary =
       spellcheck_service->GetCustomDictionary();
   TestingProfile profile2;
   SpellcheckService* spellcheck_service2 =
@@ skipping 601 matching lines @@
   EXPECT_EQ(2u, loaded_custom_words.size());
 
   histogram =
       StatisticsRecorder::FindHistogram("SpellCheck.CustomWords");
   ASSERT_TRUE(histogram != NULL);
   scoped_ptr<HistogramSamples> samples2 = histogram->SnapshotSamples();
 
   samples2->Subtract(*baseline);
   EXPECT_EQ(2,samples2->sum());
 }
+
+TEST_F(SpellcheckCustomDictionaryTest, HasWord) {
+  SpellcheckService* spellcheck_service =
+      SpellcheckServiceFactory::GetForProfile(profile_.get());
+  SpellcheckCustomDictionary* custom_dictionary =
+      spellcheck_service->GetCustomDictionary();
+  OnLoaded(*custom_dictionary, WordList());
+  EXPECT_FALSE(custom_dictionary->HasWord("foo"));
+  EXPECT_FALSE(custom_dictionary->HasWord("bar"));
+  custom_dictionary->AddWord("foo");
+  EXPECT_TRUE(custom_dictionary->HasWord("foo"));
+  EXPECT_FALSE(custom_dictionary->HasWord("bar"));
+}