input_method_engine_unittest.cc revision 0529e5d033099cbfc42635f6f6183833b09dff6e 
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
14namespace chromeos {
15
16namespace input_method {
17namespace {
18
19const char kTestExtensionId[] = "mppnpdlheglhdfmldimlhpnegondlapf";
20const char kTestExtensionId2[] = "dmpipdbjkoajgdeppkffbjhngfckdloi";
21const char kTestImeEngineId[] = "test_engine_id";
22
23enum CallsBitmap {
24  NONE = 0U,
25  ACTIVATE = 1U,
26  DEACTIVATED = 2U,
27  ONFOCUS = 4U,
28  ONBLUR = 8U
29};
30
31void 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
58class 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
108class 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
156TEST_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
186TEST_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
206TEST_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
228