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.Level0)
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.Level0)
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.Level0)
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(), 2);
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.Level0)
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.Level0)
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.Level0)
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.Level0)
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.Level0)
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.Level0)
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.Level0)
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.Level0)
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.Level0)
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.Level0)
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.Level0)
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.Level0)
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.Level0)
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.Level0)
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.Level0)
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.Level0)
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 /********************************* all test is for innerkit above ***************************************************/
466 /**
467 * @tc.name: testRegisterImeEventListener_020
468 * @tc.desc: two listener, one is innerkit(register all event), one is js(register one event)
469 * @tc.type: FUNC
470 */
471 HWTEST_F(ImeEventMonitorManagerTest, testRegisterImeEventListener_020, TestSize.Level0)
472 {
473     IMSA_HILOGI("testRegisterImeEventListener_020 start.");
474     auto listener = std::make_shared<ImeSettingListenerTestImpl>();
475     auto listener1 = std::make_shared<ImeSettingListenerTestImpl>();
476     auto ret = ImeEventMonitorManagerImpl::GetInstance().RegisterImeEventListener(EVENT_IME_CHANGE_MASK, listener);
477     EXPECT_EQ(ret, ErrorCode::NO_ERROR);
478     ret = ImeEventMonitorManager::GetInstance().RegisterImeEventListener(
479         EVENT_IME_SHOW_MASK | EVENT_IME_HIDE_MASK, listener1);
480     EXPECT_EQ(ret, ErrorCode::NO_ERROR);
481     EXPECT_EQ(InputMethodController::GetInstance()->clientInfo_.eventFlag, 7);
482     EXPECT_EQ(ImeEventMonitorManagerImpl::GetInstance().listeners_.size(), 3);
483 }
484 
485 /**
486 * @tc.name: testUnRegisterImeEventListener_021
487 * @tc.desc: two listener, one is innerkit(register all event), one is js(register all event), js unregister IME_CHANGE
488 * @tc.type: FUNC
489 */
490 HWTEST_F(ImeEventMonitorManagerTest, testUnRegisterImeEventListener_021, TestSize.Level0)
491 {
492     IMSA_HILOGI("testUnRegisterImeEventListener_021 start.");
493     auto listener = std::make_shared<ImeSettingListenerTestImpl>();
494     auto listener1 = std::make_shared<ImeSettingListenerTestImpl>();
495     auto ret = ImeEventMonitorManagerImpl::GetInstance().RegisterImeEventListener(EVENT_IME_CHANGE_MASK, listener);
496     EXPECT_EQ(ret, ErrorCode::NO_ERROR);
497     ret = ImeEventMonitorManagerImpl::GetInstance().RegisterImeEventListener(EVENT_IME_HIDE_MASK, listener);
498     EXPECT_EQ(ret, ErrorCode::NO_ERROR);
499     ret = ImeEventMonitorManagerImpl::GetInstance().RegisterImeEventListener(EVENT_IME_SHOW_MASK, listener);
500     EXPECT_EQ(ret, ErrorCode::NO_ERROR);
501     ret = ImeEventMonitorManager::GetInstance().RegisterImeEventListener(
502         EVENT_IME_SHOW_MASK | EVENT_IME_HIDE_MASK, listener1);
503     EXPECT_EQ(ret, ErrorCode::NO_ERROR);
504     EXPECT_EQ(InputMethodController::GetInstance()->clientInfo_.eventFlag, 7);
505     EXPECT_EQ(ImeEventMonitorManagerImpl::GetInstance().listeners_.size(), 3);
506     ret = ImeEventMonitorManagerImpl::GetInstance().UnRegisterImeEventListener(EVENT_IME_CHANGE_MASK, listener);
507     EXPECT_EQ(ret, ErrorCode::NO_ERROR);
508     EXPECT_EQ(InputMethodController::GetInstance()->clientInfo_.eventFlag, 6);
509     EXPECT_EQ(ImeEventMonitorManagerImpl::GetInstance().listeners_.size(), 2);
510 }
511 } // namespace MiscServices
512 } // namespace OHOS