Adds support for the os x spelling panel to chromium. Users can...

chrome/browser/spellcheck_unittest.cc

 // Copyright (c) 2006-2008 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 "webkit/glue/webkit_glue.h"
 
 #include "base/file_util.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
+#include "base/sys_string_conversions.h"
 #include "chrome/browser/spellchecker.h"
+#include "chrome/browser/spellchecker_platform_engine.h"
 #include "chrome/common/chrome_paths.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 const FilePath::CharType kTempCustomDictionaryFile[] =
     FILE_PATH_LITERAL("temp_custom_dictionary.txt");
 }  // namespace
 
 class SpellCheckTest : public testing::Test {
  private:
@@ skipping 252 matching lines @@
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kTestCases); ++i) {
     size_t input_length = 0;
     if (kTestCases[i].input != NULL) {
       input_length = wcslen(kTestCases[i].input);
     }
     int misspelling_start;
     int misspelling_length;
     bool result = spell_checker->SpellCheckWord(kTestCases[i].input,
                                                 static_cast<int>(input_length),
+                                                0,
                                                 &misspelling_start,
                                                 &misspelling_length, NULL);
 
     EXPECT_EQ(kTestCases[i].expected_result, result);
     EXPECT_EQ(kTestCases[i].misspelling_start, misspelling_start);
     EXPECT_EQ(kTestCases[i].misspelling_length, misspelling_length);
   }
 }
 
 
@@ skipping 77 matching lines @@
     {L"changable", false, 0,0,L"changeable"},
     {L"cheif", false, 0,0,L"chief"},
     {L"citezen", false, 0,0,L"citizen"},
     {L"collaegue", false, 0,0,L"colleague"},
     {L"colum", false, 0,0,L"column"},
     {L"comming", false, 0,0,L"coming"},
     {L"commited", false, 0,0,L"committed"},
     {L"compitition", false, 0,0,L"competition"},
     {L"conceed", false, 0,0,L"concede"},
     {L"congradulate", false, 0,0,L"congratulate"},
-    // TODO(pwicks): This fails as a result of 13432.
-    // Once that is fixed, uncomment this.
-    // {L"consciencious", false, 0,0,L"conscientious"},
+    {L"consciencious", false, 0, 0, L"conscientious"},
     {L"concious", false, 0,0,L"conscious"},
     {L"concensus", false, 0,0,L"consensus"},
     {L"contraversy", false, 0,0,L"controversy"},
     {L"conveniance", false, 0,0,L"convenience"},
     {L"critecize", false, 0,0,L"criticize"},
     {L"dacquiri", false, 0,0,L"daiquiri"},
     {L"decieve", false, 0,0,L"deceive"},
     {L"dicide", false, 0,0,L"decide"},
     {L"definate", false, 0,0,L"definite"},
     {L"definitly", false, 0,0,L"definitely"},
@@ skipping 52 matching lines @@
     {L"hygene", false, 0,0,L"hygiene"},
     {L"hipocrit", false, 0,0,L"hypocrite"},
     {L"idenity", false, 0,0,L"identity"},
     {L"ignorence", false, 0,0,L"ignorance"},
     {L"imaginery", false, 0,0,L"imaginary"},
     {L"immitate", false, 0,0,L"imitate"},
     {L"immitation", false, 0,0,L"imitation"},
     {L"imediately", false, 0,0,L"immediately"},
     {L"incidently", false, 0,0,L"incidentally"},
     {L"independant", false, 0,0,L"independent"},
-    // TODO(pwicks): This fails as a result of 13432.
-    // Once that is fixed, uncomment this.
-    // {L"indispensible", false, 0,0,L"indispensable"},
+    {L"indispensible", false, 0, 0, L"indispensable"},
     {L"innoculate", false, 0,0,L"inoculate"},
     {L"inteligence", false, 0,0,L"intelligence"},
     {L"intresting", false, 0,0,L"interesting"},
     {L"interuption", false, 0,0,L"interruption"},
     {L"irrelevent", false, 0,0,L"irrelevant"},
     {L"irritible", false, 0,0,L"irritable"},
     {L"iland", false, 0,0,L"island"},
     {L"jellous", false, 0,0,L"jealous"},
     {L"knowlege", false, 0,0,L"knowledge"},
     {L"labratory", false, 0,0,L"laboratory"},
@@ skipping 58 matching lines @@
     {L"practicle", false, 0,0,L"practical"},
     {L"preceed", false, 0,0,L"precede"},
     {L"predjudice", false, 0,0,L"prejudice"},
     {L"presance", false, 0,0,L"presence"},
     {L"privelege", false, 0,0,L"privilege"},
     // This one should probably work. It does in FF and Hunspell.
     // {L"probly", false, 0,0,L"probably"},
     {L"proffesional", false, 0,0,L"professional"},
     {L"professer", false, 0,0,L"professor"},
     {L"promiss", false, 0,0,L"promise"},
-    // TODO(pwicks): This fails as a result of 13432.
-    // Once that is fixed, uncomment this.
-    // {L"pronounciation", false, 0,0,L"pronunciation"},
+    {L"pronounciation", false, 0, 0, L"pronunciation"},
     {L"prufe", false, 0,0,L"proof"},
     {L"psycology", false, 0,0,L"psychology"},
     {L"publically", false, 0,0,L"publicly"},
     {L"quanity", false, 0,0,L"quantity"},
     {L"quarentine", false, 0,0,L"quarantine"},
     {L"questionaire", false, 0,0,L"questionnaire"},
     {L"readible", false, 0,0,L"readable"},
     {L"realy", false, 0,0,L"really"},
     {L"recieve", false, 0,0,L"receive"},
     {L"reciept", false, 0,0,L"receipt"},
@@ skipping 75 matching lines @@
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kTestCases); ++i) {
     std::vector<std::wstring> suggestions;
     size_t input_length = 0;
     if (kTestCases[i].input != NULL) {
       input_length = wcslen(kTestCases[i].input);
     }
     int misspelling_start;
     int misspelling_length;
     bool result = spell_checker->SpellCheckWord(kTestCases[i].input,
                                                 static_cast<int>(input_length),
+                                                0,
                                                 &misspelling_start,
                                                 &misspelling_length,
                                                 &suggestions);
 
     // Check for spelling.
     EXPECT_EQ(kTestCases[i].expected_result, result);
 
     // Check if the suggested words occur.
     bool suggested_word_is_present = false;
     for (int j=0; j < static_cast<int>(suggestions.size()); j++) {
@@ skipping 248 matching lines @@
         hunspell_directory, kTestCases[i].language, NULL, FilePath()));
 
     size_t input_length = 0;
     if (kTestCases[i].input != NULL)
       input_length = wcslen(kTestCases[i].input);
 
     int misspelling_start = 0;
     int misspelling_length = 0;
     bool result = spell_checker->SpellCheckWord(kTestCases[i].input,
                                                 static_cast<int>(input_length),
+                                                0,
                                                 &misspelling_start,
                                                 &misspelling_length, NULL);
 
     EXPECT_EQ(true, result) << kTestCases[i].language;
     EXPECT_EQ(0, misspelling_start);
     EXPECT_EQ(0, misspelling_length);
   }
 }
 
 // This test Adds words to the SpellChecker and veifies that it remembers them.
@@ skipping 21 matching lines @@
     // Now check whether it is added to Spellchecker.
     std::vector<std::wstring> suggestions;
     size_t input_length = 0;
     if (kTestCases[i].word_to_add != NULL) {
       input_length = wcslen(kTestCases[i].word_to_add);
     }
     int misspelling_start;
     int misspelling_length;
     bool result = spell_checker->SpellCheckWord(kTestCases[i].word_to_add,
                                                 static_cast<int>(input_length),
+                                                0,
                                                 &misspelling_start,
                                                 &misspelling_length,
                                                 &suggestions);
 
     // Check for spelling.
     EXPECT_TRUE(result);
   }
 
   // Now initialize another spellchecker to see that AddToWord is permanent.
   scoped_refptr<SpellChecker> spell_checker_new(new SpellChecker(
       hunspell_directory, "en-US", NULL, custom_dictionary_file));
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kTestCases); ++i) {
     // Now check whether it is added to Spellchecker.
     std::vector<std::wstring> suggestions;
     size_t input_length = 0;
     if (kTestCases[i].word_to_add != NULL) {
       input_length = wcslen(kTestCases[i].word_to_add);
     }
     int misspelling_start;
     int misspelling_length;
     bool result = spell_checker_new->SpellCheckWord(
         kTestCases[i].word_to_add,
         static_cast<int>(input_length),
+        0,
         &misspelling_start,
         &misspelling_length,
         &suggestions);
 
     // Check for spelling.
     EXPECT_TRUE(result);
   }
 
   // Remove the temp custom dictionary file.
   file_util::Delete(custom_dictionary_file, false);
@@ skipping 46 matching lines @@
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kTestCasesToBeTested); ++i) {
     std::vector<std::wstring> suggestions;
     size_t input_length = 0;
     if (kTestCasesToBeTested[i].input != NULL) {
       input_length = wcslen(kTestCasesToBeTested[i].input);
     }
     int misspelling_start;
     int misspelling_length;
     bool result = spell_checker->SpellCheckWord(kTestCasesToBeTested[i].input,
                                                 static_cast<int>(input_length),
+                                                0,
                                                 &misspelling_start,
                                                 &misspelling_length,
                                                 &suggestions);
 
     // Check for spelling.
     EXPECT_EQ(result, kTestCasesToBeTested[i].expected_result);
 
     // Check if the suggested words occur.
     bool suggested_word_is_present = false;
     for (int j=0; j < static_cast<int>(suggestions.size()); j++) {
@@ skipping 31 matching lines @@
   ASSERT_FALSE(hunspell_directory.empty());
 
   scoped_refptr<SpellChecker> spell_checker(new SpellChecker(
       hunspell_directory, "en-US", NULL, FilePath()));
   spell_checker->EnableAutoSpellCorrect(true);
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kTestCases); ++i) {
     std::wstring misspelled_word(kTestCases[i].input);
     std::wstring expected_autocorrect_word(kTestCases[i].expected_result);
     std::wstring autocorrect_word;
-    spell_checker->GetAutoCorrectionWord(misspelled_word, &autocorrect_word);
+    spell_checker->GetAutoCorrectionWord(misspelled_word, 0, &autocorrect_word);
 
     // Check for spelling.
     EXPECT_EQ(expected_autocorrect_word, autocorrect_word);
   }
 }
+
+#if defined(OS_MACOSX)
+// Tests that words are properly ignored. Currently only enabled on OS X as it
+// is the only platform to support ignoring words. Note that in this test, we
+// supply a non-zero doc_tag, in order to test that ignored words are matched to
+// the correct document.
+TEST_F(SpellCheckTest, IgnoreWords_EN_US) {
+  static const struct {
+    // A misspelled word.
+    const wchar_t* input;
+    bool input_result;
+    } kTestCases[] = {
+    {L"teh",false},
+    {L"moer", false},
+    {L"watre",false},
+    {L"noen", false},
+    };
+
+  FilePath hunspell_directory = GetHunspellDirectory();
+  ASSERT_FALSE(hunspell_directory.empty());
+
+  scoped_refptr<SpellChecker> spell_checker(new SpellChecker(
+      hunspell_directory, "en-US", NULL, FilePath()));
+
+  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kTestCases); ++i) {
+    std::wstring word(kTestCases[i].input);
+    std::string misspelled_word = base::SysWideToUTF8(word);
+    std::vector<std::wstring> suggestions;
+    size_t input_length = 0;
+    if (kTestCases[i].input != NULL) {
+      input_length = wcslen(kTestCases[i].input);
+    }
+    int misspelling_start;
+    int misspelling_length;
+
+    int doc_tag = SpellCheckerPlatform::GetDocumentTag();
+    bool result = spell_checker->SpellCheckWord(kTestCases[i].input,
+                                                static_cast<int>(input_length),
+                                                doc_tag,
+                                                &misspelling_start,
+                                                &misspelling_length,
+                                                &suggestions);
+
+    // The word should show up as misspelled.
+    EXPECT_EQ(kTestCases[i].input_result, result);
+
+    // Ignore the word.
+    SpellCheckerPlatform::IgnoreWord(misspelled_word);
+
+    // Spellcheck again.
+    result = spell_checker->SpellCheckWord(kTestCases[i].input,
+                                           static_cast<int>(input_length),
+                                           doc_tag,
+                                           &misspelling_start,
+                                           &misspelling_length,
+                                           &suggestions);
+
+    // The word should now show up as correctly spelled.
+    EXPECT_EQ(!(kTestCases[i].input_result), result);
+
+    // Close the docuemnt. Any words that we had previously ignored should no
+    // longer be ignored and thus should show up as misspelled.
+    SpellCheckerPlatform::CloseDocumentWithTag(doc_tag);
+
+    // Spellcheck one more time.
+    result = spell_checker->SpellCheckWord(kTestCases[i].input,
+                                           static_cast<int>(input_length),
+                                           doc_tag,
+                                           &misspelling_start,
+                                           &misspelling_length,
+                                           &suggestions);
+
+    // The word should now show be spelled wrong again
+    EXPECT_EQ(kTestCases[i].input_result, result);
+  }
+} // Test IgnoreWords_EN_US
+#endif // OS_MACOSX