Home | History | Annotate | Download | only in ime 
      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