| // Copyright 2010-2014, Google Inc. |
| // All rights reserved. |
| // |
| // Redistribution and use in source and binary forms, with or without |
| // modification, are permitted provided that the following conditions are |
| // met: |
| // |
| // * Redistributions of source code must retain the above copyright |
| // notice, this list of conditions and the following disclaimer. |
| // * Redistributions in binary form must reproduce the above |
| // copyright notice, this list of conditions and the following disclaimer |
| // in the documentation and/or other materials provided with the |
| // distribution. |
| // * Neither the name of Google Inc. nor the names of its |
| // contributors may be used to endorse or promote products derived from |
| // this software without specific prior written permission. |
| // |
| // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| |
| #include "dictionary/user_dictionary_session.h" |
| |
| #ifndef OS_WIN |
| #include <sys/stat.h> |
| #endif // OS_WIN |
| |
| #include "base/file_util.h" |
| #include "base/system_util.h" |
| #include "dictionary/user_dictionary_storage.pb.h" |
| #include "dictionary/user_dictionary_storage.h" |
| #include "testing/base/public/gunit.h" |
| #include "testing/base/public/testing_util.h" |
| |
| DECLARE_string(test_tmpdir); |
| |
| namespace { |
| |
| // "きょうと\t京都\t名詞\n" |
| // "!おおさか\t大阪\t地名\n" |
| // "\n" |
| // "#とうきょう\t東京\t地名\tコメント\n" |
| // "すずき\t鈴木\t人名\n"; |
| const char kDictionaryData[] = |
| "\xE3\x81\x8D\xE3\x82\x87\xE3\x81\x86\xE3\x81\xA8\t" |
| "\xE4\xBA\xAC\xE9\x83\xBD\t\xE5\x90\x8D\xE8\xA9\x9E\n" |
| "\xE3\x81\x8A\xE3\x81\x8A\xE3\x81\x95\xE3\x81\x8B\t" |
| "\xE5\xA4\xA7\xE9\x98\xAA\t\xE5\x9C\xB0\xE5\x90\x8D\n" |
| "\xE3\x81\xA8\xE3\x81\x86\xE3\x81\x8D\xE3\x82\x87\xE3" |
| "\x81\x86\t\xE6\x9D\xB1\xE4\xBA\xAC\t\xE5\x9C\xB0\xE5" |
| "\x90\x8D\t\xE3\x82\xB3\xE3\x83\xA1\xE3\x83\xB3\xE3\x83\x88\n" |
| "\xE3\x81\x99\xE3\x81\x9A\xE3\x81\x8D\t\xE9\x88\xB4" |
| "\xE6\x9C\xA8\t\xE4\xBA\xBA\xE5\x90\x8D\n"; |
| |
| using ::mozc::FileUtil; |
| using ::mozc::SystemUtil; |
| using ::mozc::user_dictionary::UserDictionary; |
| using ::mozc::user_dictionary::UserDictionaryCommandStatus; |
| using ::mozc::user_dictionary::UserDictionarySession; |
| using ::mozc::user_dictionary::UserDictionaryStorage; |
| |
| class UserDictionarySessionTest : public ::testing::Test { |
| protected: |
| virtual void SetUp() { |
| original_user_profile_directory_ = SystemUtil::GetUserProfileDirectory(); |
| SystemUtil::SetUserProfileDirectory(FLAGS_test_tmpdir); |
| FileUtil::Unlink(GetUserDictionaryFile()); |
| } |
| |
| virtual void TearDown() { |
| FileUtil::Unlink(GetUserDictionaryFile()); |
| SystemUtil::SetUserProfileDirectory(original_user_profile_directory_); |
| } |
| |
| static string GetUserDictionaryFile() { |
| #ifndef OS_WIN |
| chmod(FLAGS_test_tmpdir.c_str(), 0777); |
| #endif // OS_WIN |
| return FileUtil::JoinPath(FLAGS_test_tmpdir, "test.db"); |
| } |
| |
| void ResetEntry( |
| const string &key, const string &value, UserDictionary::PosType pos, |
| UserDictionary::Entry *entry) { |
| entry->Clear(); |
| entry->set_key(key); |
| entry->set_value(value); |
| entry->set_pos(pos); |
| } |
| |
| private: |
| string original_user_profile_directory_; |
| }; |
| |
| TEST_F(UserDictionarySessionTest, SaveAndLoad) { |
| UserDictionarySession session(GetUserDictionaryFile()); |
| |
| ASSERT_EQ(UserDictionaryCommandStatus::FILE_NOT_FOUND, session.Load()); |
| |
| session.mutable_storage()->set_version(10); |
| ASSERT_EQ(UserDictionaryCommandStatus::USER_DICTIONARY_COMMAND_SUCCESS, |
| session.Save()); |
| |
| // Clear once, in order to make sure that Load is actually working. |
| session.mutable_storage()->Clear(); |
| ASSERT_EQ(UserDictionaryCommandStatus::USER_DICTIONARY_COMMAND_SUCCESS, |
| session.Load()); |
| |
| // Make sure that the data is actually loaded. |
| EXPECT_EQ(10, session.storage().version()); |
| } |
| |
| TEST_F(UserDictionarySessionTest, LoadWithEnsuringNonEmptyStorage) { |
| UserDictionarySession session(GetUserDictionaryFile()); |
| session.SetDefaultDictionaryName("abcde"); |
| |
| ASSERT_EQ(UserDictionaryCommandStatus::FILE_NOT_FOUND, |
| session.LoadWithEnsuringNonEmptyStorage()); |
| |
| EXPECT_PROTO_PEQ( |
| "dictionaries: < name: \"abcde\" >", |
| session.storage()); |
| } |
| |
| // Unfortunately the limit size of the stored file is hard coded in |
| // user_dictionary_storage.cc, so it is not reallistic to test it on various |
| // environment for now, as it requires (unreasonablly) huge diskspace. |
| // TODO(hidehiko): enable the following test, after moving the save logic to |
| // UserDictionarySession. |
| TEST_F(UserDictionarySessionTest, DISABLED_HugeFileSave) { |
| UserDictionarySession session(GetUserDictionaryFile()); |
| |
| // Create huge dummy data. |
| { |
| UserDictionaryStorage *storage = session.mutable_storage(); |
| for (int i = 0; i < 100; ++i) { |
| UserDictionary *dictionary = storage->add_dictionaries(); |
| for (int j = 0; j < 1000; ++j) { |
| UserDictionary::Entry *entry = dictionary->add_entries(); |
| entry->set_key("dummy_key_data"); |
| entry->set_value("dummy_value_data"); |
| entry->set_pos(UserDictionary::NOUN); // Set dummy data. |
| entry->set_comment( |
| "dummy_long_long_long_long_long_long_long_long_long_comment"); |
| } |
| } |
| } |
| |
| ASSERT_EQ(UserDictionaryCommandStatus::FILE_SIZE_LIMIT_EXCEEDED, |
| session.Save()); |
| |
| session.mutable_storage()->Clear(); |
| ASSERT_EQ(UserDictionaryCommandStatus::USER_DICTIONARY_COMMAND_SUCCESS, |
| session.Load()); |
| |
| EXPECT_GT(session.storage().dictionaries_size(), 0); |
| } |
| |
| TEST_F(UserDictionarySessionTest, UndoWithoutHistory) { |
| UserDictionarySession session(GetUserDictionaryFile()); |
| EXPECT_EQ(UserDictionaryCommandStatus::NO_UNDO_HISTORY, |
| session.Undo()); |
| } |
| |
| TEST_F(UserDictionarySessionTest, CreateDictionary) { |
| UserDictionarySession session(GetUserDictionaryFile()); |
| |
| uint64 dictionary_id; |
| ASSERT_EQ(UserDictionaryCommandStatus::USER_DICTIONARY_COMMAND_SUCCESS, |
| session.CreateDictionary("user dictionary", &dictionary_id)); |
| { |
| const UserDictionaryStorage& storage = session.storage(); |
| EXPECT_EQ(1, storage.dictionaries_size()); |
| EXPECT_EQ("user dictionary", storage.dictionaries(0).name()); |
| EXPECT_EQ(dictionary_id, storage.dictionaries(0).id()); |
| } |
| |
| uint64 dummy_dictionary_id; |
| EXPECT_EQ(UserDictionaryCommandStatus::DICTIONARY_NAME_EMPTY, |
| session.CreateDictionary("", &dummy_dictionary_id)); |
| EXPECT_EQ(UserDictionaryCommandStatus::DICTIONARY_NAME_TOO_LONG, |
| session.CreateDictionary(string(500, 'a'), &dummy_dictionary_id)); |
| EXPECT_EQ(UserDictionaryCommandStatus |
| ::DICTIONARY_NAME_CONTAINS_INVALID_CHARACTER, |
| session.CreateDictionary("a\nb", &dummy_dictionary_id)); |
| EXPECT_EQ(UserDictionaryCommandStatus::DICTIONARY_NAME_DUPLICATED, |
| session.CreateDictionary("user dictionary", &dummy_dictionary_id)); |
| |
| // Test undo for CreateDictionary. |
| EXPECT_EQ(UserDictionaryCommandStatus::USER_DICTIONARY_COMMAND_SUCCESS, |
| session.Undo()); |
| EXPECT_EQ(0, session.storage().dictionaries_size()); |
| |
| while (session.storage().dictionaries_size() < |
| ::mozc::UserDictionaryStorage::max_dictionary_size()) { |
| session.mutable_storage()->add_dictionaries(); |
| } |
| EXPECT_EQ(UserDictionaryCommandStatus::DICTIONARY_SIZE_LIMIT_EXCEEDED, |
| session.CreateDictionary("dictionary 2", &dummy_dictionary_id)); |
| } |
| |
| TEST_F(UserDictionarySessionTest, DeleteDictionary) { |
| UserDictionarySession session(GetUserDictionaryFile()); |
| |
| // Add dummy dictionary. |
| const uint64 kDummyId = 10; |
| { |
| UserDictionary *user_dictionary = |
| session.mutable_storage()->add_dictionaries(); |
| user_dictionary->set_id(kDummyId); |
| } |
| |
| EXPECT_EQ(UserDictionaryCommandStatus::USER_DICTIONARY_COMMAND_SUCCESS, |
| session.DeleteDictionary(kDummyId)); |
| EXPECT_EQ(UserDictionaryCommandStatus::UNKNOWN_DICTIONARY_ID, |
| session.DeleteDictionary(100000)); |
| |
| // Test undo for DeleteDictionary. |
| EXPECT_EQ(UserDictionaryCommandStatus::USER_DICTIONARY_COMMAND_SUCCESS, |
| session.Undo()); |
| ASSERT_EQ(1, session.storage().dictionaries_size()); |
| EXPECT_EQ(kDummyId, session.storage().dictionaries(0).id()); |
| } |
| |
| TEST_F(UserDictionarySessionTest, |
| DeleteDictionaryWithEnsuringNonEmptyStroage) { |
| UserDictionarySession session(GetUserDictionaryFile()); |
| session.SetDefaultDictionaryName("abcde"); |
| |
| // Add dummy dictionary. |
| const uint64 kDummyId = 10; |
| { |
| UserDictionary *user_dictionary = |
| session.mutable_storage()->add_dictionaries(); |
| user_dictionary->set_id(kDummyId); |
| } |
| |
| EXPECT_EQ(UserDictionaryCommandStatus::USER_DICTIONARY_COMMAND_SUCCESS, |
| session.DeleteDictionaryWithEnsuringNonEmptyStorage(kDummyId)); |
| |
| EXPECT_PROTO_PEQ("dictionaries: <\n" |
| " name: \"abcde\"\n" |
| ">\n", |
| session.storage()); |
| |
| // Test undo for DeleteDictionaryWithEnsuringNonEmptyStorage. |
| EXPECT_EQ(UserDictionaryCommandStatus::USER_DICTIONARY_COMMAND_SUCCESS, |
| session.Undo()); |
| ASSERT_EQ(1, session.storage().dictionaries_size()); |
| EXPECT_EQ(kDummyId, session.storage().dictionaries(0).id()); |
| } |
| |
| TEST_F(UserDictionarySessionTest, RenameDictionary) { |
| UserDictionarySession session(GetUserDictionaryFile()); |
| |
| // Prepare the targeet dictionary. |
| uint64 dictionary_id; |
| ASSERT_EQ(UserDictionaryCommandStatus::USER_DICTIONARY_COMMAND_SUCCESS, |
| session.CreateDictionary("user dictionary", &dictionary_id)); |
| |
| ASSERT_EQ(UserDictionaryCommandStatus::USER_DICTIONARY_COMMAND_SUCCESS, |
| session.RenameDictionary(dictionary_id, "new name")); |
| EXPECT_EQ("new name", session.storage().dictionaries(0).name()); |
| |
| EXPECT_EQ(UserDictionaryCommandStatus::DICTIONARY_NAME_EMPTY, |
| session.RenameDictionary(dictionary_id, "")); |
| EXPECT_EQ(UserDictionaryCommandStatus::DICTIONARY_NAME_TOO_LONG, |
| session.RenameDictionary(dictionary_id, string(500, 'a'))); |
| EXPECT_EQ(UserDictionaryCommandStatus |
| ::DICTIONARY_NAME_CONTAINS_INVALID_CHARACTER, |
| session.RenameDictionary(dictionary_id, "a\nb")); |
| |
| // OK to rename to the same name. |
| EXPECT_EQ(UserDictionaryCommandStatus::USER_DICTIONARY_COMMAND_SUCCESS, |
| session.RenameDictionary(dictionary_id, "new name")); |
| |
| uint64 dummy_dictionary_id; |
| ASSERT_EQ(UserDictionaryCommandStatus::USER_DICTIONARY_COMMAND_SUCCESS, |
| session.CreateDictionary("another name", &dummy_dictionary_id)); |
| // NG to rename to the name of another dictionary. |
| EXPECT_EQ(UserDictionaryCommandStatus::DICTIONARY_NAME_DUPLICATED, |
| session.RenameDictionary(dictionary_id, "another name")); |
| |
| EXPECT_EQ(UserDictionaryCommandStatus::UNKNOWN_DICTIONARY_ID, |
| session.RenameDictionary(10000000, "new name 2")); |
| |
| // Test undo for RenameDictionary. |
| // Before the test, undo for create dictionary. |
| EXPECT_EQ(UserDictionaryCommandStatus::USER_DICTIONARY_COMMAND_SUCCESS, |
| session.Undo()); |
| ASSERT_EQ(1, session.storage().dictionaries_size()); |
| EXPECT_EQ(UserDictionaryCommandStatus::USER_DICTIONARY_COMMAND_SUCCESS, |
| session.Undo()); |
| EXPECT_EQ("new name", session.storage().dictionaries(0).name()); |
| EXPECT_EQ(UserDictionaryCommandStatus::USER_DICTIONARY_COMMAND_SUCCESS, |
| session.Undo()); |
| EXPECT_EQ("user dictionary", session.storage().dictionaries(0).name()); |
| } |
| |
| TEST_F(UserDictionarySessionTest, AddEntry) { |
| UserDictionarySession session(GetUserDictionaryFile()); |
| UserDictionary::Entry entry; |
| |
| uint64 dictionary_id; |
| ASSERT_EQ(UserDictionaryCommandStatus::USER_DICTIONARY_COMMAND_SUCCESS, |
| session.CreateDictionary("user dictionary", &dictionary_id)); |
| |
| ResetEntry("reading", "word", UserDictionary::NOUN, &entry); |
| ASSERT_EQ(UserDictionaryCommandStatus::USER_DICTIONARY_COMMAND_SUCCESS, |
| session.AddEntry(dictionary_id, entry)); |
| EXPECT_PROTO_PEQ("dictionaries: <\n" |
| " entries: <\n" |
| " key: \"reading\"\n" |
| " value: \"word\"\n" |
| " pos: NOUN\n" |
| " >\n" |
| ">\n", |
| session.storage()); |
| |
| ResetEntry("reading2", "word2", UserDictionary::PREFIX, &entry); |
| ASSERT_EQ(UserDictionaryCommandStatus::USER_DICTIONARY_COMMAND_SUCCESS, |
| session.AddEntry(dictionary_id, entry)); |
| EXPECT_PROTO_PEQ("dictionaries: <\n" |
| " entries: <\n" |
| " key: \"reading\"\n" |
| " value: \"word\"\n" |
| " pos: NOUN\n" |
| " >\n" |
| " entries: <\n" |
| " key: \"reading2\"\n" |
| " value: \"word2\"\n" |
| " pos: PREFIX\n" |
| " >\n" |
| ">\n", |
| session.storage()); |
| |
| ResetEntry("", "word3", UserDictionary::NOUN, &entry); |
| EXPECT_EQ(UserDictionaryCommandStatus::READING_EMPTY, |
| session.AddEntry(dictionary_id, entry)); |
| |
| // 0 is always invalid dictionary id. |
| ResetEntry("reading4", "word4", UserDictionary::NOUN, &entry); |
| EXPECT_EQ(UserDictionaryCommandStatus::UNKNOWN_DICTIONARY_ID, |
| session.AddEntry(0, entry)); |
| |
| // Test undo for AddEntry. |
| EXPECT_EQ(UserDictionaryCommandStatus::USER_DICTIONARY_COMMAND_SUCCESS, |
| session.Undo()); |
| EXPECT_PROTO_PEQ("dictionaries: <\n" |
| " entries: <\n" |
| " key: \"reading\"\n" |
| " value: \"word\"\n" |
| " pos: NOUN\n" |
| " >\n" |
| ">\n", |
| session.storage()); |
| } |
| |
| TEST_F(UserDictionarySessionTest, AddEntryLimitExceeded) { |
| UserDictionarySession session(GetUserDictionaryFile()); |
| UserDictionary::Entry entry; |
| |
| uint64 dictionary_id; |
| ASSERT_EQ(UserDictionaryCommandStatus::USER_DICTIONARY_COMMAND_SUCCESS, |
| session.CreateDictionary("user dictionary", &dictionary_id)); |
| ResetEntry("reading", "word", UserDictionary::NOUN, &entry); |
| |
| for (int i = 0; i < mozc::UserDictionaryStorage::max_entry_size(); ++i) { |
| ASSERT_EQ(UserDictionaryCommandStatus::USER_DICTIONARY_COMMAND_SUCCESS, |
| session.AddEntry(dictionary_id, entry)); |
| } |
| |
| EXPECT_EQ(UserDictionaryCommandStatus::ENTRY_SIZE_LIMIT_EXCEEDED, |
| session.AddEntry(dictionary_id, entry)); |
| } |
| |
| TEST_F(UserDictionarySessionTest, EditEntry) { |
| UserDictionarySession session(GetUserDictionaryFile()); |
| UserDictionary::Entry entry; |
| |
| uint64 dictionary_id; |
| ASSERT_EQ(UserDictionaryCommandStatus::USER_DICTIONARY_COMMAND_SUCCESS, |
| session.CreateDictionary("user dictionary", &dictionary_id)); |
| |
| ResetEntry("reading", "word", UserDictionary::NOUN, &entry); |
| ASSERT_EQ(UserDictionaryCommandStatus::USER_DICTIONARY_COMMAND_SUCCESS, |
| session.AddEntry(dictionary_id, entry)); |
| ResetEntry("reading2", "word2", UserDictionary::PREFIX, &entry); |
| ASSERT_EQ(UserDictionaryCommandStatus::USER_DICTIONARY_COMMAND_SUCCESS, |
| session.AddEntry(dictionary_id, entry)); |
| EXPECT_PROTO_PEQ("dictionaries: <\n" |
| " entries: <\n" |
| " key: \"reading\"\n" |
| " value: \"word\"\n" |
| " pos: NOUN\n" |
| " >\n" |
| " entries: <\n" |
| " key: \"reading2\"\n" |
| " value: \"word2\"\n" |
| " pos: PREFIX\n" |
| " >\n" |
| ">\n", |
| session.storage()); |
| |
| ResetEntry("reading3", "word3", UserDictionary::ADVERB, &entry); |
| ASSERT_EQ(UserDictionaryCommandStatus::USER_DICTIONARY_COMMAND_SUCCESS, |
| session.EditEntry(dictionary_id, 0, entry)); |
| EXPECT_PROTO_PEQ("dictionaries: <\n" |
| " entries: <\n" |
| " key: \"reading3\"\n" |
| " value: \"word3\"\n" |
| " pos: ADVERB\n" |
| " >\n" |
| " entries: <\n" |
| " key: \"reading2\"\n" |
| " value: \"word2\"\n" |
| " pos: PREFIX\n" |
| " >\n" |
| ">\n", |
| session.storage()); |
| |
| // Test for index out of bounds. |
| ResetEntry("reading4", "word4", UserDictionary::NOUN, &entry); |
| EXPECT_EQ(UserDictionaryCommandStatus::ENTRY_INDEX_OUT_OF_RANGE, |
| session.EditEntry(dictionary_id, -1, entry)); |
| |
| // Test for invalid entry. |
| ResetEntry("", "word4", UserDictionary::NOUN, &entry); |
| EXPECT_EQ(UserDictionaryCommandStatus::READING_EMPTY, |
| session.EditEntry(dictionary_id, 0, entry)); |
| |
| // Test for invalid dictionary id. 0 is always invalid dictionary id. |
| ResetEntry("reading4", "word4", UserDictionary::NOUN, &entry); |
| EXPECT_EQ(UserDictionaryCommandStatus::UNKNOWN_DICTIONARY_ID, |
| session.EditEntry(0, 0, entry)); |
| |
| // Test undo for EditEntry. |
| EXPECT_EQ(UserDictionaryCommandStatus::USER_DICTIONARY_COMMAND_SUCCESS, |
| session.Undo()); |
| EXPECT_PROTO_PEQ("dictionaries: <\n" |
| " entries: <\n" |
| " key: \"reading\"\n" |
| " value: \"word\"\n" |
| " pos: NOUN\n" |
| " >\n" |
| " entries: <\n" |
| " key: \"reading2\"\n" |
| " value: \"word2\"\n" |
| " pos: PREFIX\n" |
| " >\n" |
| ">\n", |
| session.storage()); |
| } |
| |
| TEST_F(UserDictionarySessionTest, DeleteEntry) { |
| UserDictionarySession session(GetUserDictionaryFile()); |
| UserDictionary::Entry entry; |
| |
| uint64 dictionary_id; |
| ASSERT_EQ(UserDictionaryCommandStatus::USER_DICTIONARY_COMMAND_SUCCESS, |
| session.CreateDictionary("user dictionary", &dictionary_id)); |
| |
| ResetEntry("reading", "word", UserDictionary::NOUN, &entry); |
| ASSERT_EQ(UserDictionaryCommandStatus::USER_DICTIONARY_COMMAND_SUCCESS, |
| session.AddEntry(dictionary_id, entry)); |
| ResetEntry("reading2", "word2", UserDictionary::NOUN, &entry); |
| ASSERT_EQ(UserDictionaryCommandStatus::USER_DICTIONARY_COMMAND_SUCCESS, |
| session.AddEntry(dictionary_id, entry)); |
| ResetEntry("reading3", "word3", UserDictionary::NOUN, &entry); |
| ASSERT_EQ(UserDictionaryCommandStatus::USER_DICTIONARY_COMMAND_SUCCESS, |
| session.AddEntry(dictionary_id, entry)); |
| ResetEntry("reading4", "word4", UserDictionary::NOUN, &entry); |
| ASSERT_EQ(UserDictionaryCommandStatus::USER_DICTIONARY_COMMAND_SUCCESS, |
| session.AddEntry(dictionary_id, entry)); |
| ResetEntry("reading5", "word5", UserDictionary::NOUN, &entry); |
| ASSERT_EQ(UserDictionaryCommandStatus::USER_DICTIONARY_COMMAND_SUCCESS, |
| session.AddEntry(dictionary_id, entry)); |
| |
| EXPECT_PROTO_PEQ("dictionaries: <\n" |
| " entries: <\n" |
| " key: \"reading\"\n" |
| " value: \"word\"\n" |
| " pos: NOUN\n" |
| " >\n" |
| " entries: <\n" |
| " key: \"reading2\"\n" |
| " value: \"word2\"\n" |
| " pos: NOUN\n" |
| " >\n" |
| " entries: <\n" |
| " key: \"reading3\"\n" |
| " value: \"word3\"\n" |
| " pos: NOUN\n" |
| " >\n" |
| " entries: <\n" |
| " key: \"reading4\"\n" |
| " value: \"word4\"\n" |
| " pos: NOUN\n" |
| " >\n" |
| " entries: <\n" |
| " key: \"reading5\"\n" |
| " value: \"word5\"\n" |
| " pos: NOUN\n" |
| " >\n" |
| ">\n", |
| session.storage()); |
| |
| |
| vector<int> index_list; |
| index_list.push_back(1); |
| index_list.push_back(3); |
| EXPECT_EQ(UserDictionaryCommandStatus::USER_DICTIONARY_COMMAND_SUCCESS, |
| session.DeleteEntry(dictionary_id, index_list)); |
| |
| EXPECT_PROTO_PEQ("dictionaries: <\n" |
| " entries: <\n" |
| " key: \"reading\"\n" |
| " value: \"word\"\n" |
| " pos: NOUN\n" |
| " >\n" |
| " entries: <\n" |
| " key: \"reading3\"\n" |
| " value: \"word3\"\n" |
| " pos: NOUN\n" |
| " >\n" |
| " entries: <\n" |
| " key: \"reading5\"\n" |
| " value: \"word5\"\n" |
| " pos: NOUN\n" |
| " >\n" |
| ">\n", |
| session.storage()); |
| |
| // Test for index out of bounds. |
| index_list.clear(); |
| index_list.push_back(0); |
| index_list.push_back(100); |
| EXPECT_EQ(UserDictionaryCommandStatus::ENTRY_INDEX_OUT_OF_RANGE, |
| session.DeleteEntry(dictionary_id, index_list)); |
| |
| // The contents shouldn't be changed. |
| EXPECT_PROTO_PEQ("dictionaries: <\n" |
| " entries: <\n" |
| " key: \"reading\"\n" |
| " value: \"word\"\n" |
| " pos: NOUN\n" |
| " >\n" |
| " entries: <\n" |
| " key: \"reading3\"\n" |
| " value: \"word3\"\n" |
| " pos: NOUN\n" |
| " >\n" |
| " entries: <\n" |
| " key: \"reading5\"\n" |
| " value: \"word5\"\n" |
| " pos: NOUN\n" |
| " >\n" |
| ">\n", |
| session.storage()); |
| |
| // Test for invalid dictionary id. |
| index_list.clear(); |
| index_list.push_back(0); |
| EXPECT_EQ(UserDictionaryCommandStatus::UNKNOWN_DICTIONARY_ID, |
| session.DeleteEntry(0, index_list)); |
| |
| // Test undo for delete entries. |
| EXPECT_EQ(UserDictionaryCommandStatus::USER_DICTIONARY_COMMAND_SUCCESS, |
| session.Undo()); |
| EXPECT_PROTO_PEQ("dictionaries: <\n" |
| " entries: <\n" |
| " key: \"reading\"\n" |
| " value: \"word\"\n" |
| " pos: NOUN\n" |
| " >\n" |
| " entries: <\n" |
| " key: \"reading2\"\n" |
| " value: \"word2\"\n" |
| " pos: NOUN\n" |
| " >\n" |
| " entries: <\n" |
| " key: \"reading3\"\n" |
| " value: \"word3\"\n" |
| " pos: NOUN\n" |
| " >\n" |
| " entries: <\n" |
| " key: \"reading4\"\n" |
| " value: \"word4\"\n" |
| " pos: NOUN\n" |
| " >\n" |
| " entries: <\n" |
| " key: \"reading5\"\n" |
| " value: \"word5\"\n" |
| " pos: NOUN\n" |
| " >\n" |
| ">\n", |
| session.storage()); |
| } |
| |
| TEST_F(UserDictionarySessionTest, ImportFromString) { |
| UserDictionarySession session(GetUserDictionaryFile()); |
| |
| uint64 dictionary_id; |
| ASSERT_EQ(UserDictionaryCommandStatus::USER_DICTIONARY_COMMAND_SUCCESS, |
| session.CreateDictionary("user dictionary", &dictionary_id)); |
| |
| ASSERT_EQ(UserDictionaryCommandStatus::USER_DICTIONARY_COMMAND_SUCCESS, |
| session.ImportFromString(dictionary_id, kDictionaryData)); |
| EXPECT_PROTO_PEQ( |
| "dictionaries: <\n" |
| " entries: <\n" |
| " key: \"\xE3\x81\x8D\xE3\x82\x87\xE3\x81\x86\xE3\x81\xA8\"\n" |
| " value: \"\xE4\xBA\xAC\xE9\x83\xBD\"\n" |
| " pos: NOUN\n" |
| " >\n" |
| " entries: <\n" |
| " key: \"\xE3\x81\x8A\xE3\x81\x8A\xE3\x81\x95\xE3\x81\x8B\"\n" |
| " value: \"\xE5\xA4\xA7\xE9\x98\xAA\"\n" |
| " pos: PLACE_NAME\n" |
| " >\n" |
| " entries: <\n" |
| " key: \"\xE3\x81\xA8\xE3\x81\x86\xE3" |
| "\x81\x8D\xE3\x82\x87\xE3\x81\x86\"\n" |
| " value: \"\xE6\x9D\xB1\xE4\xBA\xAC\"\n" |
| " pos: PLACE_NAME\n" |
| " comment: \"\xE3\x82\xB3\xE3\x83\xA1\xE3\x83\xB3\xE3\x83\x88\"\n" |
| " >\n" |
| " entries: <\n" |
| " key: \"\xE3\x81\x99\xE3\x81\x9A\xE3\x81\x8D\"\n" |
| " value: \"\xE9\x88\xB4\xE6\x9C\xA8\"\n" |
| " pos: PERSONAL_NAME\n" |
| " >\n" |
| ">", |
| session.storage()); |
| |
| ASSERT_EQ(UserDictionaryCommandStatus::UNKNOWN_DICTIONARY_ID, |
| session.ImportFromString(0, kDictionaryData)); |
| |
| // Test for Undo. |
| ASSERT_EQ(UserDictionaryCommandStatus::USER_DICTIONARY_COMMAND_SUCCESS, |
| session.Undo()); |
| |
| // The dictionary instance should be kept, but imported contents should be |
| // cleared. |
| ASSERT_EQ(1, session.storage().dictionaries_size()); |
| EXPECT_EQ(0, session.storage().dictionaries(0).entries_size()); |
| } |
| |
| TEST_F(UserDictionarySessionTest, ImportToNewDictionaryFromString) { |
| UserDictionarySession session(GetUserDictionaryFile()); |
| |
| uint64 dictionary_id; |
| ASSERT_EQ(UserDictionaryCommandStatus::USER_DICTIONARY_COMMAND_SUCCESS, |
| session.ImportToNewDictionaryFromString( |
| "user dictionary", kDictionaryData, &dictionary_id)); |
| EXPECT_PROTO_PEQ( |
| "dictionaries: <\n" |
| " name: \"user dictionary\"\n" |
| " entries: <\n" |
| " key: \"\xE3\x81\x8D\xE3\x82\x87\xE3\x81\x86\xE3\x81\xA8\"\n" |
| " value: \"\xE4\xBA\xAC\xE9\x83\xBD\"\n" |
| " pos: NOUN\n" |
| " >\n" |
| " entries: <\n" |
| " key: \"\xE3\x81\x8A\xE3\x81\x8A\xE3\x81\x95\xE3\x81\x8B\"\n" |
| " value: \"\xE5\xA4\xA7\xE9\x98\xAA\"\n" |
| " pos: PLACE_NAME\n" |
| " >\n" |
| " entries: <\n" |
| " key: \"\xE3\x81\xA8\xE3\x81\x86\xE3" |
| "\x81\x8D\xE3\x82\x87\xE3\x81\x86\"\n" |
| " value: \"\xE6\x9D\xB1\xE4\xBA\xAC\"\n" |
| " pos: PLACE_NAME\n" |
| " comment: \"\xE3\x82\xB3\xE3\x83\xA1\xE3\x83\xB3\xE3\x83\x88\"\n" |
| " >\n" |
| " entries: <\n" |
| " key: \"\xE3\x81\x99\xE3\x81\x9A\xE3\x81\x8D\"\n" |
| " value: \"\xE9\x88\xB4\xE6\x9C\xA8\"\n" |
| " pos: PERSONAL_NAME\n" |
| " >\n" |
| ">", |
| session.storage()); |
| |
| // Test for UNDO. |
| ASSERT_EQ(UserDictionaryCommandStatus::USER_DICTIONARY_COMMAND_SUCCESS, |
| session.Undo()); |
| // The dictionary instance should be removed. |
| EXPECT_EQ(0, session.storage().dictionaries_size()); |
| } |
| |
| TEST_F(UserDictionarySessionTest, ImportToNewDictionaryFromStringFailure) { |
| UserDictionarySession session(GetUserDictionaryFile()); |
| |
| // Try to create a new dictionary with a name containing |
| // an invalid character. |
| uint64 dictionary_id; |
| ASSERT_EQ(UserDictionaryCommandStatus |
| ::DICTIONARY_NAME_CONTAINS_INVALID_CHARACTER, |
| session.ImportToNewDictionaryFromString( |
| "a\nb", kDictionaryData, &dictionary_id)); |
| |
| EXPECT_EQ(0, session.storage().dictionaries_size()); |
| } |
| |
| } // namespace |
