Make castv2 performance test work.
[chromium-blink-merge.git] / chrome / browser / spellchecker / spellcheck_custom_dictionary_unittest.cc
blob3947eecf96701950df50a1630e633f3d52cbef23
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.
5 #include <vector>
7 #include "base/files/file_util.h"
8 #include "base/metrics/histogram_samples.h"
9 #include "base/metrics/statistics_recorder.h"
10 #include "base/strings/string_number_conversions.h"
11 #include "chrome/browser/spellchecker/spellcheck_custom_dictionary.h"
12 #include "chrome/browser/spellchecker/spellcheck_factory.h"
13 #include "chrome/browser/spellchecker/spellcheck_host_metrics.h"
14 #include "chrome/browser/spellchecker/spellcheck_service.h"
15 #include "chrome/common/chrome_constants.h"
16 #include "chrome/common/spellcheck_common.h"
17 #include "chrome/test/base/testing_profile.h"
18 #include "content/public/test/test_browser_thread_bundle.h"
19 #include "net/url_request/test_url_fetcher_factory.h"
20 #include "sync/api/sync_change.h"
21 #include "sync/api/sync_change_processor_wrapper_for_test.h"
22 #include "sync/api/sync_data.h"
23 #include "sync/api/sync_error_factory.h"
24 #include "sync/api/sync_error_factory_mock.h"
25 #include "sync/protocol/sync.pb.h"
26 #include "testing/gmock/include/gmock/gmock.h"
27 #include "testing/gtest/include/gtest/gtest.h"
29 #if defined(OS_WIN)
30 // For version specific disabled tests below (http://crbug.com/230534).
31 #include "base/win/windows_version.h"
32 #endif
34 using base::HistogramBase;
35 using base::HistogramSamples;
36 using base::StatisticsRecorder;
37 using chrome::spellcheck_common::WordList;
38 using chrome::spellcheck_common::WordSet;
40 namespace {
42 // Get all sync data for the custom dictionary without limiting to maximum
43 // number of syncable words.
44 syncer::SyncDataList GetAllSyncDataNoLimit(
45 const SpellcheckCustomDictionary* dictionary) {
46 syncer::SyncDataList data;
47 std::string word;
48 const WordSet& words = dictionary->GetWords();
49 for (WordSet::const_iterator it = words.begin(); it != words.end(); ++it) {
50 word = *it;
51 sync_pb::EntitySpecifics specifics;
52 specifics.mutable_dictionary()->set_word(word);
53 data.push_back(syncer::SyncData::CreateLocalData(word, word, specifics));
55 return data;
58 } // namespace
60 static KeyedService* BuildSpellcheckService(content::BrowserContext* profile) {
61 return new SpellcheckService(static_cast<Profile*>(profile));
64 class SpellcheckCustomDictionaryTest : public testing::Test {
65 protected:
66 void SetUp() override {
67 // Use SetTestingFactoryAndUse to force creation and initialization.
68 SpellcheckServiceFactory::GetInstance()->SetTestingFactoryAndUse(
69 &profile_, &BuildSpellcheckService);
71 StatisticsRecorder::Initialize();
74 // A wrapper around SpellcheckCustomDictionary::LoadDictionaryFile private
75 // function to avoid a large number of FRIEND_TEST declarations in
76 // SpellcheckCustomDictionary.
77 chrome::spellcheck_common::WordList LoadDictionaryFile(
78 const base::FilePath& path) {
79 return SpellcheckCustomDictionary::LoadDictionaryFile(path);
82 // A wrapper around SpellcheckCustomDictionary::UpdateDictionaryFile private
83 // function to avoid a large number of FRIEND_TEST declarations in
84 // SpellcheckCustomDictionary.
85 void UpdateDictionaryFile(
86 const SpellcheckCustomDictionary::Change& dictionary_change,
87 const base::FilePath& path) {
88 SpellcheckCustomDictionary::UpdateDictionaryFile(dictionary_change, path);
91 // A wrapper around SpellcheckCustomDictionary::OnLoaded private method to
92 // avoid a large number of FRIEND_TEST declarations in
93 // SpellcheckCustomDictionary.
94 void OnLoaded(
95 SpellcheckCustomDictionary& dictionary,
96 const chrome::spellcheck_common::WordList& custom_words) {
97 dictionary.OnLoaded(custom_words);
100 // A wrapper around SpellcheckCustomDictionary::Apply private method to avoid
101 // a large number of FRIEND_TEST declarations in SpellcheckCustomDictionary.
102 void Apply(
103 SpellcheckCustomDictionary& dictionary,
104 const SpellcheckCustomDictionary::Change& change) {
105 return dictionary.Apply(change);
108 content::TestBrowserThreadBundle thread_bundle_;
110 TestingProfile profile_;
111 net::TestURLFetcherFactory fetcher_factory_;
114 // An implementation of SyncErrorFactory that does not upload the error message
115 // and updates an outside error counter. This lets us know the number of error
116 // messages in an instance of this class after that instance is deleted.
117 class SyncErrorFactoryStub : public syncer::SyncErrorFactory {
118 public:
119 explicit SyncErrorFactoryStub(int* error_counter)
120 : error_counter_(error_counter) {}
121 ~SyncErrorFactoryStub() override {}
123 // Overridden from syncer::SyncErrorFactory:
124 syncer::SyncError CreateAndUploadError(
125 const tracked_objects::Location& location,
126 const std::string& message) override {
127 (*error_counter_)++;
128 return syncer::SyncError(location,
129 syncer::SyncError::DATATYPE_ERROR,
130 message,
131 syncer::DICTIONARY);
134 private:
135 int* error_counter_;
136 DISALLOW_COPY_AND_ASSIGN(SyncErrorFactoryStub);
139 // Counts the number of notifications for dictionary load and change.
140 class DictionaryObserverCounter : public SpellcheckCustomDictionary::Observer {
141 public:
142 DictionaryObserverCounter() : loads_(0), changes_(0) {}
143 virtual ~DictionaryObserverCounter() {}
145 int loads() const { return loads_; }
146 int changes() const { return changes_; }
148 // Overridden from SpellcheckCustomDictionary::Observer:
149 void OnCustomDictionaryLoaded() override { loads_++; }
150 void OnCustomDictionaryChanged(
151 const SpellcheckCustomDictionary::Change& change) override {
152 changes_++;
155 private:
156 int loads_;
157 int changes_;
158 DISALLOW_COPY_AND_ASSIGN(DictionaryObserverCounter);
161 TEST_F(SpellcheckCustomDictionaryTest, SaveAndLoad) {
162 base::FilePath path =
163 profile_.GetPath().Append(chrome::kCustomDictionaryFileName);
164 WordList loaded_custom_words = LoadDictionaryFile(path);
166 // The custom word list should be empty now.
167 WordList expected;
168 EXPECT_EQ(expected, loaded_custom_words);
170 SpellcheckCustomDictionary::Change change;
171 change.AddWord("bar");
172 change.AddWord("foo");
174 UpdateDictionaryFile(change, path);
175 expected.push_back("bar");
176 expected.push_back("foo");
178 // The custom word list should include written words.
179 loaded_custom_words = LoadDictionaryFile(path);
180 EXPECT_EQ(expected, loaded_custom_words);
182 change = SpellcheckCustomDictionary::Change();
183 change.RemoveWord("bar");
184 change.RemoveWord("foo");
185 UpdateDictionaryFile(change, path);
186 loaded_custom_words = LoadDictionaryFile(path);
187 expected.clear();
188 EXPECT_EQ(expected, loaded_custom_words);
191 TEST_F(SpellcheckCustomDictionaryTest, MultiProfile) {
192 SpellcheckService* spellcheck_service =
193 SpellcheckServiceFactory::GetForContext(&profile_);
194 SpellcheckCustomDictionary* custom_dictionary =
195 spellcheck_service->GetCustomDictionary();
196 TestingProfile profile2;
197 SpellcheckService* spellcheck_service2 =
198 static_cast<SpellcheckService*>(
199 SpellcheckServiceFactory::GetInstance()->SetTestingFactoryAndUse(
200 &profile2, &BuildSpellcheckService));
201 SpellcheckCustomDictionary* custom_dictionary2 =
202 spellcheck_service2->GetCustomDictionary();
204 WordSet expected1;
205 WordSet expected2;
207 custom_dictionary->AddWord("foo");
208 custom_dictionary->AddWord("bar");
209 expected1.insert("foo");
210 expected1.insert("bar");
212 custom_dictionary2->AddWord("hoge");
213 custom_dictionary2->AddWord("fuga");
214 expected2.insert("hoge");
215 expected2.insert("fuga");
217 WordSet actual1 = custom_dictionary->GetWords();
218 EXPECT_EQ(actual1, expected1);
220 WordSet actual2 = custom_dictionary2->GetWords();
221 EXPECT_EQ(actual2, expected2);
224 // Legacy empty dictionary should be converted to new format empty dictionary.
225 TEST_F(SpellcheckCustomDictionaryTest, LegacyEmptyDictionaryShouldBeConverted) {
226 base::FilePath path =
227 profile_.GetPath().Append(chrome::kCustomDictionaryFileName);
229 std::string content;
230 base::WriteFile(path, content.c_str(), content.length());
231 WordList loaded_custom_words = LoadDictionaryFile(path);
232 EXPECT_TRUE(loaded_custom_words.empty());
235 // Legacy dictionary with two words should be converted to new format dictionary
236 // with two words.
237 TEST_F(SpellcheckCustomDictionaryTest,
238 LegacyDictionaryWithTwoWordsShouldBeConverted) {
239 base::FilePath path =
240 profile_.GetPath().Append(chrome::kCustomDictionaryFileName);
242 std::string content = "foo\nbar\nfoo\n";
243 base::WriteFile(path, content.c_str(), content.length());
244 WordList loaded_custom_words = LoadDictionaryFile(path);
245 WordList expected;
246 expected.push_back("bar");
247 expected.push_back("foo");
248 EXPECT_EQ(expected, loaded_custom_words);
251 // Illegal words should be removed. Leading and trailing whitespace should be
252 // trimmed.
253 TEST_F(SpellcheckCustomDictionaryTest,
254 IllegalWordsShouldBeRemovedFromDictionary) {
255 base::FilePath path =
256 profile_.GetPath().Append(chrome::kCustomDictionaryFileName);
258 std::string content = "foo\n foo bar \n\n \nbar\n"
259 "01234567890123456789012345678901234567890123456789"
260 "01234567890123456789012345678901234567890123456789";
261 base::WriteFile(path, content.c_str(), content.length());
262 WordList loaded_custom_words = LoadDictionaryFile(path);
263 WordList expected;
264 expected.push_back("bar");
265 expected.push_back("foo");
266 expected.push_back("foo bar");
267 EXPECT_EQ(expected, loaded_custom_words);
270 // Write to dictionary should backup previous version and write the word to the
271 // end of the dictionary. If the dictionary file is corrupted on disk, the
272 // previous version should be reloaded.
273 TEST_F(SpellcheckCustomDictionaryTest, CorruptedWriteShouldBeRecovered) {
274 base::FilePath path =
275 profile_.GetPath().Append(chrome::kCustomDictionaryFileName);
277 std::string content = "foo\nbar";
278 base::WriteFile(path, content.c_str(), content.length());
279 WordList loaded_custom_words = LoadDictionaryFile(path);
280 WordList expected;
281 expected.push_back("bar");
282 expected.push_back("foo");
283 EXPECT_EQ(expected, loaded_custom_words);
285 SpellcheckCustomDictionary::Change change;
286 change.AddWord("baz");
287 UpdateDictionaryFile(change, path);
288 content.clear();
289 base::ReadFileToString(path, &content);
290 content.append("corruption");
291 base::WriteFile(path, content.c_str(), content.length());
292 loaded_custom_words = LoadDictionaryFile(path);
293 EXPECT_EQ(expected, loaded_custom_words);
296 TEST_F(SpellcheckCustomDictionaryTest,
297 GetAllSyncDataAccuratelyReflectsDictionaryState) {
298 SpellcheckCustomDictionary* dictionary =
299 SpellcheckServiceFactory::GetForContext(
300 &profile_)->GetCustomDictionary();
302 syncer::SyncDataList data = dictionary->GetAllSyncData(syncer::DICTIONARY);
303 EXPECT_TRUE(data.empty());
305 EXPECT_TRUE(dictionary->AddWord("bar"));
306 EXPECT_TRUE(dictionary->AddWord("foo"));
308 data = dictionary->GetAllSyncData(syncer::DICTIONARY);
309 EXPECT_EQ(2UL, data.size());
310 std::vector<std::string> words;
311 words.push_back("bar");
312 words.push_back("foo");
313 for (size_t i = 0; i < data.size(); i++) {
314 EXPECT_TRUE(data[i].GetSpecifics().has_dictionary());
315 EXPECT_EQ(syncer::DICTIONARY, data[i].GetDataType());
316 EXPECT_EQ(words[i], syncer::SyncDataLocal(data[i]).GetTag());
317 EXPECT_EQ(words[i], data[i].GetSpecifics().dictionary().word());
320 EXPECT_TRUE(dictionary->RemoveWord("bar"));
321 EXPECT_TRUE(dictionary->RemoveWord("foo"));
323 data = dictionary->GetAllSyncData(syncer::DICTIONARY);
324 EXPECT_TRUE(data.empty());
327 TEST_F(SpellcheckCustomDictionaryTest, GetAllSyncDataHasLimit) {
328 SpellcheckCustomDictionary* dictionary =
329 SpellcheckServiceFactory::GetForContext(
330 &profile_)->GetCustomDictionary();
332 SpellcheckCustomDictionary::Change change;
333 for (size_t i = 0;
334 i < chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS - 1;
335 i++) {
336 change.AddWord("foo" + base::Uint64ToString(i));
338 Apply(*dictionary, change);
339 EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS - 1,
340 dictionary->GetWords().size());
341 EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS - 1,
342 dictionary->GetAllSyncData(syncer::DICTIONARY).size());
344 dictionary->AddWord("baz");
345 EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
346 dictionary->GetWords().size());
347 EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
348 dictionary->GetAllSyncData(syncer::DICTIONARY).size());
350 dictionary->AddWord("bar");
351 EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS + 1,
352 dictionary->GetWords().size());
353 EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
354 dictionary->GetAllSyncData(syncer::DICTIONARY).size());
356 dictionary->AddWord("snafoo");
357 EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS + 2,
358 dictionary->GetWords().size());
359 EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
360 dictionary->GetAllSyncData(syncer::DICTIONARY).size());
363 TEST_F(SpellcheckCustomDictionaryTest, ProcessSyncChanges) {
364 SpellcheckService* spellcheck_service =
365 SpellcheckServiceFactory::GetForContext(&profile_);
366 SpellcheckCustomDictionary* dictionary =
367 spellcheck_service->GetCustomDictionary();
369 dictionary->AddWord("foo");
370 dictionary->AddWord("bar");
372 syncer::SyncChangeList changes;
374 // Add existing word.
375 std::string word = "foo";
376 sync_pb::EntitySpecifics specifics;
377 specifics.mutable_dictionary()->set_word(word);
378 changes.push_back(syncer::SyncChange(
379 FROM_HERE,
380 syncer::SyncChange::ACTION_ADD,
381 syncer::SyncData::CreateLocalData(word, word, specifics)));
384 // Add invalid word. This word is too long.
385 std::string word = "01234567890123456789012345678901234567890123456789"
386 "01234567890123456789012345678901234567890123456789";
387 sync_pb::EntitySpecifics specifics;
388 specifics.mutable_dictionary()->set_word(word);
389 changes.push_back(syncer::SyncChange(
390 FROM_HERE,
391 syncer::SyncChange::ACTION_ADD,
392 syncer::SyncData::CreateLocalData(word, word, specifics)));
395 // Add valid word.
396 std::string word = "baz";
397 sync_pb::EntitySpecifics specifics;
398 specifics.mutable_dictionary()->set_word(word);
399 changes.push_back(syncer::SyncChange(
400 FROM_HERE,
401 syncer::SyncChange::ACTION_ADD,
402 syncer::SyncData::CreateLocalData(word, word, specifics)));
405 // Remove missing word.
406 std::string word = "snafoo";
407 sync_pb::EntitySpecifics specifics;
408 specifics.mutable_dictionary()->set_word(word);
409 changes.push_back(syncer::SyncChange(
410 FROM_HERE,
411 syncer::SyncChange::ACTION_DELETE,
412 syncer::SyncData::CreateLocalData(word, word, specifics)));
415 // Remove existing word.
416 std::string word = "bar";
417 sync_pb::EntitySpecifics specifics;
418 specifics.mutable_dictionary()->set_word(word);
419 changes.push_back(syncer::SyncChange(
420 FROM_HERE,
421 syncer::SyncChange::ACTION_DELETE,
422 syncer::SyncData::CreateLocalData(word, word, specifics)));
425 EXPECT_FALSE(dictionary->ProcessSyncChanges(FROM_HERE, changes).IsSet());
427 const WordSet& words = dictionary->GetWords();
428 EXPECT_EQ(2UL, words.size());
429 EXPECT_EQ(0UL, words.count("bar"));
430 EXPECT_EQ(1UL, words.count("foo"));
431 EXPECT_EQ(1UL, words.count("baz"));
434 TEST_F(SpellcheckCustomDictionaryTest, MergeDataAndStartSyncing) {
435 SpellcheckService* spellcheck_service =
436 SpellcheckServiceFactory::GetForContext(&profile_);
437 SpellcheckCustomDictionary* custom_dictionary =
438 spellcheck_service->GetCustomDictionary();
439 TestingProfile profile2;
440 SpellcheckService* spellcheck_service2 =
441 static_cast<SpellcheckService*>(
442 SpellcheckServiceFactory::GetInstance()->SetTestingFactoryAndUse(
443 &profile2, &BuildSpellcheckService));
444 SpellcheckCustomDictionary* custom_dictionary2 =
445 spellcheck_service2->GetCustomDictionary();
447 SpellcheckCustomDictionary::Change change;
448 for (size_t i = 0;
449 i < chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS / 2;
450 ++i) {
451 change.AddWord("foo" + base::Uint64ToString(i));
453 Apply(*custom_dictionary, change);
455 SpellcheckCustomDictionary::Change change2;
456 for (size_t i = 0;
457 i < chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS / 2;
458 ++i) {
459 change2.AddWord("bar" + base::Uint64ToString(i));
461 Apply(*custom_dictionary2, change2);
463 int error_counter = 0;
464 EXPECT_FALSE(
465 custom_dictionary->MergeDataAndStartSyncing(
466 syncer::DICTIONARY,
467 custom_dictionary2->GetAllSyncData(
468 syncer::DICTIONARY),
469 scoped_ptr<syncer::SyncChangeProcessor>(
470 new syncer::SyncChangeProcessorWrapperForTest(
471 custom_dictionary2)),
472 scoped_ptr<syncer::SyncErrorFactory>(
473 new SyncErrorFactoryStub(&error_counter)))
474 .error()
475 .IsSet());
476 EXPECT_EQ(0, error_counter);
477 EXPECT_TRUE(custom_dictionary->IsSyncing());
479 WordSet words = custom_dictionary->GetWords();
480 WordSet words2 = custom_dictionary2->GetWords();
481 EXPECT_EQ(words.size(), words2.size());
482 EXPECT_EQ(words, words2);
485 TEST_F(SpellcheckCustomDictionaryTest, DictionaryTooBigBeforeSyncing) {
486 SpellcheckService* spellcheck_service =
487 SpellcheckServiceFactory::GetForContext(&profile_);
488 SpellcheckCustomDictionary* custom_dictionary =
489 spellcheck_service->GetCustomDictionary();
490 TestingProfile profile2;
491 SpellcheckService* spellcheck_service2 =
492 static_cast<SpellcheckService*>(
493 SpellcheckServiceFactory::GetInstance()->SetTestingFactoryAndUse(
494 &profile2, &BuildSpellcheckService));
495 SpellcheckCustomDictionary* custom_dictionary2 =
496 spellcheck_service2->GetCustomDictionary();
498 SpellcheckCustomDictionary::Change change;
499 for (size_t i = 0;
500 i < chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS + 1;
501 ++i) {
502 change.AddWord("foo" + base::Uint64ToString(i));
504 Apply(*custom_dictionary, change);
506 int error_counter = 0;
507 EXPECT_FALSE(
508 custom_dictionary->MergeDataAndStartSyncing(
509 syncer::DICTIONARY,
510 custom_dictionary2->GetAllSyncData(
511 syncer::DICTIONARY),
512 scoped_ptr<syncer::SyncChangeProcessor>(
513 new syncer::SyncChangeProcessorWrapperForTest(
514 custom_dictionary2)),
515 scoped_ptr<syncer::SyncErrorFactory>(
516 new SyncErrorFactoryStub(&error_counter)))
517 .error()
518 .IsSet());
519 EXPECT_EQ(0, error_counter);
520 EXPECT_FALSE(custom_dictionary->IsSyncing());
522 EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS + 1,
523 custom_dictionary->GetWords().size());
524 EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
525 custom_dictionary2->GetWords().size());
527 EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
528 custom_dictionary->GetAllSyncData(syncer::DICTIONARY).size());
529 EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
530 custom_dictionary2->GetAllSyncData(syncer::DICTIONARY).size());
533 TEST_F(SpellcheckCustomDictionaryTest, DictionaryTooBigAndServerFull) {
534 SpellcheckService* spellcheck_service =
535 SpellcheckServiceFactory::GetForContext(&profile_);
536 SpellcheckCustomDictionary* custom_dictionary =
537 spellcheck_service->GetCustomDictionary();
538 TestingProfile profile2;
539 SpellcheckService* spellcheck_service2 =
540 static_cast<SpellcheckService*>(
541 SpellcheckServiceFactory::GetInstance()->SetTestingFactoryAndUse(
542 &profile2, &BuildSpellcheckService));
543 SpellcheckCustomDictionary* custom_dictionary2 =
544 spellcheck_service2->GetCustomDictionary();
546 SpellcheckCustomDictionary::Change change;
547 SpellcheckCustomDictionary::Change change2;
548 for (size_t i = 0;
549 i < chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS;
550 ++i) {
551 change.AddWord("foo" + base::Uint64ToString(i));
552 change2.AddWord("bar" + base::Uint64ToString(i));
554 change.AddWord("foo");
555 Apply(*custom_dictionary, change);
556 Apply(*custom_dictionary2, change2);
558 EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS + 1,
559 custom_dictionary->GetWords().size());
560 EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
561 custom_dictionary2->GetWords().size());
563 int error_counter = 0;
564 EXPECT_FALSE(
565 custom_dictionary->MergeDataAndStartSyncing(
566 syncer::DICTIONARY,
567 custom_dictionary2->GetAllSyncData(
568 syncer::DICTIONARY),
569 scoped_ptr<syncer::SyncChangeProcessor>(
570 new syncer::SyncChangeProcessorWrapperForTest(
571 custom_dictionary2)),
572 scoped_ptr<syncer::SyncErrorFactory>(
573 new SyncErrorFactoryStub(&error_counter)))
574 .error()
575 .IsSet());
576 EXPECT_EQ(0, error_counter);
577 EXPECT_FALSE(custom_dictionary->IsSyncing());
579 EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS * 2 + 1,
580 custom_dictionary->GetWords().size());
581 EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
582 custom_dictionary2->GetWords().size());
584 EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
585 custom_dictionary->GetAllSyncData(syncer::DICTIONARY).size());
586 EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
587 custom_dictionary2->GetAllSyncData(syncer::DICTIONARY).size());
590 TEST_F(SpellcheckCustomDictionaryTest, ServerTooBig) {
591 SpellcheckService* spellcheck_service =
592 SpellcheckServiceFactory::GetForContext(&profile_);
593 SpellcheckCustomDictionary* custom_dictionary =
594 spellcheck_service->GetCustomDictionary();
595 TestingProfile profile2;
596 SpellcheckService* spellcheck_service2 =
597 static_cast<SpellcheckService*>(
598 SpellcheckServiceFactory::GetInstance()->SetTestingFactoryAndUse(
599 &profile2, &BuildSpellcheckService));
600 SpellcheckCustomDictionary* custom_dictionary2 =
601 spellcheck_service2->GetCustomDictionary();
603 SpellcheckCustomDictionary::Change change;
604 SpellcheckCustomDictionary::Change change2;
605 for (size_t i = 0;
606 i < chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS + 1;
607 ++i) {
608 change.AddWord("foo" + base::Uint64ToString(i));
609 change2.AddWord("bar" + base::Uint64ToString(i));
611 Apply(*custom_dictionary, change);
612 Apply(*custom_dictionary2, change2);
614 EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS + 1,
615 custom_dictionary->GetWords().size());
616 EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS + 1,
617 custom_dictionary2->GetWords().size());
619 int error_counter = 0;
620 EXPECT_FALSE(
621 custom_dictionary->MergeDataAndStartSyncing(
622 syncer::DICTIONARY,
623 GetAllSyncDataNoLimit(custom_dictionary2),
624 scoped_ptr<syncer::SyncChangeProcessor>(
625 new syncer::SyncChangeProcessorWrapperForTest(
626 custom_dictionary2)),
627 scoped_ptr<syncer::SyncErrorFactory>(
628 new SyncErrorFactoryStub(&error_counter)))
629 .error()
630 .IsSet());
631 EXPECT_EQ(0, error_counter);
632 EXPECT_FALSE(custom_dictionary->IsSyncing());
634 EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS * 2 + 2,
635 custom_dictionary->GetWords().size());
636 EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS + 1,
637 custom_dictionary2->GetWords().size());
639 EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
640 custom_dictionary->GetAllSyncData(syncer::DICTIONARY).size());
641 EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
642 custom_dictionary2->GetAllSyncData(syncer::DICTIONARY).size());
645 TEST_F(SpellcheckCustomDictionaryTest, DictionaryTooBigToStartSyncing) {
646 SpellcheckService* spellcheck_service =
647 SpellcheckServiceFactory::GetForContext(&profile_);
648 SpellcheckCustomDictionary* custom_dictionary =
649 spellcheck_service->GetCustomDictionary();
650 TestingProfile profile2;
651 SpellcheckService* spellcheck_service2 =
652 static_cast<SpellcheckService*>(
653 SpellcheckServiceFactory::GetInstance()->SetTestingFactoryAndUse(
654 &profile2, &BuildSpellcheckService));
655 SpellcheckCustomDictionary* custom_dictionary2 =
656 spellcheck_service2->GetCustomDictionary();
658 SpellcheckCustomDictionary::Change change;
659 for (size_t i = 0;
660 i < chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS - 1;
661 ++i) {
662 change.AddWord("foo" + base::Uint64ToString(i));
664 Apply(*custom_dictionary, change);
666 custom_dictionary2->AddWord("bar");
667 custom_dictionary2->AddWord("baz");
669 int error_counter = 0;
670 EXPECT_FALSE(
671 custom_dictionary->MergeDataAndStartSyncing(
672 syncer::DICTIONARY,
673 custom_dictionary2->GetAllSyncData(
674 syncer::DICTIONARY),
675 scoped_ptr<syncer::SyncChangeProcessor>(
676 new syncer::SyncChangeProcessorWrapperForTest(
677 custom_dictionary2)),
678 scoped_ptr<syncer::SyncErrorFactory>(
679 new SyncErrorFactoryStub(&error_counter)))
680 .error()
681 .IsSet());
682 EXPECT_EQ(0, error_counter);
683 EXPECT_FALSE(custom_dictionary->IsSyncing());
685 EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS + 1,
686 custom_dictionary->GetWords().size());
687 EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
688 custom_dictionary2->GetWords().size());
690 EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
691 custom_dictionary->GetAllSyncData(syncer::DICTIONARY).size());
692 EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
693 custom_dictionary2->GetAllSyncData(syncer::DICTIONARY).size());
696 TEST_F(SpellcheckCustomDictionaryTest, DictionaryTooBigToContiueSyncing) {
697 SpellcheckService* spellcheck_service =
698 SpellcheckServiceFactory::GetForContext(&profile_);
699 SpellcheckCustomDictionary* custom_dictionary =
700 spellcheck_service->GetCustomDictionary();
701 TestingProfile profile2;
702 SpellcheckService* spellcheck_service2 =
703 static_cast<SpellcheckService*>(
704 SpellcheckServiceFactory::GetInstance()->SetTestingFactoryAndUse(
705 &profile2, &BuildSpellcheckService));
706 SpellcheckCustomDictionary* custom_dictionary2 =
707 spellcheck_service2->GetCustomDictionary();
709 SpellcheckCustomDictionary::Change change;
710 for (size_t i = 0;
711 i < chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS - 1;
712 ++i) {
713 change.AddWord("foo" + base::Uint64ToString(i));
715 Apply(*custom_dictionary, change);
717 int error_counter = 0;
718 EXPECT_FALSE(
719 custom_dictionary->MergeDataAndStartSyncing(
720 syncer::DICTIONARY,
721 custom_dictionary2->GetAllSyncData(
722 syncer::DICTIONARY),
723 scoped_ptr<syncer::SyncChangeProcessor>(
724 new syncer::SyncChangeProcessorWrapperForTest(
725 custom_dictionary2)),
726 scoped_ptr<syncer::SyncErrorFactory>(
727 new SyncErrorFactoryStub(&error_counter)))
728 .error()
729 .IsSet());
730 EXPECT_EQ(0, error_counter);
731 EXPECT_TRUE(custom_dictionary->IsSyncing());
733 custom_dictionary->AddWord("bar");
734 EXPECT_EQ(0, error_counter);
735 EXPECT_TRUE(custom_dictionary->IsSyncing());
737 custom_dictionary->AddWord("baz");
738 EXPECT_EQ(0, error_counter);
739 EXPECT_FALSE(custom_dictionary->IsSyncing());
741 EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS + 1,
742 custom_dictionary->GetWords().size());
743 EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
744 custom_dictionary2->GetWords().size());
746 EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
747 custom_dictionary->GetAllSyncData(syncer::DICTIONARY).size());
748 EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
749 custom_dictionary2->GetAllSyncData(syncer::DICTIONARY).size());
752 TEST_F(SpellcheckCustomDictionaryTest, LoadAfterSyncStart) {
753 SpellcheckService* spellcheck_service =
754 SpellcheckServiceFactory::GetForContext(&profile_);
755 SpellcheckCustomDictionary* custom_dictionary =
756 spellcheck_service->GetCustomDictionary();
757 TestingProfile profile2;
758 SpellcheckService* spellcheck_service2 =
759 static_cast<SpellcheckService*>(
760 SpellcheckServiceFactory::GetInstance()->SetTestingFactoryAndUse(
761 &profile2, &BuildSpellcheckService));
762 SpellcheckCustomDictionary* custom_dictionary2 =
763 spellcheck_service2->GetCustomDictionary();
765 custom_dictionary->AddWord("foo");
767 int error_counter = 0;
768 EXPECT_FALSE(
769 custom_dictionary->MergeDataAndStartSyncing(
770 syncer::DICTIONARY,
771 custom_dictionary2->GetAllSyncData(
772 syncer::DICTIONARY),
773 scoped_ptr<syncer::SyncChangeProcessor>(
774 new syncer::SyncChangeProcessorWrapperForTest(
775 custom_dictionary2)),
776 scoped_ptr<syncer::SyncErrorFactory>(
777 new SyncErrorFactoryStub(&error_counter)))
778 .error()
779 .IsSet());
780 EXPECT_EQ(0, error_counter);
781 EXPECT_TRUE(custom_dictionary->IsSyncing());
783 WordList custom_words;
784 custom_words.push_back("bar");
785 OnLoaded(*custom_dictionary, custom_words);
786 EXPECT_TRUE(custom_dictionary->IsSyncing());
788 EXPECT_EQ(2UL, custom_dictionary->GetWords().size());
789 EXPECT_EQ(2UL, custom_dictionary2->GetWords().size());
791 EXPECT_EQ(2UL, custom_dictionary->GetAllSyncData(syncer::DICTIONARY).size());
792 EXPECT_EQ(2UL, custom_dictionary2->GetAllSyncData(syncer::DICTIONARY).size());
795 TEST_F(SpellcheckCustomDictionaryTest, LoadAfterSyncStartTooBigToSync) {
796 SpellcheckService* spellcheck_service =
797 SpellcheckServiceFactory::GetForContext(&profile_);
798 SpellcheckCustomDictionary* custom_dictionary =
799 spellcheck_service->GetCustomDictionary();
800 TestingProfile profile2;
801 SpellcheckService* spellcheck_service2 =
802 static_cast<SpellcheckService*>(
803 SpellcheckServiceFactory::GetInstance()->SetTestingFactoryAndUse(
804 &profile2, &BuildSpellcheckService));
805 SpellcheckCustomDictionary* custom_dictionary2 =
806 spellcheck_service2->GetCustomDictionary();
808 custom_dictionary->AddWord("foo");
810 int error_counter = 0;
811 EXPECT_FALSE(
812 custom_dictionary->MergeDataAndStartSyncing(
813 syncer::DICTIONARY,
814 custom_dictionary2->GetAllSyncData(
815 syncer::DICTIONARY),
816 scoped_ptr<syncer::SyncChangeProcessor>(
817 new syncer::SyncChangeProcessorWrapperForTest(
818 custom_dictionary2)),
819 scoped_ptr<syncer::SyncErrorFactory>(
820 new SyncErrorFactoryStub(&error_counter)))
821 .error()
822 .IsSet());
823 EXPECT_EQ(0, error_counter);
824 EXPECT_TRUE(custom_dictionary->IsSyncing());
826 WordList custom_words;
827 for (size_t i = 0;
828 i < chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS;
829 ++i) {
830 custom_words.push_back("foo" + base::Uint64ToString(i));
832 OnLoaded(*custom_dictionary, custom_words);
833 EXPECT_EQ(0, error_counter);
834 EXPECT_FALSE(custom_dictionary->IsSyncing());
836 EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS + 1,
837 custom_dictionary->GetWords().size());
838 EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
839 custom_dictionary2->GetWords().size());
841 EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
842 custom_dictionary->GetAllSyncData(syncer::DICTIONARY).size());
843 EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
844 custom_dictionary2->GetAllSyncData(syncer::DICTIONARY).size());
847 TEST_F(SpellcheckCustomDictionaryTest, LoadDuplicatesAfterSync) {
848 SpellcheckService* spellcheck_service =
849 SpellcheckServiceFactory::GetForContext(&profile_);
850 SpellcheckCustomDictionary* custom_dictionary =
851 spellcheck_service->GetCustomDictionary();
852 TestingProfile profile2;
853 SpellcheckService* spellcheck_service2 =
854 static_cast<SpellcheckService*>(
855 SpellcheckServiceFactory::GetInstance()->SetTestingFactoryAndUse(
856 &profile2, &BuildSpellcheckService));
857 SpellcheckCustomDictionary* custom_dictionary2 =
858 spellcheck_service2->GetCustomDictionary();
860 WordList to_add;
861 for (size_t i = 0;
862 i < chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS / 2;
863 ++i) {
864 to_add.push_back("foo" + base::Uint64ToString(i));
866 Apply(*custom_dictionary, SpellcheckCustomDictionary::Change(to_add));
868 int error_counter = 0;
869 EXPECT_FALSE(
870 custom_dictionary->MergeDataAndStartSyncing(
871 syncer::DICTIONARY,
872 custom_dictionary2->GetAllSyncData(
873 syncer::DICTIONARY),
874 scoped_ptr<syncer::SyncChangeProcessor>(
875 new syncer::SyncChangeProcessorWrapperForTest(
876 custom_dictionary2)),
877 scoped_ptr<syncer::SyncErrorFactory>(
878 new SyncErrorFactoryStub(&error_counter)))
879 .error()
880 .IsSet());
881 EXPECT_EQ(0, error_counter);
882 EXPECT_TRUE(custom_dictionary->IsSyncing());
884 OnLoaded(*custom_dictionary, to_add);
885 EXPECT_EQ(0, error_counter);
886 EXPECT_TRUE(custom_dictionary->IsSyncing());
888 EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS / 2,
889 custom_dictionary->GetWords().size());
890 EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS / 2,
891 custom_dictionary2->GetWords().size());
893 EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS / 2,
894 custom_dictionary->GetAllSyncData(syncer::DICTIONARY).size());
895 EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS / 2,
896 custom_dictionary2->GetAllSyncData(syncer::DICTIONARY).size());
899 TEST_F(SpellcheckCustomDictionaryTest, DictionaryLoadNotification) {
900 SpellcheckService* spellcheck_service =
901 SpellcheckServiceFactory::GetForContext(&profile_);
902 SpellcheckCustomDictionary* custom_dictionary =
903 spellcheck_service->GetCustomDictionary();
905 DictionaryObserverCounter observer;
906 custom_dictionary->AddObserver(&observer);
908 WordList custom_words;
909 custom_words.push_back("foo");
910 custom_words.push_back("bar");
911 OnLoaded(*custom_dictionary, custom_words);
913 EXPECT_GE(observer.loads(), 1);
914 EXPECT_LE(observer.loads(), 2);
915 EXPECT_EQ(0, observer.changes());
917 custom_dictionary->RemoveObserver(&observer);
920 TEST_F(SpellcheckCustomDictionaryTest, DictionaryAddWordNotification) {
921 SpellcheckService* spellcheck_service =
922 SpellcheckServiceFactory::GetForContext(&profile_);
923 SpellcheckCustomDictionary* custom_dictionary =
924 spellcheck_service->GetCustomDictionary();
926 OnLoaded(*custom_dictionary, WordList());
928 DictionaryObserverCounter observer;
929 custom_dictionary->AddObserver(&observer);
931 EXPECT_TRUE(custom_dictionary->AddWord("foo"));
932 EXPECT_TRUE(custom_dictionary->AddWord("bar"));
933 EXPECT_FALSE(custom_dictionary->AddWord("bar"));
935 EXPECT_EQ(2, observer.changes());
937 custom_dictionary->RemoveObserver(&observer);
940 TEST_F(SpellcheckCustomDictionaryTest, DictionaryRemoveWordNotification) {
941 SpellcheckService* spellcheck_service =
942 SpellcheckServiceFactory::GetForContext(&profile_);
943 SpellcheckCustomDictionary* custom_dictionary =
944 spellcheck_service->GetCustomDictionary();
946 OnLoaded(*custom_dictionary, WordList());
948 EXPECT_TRUE(custom_dictionary->AddWord("foo"));
949 EXPECT_TRUE(custom_dictionary->AddWord("bar"));
951 DictionaryObserverCounter observer;
952 custom_dictionary->AddObserver(&observer);
954 EXPECT_TRUE(custom_dictionary->RemoveWord("foo"));
955 EXPECT_TRUE(custom_dictionary->RemoveWord("bar"));
956 EXPECT_FALSE(custom_dictionary->RemoveWord("baz"));
958 EXPECT_EQ(2, observer.changes());
960 custom_dictionary->RemoveObserver(&observer);
963 TEST_F(SpellcheckCustomDictionaryTest, DictionarySyncNotification) {
964 SpellcheckService* spellcheck_service =
965 SpellcheckServiceFactory::GetForContext(&profile_);
966 SpellcheckCustomDictionary* custom_dictionary =
967 spellcheck_service->GetCustomDictionary();
968 TestingProfile profile2;
969 SpellcheckService* spellcheck_service2 =
970 static_cast<SpellcheckService*>(
971 SpellcheckServiceFactory::GetInstance()->SetTestingFactoryAndUse(
972 &profile2, &BuildSpellcheckService));
973 SpellcheckCustomDictionary* custom_dictionary2 =
974 spellcheck_service2->GetCustomDictionary();
976 OnLoaded(*custom_dictionary, WordList());
977 OnLoaded(*custom_dictionary2, WordList());
979 custom_dictionary->AddWord("foo");
980 custom_dictionary->AddWord("bar");
981 custom_dictionary2->AddWord("foo");
982 custom_dictionary2->AddWord("baz");
984 DictionaryObserverCounter observer;
985 custom_dictionary->AddObserver(&observer);
987 DictionaryObserverCounter observer2;
988 custom_dictionary2->AddObserver(&observer2);
990 int error_counter = 0;
991 EXPECT_FALSE(
992 custom_dictionary->MergeDataAndStartSyncing(
993 syncer::DICTIONARY,
994 custom_dictionary2->GetAllSyncData(
995 syncer::DICTIONARY),
996 scoped_ptr<syncer::SyncChangeProcessor>(
997 new syncer::SyncChangeProcessorWrapperForTest(
998 custom_dictionary2)),
999 scoped_ptr<syncer::SyncErrorFactory>(
1000 new SyncErrorFactoryStub(&error_counter)))
1001 .error()
1002 .IsSet());
1003 EXPECT_EQ(0, error_counter);
1004 EXPECT_TRUE(custom_dictionary->IsSyncing());
1006 EXPECT_EQ(1, observer.changes());
1007 EXPECT_EQ(1, observer2.changes());
1009 custom_dictionary->RemoveObserver(&observer);
1010 custom_dictionary2->RemoveObserver(&observer2);
1013 // The server has maximum number of words and the client has maximum number of
1014 // different words before association time. No new words should be pushed to the
1015 // sync server upon association. The client should accept words from the sync
1016 // server, however.
1017 TEST_F(SpellcheckCustomDictionaryTest, DictionarySyncLimit) {
1018 TestingProfile server_profile;
1019 SpellcheckService* server_spellcheck_service =
1020 static_cast<SpellcheckService*>(
1021 SpellcheckServiceFactory::GetInstance()->SetTestingFactoryAndUse(
1022 &server_profile, &BuildSpellcheckService));
1024 // Here, |server_custom_dictionary| plays the role of the sync server.
1025 SpellcheckCustomDictionary* server_custom_dictionary =
1026 server_spellcheck_service->GetCustomDictionary();
1028 // Upload the maximum number of words to the sync server.
1030 SpellcheckService* spellcheck_service =
1031 SpellcheckServiceFactory::GetForContext(&profile_);
1032 SpellcheckCustomDictionary* custom_dictionary =
1033 spellcheck_service->GetCustomDictionary();
1035 SpellcheckCustomDictionary::Change change;
1036 for (size_t i = 0;
1037 i < chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS;
1038 ++i) {
1039 change.AddWord("foo" + base::Uint64ToString(i));
1041 Apply(*custom_dictionary, change);
1043 int error_counter = 0;
1044 EXPECT_FALSE(
1045 custom_dictionary
1046 ->MergeDataAndStartSyncing(
1047 syncer::DICTIONARY,
1048 server_custom_dictionary->GetAllSyncData(syncer::DICTIONARY),
1049 scoped_ptr<syncer::SyncChangeProcessor>(
1050 new syncer::SyncChangeProcessorWrapperForTest(
1051 server_custom_dictionary)),
1052 scoped_ptr<syncer::SyncErrorFactory>(
1053 new SyncErrorFactoryStub(&error_counter)))
1054 .error()
1055 .IsSet());
1056 EXPECT_EQ(0, error_counter);
1057 EXPECT_TRUE(custom_dictionary->IsSyncing());
1058 EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
1059 custom_dictionary->GetWords().size());
1062 // The sync server now has the maximum number of words.
1063 EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
1064 server_custom_dictionary->GetWords().size());
1066 // Associate the sync server with a client that also has the maximum number of
1067 // words, but all of these words are different from the ones on the sync
1068 // server.
1070 TestingProfile client_profile;
1071 SpellcheckService* client_spellcheck_service =
1072 static_cast<SpellcheckService*>(
1073 SpellcheckServiceFactory::GetInstance()->SetTestingFactoryAndUse(
1074 &client_profile, &BuildSpellcheckService));
1076 // Here, |client_custom_dictionary| plays the role of the client.
1077 SpellcheckCustomDictionary* client_custom_dictionary =
1078 client_spellcheck_service->GetCustomDictionary();
1080 // Add the maximum number of words to the client. These words are all
1081 // different from those on the server.
1082 SpellcheckCustomDictionary::Change change;
1083 for (size_t i = 0;
1084 i < chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS;
1085 ++i) {
1086 change.AddWord("bar" + base::Uint64ToString(i));
1088 Apply(*client_custom_dictionary, change);
1090 // Associate the server and the client.
1091 int error_counter = 0;
1092 EXPECT_FALSE(
1093 client_custom_dictionary
1094 ->MergeDataAndStartSyncing(
1095 syncer::DICTIONARY,
1096 server_custom_dictionary->GetAllSyncData(syncer::DICTIONARY),
1097 scoped_ptr<syncer::SyncChangeProcessor>(
1098 new syncer::SyncChangeProcessorWrapperForTest(
1099 server_custom_dictionary)),
1100 scoped_ptr<syncer::SyncErrorFactory>(
1101 new SyncErrorFactoryStub(&error_counter)))
1102 .error()
1103 .IsSet());
1104 EXPECT_EQ(0, error_counter);
1105 EXPECT_FALSE(client_custom_dictionary->IsSyncing());
1106 EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS * 2,
1107 client_custom_dictionary->GetWords().size());
1110 // The sync server should not receive more words, because it has the maximum
1111 // number of words already.
1112 EXPECT_EQ(chrome::spellcheck_common::MAX_SYNCABLE_DICTIONARY_WORDS,
1113 server_custom_dictionary->GetWords().size());
1116 TEST_F(SpellcheckCustomDictionaryTest, RecordSizeStatsCorrectly) {
1117 #if defined(OS_WIN)
1118 // Failing consistently on Win7. See crbug.com/230534.
1119 if (base::win::GetVersion() >= base::win::VERSION_VISTA)
1120 return;
1121 #endif
1122 // Record a baseline.
1123 SpellCheckHostMetrics::RecordCustomWordCountStats(123);
1125 // Determine if test failures are due the statistics recorder not being
1126 // available or because the histogram just isn't there: crbug.com/230534.
1127 EXPECT_TRUE(StatisticsRecorder::IsActive());
1129 HistogramBase* histogram =
1130 StatisticsRecorder::FindHistogram("SpellCheck.CustomWords");
1131 ASSERT_TRUE(histogram != NULL);
1132 scoped_ptr<HistogramSamples> baseline = histogram->SnapshotSamples();
1134 // Load the dictionary which should be empty.
1135 base::FilePath path =
1136 profile_.GetPath().Append(chrome::kCustomDictionaryFileName);
1137 WordList loaded_custom_words = LoadDictionaryFile(path);
1138 EXPECT_EQ(0u, loaded_custom_words.size());
1140 // We expect there to be an entry with 0.
1141 histogram =
1142 StatisticsRecorder::FindHistogram("SpellCheck.CustomWords");
1143 ASSERT_TRUE(histogram != NULL);
1144 scoped_ptr<HistogramSamples> samples = histogram->SnapshotSamples();
1146 samples->Subtract(*baseline);
1147 EXPECT_EQ(0,samples->sum());
1149 SpellcheckCustomDictionary::Change change;
1150 change.AddWord("bar");
1151 change.AddWord("foo");
1152 UpdateDictionaryFile(change, path);
1154 // Load the dictionary again and it should have 2 entries.
1155 loaded_custom_words = LoadDictionaryFile(path);
1156 EXPECT_EQ(2u, loaded_custom_words.size());
1158 histogram =
1159 StatisticsRecorder::FindHistogram("SpellCheck.CustomWords");
1160 ASSERT_TRUE(histogram != NULL);
1161 scoped_ptr<HistogramSamples> samples2 = histogram->SnapshotSamples();
1163 samples2->Subtract(*baseline);
1164 EXPECT_EQ(2,samples2->sum());
1167 TEST_F(SpellcheckCustomDictionaryTest, HasWord) {
1168 SpellcheckService* spellcheck_service =
1169 SpellcheckServiceFactory::GetForContext(&profile_);
1170 SpellcheckCustomDictionary* custom_dictionary =
1171 spellcheck_service->GetCustomDictionary();
1172 OnLoaded(*custom_dictionary, WordList());
1173 EXPECT_FALSE(custom_dictionary->HasWord("foo"));
1174 EXPECT_FALSE(custom_dictionary->HasWord("bar"));
1175 custom_dictionary->AddWord("foo");
1176 EXPECT_TRUE(custom_dictionary->HasWord("foo"));
1177 EXPECT_FALSE(custom_dictionary->HasWord("bar"));