1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
|
// 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/stl_util.h"
#include "base/strings/utf_string_conversions.h"
#include "components/spellcheck/common/spellcheck_marker.h"
#include "components/spellcheck/renderer/spellcheck_provider_test.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "third_party/WebKit/public/platform/WebString.h"
// Tests for Hunspell functionality in SpellcheckingProvider
using base::ASCIIToUTF16;
using base::WideToUTF16;
namespace {
TEST_F(SpellCheckProviderTest, UsingHunspell) {
FakeTextCheckingCompletion completion;
provider_.RequestTextChecking(blink::WebString("hello"),
&completion,
std::vector<SpellCheckMarker>());
EXPECT_EQ(completion.completion_count_, 1U);
EXPECT_EQ(provider_.messages_.size(), 0U);
EXPECT_EQ(provider_.pending_text_request_size(), 0U);
}
// Tests that the SpellCheckProvider object sends a spellcheck request when a
// user finishes typing a word. Also this test verifies that this object checks
// only a line being edited by the user.
TEST_F(SpellCheckProviderTest, MultiLineText) {
FakeTextCheckingCompletion completion;
// Verify that the SpellCheckProvider class does not spellcheck empty text.
provider_.ResetResult();
provider_.RequestTextChecking(
blink::WebString(), &completion, std::vector<SpellCheckMarker>());
EXPECT_TRUE(provider_.text_.empty());
// Verify that the SpellCheckProvider class does not spellcheck text while we
// are typing a word.
provider_.ResetResult();
provider_.RequestTextChecking(
blink::WebString("First"), &completion, std::vector<SpellCheckMarker>());
EXPECT_TRUE(provider_.text_.empty());
// Verify that the SpellCheckProvider class spellcheck the first word when we
// type a space key, i.e. when we finish typing a word.
provider_.ResetResult();
provider_.RequestTextChecking(blink::WebString("First "),
&completion,
std::vector<SpellCheckMarker>());
EXPECT_EQ(ASCIIToUTF16("First "), provider_.text_);
// Verify that the SpellCheckProvider class spellcheck the first line when we
// type a return key, i.e. when we finish typing a line.
provider_.ResetResult();
provider_.RequestTextChecking(blink::WebString("First Second\n"),
&completion,
std::vector<SpellCheckMarker>());
EXPECT_EQ(ASCIIToUTF16("First Second\n"), provider_.text_);
// Verify that the SpellCheckProvider class spellcheck the lines when we
// finish typing a word "Third" to the second line.
provider_.ResetResult();
provider_.RequestTextChecking(blink::WebString("First Second\nThird "),
&completion,
std::vector<SpellCheckMarker>());
EXPECT_EQ(ASCIIToUTF16("First Second\nThird "), provider_.text_);
// Verify that the SpellCheckProvider class does not send a spellcheck request
// when a user inserts whitespace characters.
provider_.ResetResult();
provider_.RequestTextChecking(blink::WebString("First Second\nThird "),
&completion,
std::vector<SpellCheckMarker>());
EXPECT_TRUE(provider_.text_.empty());
// Verify that the SpellCheckProvider class spellcheck the lines when we type
// a period.
provider_.ResetResult();
provider_.RequestTextChecking(
blink::WebString("First Second\nThird Fourth."),
&completion,
std::vector<SpellCheckMarker>());
EXPECT_EQ(ASCIIToUTF16("First Second\nThird Fourth."), provider_.text_);
}
// Tests that the SpellCheckProvider class does not send requests to the
// spelling service when not necessary.
TEST_F(SpellCheckProviderTest, CancelUnnecessaryRequests) {
FakeTextCheckingCompletion completion;
provider_.RequestTextChecking(blink::WebString("hello."),
&completion,
std::vector<SpellCheckMarker>());
EXPECT_EQ(completion.completion_count_, 1U);
EXPECT_EQ(completion.cancellation_count_, 0U);
EXPECT_EQ(provider_.spelling_service_call_count_, 1U);
// Test that the SpellCheckProvider does not send a request with the same text
// as above.
provider_.RequestTextChecking(blink::WebString("hello."),
&completion,
std::vector<SpellCheckMarker>());
EXPECT_EQ(completion.completion_count_, 2U);
EXPECT_EQ(completion.cancellation_count_, 0U);
EXPECT_EQ(provider_.spelling_service_call_count_, 1U);
// Test that the SpellCheckProvider class cancels an incoming request that
// does not include any words.
provider_.RequestTextChecking(blink::WebString(":-)"),
&completion,
std::vector<SpellCheckMarker>());
EXPECT_EQ(completion.completion_count_, 3U);
EXPECT_EQ(completion.cancellation_count_, 1U);
EXPECT_EQ(provider_.spelling_service_call_count_, 1U);
// Test that the SpellCheckProvider class sends a request when it receives a
// Russian word.
const wchar_t kRussianWord[] = L"\x0431\x0451\x0434\x0440\x0430";
provider_.RequestTextChecking(blink::WebString(WideToUTF16(kRussianWord)),
&completion,
std::vector<SpellCheckMarker>());
EXPECT_EQ(completion.completion_count_, 4U);
EXPECT_EQ(completion.cancellation_count_, 1U);
EXPECT_EQ(provider_.spelling_service_call_count_, 2U);
}
// Tests that the SpellCheckProvider calls didFinishCheckingText() when
// necessary.
TEST_F(SpellCheckProviderTest, CompleteNecessaryRequests) {
FakeTextCheckingCompletion completion;
base::string16 text = ASCIIToUTF16("Icland is an icland ");
provider_.RequestTextChecking(
blink::WebString(text), &completion, std::vector<SpellCheckMarker>());
EXPECT_EQ(0U, completion.cancellation_count_) << "Should finish checking \""
<< text << "\"";
const int kSubstringLength = 18;
base::string16 substring = text.substr(0, kSubstringLength);
provider_.RequestTextChecking(blink::WebString(substring),
&completion,
std::vector<SpellCheckMarker>());
EXPECT_EQ(0U, completion.cancellation_count_) << "Should finish checking \""
<< substring << "\"";
provider_.RequestTextChecking(
blink::WebString(text), &completion, std::vector<SpellCheckMarker>());
EXPECT_EQ(0U, completion.cancellation_count_) << "Should finish checking \""
<< text << "\"";
}
// Tests that the SpellCheckProvider cancels spelling requests in the middle of
// a word.
TEST_F(SpellCheckProviderTest, CancelMidWordRequests) {
FakeTextCheckingCompletion completion;
provider_.RequestTextChecking(blink::WebString("hello "),
&completion,
std::vector<SpellCheckMarker>());
EXPECT_EQ(completion.completion_count_, 1U);
EXPECT_EQ(completion.cancellation_count_, 0U);
EXPECT_EQ(provider_.spelling_service_call_count_, 1U);
provider_.RequestTextChecking(blink::WebString("hello world"),
&completion,
std::vector<SpellCheckMarker>());
EXPECT_EQ(completion.completion_count_, 2U);
EXPECT_EQ(completion.cancellation_count_, 1U);
EXPECT_EQ(provider_.spelling_service_call_count_, 1U);
provider_.RequestTextChecking(blink::WebString("hello world."),
&completion,
std::vector<SpellCheckMarker>());
EXPECT_EQ(completion.completion_count_, 3U);
EXPECT_EQ(completion.cancellation_count_, 1U);
EXPECT_EQ(provider_.spelling_service_call_count_, 2U);
}
} // namespace
|
