blob: cc05c1620dc7ef829b471e6a4f9065add1f010dc [file] [log] [blame]
// Copyright (c) 2009 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/tools/test_shell/mock_spellcheck.h"
#include <map>
#include <utility>
#include "base/logging.h"
#include "base/string16.h"
#include "base/string_util.h"
#include "base/utf_string_conversions.h"
MockSpellCheck::MockSpellCheck()
: initialized_(false) {
}
MockSpellCheck::~MockSpellCheck() {
}
bool MockSpellCheck::SpellCheckWord(const string16& text,
int* misspelledOffset,
int* misspelledLength) {
DCHECK(misspelledOffset && misspelledLength);
// Initialize this spellchecker.
InitializeIfNeeded();
// Reset the result values as our spellchecker does.
*misspelledOffset = 0;
*misspelledLength = 0;
// Extract the first possible English word from the given string.
// The given string may include non-ASCII characters or numbers. So, we
// should filter out such characters before start looking up our
// misspelled-word table.
// (This is a simple version of our SpellCheckWordIterator class.)
// If the given string doesn't include any ASCII characters, we can treat the
// string as valid one.
// Unfortunately, This implementation splits a contraction, i.e. "isn't" is
// split into two pieces "isn" and "t". This is OK because webkit tests
// don't have misspelled contractions.
static const char* kWordCharacters =
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
string16 word_characters(ASCIIToUTF16(kWordCharacters));
size_t word_offset = text.find_first_of(word_characters);
if (word_offset == std::string::npos)
return true;
size_t word_end = text.find_first_not_of(word_characters, word_offset);
size_t word_length = word_end == std::string::npos ?
text.length() - word_offset : word_end - word_offset;
// Look up our misspelled-word table to check if the extracted word is a
// known misspelled word, and return the offset and the length of the
// extracted word if this word is a known misspelled word.
// (See the comment in MockSpellCheck::InitializeIfNeeded() why we use a
// misspelled-word table.)
string16 word(text, word_offset, word_length);
std::map<string16, bool>::iterator it = misspelled_words_.find(word);
if (it == misspelled_words_.end())
return true;
*misspelledOffset = static_cast<int>(word_offset);
*misspelledLength = static_cast<int>(word_length);
return false;
}
bool MockSpellCheck::InitializeIfNeeded() {
// Exit if we have already initialized this object.
if (initialized_)
return false;
// Create a table that consists of misspelled words used in WebKit layout
// tests.
// Since WebKit layout tests don't have so many misspelled words as
// well-spelled words, it is easier to compare the given word with misspelled
// ones than to compare with well-spelled ones.
static const char* kMisspelledWords[] = {
// These words are known misspelled words in webkit tests.
// If there are other misspelled words in webkit tests, please add them in
// this array.
"foo",
"Foo",
"baz",
"fo",
"LibertyF",
"chello",
"xxxtestxxx",
"XXxxx",
"Textx",
"blockquoted",
"asd",
"Lorem",
"Nunc",
"Curabitur",
"eu",
"adlj",
"adaasj",
"sdklj",
"jlkds",
"jsaada",
"jlda",
"zz",
"contentEditable",
// The following words are used by unit tests.
"ifmmp",
"qwertyuiopasd",
"qwertyuiopasdf",
};
misspelled_words_.clear();
for (size_t i = 0; i < arraysize(kMisspelledWords); ++i) {
misspelled_words_.insert(std::make_pair<string16, bool>(
ASCIIToUTF16(kMisspelledWords[i]), false));
}
// Mark as initialized to prevent this object from being initialized twice
// or more.
initialized_ = true;
// Since this MockSpellCheck class doesn't download dictionaries, this
// function always returns false.
return false;
}
void MockSpellCheck::FillSuggestions(const string16& word,
std::vector<string16>* suggestions) {
if (word == ASCIIToUTF16("wellcome"))
suggestions->push_back(ASCIIToUTF16("welcome"));
}