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 "chromeos/ime/component_extension_ime_manager.h" 7 #include "chromeos/ime/extension_ime_util.h" 8 #include "chromeos/ime/mock_component_extension_ime_manager_delegate.h" 9 #include "testing/gtest/include/gtest/gtest.h" 10 11 namespace chromeos { 12 namespace input_method { 13 14 namespace { 15 16 class TestableComponentExtensionIMEManager 17 : public ComponentExtensionIMEManager { 18 public: 19 using ComponentExtensionIMEManager::GetComponentExtensionIMEId; 20 }; 21 22 class ComponentExtensionIMEManagerTest : 23 public testing::Test, 24 public ComponentExtensionIMEManager::Observer { 25 public: 26 ComponentExtensionIMEManagerTest() 27 : mock_delegate_(NULL), 28 on_initialized_callcount_(0) { 29 } 30 31 virtual void SetUp() { 32 ime_list_.clear(); 33 34 ComponentExtensionIME ext1; 35 ext1.id = "ext1_id"; 36 ext1.description = "ext1_description"; 37 ext1.options_page_url = 38 GURL("chrome-extension://" + ext1.id + "/options.html"); 39 ext1.path = base::FilePath("ext1_file_path"); 40 41 ComponentExtensionEngine ext1_engine1; 42 ext1_engine1.engine_id = "ext1_engine1_engine_id"; 43 ext1_engine1.display_name = "ext1_engine_1_display_name"; 44 ext1_engine1.language_codes.push_back("en"); 45 ext1_engine1.layouts.push_back("us"); 46 ext1.engines.push_back(ext1_engine1); 47 48 ComponentExtensionEngine ext1_engine2; 49 ext1_engine2.engine_id = "ext1_engine2_engine_id"; 50 ext1_engine2.display_name = "ext1_engine2_display_name"; 51 ext1_engine2.language_codes.push_back("en"); 52 ext1_engine2.layouts.push_back("us"); 53 ext1.engines.push_back(ext1_engine2); 54 55 ComponentExtensionEngine ext1_engine3; 56 ext1_engine3.engine_id = "ext1_engine3_engine_id"; 57 ext1_engine3.display_name = "ext1_engine3_display_name"; 58 ext1_engine3.language_codes.push_back("ja"); 59 ext1_engine3.layouts.push_back("us"); 60 ext1.engines.push_back(ext1_engine3); 61 62 ime_list_.push_back(ext1); 63 64 ComponentExtensionIME ext2; 65 ext2.id = "ext2_id"; 66 ext2.description = "ext2_description"; 67 ext2.path = base::FilePath("ext2_file_path"); 68 69 ComponentExtensionEngine ext2_engine1; 70 ext2_engine1.engine_id = "ext2_engine1_engine_id"; 71 ext2_engine1.display_name = "ext2_engine_1_display_name"; 72 ext2_engine1.language_codes.push_back("en"); 73 ext2_engine1.layouts.push_back("us"); 74 ext2.engines.push_back(ext2_engine1); 75 76 ComponentExtensionEngine ext2_engine2; 77 ext2_engine2.engine_id = "ext2_engine2_engine_id"; 78 ext2_engine2.display_name = "ext2_engine2_display_name"; 79 ext2_engine2.language_codes.push_back("hi"); 80 ext2_engine2.layouts.push_back("us"); 81 ext2.engines.push_back(ext2_engine2); 82 83 ComponentExtensionEngine ext2_engine3; 84 ext2_engine3.engine_id = "ext2_engine3_engine_id"; 85 ext2_engine3.display_name = "ext2_engine3_display_name"; 86 ext2_engine3.language_codes.push_back("ja"); 87 ext2_engine3.layouts.push_back("jp"); 88 ext2.engines.push_back(ext2_engine3); 89 90 ime_list_.push_back(ext2); 91 92 ComponentExtensionIME ext3; 93 ext3.id = "ext3_id"; 94 ext3.description = "ext3_description"; 95 ext3.options_page_url = 96 GURL("chrome-extension://" + ext3.id + "/options.html"); 97 ext3.path = base::FilePath("ext3_file_path"); 98 99 ComponentExtensionEngine ext3_engine1; 100 ext3_engine1.engine_id = "ext3_engine1_engine_id"; 101 ext3_engine1.display_name = "ext3_engine_1_display_name"; 102 ext3_engine1.language_codes.push_back("hi"); 103 ext3_engine1.layouts.push_back("us"); 104 ext3.engines.push_back(ext3_engine1); 105 106 ComponentExtensionEngine ext3_engine2; 107 ext3_engine2.engine_id = "ext3_engine2_engine_id"; 108 ext3_engine2.display_name = "ext3_engine2_display_name"; 109 ext3_engine2.language_codes.push_back("en"); 110 ext3_engine2.layouts.push_back("us"); 111 ext3.engines.push_back(ext3_engine2); 112 113 ComponentExtensionEngine ext3_engine3; 114 ext3_engine3.engine_id = "ext3_engine3_engine_id"; 115 ext3_engine3.display_name = "ext3_engine3_display_name"; 116 ext3_engine3.language_codes.push_back("en"); 117 ext3_engine3.layouts.push_back("us"); 118 ext3.engines.push_back(ext3_engine3); 119 120 ime_list_.push_back(ext3); 121 122 mock_delegate_ = new MockComponentExtIMEManagerDelegate(); 123 mock_delegate_->set_ime_list(ime_list_); 124 component_ext_mgr_.reset(new ComponentExtensionIMEManager()); 125 component_ext_mgr_->AddObserver(this); 126 EXPECT_FALSE(component_ext_mgr_->IsInitialized()); 127 component_ext_mgr_->Initialize( 128 scoped_ptr<ComponentExtensionIMEManagerDelegate>( 129 mock_delegate_).Pass()); 130 EXPECT_TRUE(component_ext_mgr_->IsInitialized()); 131 132 } 133 134 virtual void TearDown() { 135 EXPECT_EQ(1, on_initialized_callcount_); 136 component_ext_mgr_->RemoveObserver(this); 137 } 138 139 protected: 140 MockComponentExtIMEManagerDelegate* mock_delegate_; 141 scoped_ptr<ComponentExtensionIMEManager> component_ext_mgr_; 142 std::vector<ComponentExtensionIME> ime_list_; 143 144 private: 145 virtual void OnInitialized() OVERRIDE { 146 ++on_initialized_callcount_; 147 } 148 149 int on_initialized_callcount_; 150 151 DISALLOW_COPY_AND_ASSIGN(ComponentExtensionIMEManagerTest); 152 }; 153 154 TEST_F(ComponentExtensionIMEManagerTest, LoadComponentExtensionIMETest) { 155 for (size_t i = 0; i < ime_list_.size(); ++i) { 156 for (size_t j = 0; j < ime_list_[i].engines.size(); ++j) { 157 const std::string input_method_id = 158 TestableComponentExtensionIMEManager::GetComponentExtensionIMEId( 159 ime_list_[i].id, 160 ime_list_[i].engines[j].engine_id); 161 component_ext_mgr_->LoadComponentExtensionIME(input_method_id); 162 EXPECT_EQ(ime_list_[i].id, mock_delegate_->last_loaded_extension_id()); 163 } 164 } 165 EXPECT_EQ(9, mock_delegate_->load_call_count()); 166 } 167 168 TEST_F(ComponentExtensionIMEManagerTest, UnloadComponentExtensionIMETest) { 169 for (size_t i = 0; i < ime_list_.size(); ++i) { 170 for (size_t j = 0; j < ime_list_[i].engines.size(); ++j) { 171 const std::string input_method_id = 172 TestableComponentExtensionIMEManager::GetComponentExtensionIMEId( 173 ime_list_[i].id, 174 ime_list_[i].engines[j].engine_id); 175 component_ext_mgr_->UnloadComponentExtensionIME(input_method_id); 176 EXPECT_EQ(ime_list_[i].id, mock_delegate_->last_unloaded_extension_id()); 177 } 178 } 179 EXPECT_EQ(9, mock_delegate_->unload_call_count()); 180 } 181 182 TEST_F(ComponentExtensionIMEManagerTest, IsWhitelistedTest) { 183 EXPECT_TRUE(component_ext_mgr_->IsWhitelisted( 184 TestableComponentExtensionIMEManager::GetComponentExtensionIMEId( 185 ime_list_[0].id, 186 ime_list_[0].engines[0].engine_id))); 187 EXPECT_FALSE(component_ext_mgr_->IsWhitelisted( 188 extension_ime_util::GetInputMethodID( 189 ime_list_[0].id, 190 ime_list_[0].engines[0].engine_id))); 191 EXPECT_FALSE(component_ext_mgr_->IsWhitelisted("mozc")); 192 EXPECT_FALSE(component_ext_mgr_->IsWhitelisted( 193 extension_ime_util::GetInputMethodID("AAAA", "012345"))); 194 EXPECT_FALSE(component_ext_mgr_->IsWhitelisted( 195 TestableComponentExtensionIMEManager::GetComponentExtensionIMEId( 196 "AAAA", "012345"))); 197 } 198 199 TEST_F(ComponentExtensionIMEManagerTest, IsWhitelistedExtensionTest) { 200 EXPECT_TRUE(component_ext_mgr_->IsWhitelistedExtension(ime_list_[0].id)); 201 EXPECT_TRUE(component_ext_mgr_->IsWhitelistedExtension(ime_list_[1].id)); 202 EXPECT_FALSE(component_ext_mgr_->IsWhitelistedExtension("dummy")); 203 EXPECT_FALSE(component_ext_mgr_->IsWhitelistedExtension("")); 204 } 205 206 TEST_F(ComponentExtensionIMEManagerTest, GetNameDescriptionTest) { 207 for (size_t i = 0; i < ime_list_.size(); ++i) { 208 for (size_t j = 0; j < ime_list_[i].engines.size(); ++j) { 209 const ComponentExtensionEngine& engine 210 = ime_list_[i].engines[j]; 211 212 const std::string input_method_id = 213 TestableComponentExtensionIMEManager::GetComponentExtensionIMEId( 214 ime_list_[i].id, 215 engine.engine_id); 216 217 EXPECT_EQ(input_method_id, 218 component_ext_mgr_->GetId(ime_list_[i].id, engine.engine_id)); 219 EXPECT_EQ(engine.display_name, 220 component_ext_mgr_->GetName(input_method_id)); 221 EXPECT_EQ(engine.description, 222 component_ext_mgr_->GetDescription(input_method_id)); 223 } 224 } 225 } 226 227 TEST_F(ComponentExtensionIMEManagerTest, ListIMEByLanguageTest) { 228 const std::string hindi_layout1 = 229 TestableComponentExtensionIMEManager::GetComponentExtensionIMEId( 230 ime_list_[1].id, ime_list_[1].engines[1].engine_id); 231 const std::string hindi_layout2 = 232 TestableComponentExtensionIMEManager::GetComponentExtensionIMEId( 233 ime_list_[2].id, ime_list_[2].engines[0].engine_id); 234 235 std::vector<std::string> hindi_list 236 = component_ext_mgr_->ListIMEByLanguage("hi"); 237 ASSERT_EQ(2UL, hindi_list.size()); 238 EXPECT_TRUE(hindi_list[0] == hindi_layout1 || hindi_list[0] == hindi_layout2); 239 EXPECT_TRUE(hindi_list[1] == hindi_layout1 || hindi_list[1] == hindi_layout2); 240 241 EXPECT_EQ(0UL, component_ext_mgr_->ListIMEByLanguage("ru").size()); 242 EXPECT_EQ(0UL, component_ext_mgr_->ListIMEByLanguage("").size()); 243 EXPECT_EQ(0UL, component_ext_mgr_->ListIMEByLanguage("invalid").size()); 244 EXPECT_EQ(5UL, component_ext_mgr_->ListIMEByLanguage("en").size()); 245 EXPECT_EQ(2UL, component_ext_mgr_->ListIMEByLanguage("ja").size()); 246 } 247 248 TEST_F(ComponentExtensionIMEManagerTest, GetAllIMEAsInputMethodDescriptor) { 249 input_method::InputMethodDescriptors descriptors = 250 component_ext_mgr_->GetAllIMEAsInputMethodDescriptor(); 251 size_t total_ime_size = 0; 252 for (size_t i = 0; i < ime_list_.size(); ++i) { 253 total_ime_size += ime_list_[i].engines.size(); 254 } 255 EXPECT_EQ(total_ime_size, descriptors.size()); 256 } 257 258 } // namespace 259 260 } // namespace input_method 261 } // namespace chromeos 262