chrome/browser/chromeos/input_method/input_method_engine_unittest.cc

   1 // Copyright 2014 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 "chrome/browser/chromeos/input_method/input_method_configuration.h"
   7 #include "chrome/browser/chromeos/input_method/input_method_engine.h"
   8 #include "chrome/browser/chromeos/input_method/input_method_engine_interface.h"
   9 #include "chrome/browser/chromeos/input_method/mock_input_method_manager.h"
  10 #include "chromeos/ime/extension_ime_util.h"
  11 #include "chromeos/ime/mock_component_extension_ime_manager_delegate.h"
  12 #include "testing/gtest/include/gtest/gtest.h"
  13
  14 namespace chromeos {
  15
  16 namespace input_method {
  17 namespace {
  18
  19 const char kTestExtensionId[] = "mppnpdlheglhdfmldimlhpnegondlapf";
  20 const char kTestExtensionId2[] = "dmpipdbjkoajgdeppkffbjhngfckdloi";
  21 const char kTestImeEngineId[] = "test_engine_id";
  22
  23 enum CallsBitmap {
  24   NONE = 0U,
  25   ACTIVATE = 1U,
  26   DEACTIVATED = 2U,
  27   ONFOCUS = 4U,
  28   ONBLUR = 8U
  29 };
  30
  31 void InitInputMethod() {
  32   ComponentExtensionIMEManager* comp_ime_manager =
  33       new ComponentExtensionIMEManager;
  34   MockComponentExtIMEManagerDelegate* delegate =
  35       new MockComponentExtIMEManagerDelegate;
  36
  37   ComponentExtensionIME ext1;
  38   ext1.id = kTestExtensionId;
  39
  40   ComponentExtensionEngine ext1_engine1;
  41   ext1_engine1.engine_id = kTestImeEngineId;
  42   ext1_engine1.language_codes.push_back("en-US");
  43   ext1_engine1.layouts.push_back("us");
  44   ext1.engines.push_back(ext1_engine1);
  45
  46   std::vector<ComponentExtensionIME> ime_list;
  47   ime_list.push_back(ext1);
  48   delegate->set_ime_list(ime_list);
  49   comp_ime_manager->Initialize(
  50       scoped_ptr<ComponentExtensionIMEManagerDelegate>(delegate).Pass());
  51
  52   MockInputMethodManager* manager = new MockInputMethodManager;
  53   manager->SetComponentExtensionIMEManager(
  54       scoped_ptr<ComponentExtensionIMEManager>(comp_ime_manager).Pass());
  55   InitializeForTesting(manager);
  56 }
  57
  58 class TestObserver : public InputMethodEngineInterface::Observer {
  59  public:
  60   TestObserver() : calls_bitmap_(NONE) {}
  61   virtual ~TestObserver() {}
  62
  63   virtual void OnActivate(const std::string& engine_id) OVERRIDE {
  64     calls_bitmap_ |= ACTIVATE;
  65   }
  66   virtual void OnDeactivated(const std::string& engine_id) OVERRIDE {
  67     calls_bitmap_ |= DEACTIVATED;
  68   }
  69   virtual void OnFocus(
  70       const InputMethodEngineInterface::InputContext& context) OVERRIDE {
  71     calls_bitmap_ |= ONFOCUS;
  72   }
  73   virtual void OnBlur(int context_id) OVERRIDE {
  74     calls_bitmap_ |= ONBLUR;
  75   }
  76   virtual void OnKeyEvent(
  77       const std::string& engine_id,
  78       const InputMethodEngineInterface::KeyboardEvent& event,
  79       input_method::KeyEventHandle* key_data) OVERRIDE {}
  80   virtual void OnInputContextUpdate(
  81       const InputMethodEngineInterface::InputContext& context) OVERRIDE {}
  82   virtual void OnCandidateClicked(
  83       const std::string& engine_id,
  84       int candidate_id,
  85       InputMethodEngineInterface::MouseButtonEvent button) OVERRIDE {}
  86   virtual void OnMenuItemActivated(
  87       const std::string& engine_id,
  88       const std::string& menu_id) OVERRIDE {}
  89   virtual void OnSurroundingTextChanged(
  90       const std::string& engine_id,
  91       const std::string& text,
  92       int cursor_pos,
  93       int anchor_pos) OVERRIDE {}
  94   virtual void OnReset(const std::string& engine_id) OVERRIDE {}
  95
  96   unsigned char GetCallsBitmapAndReset() {
  97     unsigned char ret = calls_bitmap_;
  98     calls_bitmap_ = NONE;
  99     return ret;
 100   }
 101
 102  private:
 103   unsigned char calls_bitmap_;
 104
 105   DISALLOW_COPY_AND_ASSIGN(TestObserver);
 106 };
 107
 108 class InputMethodEngineTest :  public testing::Test {
 109  public:
 110   InputMethodEngineTest() : observer_(NULL), input_view_("inputview.html") {
 111     languages_.push_back("en-US");
 112     layouts_.push_back("us");
 113     InitInputMethod();
 114     IMEBridge::Initialize();
 115   }
 116   virtual ~InputMethodEngineTest() {
 117     engine_.reset();
 118     Shutdown();
 119   }
 120
 121  protected:
 122   void CreateEngine(bool whitelisted) {
 123     engine_.reset(new InputMethodEngine());
 124     observer_ = new TestObserver();
 125     scoped_ptr<InputMethodEngineInterface::Observer> observer_ptr(observer_);
 126     engine_->Initialize(observer_ptr.Pass(),
 127                         "",
 128                         whitelisted ? kTestExtensionId : kTestExtensionId2,
 129                         kTestImeEngineId,
 130                         languages_,
 131                         layouts_,
 132                         options_page_,
 133                         input_view_);
 134   }
 135
 136   void FocusIn(ui::TextInputType input_type) {
 137     IMEEngineHandlerInterface::InputContext input_context(
 138         input_type, ui::TEXT_INPUT_MODE_DEFAULT);
 139     engine_->FocusIn(input_context);
 140     IMEBridge::Get()->SetCurrentTextInputType(input_type);
 141   }
 142
 143   scoped_ptr<InputMethodEngine> engine_;
 144   TestObserver* observer_;
 145   std::vector<std::string> languages_;
 146   std::vector<std::string> layouts_;
 147   GURL options_page_;
 148   GURL input_view_;
 149
 150  private:
 151   DISALLOW_COPY_AND_ASSIGN(InputMethodEngineTest);
 152 };
 153
 154 }  // namespace
 155
 156 TEST_F(InputMethodEngineTest, TestSwitching) {
 157   CreateEngine(false);
 158   // Enable/disable with focus.
 159   FocusIn(ui::TEXT_INPUT_TYPE_URL);
 160   EXPECT_EQ(NONE, observer_->GetCallsBitmapAndReset());
 161   engine_->Enable();
 162   EXPECT_EQ(ACTIVATE | ONFOCUS, observer_->GetCallsBitmapAndReset());
 163   engine_->Disable();
 164   EXPECT_EQ(DEACTIVATED, observer_->GetCallsBitmapAndReset());
 165   // Enable/disable without focus.
 166   engine_->FocusOut();
 167   EXPECT_EQ(NONE, observer_->GetCallsBitmapAndReset());
 168   engine_->Enable();
 169   EXPECT_EQ(ACTIVATE | ONFOCUS, observer_->GetCallsBitmapAndReset());
 170   engine_->Disable();
 171   EXPECT_EQ(DEACTIVATED, observer_->GetCallsBitmapAndReset());
 172   // Focus change when enabled.
 173   engine_->Enable();
 174   EXPECT_EQ(ACTIVATE | ONFOCUS, observer_->GetCallsBitmapAndReset());
 175   engine_->FocusOut();
 176   EXPECT_EQ(ONBLUR, observer_->GetCallsBitmapAndReset());
 177   // Focus change when disabled.
 178   engine_->Disable();
 179   EXPECT_EQ(DEACTIVATED, observer_->GetCallsBitmapAndReset());
 180   FocusIn(ui::TEXT_INPUT_TYPE_TEXT);
 181   EXPECT_EQ(NONE, observer_->GetCallsBitmapAndReset());
 182   engine_->FocusOut();
 183   EXPECT_EQ(NONE, observer_->GetCallsBitmapAndReset());
 184 }
 185
 186 TEST_F(InputMethodEngineTest, TestSwitching_Password_3rd_Party) {
 187   CreateEngine(false);
 188   // Enable/disable with focus.
 189   FocusIn(ui::TEXT_INPUT_TYPE_PASSWORD);
 190   EXPECT_EQ(NONE, observer_->GetCallsBitmapAndReset());
 191   engine_->Enable();
 192   EXPECT_EQ(ACTIVATE, observer_->GetCallsBitmapAndReset());
 193   engine_->Disable();
 194   EXPECT_EQ(DEACTIVATED, observer_->GetCallsBitmapAndReset());
 195   // Focus change when enabled.
 196   engine_->Enable();
 197   EXPECT_EQ(ACTIVATE, observer_->GetCallsBitmapAndReset());
 198   engine_->FocusOut();
 199   EXPECT_EQ(NONE, observer_->GetCallsBitmapAndReset());
 200   FocusIn(ui::TEXT_INPUT_TYPE_PASSWORD);
 201   EXPECT_EQ(NONE, observer_->GetCallsBitmapAndReset());
 202   engine_->Disable();
 203   EXPECT_EQ(DEACTIVATED, observer_->GetCallsBitmapAndReset());
 204 }
 205
 206 TEST_F(InputMethodEngineTest, TestSwitching_Password_Whitelisted) {
 207   CreateEngine(true);
 208   // Enable/disable with focus.
 209   FocusIn(ui::TEXT_INPUT_TYPE_PASSWORD);
 210   EXPECT_EQ(NONE, observer_->GetCallsBitmapAndReset());
 211   engine_->Enable();
 212   EXPECT_EQ(ACTIVATE | ONFOCUS, observer_->GetCallsBitmapAndReset());
 213   engine_->Disable();
 214   EXPECT_EQ(DEACTIVATED, observer_->GetCallsBitmapAndReset());
 215   // Focus change when enabled.
 216   engine_->Enable();
 217   EXPECT_EQ(ACTIVATE | ONFOCUS, observer_->GetCallsBitmapAndReset());
 218   engine_->FocusOut();
 219   EXPECT_EQ(ONBLUR, observer_->GetCallsBitmapAndReset());
 220   FocusIn(ui::TEXT_INPUT_TYPE_PASSWORD);
 221   EXPECT_EQ(ONFOCUS, observer_->GetCallsBitmapAndReset());
 222   engine_->Disable();
 223   EXPECT_EQ(DEACTIVATED, observer_->GetCallsBitmapAndReset());
 224 }
 225
 226 }  // namespace input_method
 227 }  // namespace chromeos