Asynchronous spellchecking on Win and Linux

chrome/renderer/spellchecker/spellcheck_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 "webkit/glue/webkit_glue.h"
 
 #include "base/file_util.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
 #include "base/platform_file.h"
 #include "base/sys_string_conversions.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/renderer/spellchecker/spellcheck.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/spellcheck_common.h"
 #include "chrome/common/spellcheck_result.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/WebTextCheckingCompletion.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/WebTextCheckingResult.h"
 
 
 namespace {
 
 FilePath GetHunspellDirectory() {
   FilePath hunspell_directory;
   if (!PathService::Get(base::DIR_SOURCE_ROOT, &hunspell_directory))
     return FilePath();
 
   hunspell_directory = hunspell_directory.AppendASCII("third_party");
   hunspell_directory = hunspell_directory.AppendASCII("hunspell_dictionaries");
   return hunspell_directory;
 }
 
 }  // namespace
 
 class SpellCheckTest : public testing::Test {
  public:
   SpellCheckTest() {
     ReinitializeSpellCheck("en-US");
   }
 
   void ReinitializeSpellCheck(const std::string& language) {
     spell_check_.reset(new SpellCheck());
+    InitializeSpellCheck(language);
+  }
 
+  void UninitializeSpellCheck() {
+    spell_check_.reset(new SpellCheck());
+  }
+
+  void InitializeSpellCheck(const std::string& language) {
     FilePath hunspell_directory = GetHunspellDirectory();
     EXPECT_FALSE(hunspell_directory.empty());
     base::PlatformFile file = base::CreatePlatformFile(
         SpellCheckCommon::GetVersionedFileName(language, hunspell_directory),
         base::PLATFORM_FILE_OPEN | base::PLATFORM_FILE_READ, NULL, NULL);
     spell_check_->Init(
         file, std::vector<std::string>(), language);
   }
 
   virtual ~SpellCheckTest() {
   }
 
   SpellCheck* spell_check() { return spell_check_.get(); }
 
 #if !defined(OS_MACOSX)
  protected:
   void TestSpellCheckParagraph(
       const string16& input,
       const std::vector<SpellCheckResult>& expected) {
     std::vector<SpellCheckResult> results;
     spell_check()->SpellCheckParagraph(input,
-                                       0,
                                        &results);
 
     EXPECT_EQ(results.size(), expected.size());
     size_t size = std::min(results.size(), expected.size());
     for (size_t j = 0; j < size; ++j) {
       EXPECT_EQ(results[j].type, SpellCheckResult::SPELLING);
       EXPECT_EQ(results[j].location, expected[j].location);
       EXPECT_EQ(results[j].length, expected[j].length);
     }
   }
 #endif
 
  private:
   scoped_ptr<SpellCheck> spell_check_;
+  MessageLoop loop;
+};
+
+// A fake completion object for verification.
+class MockTextCheckingCompletion : public WebKit::WebTextCheckingCompletion {
+ public:
+  MockTextCheckingCompletion()
+      : completion_count_(0) {
+  }
+
+  virtual void didFinishCheckingText(
+      const WebKit::WebVector<WebKit::WebTextCheckingResult>& results) {
+    completion_count_++;
+    last_results_ = results;
+  }
+
+  size_t completion_count_;
+  WebKit::WebVector<WebKit::WebTextCheckingResult> last_results_;
 };
 
 // Operates unit tests for the webkit_glue::SpellCheckWord() function
 // with the US English dictionary.
 // The unit tests in this function consist of:
 //   * Tests for the function with empty strings;
 //   * Tests for the function with a valid English word;
 //   * Tests for the function with a valid non-English word;
 //   * Tests for the function with a valid English word with a preceding
 //     space character;
@@ skipping 712 matching lines @@
       SpellCheckResult::SPELLING, 135, 3));
   expected.push_back(SpellCheckResult(
       SpellCheckResult::SPELLING, 163, 3));
   expected.push_back(SpellCheckResult(
       SpellCheckResult::SPELLING, 195, 3));
   expected.push_back(SpellCheckResult(
       SpellCheckResult::SPELLING, 298, 3));
 
   TestSpellCheckParagraph(text, expected);
 }
+
+// We also skip RequestSpellCheck tests on Mac, because a system spellchecker
+// is used on Mac instead of SpellCheck::RequestTextChecking.
+
+// Make sure RequestTextChecking does not crash if input is empty.
+TEST_F(SpellCheckTest, RequestSpellCheckWithEmptyString) {
+  MockTextCheckingCompletion completion;
+
+  const string16 text = ASCIIToUTF16("");
+  spell_check()->RequestTextChecking(text, 0, &completion);
+
+  MessageLoop::current()->RunAllPending();
+
+  EXPECT_EQ(completion.completion_count_, 1U);
+}
+
+// A simple test case having no misspellings.
+TEST_F(SpellCheckTest, RequestSpellCheckWithoutMisspelling) {
+  MockTextCheckingCompletion completion;
+
+  const string16 text = ASCIIToUTF16("hello");
+  spell_check()->RequestTextChecking(text, 0, &completion);
+
+  MessageLoop::current()->RunAllPending();
+
+  EXPECT_EQ(completion.completion_count_, 1U);
+}
+
+// A simple test case having one misspelling.
+TEST_F(SpellCheckTest, RequestSpellCheckWithSingleMisspelling) {
+  MockTextCheckingCompletion completion;
+
+  const string16 text = ASCIIToUTF16("apple, zz");
+  spell_check()->RequestTextChecking(text, 0, &completion);
+
+  MessageLoop::current()->RunAllPending();
+
+  EXPECT_EQ(completion.completion_count_, 1U);
+  EXPECT_EQ(completion.last_results_.size(), 1U);
+  EXPECT_EQ(completion.last_results_[0].location, 7);
+  EXPECT_EQ(completion.last_results_[0].length, 2);
+}
+
+// A simple test case having a few misspellings.
+TEST_F(SpellCheckTest, RequestSpellCheckWithMisspellings) {
+  MockTextCheckingCompletion completion;
+
+  const string16 text = ASCIIToUTF16("apple, zz, orange, zz");
+  spell_check()->RequestTextChecking(text, 0, &completion);
+
+  MessageLoop::current()->RunAllPending();
+
+  EXPECT_EQ(completion.completion_count_, 1U);
+  EXPECT_EQ(completion.last_results_.size(), 2U);
+  EXPECT_EQ(completion.last_results_[0].location, 7);
+  EXPECT_EQ(completion.last_results_[0].length, 2);
+  EXPECT_EQ(completion.last_results_[1].location, 19);
+  EXPECT_EQ(completion.last_results_[1].length, 2);
+}
+
+// A test case that multiple requests comes at once. Make sure all
+// requests are processed.
+TEST_F(SpellCheckTest, RequestSpellCheckWithMultipleRequests) {
+  MockTextCheckingCompletion completion[3];
+
+  const string16 text[3] = {
+    ASCIIToUTF16("what, zz"),
+    ASCIIToUTF16("apple, zz"),
+    ASCIIToUTF16("orange, zz")
+  };
+
+  for (int i = 0; i < 3; ++i)
+    spell_check()->RequestTextChecking(text[i], 0, &completion[i]);
+
+  MessageLoop::current()->RunAllPending();
+
+  for (int i = 0; i < 3; ++i) {
+    EXPECT_EQ(completion[i].completion_count_, 1U);
+    EXPECT_EQ(completion[i].last_results_.size(), 1U);
+    EXPECT_EQ(completion[i].last_results_[0].location, 6 + i);
+    EXPECT_EQ(completion[i].last_results_[0].length, 2);
+  }
+}
+
+// A test case that spellchecking is requested before initializing.
+// In this case, we postpone to post a request.
+TEST_F(SpellCheckTest, RequestSpellCheckWithoutInitialization) {
+  UninitializeSpellCheck();
+
+  MockTextCheckingCompletion completion;
+  const string16 text = ASCIIToUTF16("zz");
+
+  spell_check()->RequestTextChecking(text, 0, &completion);
+
+  // The task will not be posted yet.
+  MessageLoop::current()->RunAllPending();
+  EXPECT_EQ(completion.completion_count_, 0U);
+}
+
+// Requests several spellchecking before initializing. Except the last one,
+// posting requests is cancelled and text is rendered as correct one.
+TEST_F(SpellCheckTest, RequestSpellCheckMultipleTimesWithoutInitialization) {
+  UninitializeSpellCheck();
+
+  MockTextCheckingCompletion completion[3];
+  const string16 text[3] = {
+    ASCIIToUTF16("what, zz"),
+    ASCIIToUTF16("apple, zz"),
+    ASCIIToUTF16("orange, zz")
+  };
+
+  // Calls RequestTextchecking a few times.
+  for (int i = 0; i < 3; ++i)
+    spell_check()->RequestTextChecking(text[i], 0, &completion[i]);
+
+  // The last task will be posted after initialization, however the other
+  // requests should be pressed without spellchecking.
+  MessageLoop::current()->RunAllPending();
+  for (int i = 0; i < 2; ++i)
+    EXPECT_EQ(completion[i].completion_count_, 1U);
+  EXPECT_EQ(completion[2].completion_count_, 0U);
+
+  // Checks the last request is processed after initialization.
+  InitializeSpellCheck("en-US");
+
+  // Calls PostDelayedSpellCheckTask instead of OnInit here for simplicity.
+  spell_check()->PostDelayedSpellCheckTask();
+  MessageLoop::current()->RunAllPending();
+  for (int i = 0; i < 3; ++i)
+    EXPECT_EQ(completion[i].completion_count_, 1U);
+}
+
 #endif