chrome/renderer/spellchecker/spellcheck_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 "webkit/glue/webkit_glue.h"
   6
   7 #include "base/file_util.h"
   8 #include "base/message_loop/message_loop.h"
   9 #include "base/path_service.h"
  10 #include "base/platform_file.h"
  11 #include "base/strings/sys_string_conversions.h"
  12 #include "base/strings/utf_string_conversions.h"
  13 #include "chrome/common/chrome_paths.h"
  14 #include "chrome/common/spellcheck_common.h"
  15 #include "chrome/common/spellcheck_result.h"
  16 #include "chrome/renderer/spellchecker/hunspell_engine.h"
  17 #include "chrome/renderer/spellchecker/spellcheck.h"
  18 #include "testing/gtest/include/gtest/gtest.h"
  19 #include "third_party/WebKit/public/web/WebTextCheckingCompletion.h"
  20 #include "third_party/WebKit/public/web/WebTextCheckingResult.h"
  21 #include "ui/base/l10n/l10n_util.h"
  22
  23 namespace {
  24
  25 base::FilePath GetHunspellDirectory() {
  26   base::FilePath hunspell_directory;
  27   if (!PathService::Get(base::DIR_SOURCE_ROOT, &hunspell_directory))
  28     return base::FilePath();
  29
  30   hunspell_directory = hunspell_directory.AppendASCII("third_party");
  31   hunspell_directory = hunspell_directory.AppendASCII("hunspell_dictionaries");
  32   return hunspell_directory;
  33 }
  34
  35 }  // namespace
  36
  37 // TODO(groby): This needs to be a BrowserTest for OSX.
  38 class SpellCheckTest : public testing::Test {
  39  public:
  40   SpellCheckTest() {
  41     ReinitializeSpellCheck("en-US");
  42   }
  43
  44   void ReinitializeSpellCheck(const std::string& language) {
  45     spell_check_.reset(new SpellCheck());
  46     InitializeSpellCheck(language);
  47   }
  48
  49   void UninitializeSpellCheck() {
  50     spell_check_.reset(new SpellCheck());
  51   }
  52
  53   bool InitializeIfNeeded() {
  54     return spell_check()->InitializeIfNeeded();
  55   }
  56
  57   void InitializeSpellCheck(const std::string& language) {
  58     base::FilePath hunspell_directory = GetHunspellDirectory();
  59     EXPECT_FALSE(hunspell_directory.empty());
  60     base::PlatformFile file = base::CreatePlatformFile(
  61         chrome::spellcheck_common::GetVersionedFileName(language,
  62             hunspell_directory),
  63         base::PLATFORM_FILE_OPEN | base::PLATFORM_FILE_READ, NULL, NULL);
  64 #if defined(OS_MACOSX)
  65     // TODO(groby): Forcing spellcheck to use hunspell, even on OSX.
  66     // Instead, tests should exercise individual spelling engines.
  67     spell_check_->spellcheck_.platform_spelling_engine_.reset(
  68         new HunspellEngine);
  69 #endif
  70     spell_check_->Init(file, std::set<std::string>(), language);
  71   }
  72
  73   void EnableAutoCorrect(bool enable_autocorrect) {
  74     spell_check_->OnEnableAutoSpellCorrect(enable_autocorrect);
  75   }
  76
  77   virtual ~SpellCheckTest() {
  78   }
  79
  80   SpellCheck* spell_check() { return spell_check_.get(); }
  81
  82   bool CheckSpelling(const std::string& word, int tag) {
  83     return spell_check_->spellcheck_.platform_spelling_engine_->CheckSpelling(
  84         ASCIIToUTF16(word), tag);
  85   }
  86
  87 #if !defined(OS_MACOSX)
  88  protected:
  89   void TestSpellCheckParagraph(
  90       const string16& input,
  91       const std::vector<SpellCheckResult>& expected) {
  92     WebKit::WebVector<WebKit::WebTextCheckingResult> results;
  93     spell_check()->SpellCheckParagraph(input,
  94                                        &results);
  95
  96     EXPECT_EQ(results.size(), expected.size());
  97     size_t size = std::min(results.size(), expected.size());
  98     for (size_t j = 0; j < size; ++j) {
  99       EXPECT_EQ(results[j].type, WebKit::WebTextCheckingTypeSpelling);
 100       EXPECT_EQ(results[j].location, expected[j].location);
 101       EXPECT_EQ(results[j].length, expected[j].length);
 102     }
 103   }
 104 #endif
 105
 106  private:
 107   scoped_ptr<SpellCheck> spell_check_;
 108   base::MessageLoop loop;
 109 };
 110
 111 // A fake completion object for verification.
 112 class MockTextCheckingCompletion : public WebKit::WebTextCheckingCompletion {
 113  public:
 114   MockTextCheckingCompletion()
 115       : completion_count_(0) {
 116   }
 117
 118   virtual void didFinishCheckingText(
 119       const WebKit::WebVector<WebKit::WebTextCheckingResult>& results)
 120           OVERRIDE {
 121     completion_count_++;
 122     last_results_ = results;
 123   }
 124
 125   virtual void didCancelCheckingText() OVERRIDE {
 126     completion_count_++;
 127   }
 128
 129   size_t completion_count_;
 130   WebKit::WebVector<WebKit::WebTextCheckingResult> last_results_;
 131 };
 132
 133 // Operates unit tests for the webkit_glue::SpellCheckWord() function
 134 // with the US English dictionary.
 135 // The unit tests in this function consist of:
 136 //   * Tests for the function with empty strings;
 137 //   * Tests for the function with a valid English word;
 138 //   * Tests for the function with a valid non-English word;
 139 //   * Tests for the function with a valid English word with a preceding
 140 //     space character;
 141 //   * Tests for the function with a valid English word with a preceding
 142 //     non-English word;
 143 //   * Tests for the function with a valid English word with a following
 144 //     space character;
 145 //   * Tests for the function with a valid English word with a following
 146 //     non-English word;
 147 //   * Tests for the function with two valid English words concatenated
 148 //     with space characters or non-English words;
 149 //   * Tests for the function with an invalid English word;
 150 //   * Tests for the function with an invalid English word with a preceding
 151 //     space character;
 152 //   * Tests for the function with an invalid English word with a preceding
 153 //     non-English word;
 154 //   * Tests for the function with an invalid English word with a following
 155 //     space character;
 156 //   * Tests for the function with an invalid English word with a following
 157 //     non-English word, and;
 158 //   * Tests for the function with two invalid English words concatenated
 159 //     with space characters or non-English words.
 160 // A test with a "[ROBUSTNESS]" mark shows it is a robustness test and it uses
 161 // grammatically incorrect string.
 162 // TODO(groby): Please feel free to add more tests.
 163 TEST_F(SpellCheckTest, SpellCheckStrings_EN_US) {
 164   static const struct {
 165     // A string to be tested.
 166     const wchar_t* input;
 167     // An expected result for this test case.
 168     //   * true: the input string does not have any invalid words.
 169     //   * false: the input string has one or more invalid words.
 170     bool expected_result;
 171     // The position and the length of the first invalid word.
 172     int misspelling_start;
 173     int misspelling_length;
 174   } kTestCases[] = {
 175     // Empty strings.
 176     {L"", true},
 177     {L" ", true},
 178     {L"\xA0", true},
 179     {L"\x3000", true},
 180
 181     // A valid English word "hello".
 182     {L"hello", true},
 183     // A valid Chinese word (meaning "hello") consisting of two CJKV
 184     // ideographs
 185     {L"\x4F60\x597D", true},
 186     // A valid Korean word (meaning "hello") consisting of five hangul
 187     // syllables
 188     {L"\xC548\xB155\xD558\xC138\xC694", true},
 189     // A valid Japanese word (meaning "hello") consisting of five Hiragana
 190     // letters
 191     {L"\x3053\x3093\x306B\x3061\x306F", true},
 192     // A valid Hindi word (meaning ?) consisting of six Devanagari letters
 193     // (This word is copied from "http://b/issue?id=857583".)
 194     {L"\x0930\x093E\x091C\x0927\x093E\x0928", true},
 195     // A valid English word "affix" using a Latin ligature 'ffi'
 196     {L"a\xFB03x", true},
 197     // A valid English word "hello" (fullwidth version)
 198     {L"\xFF28\xFF45\xFF4C\xFF4C\xFF4F", true},
 199     // Two valid Greek words (meaning "hello") consisting of seven Greek
 200     // letters
 201     {L"\x03B3\x03B5\x03B9\x03AC" L" " L"\x03C3\x03BF\x03C5", true},
 202     // A valid Russian word (meaning "hello") consisting of twelve Cyrillic
 203     // letters
 204     {L"\x0437\x0434\x0440\x0430\x0432\x0441"
 205      L"\x0442\x0432\x0443\x0439\x0442\x0435", true},
 206     // A valid English contraction
 207     {L"isn't", true},
 208     // A valid English word enclosed with underscores.
 209     {L"_hello_", true},
 210
 211     // A valid English word with a preceding whitespace
 212     {L" " L"hello", true},
 213     // A valid English word with a preceding no-break space
 214     {L"\xA0" L"hello", true},
 215     // A valid English word with a preceding ideographic space
 216     {L"\x3000" L"hello", true},
 217     // A valid English word with a preceding Chinese word
 218     {L"\x4F60\x597D" L"hello", true},
 219     // [ROBUSTNESS] A valid English word with a preceding Korean word
 220     {L"\xC548\xB155\xD558\xC138\xC694" L"hello", true},
 221     // A valid English word with a preceding Japanese word
 222     {L"\x3053\x3093\x306B\x3061\x306F" L"hello", true},
 223     // [ROBUSTNESS] A valid English word with a preceding Hindi word
 224     {L"\x0930\x093E\x091C\x0927\x093E\x0928" L"hello", true},
 225     // [ROBUSTNESS] A valid English word with two preceding Greek words
 226     {L"\x03B3\x03B5\x03B9\x03AC" L" " L"\x03C3\x03BF\x03C5"
 227      L"hello", true},
 228     // [ROBUSTNESS] A valid English word with a preceding Russian word
 229     {L"\x0437\x0434\x0440\x0430\x0432\x0441"
 230      L"\x0442\x0432\x0443\x0439\x0442\x0435" L"hello", true},
 231
 232     // A valid English word with a following whitespace
 233     {L"hello" L" ", true},
 234     // A valid English word with a following no-break space
 235     {L"hello" L"\xA0", true},
 236     // A valid English word with a following ideographic space
 237     {L"hello" L"\x3000", true},
 238     // A valid English word with a following Chinese word
 239     {L"hello" L"\x4F60\x597D", true},
 240     // [ROBUSTNESS] A valid English word with a following Korean word
 241     {L"hello" L"\xC548\xB155\xD558\xC138\xC694", true},
 242     // A valid English word with a following Japanese word
 243     {L"hello" L"\x3053\x3093\x306B\x3061\x306F", true},
 244     // [ROBUSTNESS] A valid English word with a following Hindi word
 245     {L"hello" L"\x0930\x093E\x091C\x0927\x093E\x0928", true},
 246     // [ROBUSTNESS] A valid English word with two following Greek words
 247     {L"hello"
 248      L"\x03B3\x03B5\x03B9\x03AC" L" " L"\x03C3\x03BF\x03C5", true},
 249     // [ROBUSTNESS] A valid English word with a following Russian word
 250     {L"hello" L"\x0437\x0434\x0440\x0430\x0432\x0441"
 251      L"\x0442\x0432\x0443\x0439\x0442\x0435", true},
 252
 253     // Two valid English words concatenated with a whitespace
 254     {L"hello" L" " L"hello", true},
 255     // Two valid English words concatenated with a no-break space
 256     {L"hello" L"\xA0" L"hello", true},
 257     // Two valid English words concatenated with an ideographic space
 258     {L"hello" L"\x3000" L"hello", true},
 259     // Two valid English words concatenated with a Chinese word
 260     {L"hello" L"\x4F60\x597D" L"hello", true},
 261     // [ROBUSTNESS] Two valid English words concatenated with a Korean word
 262     {L"hello" L"\xC548\xB155\xD558\xC138\xC694" L"hello", true},
 263     // Two valid English words concatenated with a Japanese word
 264     {L"hello" L"\x3053\x3093\x306B\x3061\x306F" L"hello", true},
 265     // [ROBUSTNESS] Two valid English words concatenated with a Hindi word
 266     {L"hello" L"\x0930\x093E\x091C\x0927\x093E\x0928" L"hello" , true},
 267     // [ROBUSTNESS] Two valid English words concatenated with two Greek words
 268     {L"hello" L"\x03B3\x03B5\x03B9\x03AC" L" " L"\x03C3\x03BF\x03C5"
 269      L"hello", true},
 270     // [ROBUSTNESS] Two valid English words concatenated with a Russian word
 271     {L"hello" L"\x0437\x0434\x0440\x0430\x0432\x0441"
 272      L"\x0442\x0432\x0443\x0439\x0442\x0435" L"hello", true},
 273     // [ROBUSTNESS] Two valid English words concatenated with a contraction
 274     // character.
 275     {L"hello:hello", true},
 276
 277     // An invalid English word
 278     {L"ifmmp", false, 0, 5},
 279     // An invalid English word "bffly" containing a Latin ligature 'ffl'
 280     {L"b\xFB04y", false, 0, 3},
 281     // An invalid English word "ifmmp" (fullwidth version)
 282     {L"\xFF29\xFF46\xFF4D\xFF4D\xFF50", false, 0, 5},
 283     // An invalid English contraction
 284     {L"jtm'u", false, 0, 5},
 285     // An invalid English word enclosed with underscores.
 286     {L"_ifmmp_", false, 1, 5},
 287
 288     // An invalid English word with a preceding whitespace
 289     {L" " L"ifmmp", false, 1, 5},
 290     // An invalid English word with a preceding no-break space
 291     {L"\xA0" L"ifmmp", false, 1, 5},
 292     // An invalid English word with a preceding ideographic space
 293     {L"\x3000" L"ifmmp", false, 1, 5},
 294     // An invalid English word with a preceding Chinese word
 295     {L"\x4F60\x597D" L"ifmmp", false, 2, 5},
 296     // [ROBUSTNESS] An invalid English word with a preceding Korean word
 297     {L"\xC548\xB155\xD558\xC138\xC694" L"ifmmp", false, 5, 5},
 298     // An invalid English word with a preceding Japanese word
 299     {L"\x3053\x3093\x306B\x3061\x306F" L"ifmmp", false, 5, 5},
 300     // [ROBUSTNESS] An invalid English word with a preceding Hindi word
 301     {L"\x0930\x093E\x091C\x0927\x093E\x0928" L"ifmmp", false, 6, 5},
 302     // [ROBUSTNESS] An invalid English word with two preceding Greek words
 303     {L"\x03B3\x03B5\x03B9\x03AC" L" " L"\x03C3\x03BF\x03C5"
 304      L"ifmmp", false, 8, 5},
 305     // [ROBUSTNESS] An invalid English word with a preceding Russian word
 306     {L"\x0437\x0434\x0440\x0430\x0432\x0441"
 307      L"\x0442\x0432\x0443\x0439\x0442\x0435" L"ifmmp", false, 12, 5},
 308
 309     // An invalid English word with a following whitespace
 310     {L"ifmmp" L" ", false, 0, 5},
 311     // An invalid English word with a following no-break space
 312     {L"ifmmp" L"\xA0", false, 0, 5},
 313     // An invalid English word with a following ideographic space
 314     {L"ifmmp" L"\x3000", false, 0, 5},
 315     // An invalid English word with a following Chinese word
 316     {L"ifmmp" L"\x4F60\x597D", false, 0, 5},
 317     // [ROBUSTNESS] An invalid English word with a following Korean word
 318     {L"ifmmp" L"\xC548\xB155\xD558\xC138\xC694", false, 0, 5},
 319     // An invalid English word with a following Japanese word
 320     {L"ifmmp" L"\x3053\x3093\x306B\x3061\x306F", false, 0, 5},
 321     // [ROBUSTNESS] An invalid English word with a following Hindi word
 322     {L"ifmmp" L"\x0930\x093E\x091C\x0927\x093E\x0928", false, 0, 5},
 323     // [ROBUSTNESS] An invalid English word with two following Greek words
 324     {L"ifmmp"
 325      L"\x03B3\x03B5\x03B9\x03AC" L" " L"\x03C3\x03BF\x03C5", false, 0, 5},
 326     // [ROBUSTNESS] An invalid English word with a following Russian word
 327     {L"ifmmp" L"\x0437\x0434\x0440\x0430\x0432\x0441"
 328      L"\x0442\x0432\x0443\x0439\x0442\x0435", false, 0, 5},
 329
 330     // Two invalid English words concatenated with a whitespace
 331     {L"ifmmp" L" " L"ifmmp", false, 0, 5},
 332     // Two invalid English words concatenated with a no-break space
 333     {L"ifmmp" L"\xA0" L"ifmmp", false, 0, 5},
 334     // Two invalid English words concatenated with an ideographic space
 335     {L"ifmmp" L"\x3000" L"ifmmp", false, 0, 5},
 336     // Two invalid English words concatenated with a Chinese word
 337     {L"ifmmp" L"\x4F60\x597D" L"ifmmp", false, 0, 5},
 338     // [ROBUSTNESS] Two invalid English words concatenated with a Korean word
 339     {L"ifmmp" L"\xC548\xB155\xD558\xC138\xC694" L"ifmmp", false, 0, 5},
 340     // Two invalid English words concatenated with a Japanese word
 341     {L"ifmmp" L"\x3053\x3093\x306B\x3061\x306F" L"ifmmp", false, 0, 5},
 342     // [ROBUSTNESS] Two invalid English words concatenated with a Hindi word
 343     {L"ifmmp" L"\x0930\x093E\x091C\x0927\x093E\x0928" L"ifmmp" , false, 0, 5},
 344     // [ROBUSTNESS] Two invalid English words concatenated with two Greek words
 345     {L"ifmmp" L"\x03B3\x03B5\x03B9\x03AC" L" " L"\x03C3\x03BF\x03C5"
 346      L"ifmmp", false, 0, 5},
 347     // [ROBUSTNESS] Two invalid English words concatenated with a Russian word
 348     {L"ifmmp" L"\x0437\x0434\x0440\x0430\x0432\x0441"
 349      L"\x0442\x0432\x0443\x0439\x0442\x0435" L"ifmmp", false, 0, 5},
 350     // [ROBUSTNESS] Two invalid English words concatenated with a contraction
 351     // character.
 352     {L"ifmmp:ifmmp", false, 0, 11},
 353
 354     // [REGRESSION] Issue 13432: "Any word of 13 or 14 characters is not
 355     // spellcheck" <http://crbug.com/13432>.
 356     {L"qwertyuiopasd", false, 0, 13},
 357     {L"qwertyuiopasdf", false, 0, 14},
 358
 359     // [REGRESSION] Issue 128896: "en_US hunspell dictionary includes
 360     // acknowledgement but not acknowledgements" <http://crbug.com/128896>
 361     {L"acknowledgement", true},
 362     {L"acknowledgements", true},
 363
 364     // Issue 123290: "Spellchecker should treat numbers as word characters"
 365     {L"0th", true},
 366     {L"1st", true},
 367     {L"2nd", true},
 368     {L"3rd", true},
 369     {L"4th", true},
 370     {L"5th", true},
 371     {L"6th", true},
 372     {L"7th", true},
 373     {L"8th", true},
 374     {L"9th", true},
 375     {L"10th", true},
 376     {L"100th", true},
 377     {L"1000th", true},
 378     {L"25", true},
 379     {L"2012", true},
 380     {L"100,000,000", true},
 381     {L"3.141592653", true},
 382
 383   };
 384
 385   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kTestCases); ++i) {
 386     size_t input_length = 0;
 387     if (kTestCases[i].input != NULL) {
 388       input_length = wcslen(kTestCases[i].input);
 389     }
 390     int misspelling_start;
 391     int misspelling_length;
 392     bool result = spell_check()->SpellCheckWord(
 393         WideToUTF16(kTestCases[i].input).c_str(),
 394         static_cast<int>(input_length),
 395         0,
 396         &misspelling_start,
 397         &misspelling_length, NULL);
 398
 399     EXPECT_EQ(kTestCases[i].expected_result, result);
 400     EXPECT_EQ(kTestCases[i].misspelling_start, misspelling_start);
 401     EXPECT_EQ(kTestCases[i].misspelling_length, misspelling_length);
 402   }
 403 }
 404
 405 TEST_F(SpellCheckTest, SpellCheckSuggestions_EN_US) {
 406   static const struct {
 407     // A string to be tested.
 408     const wchar_t* input;
 409     // An expected result for this test case.
 410     //   * true: the input string does not have any invalid words.
 411     //   * false: the input string has one or more invalid words.
 412     bool expected_result;
 413     // The position and the length of the first invalid word.
 414     int misspelling_start;
 415     int misspelling_length;
 416
 417     // A suggested word that should occur.
 418     const wchar_t* suggested_word;
 419   } kTestCases[] = {
 420     {L"ello", false, 0, 0, L"hello"},
 421     {L"ello", false, 0, 0, L"cello"},
 422     {L"wate", false, 0, 0, L"water"},
 423     {L"wate", false, 0, 0, L"waste"},
 424     {L"wate", false, 0, 0, L"sate"},
 425     {L"wate", false, 0, 0, L"ate"},
 426     {L"jum", false, 0, 0, L"jump"},
 427     {L"jum", false, 0, 0, L"hum"},
 428     {L"jum", false, 0, 0, L"sum"},
 429     {L"jum", false, 0, 0, L"um"},
 430     // A regression test for Issue 36523.
 431     {L"privliged", false, 0, 0, L"privileged"},
 432     // TODO (Sidchat): add many more examples.
 433   };
 434
 435   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kTestCases); ++i) {
 436     std::vector<string16> suggestions;
 437     size_t input_length = 0;
 438     if (kTestCases[i].input != NULL) {
 439       input_length = wcslen(kTestCases[i].input);
 440     }
 441     int misspelling_start;
 442     int misspelling_length;
 443     bool result = spell_check()->SpellCheckWord(
 444         WideToUTF16(kTestCases[i].input).c_str(),
 445         static_cast<int>(input_length),
 446         0,
 447         &misspelling_start,
 448         &misspelling_length,
 449         &suggestions);
 450
 451     // Check for spelling.
 452     EXPECT_EQ(kTestCases[i].expected_result, result);
 453
 454     // Check if the suggested words occur.
 455     bool suggested_word_is_present = false;
 456     for (int j = 0; j < static_cast<int>(suggestions.size()); j++) {
 457       if (suggestions.at(j).compare(WideToUTF16(kTestCases[i].suggested_word))
 458           == 0) {
 459         suggested_word_is_present = true;
 460         break;
 461       }
 462     }
 463
 464     EXPECT_TRUE(suggested_word_is_present);
 465   }
 466 }
 467
 468 // This test verifies our spellchecker can split a text into words and check
 469 // the spelling of each word in the text.
 470 #if defined(THREAD_SANITIZER)
 471 // SpellCheckTest.SpellCheckText fails under ThreadSanitizer v2.
 472 // See http://crbug.com/217909.
 473 #define MAYBE_SpellCheckText DISABLED_SpellCheckText
 474 #else
 475 #define MAYBE_SpellCheckText SpellCheckText
 476 #endif  // THREAD_SANITIZER
 477 TEST_F(SpellCheckTest, MAYBE_SpellCheckText) {
 478   static const struct {
 479     const char* language;
 480     const wchar_t* input;
 481   } kTestCases[] = {
 482     {
 483       // Afrikaans
 484       "af-ZA",
 485       L"Google se missie is om die w\x00EAreld se inligting te organiseer en "
 486       L"dit bruikbaar en toeganklik te maak."
 487     }, {
 488       // Catalan
 489       "ca-ES",
 490       L"La missi\x00F3 de Google \x00E9s organitzar la informaci\x00F3 "
 491       L"del m\x00F3n i fer que sigui \x00FAtil i accessible universalment."
 492     }, {
 493       // Czech
 494       "cs-CZ",
 495       L"Posl\x00E1n\x00EDm spole\x010Dnosti Google je "
 496       L"uspo\x0159\x00E1\x0064\x0061t informace z cel\x00E9ho sv\x011Bta "
 497       L"tak, aby byly v\x0161\x0065obecn\x011B p\x0159\x00EDstupn\x00E9 "
 498       L"a u\x017Eite\x010Dn\x00E9."
 499     }, {
 500       // Danish
 501       "da-DK",
 502       L"Googles "
 503       L"mission er at organisere verdens information og g\x00F8re den "
 504       L"almindeligt tilg\x00E6ngelig og nyttig."
 505     }, {
 506       // German
 507       "de-DE",
 508       L"Das Ziel von Google besteht darin, die auf der Welt vorhandenen "
 509       L"Informationen zu organisieren und allgemein zug\x00E4nglich und "
 510       L"nutzbar zu machen."
 511     }, {
 512       // Greek
 513       "el-GR",
 514       L"\x0391\x03C0\x03BF\x03C3\x03C4\x03BF\x03BB\x03AE "
 515       L"\x03C4\x03B7\x03C2 Google \x03B5\x03AF\x03BD\x03B1\x03B9 "
 516       L"\x03BD\x03B1 \x03BF\x03C1\x03B3\x03B1\x03BD\x03CE\x03BD\x03B5\x03B9 "
 517       L"\x03C4\x03B9\x03C2 "
 518       L"\x03C0\x03BB\x03B7\x03C1\x03BF\x03C6\x03BF\x03C1\x03AF\x03B5\x03C2 "
 519       L"\x03C4\x03BF\x03C5 \x03BA\x03CC\x03C3\x03BC\x03BF\x03C5 "
 520       L"\x03BA\x03B1\x03B9 \x03BD\x03B1 \x03C4\x03B9\x03C2 "
 521       L"\x03BA\x03B1\x03B8\x03B9\x03C3\x03C4\x03AC "
 522       L"\x03C0\x03C1\x03BF\x03C3\x03B2\x03AC\x03C3\x03B9\x03BC\x03B5\x03C2 "
 523       L"\x03BA\x03B1\x03B9 \x03C7\x03C1\x03AE\x03C3\x03B9\x03BC\x03B5\x03C2."
 524     }, {
 525       // English (Australia)
 526       "en-AU",
 527       L"Google's mission is to organise the world's information and make it "
 528       L"universally accessible and useful."
 529     }, {
 530       // English (Canada)
 531       "en-CA",
 532       L"Google's mission is to organize the world's information and make it "
 533       L"universally accessible and useful."
 534     }, {
 535       // English (United Kingdom)
 536       "en-GB",
 537       L"Google's mission is to organise the world's information and make it "
 538       L"universally accessible and useful."
 539     }, {
 540       // English (United States)
 541       "en-US",
 542       L"Google's mission is to organize the world's information and make it "
 543       L"universally accessible and useful."
 544     }, {
 545       // Bulgarian
 546       "bg-BG",
 547       L"\x041c\x0438\x0441\x0438\x044f\x0442\x0430 "
 548       L"\x043d\x0430 Google \x0435 \x0434\x0430 \x043e"
 549       L"\x0440\x0433\x0430\x043d\x0438\x0437\x0438\x0440"
 550       L"\x0430 \x0441\x0432\x0435\x0442\x043e\x0432"
 551       L"\x043d\x0430\x0442\x0430 \x0438\x043d\x0444"
 552       L"\x043e\x0440\x043c\x0430\x0446\x0438\x044f "
 553       L"\x0438 \x0434\x0430 \x044f \x043d"
 554       L"\x0430\x043f\x0440\x0430\x0432\x0438 \x0443"
 555       L"\x043d\x0438\x0432\x0435\x0440\x0441\x0430\x043b"
 556       L"\x043d\x043e \x0434\x043e\x0441\x0442\x044a"
 557       L"\x043f\x043d\x0430 \x0438 \x043f\x043e"
 558       L"\x043b\x0435\x0437\x043d\x0430."
 559     }, {
 560       // Spanish
 561       "es-ES",
 562       L"La misi\x00F3n de "
 563       // L"Google" - to be added.
 564       L" es organizar la informaci\x00F3n mundial "
 565       L"para que resulte universalmente accesible y \x00FAtil."
 566     }, {
 567       // Estonian
 568       "et-EE",
 569       // L"Google'ile " - to be added.
 570       L"\x00FClesanne on korraldada maailma teavet ja teeb selle "
 571       L"k\x00F5igile k\x00E4ttesaadavaks ja kasulikuks.",
 572     }, {
 573       // Faroese
 574       "fo-FO",
 575       L"Google er at samskipa alla vitan \x00ED heiminum og gera hana alment "
 576       L"atkomiliga og n\x00FDtiliga."
 577     }, {
 578       // French
 579       "fr-FR",
 580       L"Google a pour mission d'organiser les informations \x00E0 "
 581       L"l'\x00E9\x0063helle mondiale dans le but de les rendre accessibles "
 582       L"et utiles \x00E0 tous."
 583     }, {
 584       // Hebrew
 585       "he-IL",
 586       L"\x05D4\x05DE\x05E9\x05D9\x05DE\x05D4 \x05E9\x05DC Google "
 587       L"\x05D4\x05D9\x05D0 \x05DC\x05D0\x05E8\x05D2\x05DF "
 588       L"\x05D0\x05EA \x05D4\x05DE\x05D9\x05D3\x05E2 "
 589       L"\x05D4\x05E2\x05D5\x05DC\x05DE\x05D9 "
 590       L"\x05D5\x05DC\x05D4\x05E4\x05D5\x05DA \x05D0\x05D5\x05EA\x05D5 "
 591       L"\x05DC\x05D6\x05DE\x05D9\x05DF "
 592       L"\x05D5\x05E9\x05D9\x05DE\x05D5\x05E9\x05D9 \x05D1\x05DB\x05DC "
 593       L"\x05D4\x05E2\x05D5\x05DC\x05DD. "
 594       // Two words with ASCII double/single quoation marks.
 595       L"\x05DE\x05E0\x05DB\x0022\x05DC \x05E6\x0027\x05D9\x05E4\x05E1"
 596     }, {
 597       // Hindi
 598       "hi-IN",
 599       L"Google \x0915\x093E \x092E\x093F\x0936\x0928 "
 600       L"\x0926\x0941\x0928\x093F\x092F\x093E \x0915\x0940 "
 601       L"\x091C\x093E\x0928\x0915\x093E\x0930\x0940 \x0915\x094B "
 602       L"\x0935\x094D\x092F\x0935\x0938\x094D\x0925\x093F\x0924 "
 603       L"\x0915\x0930\x0928\x093E \x0914\x0930 \x0909\x0938\x0947 "
 604       L"\x0938\x093E\x0930\x094D\x0935\x092D\x094C\x092E\x093F\x0915 "
 605       L"\x0930\x0942\x092A \x0938\x0947 \x092A\x0939\x0941\x0901\x091A "
 606       L"\x092E\x0947\x0902 \x0914\x0930 \x0909\x092A\x092F\x094B\x0917\x0940 "
 607       L"\x092C\x0928\x093E\x0928\x093E \x0939\x0948."
 608     }, {
 609       // Hungarian
 610       "hu-HU",
 611       L"A Google azt a k\x00FCldet\x00E9st v\x00E1llalta mag\x00E1ra, "
 612       L"hogy a vil\x00E1gon fellelhet\x0151 inform\x00E1\x0063i\x00F3kat "
 613       L"rendszerezze \x00E9s \x00E1ltal\x00E1nosan el\x00E9rhet\x0151v\x00E9, "
 614       L"illetve haszn\x00E1lhat\x00F3v\x00E1 tegye."
 615     }, {
 616       // Croatian
 617       "hr-HR",
 618       // L"Googleova " - to be added.
 619       L"je misija organizirati svjetske informacije i u\x010Diniti ih "
 620       // L"univerzalno " - to be added.
 621       L"pristupa\x010Dnima i korisnima."
 622     }, {
 623       // Indonesian
 624       "id-ID",
 625       L"Misi Google adalah untuk mengelola informasi dunia dan membuatnya "
 626       L"dapat diakses dan bermanfaat secara universal."
 627     }, {
 628       // Italian
 629       "it-IT",
 630       L"La missione di Google \x00E8 organizzare le informazioni a livello "
 631       L"mondiale e renderle universalmente accessibili e fruibili."
 632     }, {
 633       // Lithuanian
 634       "lt-LT",
 635       L"\x201EGoogle\x201C tikslas \x2013 rinkti ir sisteminti pasaulio "
 636       L"informacij\x0105 bei padaryti j\x0105 prieinam\x0105 ir "
 637       L"nauding\x0105 visiems."
 638     }, {
 639       // Latvian
 640       "lv-LV",
 641       L"Google uzdevums ir k\x0101rtot pasaules inform\x0101"
 642       L"ciju un padar\x012Bt to univers\x0101li pieejamu un noder\x012Bgu."
 643     }, {
 644       // Norwegian
 645       "nb-NO",
 646       // L"Googles " - to be added.
 647       L"m\x00E5l er \x00E5 organisere informasjonen i verden og "
 648       L"gj\x00F8re den tilgjengelig og nyttig for alle."
 649     }, {
 650       // Dutch
 651       "nl-NL",
 652       L"Het doel van Google is om alle informatie wereldwijd toegankelijk "
 653       L"en bruikbaar te maken."
 654     }, {
 655       // Polish
 656       "pl-PL",
 657       L"Misj\x0105 Google jest uporz\x0105" L"dkowanie \x015Bwiatowych "
 658       L"zasob\x00F3w informacji, aby sta\x0142y si\x0119 one powszechnie "
 659       L"dost\x0119pne i u\x017Cyteczne."
 660     }, {
 661       // Portuguese (Brazil)
 662       "pt-BR",
 663       L"A miss\x00E3o do "
 664 #if !defined(OS_MACOSX)
 665       L"Google "
 666 #endif
 667       L"\x00E9 organizar as informa\x00E7\x00F5"
 668       L"es do mundo todo e "
 669 #if !defined(OS_MACOSX)
 670       L"torn\x00E1-las "
 671 #endif
 672       L"acess\x00EDveis e \x00FAteis em car\x00E1ter universal."
 673     }, {
 674       // Portuguese (Portugal)
 675       "pt-PT",
 676       L"O "
 677 #if !defined(OS_MACOSX)
 678       L"Google "
 679 #endif
 680       L"tem por miss\x00E3o organizar a informa\x00E7\x00E3o do "
 681       L"mundo e "
 682 #if !defined(OS_MACOSX)
 683       L"torn\x00E1-la "
 684 #endif
 685       L"universalmente acess\x00EDvel e \x00FAtil"
 686     }, {
 687       // Romanian
 688       "ro-RO",
 689       L"Misiunea Google este de a organiza informa\x021B3iile lumii \x0219i de "
 690       L"a le face accesibile \x0219i utile la nivel universal."
 691     }, {
 692       // Russian
 693       "ru-RU",
 694       L"\x041C\x0438\x0441\x0441\x0438\x044F Google "
 695       L"\x0441\x043E\x0441\x0442\x043E\x0438\x0442 \x0432 "
 696       L"\x043E\x0440\x0433\x0430\x043D\x0438\x0437\x0430\x0446\x0438\x0438 "
 697       L"\x043C\x0438\x0440\x043E\x0432\x043E\x0439 "
 698       L"\x0438\x043D\x0444\x043E\x0440\x043C\x0430\x0446\x0438\x0438, "
 699       L"\x043E\x0431\x0435\x0441\x043F\x0435\x0447\x0435\x043D\x0438\x0438 "
 700       L"\x0435\x0435 "
 701       L"\x0434\x043E\x0441\x0442\x0443\x043F\x043D\x043E\x0441\x0442\x0438 "
 702       L"\x0438 \x043F\x043E\x043B\x044C\x0437\x044B \x0434\x043B\x044F "
 703       L"\x0432\x0441\x0435\x0445."
 704       // A Russian word including U+0451. (Bug 15558 <http://crbug.com/15558>)
 705       L"\u0451\u043B\u043A\u0430"
 706     }, {
 707       // Serbo-Croatian (Serbian Latin)
 708       "sh",
 709       L"Google-ova misija je da organizuje sve informacije na svetu i "
 710       L"u\x010dini ih univerzal-no dostupnim i korisnim."
 711     }, {
 712       // Serbian
 713       "sr",
 714       L"\x0047\x006f\x006f\x0067\x006c\x0065\x002d\x043e\x0432\x0430 "
 715       L"\x043c\x0438\x0441\x0438\x0458\x0430 \x0458\x0435 \x0434\x0430 "
 716       L"\x043e\x0440\x0433\x0430\x043d\x0438\x0437\x0443\x0458\x0435 "
 717       L"\x0441\x0432\x0435 "
 718       L"\x0438\x043d\x0444\x043e\x0440\x043c\x0430\x0446\x0438\x0458\x0435 "
 719       L"\x043d\x0430 \x0441\x0432\x0435\x0442\x0443 \x0438 "
 720       L"\x0443\x0447\x0438\x043d\x0438 \x0438\x0445 "
 721       L"\x0443\x043d\x0438\x0432\x0435\x0440\x0437\x0430\x043b\x043d\x043e "
 722       L"\x0434\x043e\x0441\x0442\x0443\x043f\x043d\x0438\x043c \x0438 "
 723       L"\x043a\x043e\x0440\x0438\x0441\x043d\x0438\x043c."
 724     }, {
 725       // Slovak
 726       "sk-SK",
 727       L"Spolo\x010Dnos\x0165 Google si dala za \x00FAlohu usporiada\x0165 "
 728       L"inform\x00E1\x0063ie "
 729       L"z cel\x00E9ho sveta a zabezpe\x010Di\x0165, "
 730       L"aby boli v\x0161eobecne dostupn\x00E9 a u\x017Eito\x010Dn\x00E9."
 731     }, {
 732       // Slovenian
 733       "sl-SI",
 734       // L"Googlovo " - to be added.
 735       L"poslanstvo je organizirati svetovne informacije in "
 736       L"omogo\x010Diti njihovo dostopnost in s tem uporabnost za vse."
 737     }, {
 738       // Swedish
 739       "sv-SE",
 740       L"Googles m\x00E5ls\x00E4ttning \x00E4r att ordna v\x00E4rldens "
 741       L"samlade information och g\x00F6ra den tillg\x00E4nglig f\x00F6r alla."
 742     }, {
 743       // Turkish
 744       "tr-TR",
 745       // L"Google\x2019\x0131n " - to be added.
 746       L"misyonu, d\x00FCnyadaki t\x00FCm bilgileri "
 747       L"organize etmek ve evrensel olarak eri\x015Filebilir ve "
 748       L"kullan\x0131\x015Fl\x0131 k\x0131lmakt\x0131r."
 749     }, {
 750       // Ukranian
 751       "uk-UA",
 752       L"\x041c\x0456\x0441\x0456\x044f "
 753       L"\x043a\x043e\x043c\x043f\x0430\x043d\x0456\x0457 Google "
 754       L"\x043f\x043e\x043b\x044f\x0433\x0430\x0454 \x0432 "
 755       L"\x0442\x043e\x043c\x0443, \x0449\x043e\x0431 "
 756       L"\x0443\x043f\x043e\x0440\x044f\x0434\x043a\x0443\x0432\x0430\x0442"
 757       L"\x0438 \x0456\x043d\x0444\x043e\x0440\x043c\x0430\x0446\x0456\x044e "
 758       L"\x0437 \x0443\x0441\x044c\x043e\x0433\x043e "
 759       L"\x0441\x0432\x0456\x0442\x0443 \x0442\x0430 "
 760       L"\x0437\x0440\x043e\x0431\x0438\x0442\x0438 \x0457\x0457 "
 761       L"\x0443\x043d\x0456\x0432\x0435\x0440\x0441\x0430\x043b\x044c\x043d"
 762       L"\x043e \x0434\x043e\x0441\x0442\x0443\x043f\x043d\x043e\x044e "
 763       L"\x0442\x0430 \x043a\x043e\x0440\x0438\x0441\x043d\x043e\x044e."
 764     }, {
 765       // Vietnamese
 766       "vi-VN",
 767       L"Nhi\x1EC7m v\x1EE5 c\x1EE7\x0061 "
 768       L"Google la \x0111\x1EC3 t\x1ED5 ch\x1EE9\x0063 "
 769       L"c\x00E1\x0063 th\x00F4ng tin c\x1EE7\x0061 "
 770       L"th\x1EBF gi\x1EDBi va l\x00E0m cho n\x00F3 universal c\x00F3 "
 771       L"th\x1EC3 truy c\x1EADp va h\x1EEFu d\x1EE5ng h\x01A1n."
 772     }, {
 773       // Korean
 774       "ko",
 775       L"Google\xC758 \xBAA9\xD45C\xB294 \xC804\xC138\xACC4\xC758 "
 776       L"\xC815\xBCF4\xB97C \xCCB4\xACC4\xD654\xD558\xC5EC \xBAA8\xB450\xAC00 "
 777       L"\xD3B8\xB9AC\xD558\xAC8C \xC774\xC6A9\xD560 \xC218 "
 778       L"\xC788\xB3C4\xB85D \xD558\xB294 \xAC83\xC785\xB2C8\xB2E4."
 779     }, {
 780       // Albanian
 781       "sq",
 782       L"Misioni i Google \x00EBsht\x00EB q\x00EB t\x00EB organizoj\x00EB "
 783       L"informacionin e bot\x00EBs dhe t\x00EB b\x00EBjn\x00EB at\x00EB "
 784       L"universalisht t\x00EB arritshme dhe t\x00EB dobishme."
 785     }, {
 786       // Tamil
 787       "ta",
 788       L"Google \x0B87\x0BA9\x0BCD "
 789       L"\x0BA8\x0BC7\x0BBE\x0B95\x0BCD\x0B95\x0BAE\x0BCD "
 790       L"\x0B89\x0BB2\x0B95\x0BBF\x0BA9\x0BCD \x0BA4\x0B95\x0BB5\x0BB2\x0BCD "
 791       L"\x0B8F\x0BB1\x0BCD\x0BAA\x0BBE\x0B9F\x0BC1 \x0B87\x0BA4\x0BC1 "
 792       L"\u0B89\u0BB2\u0B95\u0BB3\u0BBE\u0BB5\u0BBF\u0BAF "
 793       L"\x0B85\x0BA3\x0BC1\x0B95\x0B95\x0BCD \x0B95\x0BC2\x0B9F\x0BBF\x0BAF "
 794       L"\x0BAE\x0BB1\x0BCD\x0BB1\x0BC1\x0BAE\x0BCD "
 795       L"\x0BAA\x0BAF\x0BA9\x0BC1\x0BB3\x0BCD\x0BB3 "
 796       L"\x0B9A\x0BC6\x0BAF\x0BCD\x0BAF \x0B89\x0BB3\x0BCD\x0BB3\x0BA4\x0BC1."
 797     },
 798   };
 799
 800   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kTestCases); ++i) {
 801     ReinitializeSpellCheck(kTestCases[i].language);
 802     size_t input_length = 0;
 803     if (kTestCases[i].input != NULL)
 804       input_length = wcslen(kTestCases[i].input);
 805
 806     int misspelling_start = 0;
 807     int misspelling_length = 0;
 808     bool result = spell_check()->SpellCheckWord(
 809         WideToUTF16(kTestCases[i].input).c_str(),
 810         static_cast<int>(input_length),
 811         0,
 812         &misspelling_start,
 813         &misspelling_length, NULL);
 814
 815     EXPECT_TRUE(result)
 816         << "\""
 817         << std::wstring(kTestCases[i].input).substr(
 818                misspelling_start, misspelling_length)
 819         << "\" is misspelled in "
 820         << kTestCases[i].language
 821         << ".";
 822     EXPECT_EQ(0, misspelling_start);
 823     EXPECT_EQ(0, misspelling_length);
 824   }
 825 }
 826
 827 TEST_F(SpellCheckTest, GetAutoCorrectionWord_EN_US) {
 828   static const struct {
 829     // A misspelled word.
 830     const char* input;
 831
 832     // An expected result for this test case.
 833     // Should be an empty string if there are no suggestions for auto correct.
 834     const char* expected_result;
 835   } kTestCases[] = {
 836     {"teh", "the"},
 837     {"moer", "more"},
 838     {"watre", "water"},
 839     {"noen", ""},
 840     {"what", ""},
 841   };
 842
 843   EnableAutoCorrect(true);
 844
 845   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kTestCases); ++i) {
 846     string16 misspelled_word(UTF8ToUTF16(kTestCases[i].input));
 847     string16 expected_autocorrect_word(
 848         UTF8ToUTF16(kTestCases[i].expected_result));
 849     string16 autocorrect_word = spell_check()->GetAutoCorrectionWord(
 850         misspelled_word, 0);
 851
 852     // Check for spelling.
 853     EXPECT_EQ(expected_autocorrect_word, autocorrect_word);
 854   }
 855 }
 856
 857 // Verify that our SpellCheck::SpellCheckWord() returns false when it checks
 858 // misspelled words.
 859 TEST_F(SpellCheckTest, MisspelledWords) {
 860   static const struct {
 861     const char* language;
 862     const wchar_t* input;
 863   } kTestCases[] = {
 864     {
 865       // A misspelled word for English
 866       "en-US",
 867       L"aaaaaaaaaa",
 868     }, {
 869       // A misspelled word for Greek.
 870       "el-GR",
 871       L"\x03B1\x03B1\x03B1\x03B1\x03B1\x03B1\x03B1\x03B1\x03B1\x03B1",
 872     }, {
 873       // A misspelled word for Hebrew
 874       "he-IL",
 875       L"\x05D0\x05D0\x05D0\x05D0\x05D0\x05D0\x05D0\x05D0\x05D0\x05D0",
 876     }, {
 877       // Hindi
 878       "hi-IN",
 879       L"\x0905\x0905\x0905\x0905\x0905\x0905\x0905\x0905\x0905\x0905",
 880     }, {
 881       // A misspelled word for Russian
 882       "ru-RU",
 883       L"\x0430\x0430\x0430\x0430\x0430\x0430\x0430\x0430\x0430\x0430",
 884     },
 885   };
 886
 887   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kTestCases); ++i) {
 888     ReinitializeSpellCheck(kTestCases[i].language);
 889
 890     string16 word(WideToUTF16(kTestCases[i].input));
 891     int word_length = static_cast<int>(word.length());
 892     int misspelling_start = 0;
 893     int misspelling_length = 0;
 894     bool result = spell_check()->SpellCheckWord(word.c_str(),
 895                                                 word_length,
 896                                                 0,
 897                                                 &misspelling_start,
 898                                                 &misspelling_length,
 899                                                 NULL);
 900     EXPECT_FALSE(result);
 901     EXPECT_EQ(0, misspelling_start);
 902     EXPECT_EQ(word_length, misspelling_length);
 903   }
 904 }
 905
 906 // Since SpellCheck::SpellCheckParagraph is not implemented on Mac,
 907 // we skip these SpellCheckParagraph tests on Mac.
 908 #if !defined(OS_MACOSX)
 909
 910 // Make sure SpellCheckParagraph does not crash if the input is empty.
 911 TEST_F(SpellCheckTest, SpellCheckParagraphEmptyParagraph) {
 912   std::vector<SpellCheckResult> expected;
 913   TestSpellCheckParagraph(UTF8ToUTF16(""), expected);
 914 }
 915
 916 // A simple test case having no misspellings.
 917 TEST_F(SpellCheckTest, SpellCheckParagraphNoMisspellings) {
 918   const string16 text = UTF8ToUTF16("apple");
 919   std::vector<SpellCheckResult> expected;
 920   TestSpellCheckParagraph(text, expected);
 921 }
 922
 923 // A simple test case having one misspelling.
 924 TEST_F(SpellCheckTest, SpellCheckParagraphSingleMisspellings) {
 925   const string16 text = UTF8ToUTF16("zz");
 926   std::vector<SpellCheckResult> expected;
 927   expected.push_back(SpellCheckResult(
 928       SpellCheckResult::SPELLING, 0, 2));
 929
 930   TestSpellCheckParagraph(text, expected);
 931 }
 932
 933 // A simple test case having multiple misspellings.
 934 TEST_F(SpellCheckTest, SpellCheckParagraphMultipleMisspellings) {
 935   const string16 text = UTF8ToUTF16("zz, zz");
 936   std::vector<SpellCheckResult> expected;
 937   expected.push_back(SpellCheckResult(
 938       SpellCheckResult::SPELLING, 0, 2));
 939   expected.push_back(SpellCheckResult(
 940       SpellCheckResult::SPELLING, 4, 2));
 941
 942   TestSpellCheckParagraph(text, expected);
 943 }
 944
 945 // Make sure a relatively long (correct) sentence can be spellchecked.
 946 TEST_F(SpellCheckTest, SpellCheckParagraphLongSentence) {
 947   std::vector<SpellCheckResult> expected;
 948   // The text is taken from US constitution preamble.
 949   const string16 text = UTF8ToUTF16(
 950       "We the people of the United States, in order to form a more perfect "
 951       "union, establish justice, insure domestic tranquility, provide for "
 952       "the common defense, promote the general welfare, and secure the "
 953       "blessings of liberty to ourselves and our posterity, do ordain and "
 954       "establish this Constitution for the United States of America.");
 955
 956   TestSpellCheckParagraph(text, expected);
 957 }
 958
 959 // Make sure all misspellings can be found in a relatively long sentence.
 960 TEST_F(SpellCheckTest, SpellCheckParagraphLongSentenceMultipleMisspellings) {
 961   std::vector<SpellCheckResult> expected;
 962
 963   // All 'the' are converted to 'hte' in US consitition preamble.
 964   const string16 text = UTF8ToUTF16(
 965       "We hte people of hte United States, in order to form a more perfect "
 966       "union, establish justice, insure domestic tranquility, provide for "
 967       "hte common defense, promote hte general welfare, and secure hte "
 968       "blessings of liberty to ourselves and our posterity, do ordain and "
 969       "establish this Constitution for hte United States of America.");
 970
 971   expected.push_back(SpellCheckResult(
 972       SpellCheckResult::SPELLING, 3, 3));
 973   expected.push_back(SpellCheckResult(
 974       SpellCheckResult::SPELLING, 17, 3));
 975   expected.push_back(SpellCheckResult(
 976       SpellCheckResult::SPELLING, 135, 3));
 977   expected.push_back(SpellCheckResult(
 978       SpellCheckResult::SPELLING, 163, 3));
 979   expected.push_back(SpellCheckResult(
 980       SpellCheckResult::SPELLING, 195, 3));
 981   expected.push_back(SpellCheckResult(
 982       SpellCheckResult::SPELLING, 298, 3));
 983
 984   TestSpellCheckParagraph(text, expected);
 985 }
 986
 987 // We also skip RequestSpellCheck tests on Mac, because a system spellchecker
 988 // is used on Mac instead of SpellCheck::RequestTextChecking.
 989
 990 // Make sure RequestTextChecking does not crash if input is empty.
 991 TEST_F(SpellCheckTest, RequestSpellCheckWithEmptyString) {
 992   MockTextCheckingCompletion completion;
 993
 994   spell_check()->RequestTextChecking(string16(), &completion);
 995
 996   base::MessageLoop::current()->RunUntilIdle();
 997
 998   EXPECT_EQ(completion.completion_count_, 1U);
 999 }
1000
1001 // A simple test case having no misspellings.
1002 TEST_F(SpellCheckTest, RequestSpellCheckWithoutMisspelling) {
1003   MockTextCheckingCompletion completion;
1004
1005   const string16 text = ASCIIToUTF16("hello");
1006   spell_check()->RequestTextChecking(text, &completion);
1007
1008   base::MessageLoop::current()->RunUntilIdle();
1009
1010   EXPECT_EQ(completion.completion_count_, 1U);
1011 }
1012
1013 // A simple test case having one misspelling.
1014 TEST_F(SpellCheckTest, RequestSpellCheckWithSingleMisspelling) {
1015   MockTextCheckingCompletion completion;
1016
1017   const string16 text = ASCIIToUTF16("apple, zz");
1018   spell_check()->RequestTextChecking(text, &completion);
1019
1020   base::MessageLoop::current()->RunUntilIdle();
1021
1022   EXPECT_EQ(completion.completion_count_, 1U);
1023   EXPECT_EQ(completion.last_results_.size(), 1U);
1024   EXPECT_EQ(completion.last_results_[0].location, 7);
1025   EXPECT_EQ(completion.last_results_[0].length, 2);
1026 }
1027
1028 // A simple test case having a few misspellings.
1029 TEST_F(SpellCheckTest, RequestSpellCheckWithMisspellings) {
1030   MockTextCheckingCompletion completion;
1031
1032   const string16 text = ASCIIToUTF16("apple, zz, orange, zz");
1033   spell_check()->RequestTextChecking(text, &completion);
1034
1035   base::MessageLoop::current()->RunUntilIdle();
1036
1037   EXPECT_EQ(completion.completion_count_, 1U);
1038   EXPECT_EQ(completion.last_results_.size(), 2U);
1039   EXPECT_EQ(completion.last_results_[0].location, 7);
1040   EXPECT_EQ(completion.last_results_[0].length, 2);
1041   EXPECT_EQ(completion.last_results_[1].location, 19);
1042   EXPECT_EQ(completion.last_results_[1].length, 2);
1043 }
1044
1045 // A test case that multiple requests comes at once. Make sure all
1046 // requests are processed.
1047 TEST_F(SpellCheckTest, RequestSpellCheckWithMultipleRequests) {
1048   MockTextCheckingCompletion completion[3];
1049
1050   const string16 text[3] = {
1051     ASCIIToUTF16("what, zz"),
1052     ASCIIToUTF16("apple, zz"),
1053     ASCIIToUTF16("orange, zz")
1054   };
1055
1056   for (int i = 0; i < 3; ++i)
1057     spell_check()->RequestTextChecking(text[i], &completion[i]);
1058
1059   base::MessageLoop::current()->RunUntilIdle();
1060
1061   for (int i = 0; i < 3; ++i) {
1062     EXPECT_EQ(completion[i].completion_count_, 1U);
1063     EXPECT_EQ(completion[i].last_results_.size(), 1U);
1064     EXPECT_EQ(completion[i].last_results_[0].location, 6 + i);
1065     EXPECT_EQ(completion[i].last_results_[0].length, 2);
1066   }
1067 }
1068
1069 // A test case that spellchecking is requested before initializing.
1070 // In this case, we postpone to post a request.
1071 TEST_F(SpellCheckTest, RequestSpellCheckWithoutInitialization) {
1072   UninitializeSpellCheck();
1073
1074   MockTextCheckingCompletion completion;
1075   const string16 text = ASCIIToUTF16("zz");
1076
1077   spell_check()->RequestTextChecking(text, &completion);
1078
1079   // The task will not be posted yet.
1080   base::MessageLoop::current()->RunUntilIdle();
1081   EXPECT_EQ(completion.completion_count_, 0U);
1082 }
1083
1084 // Requests several spellchecking before initializing. Except the last one,
1085 // posting requests is cancelled and text is rendered as correct one.
1086 TEST_F(SpellCheckTest, RequestSpellCheckMultipleTimesWithoutInitialization) {
1087   UninitializeSpellCheck();
1088
1089   MockTextCheckingCompletion completion[3];
1090   const string16 text[3] = {
1091     ASCIIToUTF16("what, zz"),
1092     ASCIIToUTF16("apple, zz"),
1093     ASCIIToUTF16("orange, zz")
1094   };
1095
1096   // Calls RequestTextchecking a few times.
1097   for (int i = 0; i < 3; ++i)
1098     spell_check()->RequestTextChecking(text[i], &completion[i]);
1099
1100   // The last task will be posted after initialization, however the other
1101   // requests should be pressed without spellchecking.
1102   base::MessageLoop::current()->RunUntilIdle();
1103   for (int i = 0; i < 2; ++i)
1104     EXPECT_EQ(completion[i].completion_count_, 1U);
1105   EXPECT_EQ(completion[2].completion_count_, 0U);
1106
1107   // Checks the last request is processed after initialization.
1108   InitializeSpellCheck("en-US");
1109
1110   // Calls PostDelayedSpellCheckTask instead of OnInit here for simplicity.
1111   spell_check()->PostDelayedSpellCheckTask(
1112       spell_check()->pending_request_param_.release());
1113   base::MessageLoop::current()->RunUntilIdle();
1114   for (int i = 0; i < 3; ++i)
1115     EXPECT_EQ(completion[i].completion_count_, 1U);
1116 }
1117
1118 TEST_F(SpellCheckTest, CreateTextCheckingResults) {
1119   // Verify that the SpellCheck class keeps the spelling marker added to a
1120   // misspelled word "zz".
1121   {
1122     string16 text = ASCIIToUTF16("zz");
1123     std::vector<SpellCheckResult> spellcheck_results;
1124     spellcheck_results.push_back(SpellCheckResult(
1125         SpellCheckResult::SPELLING, 0, 2, string16()));
1126     WebKit::WebVector<WebKit::WebTextCheckingResult> textcheck_results;
1127     spell_check()->CreateTextCheckingResults(SpellCheck::USE_NATIVE_CHECKER,
1128                                              0,
1129                                              text,
1130                                              spellcheck_results,
1131                                              &textcheck_results);
1132     EXPECT_EQ(spellcheck_results.size(), textcheck_results.size());
1133     EXPECT_EQ(WebKit::WebTextCheckingTypeSpelling, textcheck_results[0].type);
1134     EXPECT_EQ(spellcheck_results[0].location, textcheck_results[0].location);
1135     EXPECT_EQ(spellcheck_results[0].length, textcheck_results[0].length);
1136   }
1137
1138   // Verify that the SpellCheck class replaces the spelling marker added to a
1139   // contextually-misspelled word "bean" with a grammar marker.
1140   {
1141     string16 text = ASCIIToUTF16("I have bean to USA.");
1142     std::vector<SpellCheckResult> spellcheck_results;
1143     spellcheck_results.push_back(SpellCheckResult(
1144         SpellCheckResult::SPELLING, 7, 4, string16()));
1145     WebKit::WebVector<WebKit::WebTextCheckingResult> textcheck_results;
1146     spell_check()->CreateTextCheckingResults(SpellCheck::USE_NATIVE_CHECKER,
1147                                              0,
1148                                              text,
1149                                              spellcheck_results,
1150                                              &textcheck_results);
1151     EXPECT_EQ(spellcheck_results.size(), textcheck_results.size());
1152     EXPECT_EQ(WebKit::WebTextCheckingTypeGrammar, textcheck_results[0].type);
1153     EXPECT_EQ(spellcheck_results[0].location, textcheck_results[0].location);
1154     EXPECT_EQ(spellcheck_results[0].length, textcheck_results[0].length);
1155   }
1156 }
1157
1158 #endif
1159
1160 // Checks some words that should be present in all English dictionaries.
1161 TEST_F(SpellCheckTest, EnglishWords) {
1162   static const struct {
1163     const char* input;
1164     bool should_pass;
1165   } kTestCases[] = {
1166     // Issue 146093: "Chromebook" and "Chromebox" not included in spell-checking
1167     // dictionary.
1168     {"Chromebook", true},
1169     {"Chromebooks", true},
1170     {"Chromebox", true},
1171     {"Chromeboxes", true},
1172     {"Chromeblade", true},
1173     {"Chromeblades", true},
1174     {"Chromebase", true},
1175     {"Chromebases", true},
1176     // Issue 94708: Spell-checker incorrectly reports whisky as misspelled.
1177     {"whisky", true},
1178     {"whiskey", true},
1179     {"whiskies", true},
1180     // Issue 98678: "Recency" should be included in client-side dictionary.
1181     {"recency", true},
1182     {"recencies", false},
1183     // Issue 140486
1184     {"movie", true},
1185     {"movies", true},
1186   };
1187
1188   static const char* kLocales[] = { "en-GB", "en-US", "en-CA", "en-AU" };
1189
1190   for (size_t j = 0; j < arraysize(kLocales); ++j) {
1191     ReinitializeSpellCheck(kLocales[j]);
1192     for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kTestCases); ++i) {
1193       size_t input_length = 0;
1194       if (kTestCases[i].input != NULL)
1195         input_length = strlen(kTestCases[i].input);
1196
1197       int misspelling_start = 0;
1198       int misspelling_length = 0;
1199       bool result = spell_check()->SpellCheckWord(
1200           ASCIIToUTF16(kTestCases[i].input).c_str(),
1201           static_cast<int>(input_length),
1202           0,
1203           &misspelling_start,
1204           &misspelling_length, NULL);
1205
1206       EXPECT_EQ(kTestCases[i].should_pass, result) << kTestCases[i].input <<
1207           " in " << kLocales[j];
1208     }
1209   }
1210 }
1211
1212 // Checks that NOSUGGEST works in English dictionaries.
1213 TEST_F(SpellCheckTest, NoSuggest) {
1214   static const struct {
1215     const char* input;
1216     const char* suggestion;
1217     const char* locale;
1218     bool should_pass;
1219   } kTestCases[] = {
1220     {"suckerbert", "cocksucker",  "en-GB", true},
1221     {"suckerbert", "cocksucker",  "en-US", true},
1222     {"suckerbert", "cocksucker",  "en-CA", true},
1223     {"suckerbert", "cocksucker",  "en-AU", true},
1224     {"suckerbert", "cocksuckers", "en-GB", true},
1225     {"suckerbert", "cocksuckers", "en-US", true},
1226     {"suckerbert", "cocksuckers", "en-CA", true},
1227     {"suckerbert", "cocksuckers", "en-AU", true},
1228     {"Batasunaa",  "Batasuna",    "ca-ES", true},
1229     {"pornoo",     "porno",       "it-IT", true},
1230     {"catass",     "catas",       "lt-LT", true},
1231     {"kuracc",     "kurac",       "sl-SI", true},
1232     {"pittt",      "pitt",        "sv-SE", true},
1233   };
1234
1235   size_t test_cases_size = ARRAYSIZE_UNSAFE(kTestCases);
1236   for (size_t i = 0; i < test_cases_size; ++i) {
1237     ReinitializeSpellCheck(kTestCases[i].locale);
1238     size_t suggestion_length = 0;
1239     if (kTestCases[i].suggestion != NULL)
1240       suggestion_length = strlen(kTestCases[i].suggestion);
1241
1242     // First check that the NOSUGGEST flag didn't mark this word as not being in
1243     // the dictionary.
1244     int misspelling_start = 0;
1245     int misspelling_length = 0;
1246     bool result = spell_check()->SpellCheckWord(
1247         ASCIIToUTF16(kTestCases[i].suggestion).c_str(),
1248         static_cast<int>(suggestion_length),
1249         0,
1250         &misspelling_start,
1251         &misspelling_length, NULL);
1252
1253     EXPECT_EQ(kTestCases[i].should_pass, result) << kTestCases[i].suggestion <<
1254         " in " << kTestCases[i].locale;
1255
1256     // Now verify that this test case does not show up as a suggestion.
1257     std::vector<string16> suggestions;
1258     size_t input_length = 0;
1259     if (kTestCases[i].input != NULL)
1260       input_length = strlen(kTestCases[i].input);
1261     result = spell_check()->SpellCheckWord(
1262         ASCIIToUTF16(kTestCases[i].input).c_str(),
1263         static_cast<int>(input_length),
1264         0,
1265         &misspelling_start,
1266         &misspelling_length,
1267         &suggestions);
1268     // Input word should be a misspelling.
1269     EXPECT_FALSE(result) << kTestCases[i].input
1270                          << " is not a misspelling in "
1271                          << kTestCases[i].locale;
1272     // Check if the suggested words occur.
1273     for (int j = 0; j < static_cast<int>(suggestions.size()); j++) {
1274       for (size_t t = 0; t < test_cases_size; t++) {
1275         int compare_result =
1276             suggestions.at(j).compare(ASCIIToUTF16(kTestCases[t].suggestion));
1277         EXPECT_FALSE(compare_result == 0) << kTestCases[t].suggestion <<
1278             " in " << kTestCases[i].locale;
1279       }
1280     }
1281   }
1282 }
1283
1284 // Check that the correct dictionary files are checked in.
1285 TEST_F(SpellCheckTest, DictionaryFiles) {
1286   std::vector<std::string> spellcheck_languages;
1287   chrome::spellcheck_common::SpellCheckLanguages(&spellcheck_languages);
1288   EXPECT_FALSE(spellcheck_languages.empty());
1289
1290   base::FilePath hunspell = GetHunspellDirectory();
1291   for (size_t i = 0; i < spellcheck_languages.size(); ++i) {
1292     base::FilePath dict = chrome::spellcheck_common::GetVersionedFileName(
1293         spellcheck_languages[i], hunspell);
1294     EXPECT_TRUE(base::PathExists(dict)) << dict.value() << " not found";
1295   }
1296 }
1297
1298 // TODO(groby): Add a test for hunspell itself, when MAXWORDLEN is exceeded.
1299 TEST_F(SpellCheckTest, SpellingEngine_CheckSpelling) {
1300   static const struct {
1301     const char* word;
1302     bool expected_result;
1303   } kTestCases[] = {
1304     { "", true },
1305     { "automatic", true },
1306     { "hello", true },
1307     { "forglobantic", false },
1308     { "xfdssfsdfaasds", false },
1309     {  // 64 chars are the longest word to check - this should fail checking.
1310       "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijkl",
1311       false
1312     },
1313     {  // Any word longer than 64 chars should be exempt from checking.
1314       "reallylongwordthatabsolutelyexceedsthespecifiedcharacterlimitabit",
1315       true
1316     }
1317   };
1318
1319   // Initialization magic - call InitializeIfNeeded twice. The first one simply
1320   // flags internal state that a dictionary was requested. The second one will
1321   // take the passed-in file and initialize hunspell with it. (The file was
1322   // passed to hunspell in the ctor for the test fixture).
1323   // This needs to be done since we need to ensure the SpellingEngine object
1324   // contained in |spellcheck_| from the test fixture does get initialized.
1325   // TODO(groby): Clean up this mess.
1326   InitializeIfNeeded();
1327   ASSERT_FALSE(InitializeIfNeeded());
1328
1329   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kTestCases); ++i) {
1330     bool result = CheckSpelling(kTestCases[i].word, 0);
1331     EXPECT_EQ(kTestCases[i].expected_result, result) <<
1332         "Failed test for " << kTestCases[i].word;
1333   }
1334 }
1335
1336 // Chrome should not suggest "Othello" for "hellllo" or "identically" for
1337 // "accidently".
1338 TEST_F(SpellCheckTest, LogicalSuggestions) {
1339   static const struct {
1340     const char* misspelled;
1341     const char* suggestion;
1342   } kTestCases[] = {
1343     { "hellllo", "hello" },
1344     { "accidently", "accidentally" }
1345   };
1346
1347   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kTestCases); ++i) {
1348     int misspelling_start = 0;
1349     int misspelling_length = 0;
1350     std::vector<string16> suggestions;
1351     EXPECT_FALSE(spell_check()->SpellCheckWord(
1352         ASCIIToUTF16(kTestCases[i].misspelled).c_str(),
1353         strlen(kTestCases[i].misspelled),
1354         0,
1355         &misspelling_start,
1356         &misspelling_length,
1357         &suggestions));
1358     EXPECT_GE(suggestions.size(), static_cast<size_t>(1));
1359     if (suggestions.size() > 0)
1360       EXPECT_EQ(suggestions[0], ASCIIToUTF16(kTestCases[i].suggestion));
1361   }
1362 }