| OLD | NEW |
| (Empty) |
| 1 // Copyright 2013 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. | |
| 4 | |
| 5 #include "base/logging.h" | |
| 6 #include "testing/gtest/include/gtest/gtest.h" | |
| 7 #include "ui/base/ime/chromeos/component_extension_ime_manager.h" | |
| 8 #include "ui/base/ime/chromeos/extension_ime_util.h" | |
| 9 #include "ui/base/ime/chromeos/mock_component_extension_ime_manager_delegate.h" | |
| 10 | |
| 11 namespace chromeos { | |
| 12 namespace input_method { | |
| 13 | |
| 14 namespace { | |
| 15 | |
| 16 class ComponentExtensionIMEManagerTest : public testing::Test { | |
| 17 public: | |
| 18 ComponentExtensionIMEManagerTest() : mock_delegate_(NULL) {} | |
| 19 | |
| 20 virtual void SetUp() { | |
| 21 ime_list_.clear(); | |
| 22 | |
| 23 ComponentExtensionIME ext1; | |
| 24 ext1.id = "ext1_id_xxxxxxxxxxxxxxxxxxxxxxxx"; | |
| 25 ext1.description = "ext1_description"; | |
| 26 ext1.options_page_url = | |
| 27 GURL("chrome-extension://" + ext1.id + "/options.html"); | |
| 28 ext1.path = base::FilePath("ext1_file_path"); | |
| 29 | |
| 30 ComponentExtensionEngine ext1_engine1; | |
| 31 ext1_engine1.engine_id = "zh-t-i0-pinyin"; | |
| 32 ext1_engine1.display_name = "ext1_engine_1_display_name"; | |
| 33 ext1_engine1.language_codes.push_back("zh-CN"); | |
| 34 ext1_engine1.layouts.push_back("us"); | |
| 35 ext1.engines.push_back(ext1_engine1); | |
| 36 | |
| 37 ComponentExtensionEngine ext1_engine2; | |
| 38 ext1_engine2.engine_id = "mozc_us"; | |
| 39 ext1_engine2.display_name = "ext1_engine2_display_name"; | |
| 40 ext1_engine2.language_codes.push_back("jp"); | |
| 41 ext1_engine2.layouts.push_back("us"); | |
| 42 ext1.engines.push_back(ext1_engine2); | |
| 43 | |
| 44 ComponentExtensionEngine ext1_engine3; | |
| 45 ext1_engine3.engine_id = "xkb:ru::rus"; | |
| 46 ext1_engine3.display_name = "ext1_engine3_display_name"; | |
| 47 ext1_engine3.language_codes.push_back("ru"); | |
| 48 ext1_engine3.layouts.push_back("ru"); | |
| 49 ext1.engines.push_back(ext1_engine3); | |
| 50 | |
| 51 ime_list_.push_back(ext1); | |
| 52 | |
| 53 ComponentExtensionIME ext2; | |
| 54 ext2.id = "ext2_id_xxxxxxxxxxxxxxxxxxxxxxxx"; | |
| 55 ext2.description = "ext2_description"; | |
| 56 ext2.path = base::FilePath("ext2_file_path"); | |
| 57 | |
| 58 ComponentExtensionEngine ext2_engine1; | |
| 59 ext2_engine1.engine_id = "vkd_ru_phone_aatseel"; | |
| 60 ext2_engine1.display_name = "ext2_engine_1_display_name"; | |
| 61 ext2_engine1.language_codes.push_back("ru"); | |
| 62 ext2_engine1.layouts.push_back("us"); | |
| 63 ext2.engines.push_back(ext2_engine1); | |
| 64 | |
| 65 ComponentExtensionEngine ext2_engine2; | |
| 66 ext2_engine2.engine_id = "vkd_vi_telex"; | |
| 67 ext2_engine2.display_name = "ext2_engine2_display_name"; | |
| 68 ext2_engine2.language_codes.push_back("hi"); | |
| 69 ext2_engine2.layouts.push_back("us"); | |
| 70 ext2.engines.push_back(ext2_engine2); | |
| 71 | |
| 72 ComponentExtensionEngine ext2_engine3; | |
| 73 ext2_engine3.engine_id = "xkb:us::eng"; | |
| 74 ext2_engine3.display_name = "ext2_engine3_display_name"; | |
| 75 ext2_engine3.language_codes.push_back("us"); | |
| 76 ext2_engine3.layouts.push_back("us"); | |
| 77 ext2.engines.push_back(ext2_engine3); | |
| 78 | |
| 79 ime_list_.push_back(ext2); | |
| 80 | |
| 81 ComponentExtensionIME ext3; | |
| 82 ext3.id = "ext3_id_xxxxxxxxxxxxxxxxxxxxxxxx"; | |
| 83 ext3.description = "ext3_description"; | |
| 84 ext3.options_page_url = | |
| 85 GURL("chrome-extension://" + ext3.id + "/options.html"); | |
| 86 ext3.path = base::FilePath("ext3_file_path"); | |
| 87 | |
| 88 ComponentExtensionEngine ext3_engine1; | |
| 89 ext3_engine1.engine_id = "ext3_engine1_engine_id"; | |
| 90 ext3_engine1.display_name = "ext3_engine_1_display_name"; | |
| 91 ext3_engine1.language_codes.push_back("hi"); | |
| 92 ext3_engine1.layouts.push_back("us"); | |
| 93 ext3.engines.push_back(ext3_engine1); | |
| 94 | |
| 95 ComponentExtensionEngine ext3_engine2; | |
| 96 ext3_engine2.engine_id = "ext3_engine2_engine_id"; | |
| 97 ext3_engine2.display_name = "ext3_engine2_display_name"; | |
| 98 ext3_engine2.language_codes.push_back("en"); | |
| 99 ext3_engine2.layouts.push_back("us"); | |
| 100 ext3.engines.push_back(ext3_engine2); | |
| 101 | |
| 102 ComponentExtensionEngine ext3_engine3; | |
| 103 ext3_engine3.engine_id = "ext3_engine3_engine_id"; | |
| 104 ext3_engine3.display_name = "ext3_engine3_display_name"; | |
| 105 ext3_engine3.language_codes.push_back("en"); | |
| 106 ext3_engine3.layouts.push_back("us"); | |
| 107 ext3.engines.push_back(ext3_engine3); | |
| 108 | |
| 109 ime_list_.push_back(ext3); | |
| 110 | |
| 111 mock_delegate_ = new MockComponentExtIMEManagerDelegate(); | |
| 112 mock_delegate_->set_ime_list(ime_list_); | |
| 113 component_ext_mgr_.reset(new ComponentExtensionIMEManager()); | |
| 114 component_ext_mgr_->Initialize( | |
| 115 scoped_ptr<ComponentExtensionIMEManagerDelegate>( | |
| 116 mock_delegate_).Pass()); | |
| 117 } | |
| 118 | |
| 119 virtual void TearDown() { | |
| 120 } | |
| 121 | |
| 122 protected: | |
| 123 MockComponentExtIMEManagerDelegate* mock_delegate_; | |
| 124 scoped_ptr<ComponentExtensionIMEManager> component_ext_mgr_; | |
| 125 std::vector<ComponentExtensionIME> ime_list_; | |
| 126 | |
| 127 private: | |
| 128 | |
| 129 DISALLOW_COPY_AND_ASSIGN(ComponentExtensionIMEManagerTest); | |
| 130 }; | |
| 131 | |
| 132 TEST_F(ComponentExtensionIMEManagerTest, LoadComponentExtensionIMETest) { | |
| 133 for (size_t i = 0; i < ime_list_.size(); ++i) { | |
| 134 for (size_t j = 0; j < ime_list_[i].engines.size(); ++j) { | |
| 135 const std::string input_method_id = | |
| 136 extension_ime_util::GetComponentInputMethodID( | |
| 137 ime_list_[i].id, | |
| 138 ime_list_[i].engines[j].engine_id); | |
| 139 component_ext_mgr_->LoadComponentExtensionIME(NULL /* profile */, | |
| 140 input_method_id); | |
| 141 EXPECT_EQ(ime_list_[i].id, mock_delegate_->last_loaded_extension_id()); | |
| 142 } | |
| 143 } | |
| 144 EXPECT_EQ(9, mock_delegate_->load_call_count()); | |
| 145 } | |
| 146 | |
| 147 TEST_F(ComponentExtensionIMEManagerTest, UnloadComponentExtensionIMETest) { | |
| 148 for (size_t i = 0; i < ime_list_.size(); ++i) { | |
| 149 for (size_t j = 0; j < ime_list_[i].engines.size(); ++j) { | |
| 150 const std::string input_method_id = | |
| 151 extension_ime_util::GetComponentInputMethodID( | |
| 152 ime_list_[i].id, | |
| 153 ime_list_[i].engines[j].engine_id); | |
| 154 component_ext_mgr_->UnloadComponentExtensionIME(NULL /* profile */, | |
| 155 input_method_id); | |
| 156 EXPECT_EQ(ime_list_[i].id, mock_delegate_->last_unloaded_extension_id()); | |
| 157 } | |
| 158 } | |
| 159 EXPECT_EQ(9, mock_delegate_->unload_call_count()); | |
| 160 } | |
| 161 | |
| 162 TEST_F(ComponentExtensionIMEManagerTest, IsWhitelistedTest) { | |
| 163 EXPECT_TRUE(component_ext_mgr_->IsWhitelisted( | |
| 164 extension_ime_util::GetComponentInputMethodID( | |
| 165 ime_list_[0].id, | |
| 166 ime_list_[0].engines[0].engine_id))); | |
| 167 EXPECT_FALSE(component_ext_mgr_->IsWhitelisted( | |
| 168 extension_ime_util::GetInputMethodID( | |
| 169 ime_list_[0].id, | |
| 170 ime_list_[0].engines[0].engine_id))); | |
| 171 EXPECT_FALSE(component_ext_mgr_->IsWhitelisted("mozc")); | |
| 172 EXPECT_FALSE(component_ext_mgr_->IsWhitelisted( | |
| 173 extension_ime_util::GetInputMethodID("AAAA", "012345"))); | |
| 174 EXPECT_FALSE(component_ext_mgr_->IsWhitelisted( | |
| 175 extension_ime_util::GetComponentInputMethodID( | |
| 176 "AAAA", "012345"))); | |
| 177 } | |
| 178 | |
| 179 TEST_F(ComponentExtensionIMEManagerTest, IsWhitelistedExtensionTest) { | |
| 180 EXPECT_TRUE(component_ext_mgr_->IsWhitelistedExtension(ime_list_[0].id)); | |
| 181 EXPECT_TRUE(component_ext_mgr_->IsWhitelistedExtension(ime_list_[1].id)); | |
| 182 EXPECT_FALSE(component_ext_mgr_->IsWhitelistedExtension("dummy")); | |
| 183 EXPECT_FALSE(component_ext_mgr_->IsWhitelistedExtension("")); | |
| 184 } | |
| 185 | |
| 186 TEST_F(ComponentExtensionIMEManagerTest, GetAllIMEAsInputMethodDescriptor) { | |
| 187 input_method::InputMethodDescriptors descriptors = | |
| 188 component_ext_mgr_->GetAllIMEAsInputMethodDescriptor(); | |
| 189 size_t total_ime_size = 0; | |
| 190 for (size_t i = 0; i < ime_list_.size(); ++i) { | |
| 191 total_ime_size += ime_list_[i].engines.size(); | |
| 192 } | |
| 193 EXPECT_EQ(total_ime_size, descriptors.size()); | |
| 194 | |
| 195 // Verify order | |
| 196 for (size_t i = 0; i < descriptors.size(); ++i) { | |
| 197 const input_method::InputMethodDescriptor& d = descriptors[i]; | |
| 198 if (i < 2) { | |
| 199 EXPECT_TRUE(d.id().find("xkb:") != std::string::npos); | |
| 200 } else if (i >= 2 && i < 4) { | |
| 201 EXPECT_TRUE(d.id().find("vkd_") != std::string::npos); | |
| 202 } | |
| 203 } | |
| 204 } | |
| 205 | |
| 206 } // namespace | |
| 207 | |
| 208 } // namespace input_method | |
| 209 } // namespace chromeos | |
| OLD | NEW |