1 /*
2 * Copyright (c) 2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #define private public
16 #define protected public
17 #include "ime_event_monitor_manager.h"
18
19 #include "ime_event_monitor_manager_impl.h"
20 #include "input_method_controller.h"
21 #undef private
22 #include <gtest/gtest.h>
23 #include <sys/time.h>
24 #include <unistd.h>
25
26 #include "ime_setting_listener_test_impl.h"
27 #include "tdd_util.h"
28
29 using namespace testing::ext;
30 namespace OHOS {
31 namespace MiscServices {
32 class ImeEventMonitorManagerTest : public testing::Test {
33 public:
34 static void SetUpTestCase();
35 static void TearDownTestCase();
36 void SetUp();
37 void TearDown();
38 };
39
SetUpTestCase()40 void ImeEventMonitorManagerTest::SetUpTestCase()
41 {
42 TddUtil::StorageSelfTokenID();
43 IMSA_HILOGI("ImeEventMonitorManagerTest::SetUpTestCase");
44 }
45
TearDownTestCase()46 void ImeEventMonitorManagerTest::TearDownTestCase()
47 {
48 IMSA_HILOGI("ImeEventMonitorManagerTest::TearDownTestCase");
49 }
50
SetUp()51 void ImeEventMonitorManagerTest::SetUp()
52 {
53 // native sa permission
54 TddUtil::GrantNativePermission();
55 IMSA_HILOGI("ImeEventMonitorManagerTest::SetUp");
56 }
57
TearDown()58 void ImeEventMonitorManagerTest::TearDown()
59 {
60 TddUtil::RestoreSelfTokenID();
61 ImeEventMonitorManagerImpl::GetInstance().listeners_.clear();
62 InputMethodController::GetInstance()->clientInfo_.eventFlag = 0;
63 IMSA_HILOGI("ImeEventMonitorManagerTest::TearDown");
64 }
65
66 /**
67 * @tc.name: testRegisterImeEventListener_001
68 * @tc.desc: eventType is 0
69 * @tc.type: FUNC
70 */
71 HWTEST_F(ImeEventMonitorManagerTest, testRegisterImeEventListener_001, TestSize.Level1)
72 {
73 IMSA_HILOGI("testRegisterImeEventListener_001 start.");
74 auto listener = std::make_shared<ImeSettingListenerTestImpl>();
75 auto ret = ImeEventMonitorManager::GetInstance().RegisterImeEventListener(0, listener);
76 EXPECT_EQ(ret, ErrorCode::ERROR_BAD_PARAMETERS);
77 EXPECT_TRUE(ImeEventMonitorManagerImpl::GetInstance().listeners_.empty());
78 }
79
80 /**
81 * @tc.name: testUnRegisterImeEventListener_002
82 * @tc.desc: eventFlag is 0
83 * @tc.type: FUNC
84 */
85 HWTEST_F(ImeEventMonitorManagerTest, testUnRegisterImeEventListener_002, TestSize.Level1)
86 {
87 IMSA_HILOGI("testUnRegisterImeEventListener_002 start.");
88 auto listener = std::make_shared<ImeSettingListenerTestImpl>();
89 auto ret = ImeEventMonitorManager::GetInstance().UnRegisterImeEventListener(0, listener);
90 EXPECT_EQ(ret, ErrorCode::ERROR_BAD_PARAMETERS);
91 EXPECT_TRUE(ImeEventMonitorManagerImpl::GetInstance().listeners_.empty());
92 }
93
94 /**
95 * @tc.name: testRegisterImeEventListener_003
96 * @tc.desc: eventFlag is 15
97 * @tc.type: FUNC
98 */
99 HWTEST_F(ImeEventMonitorManagerTest, testRegisterImeEventListener_003, TestSize.Level1)
100 {
101 IMSA_HILOGI("testUnRegisterImeEventListener_003 start.");
102 auto listener = std::make_shared<ImeSettingListenerTestImpl>();
103 auto ret = ImeEventMonitorManager::GetInstance().RegisterImeEventListener(15, listener);
104 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
105 EXPECT_EQ(ImeEventMonitorManagerImpl::GetInstance().listeners_.size(), 3);
106 auto it = ImeEventMonitorManagerImpl::GetInstance().listeners_.find(EVENT_IME_HIDE_MASK);
107 ASSERT_NE(it, ImeEventMonitorManagerImpl::GetInstance().listeners_.end());
108 it = ImeEventMonitorManagerImpl::GetInstance().listeners_.find(EVENT_IME_SHOW_MASK);
109 ASSERT_NE(it, ImeEventMonitorManagerImpl::GetInstance().listeners_.end());
110 }
111
112 /**
113 * @tc.name: testRegisterImeEventListener_004
114 * @tc.desc: eventFlag is 5
115 * @tc.type: FUNC
116 */
117 HWTEST_F(ImeEventMonitorManagerTest, testRegisterImeEventListener_004, TestSize.Level1)
118 {
119 IMSA_HILOGI("testRegisterImeEventListener_004 start.");
120 auto listener = std::make_shared<ImeSettingListenerTestImpl>();
121 auto ret = ImeEventMonitorManager::GetInstance().RegisterImeEventListener(5, listener);
122 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
123 EXPECT_EQ(ImeEventMonitorManagerImpl::GetInstance().listeners_.size(), 1);
124 auto it = ImeEventMonitorManagerImpl::GetInstance().listeners_.find(EVENT_IME_HIDE_MASK);
125 ASSERT_NE(it, ImeEventMonitorManagerImpl::GetInstance().listeners_.end());
126 EXPECT_EQ(it->second.size(), 1);
127 }
128
129 /**
130 * @tc.name: testRegisterImeEventListener_005
131 * @tc.desc: listener is nullptr
132 * @tc.type: FUNC
133 */
134 HWTEST_F(ImeEventMonitorManagerTest, testRegisterImeEventListener_005, TestSize.Level1)
135 {
136 IMSA_HILOGI("testRegisterImeEventListener_005 start.");
137 auto ret = ImeEventMonitorManager::GetInstance().RegisterImeEventListener(EVENT_IME_SHOW_MASK, nullptr);
138 EXPECT_EQ(ret, ErrorCode::ERROR_BAD_PARAMETERS);
139 EXPECT_TRUE(ImeEventMonitorManagerImpl::GetInstance().listeners_.empty());
140 }
141
142 /**
143 * @tc.name: testUnRegisterImeEventListener_006
144 * @tc.desc: listener is nullptr
145 * @tc.type: FUNC
146 */
147 HWTEST_F(ImeEventMonitorManagerTest, testUnRegisterImeEventListener_006, TestSize.Level1)
148 {
149 IMSA_HILOGI("testUnRegisterImeEventListener_006 start.");
150 auto ret = ImeEventMonitorManager::GetInstance().UnRegisterImeEventListener(EVENT_IME_SHOW_MASK, nullptr);
151 EXPECT_EQ(ret, ErrorCode::ERROR_BAD_PARAMETERS);
152 EXPECT_TRUE(ImeEventMonitorManagerImpl::GetInstance().listeners_.empty());
153 }
154
155 /**
156 * @tc.name: testRegisterImeEventListener_007
157 * @tc.desc: UpdateListenEventFlag filed
158 * @tc.type: FUNC
159 */
160 HWTEST_F(ImeEventMonitorManagerTest, testRegisterImeEventListener_007, TestSize.Level1)
161 {
162 IMSA_HILOGI("testRegisterImeEventListener_007 start.");
163 TddUtil::RestoreSelfTokenID();
164 auto listener = std::make_shared<ImeSettingListenerTestImpl>();
165 auto ret = ImeEventMonitorManager::GetInstance().RegisterImeEventListener(EVENT_IME_SHOW_MASK, listener);
166 EXPECT_EQ(ret, ErrorCode::ERROR_STATUS_SYSTEM_PERMISSION);
167 EXPECT_TRUE(ImeEventMonitorManagerImpl::GetInstance().listeners_.empty());
168 }
169
170 /**
171 * @tc.name: testUnRegisterImeEventListener_008
172 * @tc.desc: one listener register one event, unregister with UpdateListenEventFlag filed
173 * @tc.type: FUNC
174 */
175 HWTEST_F(ImeEventMonitorManagerTest, testUnRegisterImeEventListener_008, TestSize.Level1)
176 {
177 IMSA_HILOGI("testUnRegisterImeEventListener_008 start.");
178 auto listener = std::make_shared<ImeSettingListenerTestImpl>();
179 auto ret = ImeEventMonitorManager::GetInstance().RegisterImeEventListener(EVENT_IME_HIDE_MASK, listener);
180 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
181 EXPECT_EQ(ImeEventMonitorManagerImpl::GetInstance().listeners_.size(), 1);
182 EXPECT_EQ(InputMethodController::GetInstance()->clientInfo_.eventFlag, 4);
183 TddUtil::RestoreSelfTokenID();
184 ret = ImeEventMonitorManager::GetInstance().UnRegisterImeEventListener(EVENT_IME_HIDE_MASK, listener);
185 EXPECT_EQ(ret, ErrorCode::ERROR_STATUS_SYSTEM_PERMISSION);
186 EXPECT_TRUE(ImeEventMonitorManagerImpl::GetInstance().listeners_.empty());
187 EXPECT_EQ(InputMethodController::GetInstance()->clientInfo_.eventFlag, 0);
188 }
189
190 /**
191 * @tc.name: testRegisterImeEventListener_009
192 * @tc.desc: one listener register one event
193 * @tc.type: FUNC
194 */
195 HWTEST_F(ImeEventMonitorManagerTest, testRegisterImeEventListener_009, TestSize.Level1)
196 {
197 IMSA_HILOGI("testRegisterImeEventListener_009 start.");
198 auto listener = std::make_shared<ImeSettingListenerTestImpl>();
199 auto ret = ImeEventMonitorManager::GetInstance().RegisterImeEventListener(EVENT_IME_HIDE_MASK, listener);
200 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
201 EXPECT_EQ(ImeEventMonitorManagerImpl::GetInstance().listeners_.size(), 1);
202 EXPECT_EQ(InputMethodController::GetInstance()->clientInfo_.eventFlag, 4);
203 auto it = ImeEventMonitorManagerImpl::GetInstance().listeners_.find(EVENT_IME_HIDE_MASK);
204 ASSERT_NE(it, ImeEventMonitorManagerImpl::GetInstance().listeners_.end());
205 ASSERT_EQ(it->second.size(), 1);
206 auto iter = it->second.find(listener);
207 EXPECT_NE(iter, it->second.end());
208 }
209
210 /**
211 * @tc.name: testRegisterImeEventListener_010
212 * @tc.desc: one listener register EVENT_IME_HIDE_MASK|EVENT_IME_SHOW_MASK
213 * @tc.type: FUNC
214 */
215 HWTEST_F(ImeEventMonitorManagerTest, testRegisterImeEventListener_010, TestSize.Level1)
216 {
217 IMSA_HILOGI("testRegisterImeEventListener_010 start.");
218 auto listener = std::make_shared<ImeSettingListenerTestImpl>();
219 auto ret = ImeEventMonitorManager::GetInstance().RegisterImeEventListener(
220 EVENT_IME_HIDE_MASK | EVENT_IME_SHOW_MASK, listener);
221 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
222 EXPECT_EQ(InputMethodController::GetInstance()->clientInfo_.eventFlag, 6);
223 EXPECT_EQ(ImeEventMonitorManagerImpl::GetInstance().listeners_.size(), 2);
224 auto it = ImeEventMonitorManagerImpl::GetInstance().listeners_.find(EVENT_IME_HIDE_MASK);
225 ASSERT_NE(it, ImeEventMonitorManagerImpl::GetInstance().listeners_.end());
226 ASSERT_EQ(it->second.size(), 1);
227 auto iter = it->second.find(listener);
228 EXPECT_NE(iter, it->second.end());
229
230 it = ImeEventMonitorManagerImpl::GetInstance().listeners_.find(EVENT_IME_SHOW_MASK);
231 ASSERT_NE(it, ImeEventMonitorManagerImpl::GetInstance().listeners_.end());
232 ASSERT_EQ(it->second.size(), 1);
233 iter = it->second.find(listener);
234 EXPECT_NE(iter, it->second.end());
235 }
236
237 /**
238 * @tc.name: testRegisterImeEventListener_011
239 * @tc.desc: one listener register EVENT_IME_SHOW_MASK|EVENT_IME_HIDE_MASK|EVENT_IME_CHANGE_MASK
240 * @tc.type: FUNC
241 */
242 HWTEST_F(ImeEventMonitorManagerTest, testRegisterImeEventListener_011, TestSize.Level1)
243 {
244 IMSA_HILOGI("testRegisterImeEventListener_011 start.");
245 auto listener = std::make_shared<ImeSettingListenerTestImpl>();
246 auto ret = ImeEventMonitorManager::GetInstance().RegisterImeEventListener(
247 EVENT_IME_SHOW_MASK | EVENT_IME_HIDE_MASK | EVENT_IME_CHANGE_MASK, listener);
248 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
249 EXPECT_EQ(InputMethodController::GetInstance()->clientInfo_.eventFlag, 6);
250 EXPECT_EQ(ImeEventMonitorManagerImpl::GetInstance().listeners_.size(), 2);
251 auto it = ImeEventMonitorManagerImpl::GetInstance().listeners_.find(EVENT_IME_CHANGE_MASK);
252 ASSERT_EQ(it, ImeEventMonitorManagerImpl::GetInstance().listeners_.end());
253 }
254
255 /**
256 * @tc.name: testRegisterImeEventListener_012
257 * @tc.desc: two listener register same event
258 * @tc.type: FUNC
259 */
260 HWTEST_F(ImeEventMonitorManagerTest, testRegisterImeEventListener_012, TestSize.Level1)
261 {
262 IMSA_HILOGI("testRegisterImeEventListener_012 start.");
263 auto listener = std::make_shared<ImeSettingListenerTestImpl>();
264 auto listener1 = std::make_shared<ImeSettingListenerTestImpl>();
265 auto ret = ImeEventMonitorManager::GetInstance().RegisterImeEventListener(
266 EVENT_IME_SHOW_MASK | EVENT_IME_HIDE_MASK, listener);
267 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
268 ret = ImeEventMonitorManager::GetInstance().RegisterImeEventListener(
269 EVENT_IME_SHOW_MASK | EVENT_IME_HIDE_MASK, listener1);
270 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
271 EXPECT_EQ(InputMethodController::GetInstance()->clientInfo_.eventFlag, 6);
272 EXPECT_EQ(ImeEventMonitorManagerImpl::GetInstance().listeners_.size(), 2);
273 auto it = ImeEventMonitorManagerImpl::GetInstance().listeners_.find(EVENT_IME_HIDE_MASK);
274 ASSERT_NE(it, ImeEventMonitorManagerImpl::GetInstance().listeners_.end());
275 ASSERT_EQ(it->second.size(), 2);
276 auto iter = it->second.find(listener);
277 EXPECT_NE(iter, it->second.end());
278 iter = it->second.find(listener1);
279 EXPECT_NE(iter, it->second.end());
280 it = ImeEventMonitorManagerImpl::GetInstance().listeners_.find(EVENT_IME_SHOW_MASK);
281 ASSERT_NE(it, ImeEventMonitorManagerImpl::GetInstance().listeners_.end());
282 ASSERT_EQ(it->second.size(), 2);
283 iter = it->second.find(listener);
284 EXPECT_NE(iter, it->second.end());
285 iter = it->second.find(listener1);
286 EXPECT_NE(iter, it->second.end());
287 }
288
289 /**
290 * @tc.name: testRegisterImeEventListener_013
291 * @tc.desc: two listener register not same event
292 * @tc.type: FUNC
293 */
294 HWTEST_F(ImeEventMonitorManagerTest, testRegisterImeEventListener_013, TestSize.Level1)
295 {
296 IMSA_HILOGI("testRegisterImeEventListener_013 start.");
297 auto listener = std::make_shared<ImeSettingListenerTestImpl>();
298 auto listener1 = std::make_shared<ImeSettingListenerTestImpl>();
299 auto ret = ImeEventMonitorManager::GetInstance().RegisterImeEventListener(EVENT_IME_SHOW_MASK, listener);
300 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
301 ret = ImeEventMonitorManager::GetInstance().RegisterImeEventListener(
302 EVENT_IME_SHOW_MASK | EVENT_IME_HIDE_MASK, listener1);
303 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
304 EXPECT_EQ(InputMethodController::GetInstance()->clientInfo_.eventFlag, 6);
305
306 EXPECT_EQ(ImeEventMonitorManagerImpl::GetInstance().listeners_.size(), 2);
307 auto it = ImeEventMonitorManagerImpl::GetInstance().listeners_.find(EVENT_IME_SHOW_MASK);
308 ASSERT_NE(it, ImeEventMonitorManagerImpl::GetInstance().listeners_.end());
309 ASSERT_EQ(it->second.size(), 2);
310 auto iter = it->second.find(listener);
311 EXPECT_NE(iter, it->second.end());
312 iter = it->second.find(listener1);
313 EXPECT_NE(iter, it->second.end());
314 it = ImeEventMonitorManagerImpl::GetInstance().listeners_.find(EVENT_IME_HIDE_MASK);
315 ASSERT_NE(it, ImeEventMonitorManagerImpl::GetInstance().listeners_.end());
316 ASSERT_EQ(it->second.size(), 1);
317 iter = it->second.find(listener1);
318 EXPECT_NE(iter, it->second.end());
319 }
320
321 /**
322 * @tc.name: testUnRegisterImeEventListener_014
323 * @tc.desc: one listener register one event, unregister
324 * @tc.type: FUNC
325 */
326 HWTEST_F(ImeEventMonitorManagerTest, testUnRegisterImeEventListener_014, TestSize.Level1)
327 {
328 IMSA_HILOGI("testUnRegisterImeEventListener_014 start.");
329 auto listener = std::make_shared<ImeSettingListenerTestImpl>();
330 auto ret = ImeEventMonitorManager::GetInstance().RegisterImeEventListener(EVENT_IME_SHOW_MASK, listener);
331 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
332 EXPECT_EQ(InputMethodController::GetInstance()->clientInfo_.eventFlag, 2);
333 EXPECT_EQ(ImeEventMonitorManagerImpl::GetInstance().listeners_.size(), 1);
334 ret = ImeEventMonitorManager::GetInstance().UnRegisterImeEventListener(EVENT_IME_SHOW_MASK, listener);
335 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
336 EXPECT_TRUE(ImeEventMonitorManagerImpl::GetInstance().listeners_.empty());
337 EXPECT_EQ(InputMethodController::GetInstance()->clientInfo_.eventFlag, 0);
338 }
339
340 /**
341 * @tc.name: testUnRegisterImeEventListener_015
342 * @tc.desc: one listener register all events, unregister one events
343 * @tc.type: FUNC
344 */
345 HWTEST_F(ImeEventMonitorManagerTest, testUnRegisterImeEventListener_015, TestSize.Level1)
346 {
347 IMSA_HILOGI("testUnRegisterImeEventListener_015 start.");
348 auto listener = std::make_shared<ImeSettingListenerTestImpl>();
349 auto ret = ImeEventMonitorManager::GetInstance().RegisterImeEventListener(
350 EVENT_IME_SHOW_MASK | EVENT_IME_HIDE_MASK, listener);
351 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
352 EXPECT_EQ(InputMethodController::GetInstance()->clientInfo_.eventFlag, 6);
353 EXPECT_EQ(ImeEventMonitorManagerImpl::GetInstance().listeners_.size(), 2);
354 ret = ImeEventMonitorManager::GetInstance().UnRegisterImeEventListener(EVENT_IME_HIDE_MASK, listener);
355 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
356 EXPECT_EQ(InputMethodController::GetInstance()->clientInfo_.eventFlag, 2);
357 EXPECT_EQ(ImeEventMonitorManagerImpl::GetInstance().listeners_.size(), 1);
358 }
359
360 /**
361 * @tc.name: testUnRegisterImeEventListener_016
362 * @tc.desc: one listener register all events, unregister all events
363 * @tc.type: FUNC
364 */
365 HWTEST_F(ImeEventMonitorManagerTest, testUnRegisterImeEventListener_016, TestSize.Level1)
366 {
367 IMSA_HILOGI("testUnRegisterImeEventListener_016 start.");
368 auto listener = std::make_shared<ImeSettingListenerTestImpl>();
369 auto ret = ImeEventMonitorManager::GetInstance().RegisterImeEventListener(
370 EVENT_IME_SHOW_MASK | EVENT_IME_HIDE_MASK, listener);
371 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
372 EXPECT_EQ(InputMethodController::GetInstance()->clientInfo_.eventFlag, 6);
373 EXPECT_EQ(ImeEventMonitorManagerImpl::GetInstance().listeners_.size(), 2);
374 ret = ImeEventMonitorManager::GetInstance().UnRegisterImeEventListener(
375 EVENT_IME_SHOW_MASK | EVENT_IME_HIDE_MASK, listener);
376 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
377 EXPECT_TRUE(ImeEventMonitorManagerImpl::GetInstance().listeners_.empty());
378 EXPECT_EQ(InputMethodController::GetInstance()->clientInfo_.eventFlag, 0);
379 }
380
381 /**
382 * @tc.name: testUnRegisterImeEventListener_017
383 * @tc.desc: two listener register same event, unregister one listener
384 * @tc.type: FUNC
385 */
386 HWTEST_F(ImeEventMonitorManagerTest, testUnRegisterImeEventListener_017, TestSize.Level1)
387 {
388 IMSA_HILOGI("testUnRegisterImeEventListener_017 start.");
389 auto listener = std::make_shared<ImeSettingListenerTestImpl>();
390 auto listener1 = std::make_shared<ImeSettingListenerTestImpl>();
391 auto ret = ImeEventMonitorManager::GetInstance().RegisterImeEventListener(EVENT_IME_SHOW_MASK, listener);
392 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
393 ret = ImeEventMonitorManager::GetInstance().RegisterImeEventListener(EVENT_IME_SHOW_MASK, listener1);
394 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
395 EXPECT_EQ(InputMethodController::GetInstance()->clientInfo_.eventFlag, 2);
396 EXPECT_EQ(ImeEventMonitorManagerImpl::GetInstance().listeners_.size(), 1);
397 ret = ImeEventMonitorManager::GetInstance().UnRegisterImeEventListener(EVENT_IME_SHOW_MASK, listener);
398 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
399 EXPECT_EQ(InputMethodController::GetInstance()->clientInfo_.eventFlag, 2);
400 EXPECT_EQ(ImeEventMonitorManagerImpl::GetInstance().listeners_.size(), 1);
401 auto it = ImeEventMonitorManagerImpl::GetInstance().listeners_.find(EVENT_IME_SHOW_MASK);
402 ASSERT_NE(it, ImeEventMonitorManagerImpl::GetInstance().listeners_.end());
403 ASSERT_EQ(it->second.size(), 1);
404 auto iter = it->second.find(listener1);
405 EXPECT_NE(iter, it->second.end());
406 }
407
408 /**
409 * @tc.name: testUnRegisterImeEventListener_018
410 * @tc.desc: two listener register same event, unregister one listener with error event
411 * @tc.type: FUNC
412 */
413 HWTEST_F(ImeEventMonitorManagerTest, testUnRegisterImeEventListener_018, TestSize.Level1)
414 {
415 IMSA_HILOGI("testUnRegisterImeEventListener_018 start.");
416 auto listener = std::make_shared<ImeSettingListenerTestImpl>();
417 auto listener1 = std::make_shared<ImeSettingListenerTestImpl>();
418 auto ret = ImeEventMonitorManager::GetInstance().RegisterImeEventListener(EVENT_IME_SHOW_MASK, listener);
419 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
420 ret = ImeEventMonitorManager::GetInstance().RegisterImeEventListener(EVENT_IME_SHOW_MASK, listener1);
421 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
422 EXPECT_EQ(InputMethodController::GetInstance()->clientInfo_.eventFlag, 2);
423 EXPECT_EQ(ImeEventMonitorManagerImpl::GetInstance().listeners_.size(), 1);
424 ret = ImeEventMonitorManager::GetInstance().UnRegisterImeEventListener(EVENT_IME_HIDE_MASK, listener);
425 EXPECT_EQ(ret, ErrorCode::ERROR_BAD_PARAMETERS);
426 EXPECT_EQ(InputMethodController::GetInstance()->clientInfo_.eventFlag, 2);
427 EXPECT_EQ(ImeEventMonitorManagerImpl::GetInstance().listeners_.size(), 1);
428 auto it = ImeEventMonitorManagerImpl::GetInstance().listeners_.find(EVENT_IME_SHOW_MASK);
429 ASSERT_NE(it, ImeEventMonitorManagerImpl::GetInstance().listeners_.end());
430 ASSERT_EQ(it->second.size(), 2);
431 auto iter = it->second.find(listener);
432 EXPECT_NE(iter, it->second.end());
433 iter = it->second.find(listener1);
434 EXPECT_NE(iter, it->second.end());
435 }
436 /**
437 * @tc.name: testUnRegisterImeEventListener_019
438 * @tc.desc: two listener register same event, unregister one listener with error listener
439 * @tc.type: FUNC
440 */
441 HWTEST_F(ImeEventMonitorManagerTest, testUnRegisterImeEventListener_019, TestSize.Level1)
442 {
443 IMSA_HILOGI("testUnRegisterImeEventListener_019 start.");
444 auto listener = std::make_shared<ImeSettingListenerTestImpl>();
445 auto listener1 = std::make_shared<ImeSettingListenerTestImpl>();
446 auto listener2 = std::make_shared<ImeSettingListenerTestImpl>();
447 auto ret = ImeEventMonitorManager::GetInstance().RegisterImeEventListener(EVENT_IME_SHOW_MASK, listener);
448 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
449 ret = ImeEventMonitorManager::GetInstance().RegisterImeEventListener(EVENT_IME_SHOW_MASK, listener1);
450 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
451 EXPECT_EQ(InputMethodController::GetInstance()->clientInfo_.eventFlag, 2);
452 EXPECT_EQ(ImeEventMonitorManagerImpl::GetInstance().listeners_.size(), 1);
453 ret = ImeEventMonitorManager::GetInstance().UnRegisterImeEventListener(EVENT_IME_SHOW_MASK, listener2);
454 EXPECT_EQ(ret, ErrorCode::ERROR_BAD_PARAMETERS);
455 EXPECT_EQ(InputMethodController::GetInstance()->clientInfo_.eventFlag, 2);
456 EXPECT_EQ(ImeEventMonitorManagerImpl::GetInstance().listeners_.size(), 1);
457 auto it = ImeEventMonitorManagerImpl::GetInstance().listeners_.find(EVENT_IME_SHOW_MASK);
458 ASSERT_NE(it, ImeEventMonitorManagerImpl::GetInstance().listeners_.end());
459 ASSERT_EQ(it->second.size(), 2);
460 auto iter = it->second.find(listener);
461 EXPECT_NE(iter, it->second.end());
462 iter = it->second.find(listener1);
463 EXPECT_NE(iter, it->second.end());
464 }
465
466 /**
467 * @tc.name: testInputStatusChangedListener
468 * @tc.desc: register and unregister EVENT_INPUT_STATUS_CHANGED_MASK,
469 * there is no effect on EVENT_IME_SHOW_MASK and EVENT_HIDE_SHOW_MASK
470 * @tc.type: FUNC
471 */
472 HWTEST_F(ImeEventMonitorManagerTest, testInputStatusChangedListener, TestSize.Level1)
473 {
474 IMSA_HILOGI("testInputStatusChangedListener start.");
475 auto listener = std::make_shared<ImeSettingListenerTestImpl>();
476 auto listener1 = std::make_shared<ImeSettingListenerTestImpl>();
477 auto ret = ImeEventMonitorManager::GetInstance().RegisterImeEventListener(
478 EVENT_IME_SHOW_MASK | EVENT_IME_HIDE_MASK, listener);
479 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
480 EXPECT_EQ(InputMethodController::GetInstance()->clientInfo_.eventFlag, 6);
481
482 ret = ImeEventMonitorManager::GetInstance().RegisterImeEventListener(EVENT_INPUT_STATUS_CHANGED_MASK, listener);
483 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
484 EXPECT_EQ(InputMethodController::GetInstance()->clientInfo_.eventFlag, 14);
485
486 ret = ImeEventMonitorManager::GetInstance().UnRegisterImeEventListener(EVENT_INPUT_STATUS_CHANGED_MASK, listener);
487 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
488 EXPECT_EQ(InputMethodController::GetInstance()->clientInfo_.eventFlag, 6);
489 auto it = ImeEventMonitorManagerImpl::GetInstance().listeners_.find(EVENT_IME_HIDE_MASK);
490 ASSERT_NE(it, ImeEventMonitorManagerImpl::GetInstance().listeners_.end());
491 ASSERT_EQ(it->second.size(), 1);
492 auto iter = it->second.find(listener);
493
494 ret = ImeEventMonitorManager::GetInstance().RegisterImeEventListener(EVENT_INPUT_STATUS_CHANGED_MASK, listener1);
495 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
496 EXPECT_EQ(InputMethodController::GetInstance()->clientInfo_.eventFlag, 14);
497 it = ImeEventMonitorManagerImpl::GetInstance().listeners_.find(EVENT_INPUT_STATUS_CHANGED_MASK);
498 ASSERT_NE(it, ImeEventMonitorManagerImpl::GetInstance().listeners_.end());
499 ASSERT_EQ(it->second.size(), 1);
500 iter = it->second.find(listener1);
501 EXPECT_NE(iter, it->second.end());
502
503 ret = ImeEventMonitorManager::GetInstance().RegisterImeEventListener(EVENT_INPUT_STATUS_CHANGED_MASK, listener);
504 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
505 EXPECT_EQ(InputMethodController::GetInstance()->clientInfo_.eventFlag, 14);
506 it = ImeEventMonitorManagerImpl::GetInstance().listeners_.find(EVENT_INPUT_STATUS_CHANGED_MASK);
507 ASSERT_NE(it, ImeEventMonitorManagerImpl::GetInstance().listeners_.end());
508 ASSERT_EQ(it->second.size(), 2);
509 }
510
511 /********************************* all test is for innerkit above ***************************************************/
512 /**
513 * @tc.name: testRegisterImeEventListener_020
514 * @tc.desc: two listener, one is innerkit(register all event), one is js(register one event)
515 * @tc.type: FUNC
516 */
517 HWTEST_F(ImeEventMonitorManagerTest, testRegisterImeEventListener_020, TestSize.Level1)
518 {
519 IMSA_HILOGI("testRegisterImeEventListener_020 start.");
520 auto listener = std::make_shared<ImeSettingListenerTestImpl>();
521 auto listener1 = std::make_shared<ImeSettingListenerTestImpl>();
522 auto ret = ImeEventMonitorManagerImpl::GetInstance().RegisterImeEventListener(EVENT_IME_CHANGE_MASK, listener);
523 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
524 ret = ImeEventMonitorManager::GetInstance().RegisterImeEventListener(
525 EVENT_IME_SHOW_MASK | EVENT_IME_HIDE_MASK, listener1);
526 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
527 EXPECT_EQ(InputMethodController::GetInstance()->clientInfo_.eventFlag, 7);
528 EXPECT_EQ(ImeEventMonitorManagerImpl::GetInstance().listeners_.size(), 3);
529 }
530
531 /**
532 * @tc.name: testUnRegisterImeEventListener_021
533 * @tc.desc: two listener, one is innerkit(register all event), one is js(register all event), js unregister IME_CHANGE
534 * @tc.type: FUNC
535 */
536 HWTEST_F(ImeEventMonitorManagerTest, testUnRegisterImeEventListener_021, TestSize.Level1)
537 {
538 IMSA_HILOGI("testUnRegisterImeEventListener_021 start.");
539 auto listener = std::make_shared<ImeSettingListenerTestImpl>();
540 auto listener1 = std::make_shared<ImeSettingListenerTestImpl>();
541 auto ret = ImeEventMonitorManagerImpl::GetInstance().RegisterImeEventListener(EVENT_IME_CHANGE_MASK, listener);
542 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
543 ret = ImeEventMonitorManagerImpl::GetInstance().RegisterImeEventListener(EVENT_IME_HIDE_MASK, listener);
544 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
545 ret = ImeEventMonitorManagerImpl::GetInstance().RegisterImeEventListener(EVENT_IME_SHOW_MASK, listener);
546 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
547 ret = ImeEventMonitorManager::GetInstance().RegisterImeEventListener(
548 EVENT_IME_SHOW_MASK | EVENT_IME_HIDE_MASK, listener1);
549 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
550 EXPECT_EQ(InputMethodController::GetInstance()->clientInfo_.eventFlag, 7);
551 EXPECT_EQ(ImeEventMonitorManagerImpl::GetInstance().listeners_.size(), 3);
552 ret = ImeEventMonitorManagerImpl::GetInstance().UnRegisterImeEventListener(EVENT_IME_CHANGE_MASK, listener);
553 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
554 EXPECT_EQ(InputMethodController::GetInstance()->clientInfo_.eventFlag, 6);
555 EXPECT_EQ(ImeEventMonitorManagerImpl::GetInstance().listeners_.size(), 2);
556 }
557 } // namespace MiscServices
558 } // namespace OHOS