1 /*
2 * Copyright (C) 2022 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 "full_ime_info_manager.h"
18 #include "ime_cfg_manager.h"
19 #include "ime_info_inquirer.h"
20 #include "input_method_agent_service_impl.h"
21 #include "input_method_core_service_impl.h"
22 #include "input_method_controller.h"
23 #include "input_method_system_ability.h"
24 #include "peruser_session.h"
25 #include "wms_connection_observer.h"
26 #include "settings_data_utils.h"
27 #include "input_type_manager.h"
28 #include "user_session_manager.h"
29 #include "system_param_adapter.h"
30 #include "ime_state_manager_factory.h"
31 #undef private
32 #include <gtest/gtest.h>
33 #include <gtest/hwext/gtest-multithread.h>
34 #include <sys/time.h>
35 #include <unistd.h>
36
37 #include <string>
38 #include <vector>
39
40 #include "application_info.h"
41 #include "combination_key.h"
42 #include "focus_change_listener.h"
43 #include "global.h"
44 #include "iinput_method_agent.h"
45 #include "iinput_method_core.h"
46 #include "ime_cfg_manager.h"
47 #include "input_client_stub.h"
48 #include "input_method_agent_proxy.h"
49 #include "input_method_agent_stub.h"
50 #include "input_method_core_stub.h"
51 #include "im_common_event_manager.h"
52 #include "input_method_agent_service_impl.h"
53 #include "input_method_core_service_impl.h"
54 #include "input_client_service_impl.h"
55 #include "itypes_util.h"
56 #include "keyboard_event.h"
57 #include "os_account_manager.h"
58 #include "tdd_util.h"
59
60 using namespace testing::ext;
61 using namespace testing::mt;
62 namespace OHOS {
63 namespace MiscServices {
64 using namespace AppExecFwk;
65 class InputMethodPrivateMemberTest : public testing::Test {
66 public:
67 static void SetUpTestCase(void);
68 static void TearDownTestCase(void);
69 void SetUp();
70 void TearDown();
71 static sptr<InputMethodSystemAbility> service_;
72 static void TestImfStartIme();
73 static std::atomic<int32_t> tryLockFailCount_;
74 static std::shared_ptr<PerUserSession> session_;
75 };
76 constexpr std::int32_t MAIN_USER_ID = 100;
77 constexpr std::int32_t INVALID_USER_ID = 10001;
78 constexpr std::int32_t INVALID_PROCESS_ID = -1;
79 constexpr int32_t MS_TO_US = 1000;
80 constexpr int32_t WAIT_FOR_THREAD_SCHEDULE = 10;
81 constexpr int32_t WAIT_ATTACH_FINISH_DELAY = 50;
82 constexpr uint32_t MAX_ATTACH_COUNT = 100000;
83 std::atomic<int32_t> InputMethodPrivateMemberTest::tryLockFailCount_ = 0;
84 std::shared_ptr<PerUserSession> InputMethodPrivateMemberTest::session_ = nullptr;
TestImfStartIme()85 void InputMethodPrivateMemberTest::TestImfStartIme()
86 {
87 auto imeToStart = std::make_shared<ImeNativeCfg>();
88 int32_t startRet = session_->StartIme(imeToStart, false);
89 IMSA_HILOGI("startRet is %{public}d.", startRet);
90 if (startRet == ErrorCode::ERROR_IME_START_INPUT_FAILED) {
91 tryLockFailCount_++;
92 IMSA_HILOGI("tryLockFailCount_ is %{public}d.", tryLockFailCount_.load());
93 }
94 }
95 constexpr const char *EVENT_LARGE_MEMORY_STATUS_CHANGED = "usual.event.memmgr.large_memory_status_changed";
96 constexpr const char *EVENT_MEMORY_STATE = "memory_state";
97 constexpr const char *EVENT_PARAM_UID = "uid";
98
SetUpTestCase(void)99 void InputMethodPrivateMemberTest::SetUpTestCase(void)
100 {
101 std::this_thread::sleep_for(std::chrono::seconds(1));
102 IMSA_HILOGI("InputMethodPrivateMemberTest::SetUpTestCase");
103 service_ = new (std::nothrow) InputMethodSystemAbility();
104 if (service_ == nullptr) {
105 return;
106 }
107 service_->OnStart();
108 }
109
TearDownTestCase(void)110 void InputMethodPrivateMemberTest::TearDownTestCase(void)
111 {
112 service_->OnStop();
113 IMSA_HILOGI("InputMethodPrivateMemberTest::TearDownTestCase");
114 }
115
SetUp(void)116 void InputMethodPrivateMemberTest::SetUp(void)
117 {
118 IMSA_HILOGI("InputMethodPrivateMemberTest::SetUp");
119 ImeCfgManager::GetInstance().imeConfigs_.clear();
120 FullImeInfoManager::GetInstance().fullImeInfos_.clear();
121 ImeEnabledInfoManager::GetInstance().imeEnabledCfg_.clear();
122 service_->userId_ = MAIN_USER_ID;
123 }
124
TearDown(void)125 void InputMethodPrivateMemberTest::TearDown(void)
126 {
127 IMSA_HILOGI("InputMethodPrivateMemberTest::TearDown");
128 ImeCfgManager::GetInstance().imeConfigs_.clear();
129 FullImeInfoManager::GetInstance().fullImeInfos_.clear();
130 ImeEnabledInfoManager::GetInstance().imeEnabledCfg_.clear();
131 }
132 sptr<InputMethodSystemAbility> InputMethodPrivateMemberTest::service_;
133
134 /**
135 * @tc.name: SA_TestOnStart
136 * @tc.desc: SA OnStart.
137 * @tc.type: FUNC
138 * @tc.require:
139 */
140 HWTEST_F(InputMethodPrivateMemberTest, SA_TestOnStart, TestSize.Level0)
141 {
142 InputMethodSystemAbility ability;
143 ability.state_ = ServiceRunningState::STATE_RUNNING;
144 ability.OnStart();
145 EXPECT_EQ(ability.identityChecker_, nullptr);
146 }
147
148 /**
149 * @tc.name: SA_GetExtends
150 * @tc.desc: SA GetExtends.
151 * @tc.type: FUNC
152 * @tc.require: issuesI640YZ
153 */
154 HWTEST_F(InputMethodPrivateMemberTest, SA_GetExtends, TestSize.Level0)
155 {
156 constexpr int32_t metaDataNums = 5;
157 ImeInfoInquirer inquirer;
158 std::vector<Metadata> metaData;
159 Metadata metadata[metaDataNums] = {
160 { "language", "english", "" },
161 { "mode", "mode", "" },
162 { "locale", "local", "" },
163 { "icon", "icon", "" },
164 { "", "", "" }
165 };
166 for (auto const &data : metadata) {
167 metaData.emplace_back(data);
168 }
169 auto subProperty = inquirer.GetExtends(metaData);
170 EXPECT_EQ(subProperty.language, "english");
171 EXPECT_EQ(subProperty.mode, "mode");
172 EXPECT_EQ(subProperty.locale, "local");
173 EXPECT_EQ(subProperty.icon, "icon");
174 }
175
176 /**
177 * @tc.name: SA_TestOnUserStarted
178 * @tc.desc: SA_TestOnUserStarted.
179 * @tc.type: FUNC
180 * @tc.require:
181 */
182 HWTEST_F(InputMethodPrivateMemberTest, SA_TestOnUserStarted, TestSize.Level0)
183 {
184 // isScbEnable_ is true
185 service_->isScbEnable_ = true;
186 MessageParcel *parcel = nullptr;
187 auto msg = std::make_shared<Message>(MessageID::MSG_ID_USER_START, parcel);
188 auto ret = service_->OnUserStarted(msg.get());
189 EXPECT_EQ(ret, ErrorCode::ERROR_NULL_POINTER);
190
191 // msg is nullptr
192 service_->isScbEnable_ = false;
193 ret = service_->OnUserStarted(msg.get());
194 EXPECT_EQ(ret, ErrorCode::ERROR_NULL_POINTER);
195
196 // userId is same
197 service_->userId_ = 50;
198 MessageParcel *parcel1 = new MessageParcel();
199 parcel1->WriteInt32(50);
200 auto msg1 = std::make_shared<Message>(MessageID::MSG_ID_USER_START, parcel1);
201 ret = service_->OnUserStarted(msg1.get());
202 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
203
204 // start ime
205 WmsConnectionObserver observer(nullptr);
206 observer.OnConnected(60, 0);
207 // imeStarting_ is true
208 IMSA_HILOGI("InputMethodPrivateMemberTest::imeStarting_ is true");
209 service_->userId_ = 50;
210 MessageParcel *parcel2 = new MessageParcel();
211 parcel2->WriteInt32(60);
212 auto msg2 = std::make_shared<Message>(MessageID::MSG_ID_USER_START, parcel2);
213 ret = service_->OnUserStarted(msg2.get());
214 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
215 // imeStarting_ is false
216 IMSA_HILOGI("InputMethodPrivateMemberTest::imeStarting_ is false");
217 service_->userId_ = 50;
218 MessageParcel *parcel3 = new MessageParcel();
219 observer.OnConnected(333, 0);
220 parcel3->WriteInt32(333);
221 auto msg3 = std::make_shared<Message>(MessageID::MSG_ID_USER_START, parcel3);
222 ret = service_->OnUserStarted(msg3.get());
223 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
224 }
225
226 /**
227 * @tc.name: SA_TestOnUserRemoved
228 * @tc.desc: SA_TestOnUserRemoved.
229 * @tc.type: FUNC
230 * @tc.require:
231 */
232 HWTEST_F(InputMethodPrivateMemberTest, SA_TestOnUserRemoved, TestSize.Level0)
233 {
234 // msg is nullptr
235 auto *msg = new Message(MessageID::MSG_ID_USER_REMOVED, nullptr);
236 auto ret = service_->OnUserRemoved(msg);
237 EXPECT_EQ(ret, ErrorCode::ERROR_NULL_POINTER);
238 MessageHandler::Instance()->SendMessage(msg);
239
240 // move userId
241 MessageParcel *parcel1 = new MessageParcel();
242 parcel1->WriteInt32(60);
243 auto msg1 = std::make_shared<Message>(MessageID::MSG_ID_USER_REMOVED, parcel1);
244 auto ret1 = service_->OnUserRemoved(msg1.get());
245 EXPECT_EQ(ret1, ErrorCode::NO_ERROR);
246 }
247
248 /**
249 * @tc.name: SA_ListInputMethodInfoWithInexistentUserId
250 * @tc.desc: SA ListInputMethodInfo With Inexistent UserId.
251 * @tc.type: FUNC
252 * @tc.require: issuesI669E8
253 */
254 HWTEST_F(InputMethodPrivateMemberTest, SA_ListInputMethodInfoWithInexistentUserId, TestSize.Level0)
255 {
256 ImeInfoInquirer inquirer;
257 constexpr int32_t userId = 1;
258 auto inputMethodInfos = inquirer.ListInputMethodInfo(userId);
259 EXPECT_TRUE(inputMethodInfos.empty());
260 }
261
262 /**
263 * @tc.name: IMC_ListInputMethodCommonWithErrorStatus
264 * @tc.desc: IMC ListInputMethodCommon With Error Status.
265 * @tc.type: FUNC
266 * @tc.require: issuesI669E8
267 */
268 HWTEST_F(InputMethodPrivateMemberTest, IMC_ListInputMethodCommonWithErrorStatus, TestSize.Level0)
269 {
270 std::vector<Property> props;
271 auto ret = InputMethodController::GetInstance()->ListInputMethodCommon(static_cast<InputMethodStatus>(5), props);
272 EXPECT_EQ(ret, ErrorCode::ERROR_BAD_PARAMETERS);
273 EXPECT_TRUE(props.empty());
274 }
275
276 /**
277 * @tc.name: PerUserSessionCoreOrAgentNullptr
278 * @tc.desc: Test PerUserSession with core nullptr.
279 * @tc.type: FUNC
280 * @tc.require: issuesI794QF
281 * @tc.author: Zhaolinglan
282 */
283 HWTEST_F(InputMethodPrivateMemberTest, PerUserSessionCoreOrAgentNullptr, TestSize.Level0)
284 {
285 IMSA_HILOGI("InputMethodPrivateMemberTest PerUserSessionCoreOrAgentNullptr TEST START");
286 auto userSession = std::make_shared<PerUserSession>(MAIN_USER_ID);
287 auto imc = InputMethodController::GetInstance();
288 auto clientGroup = std::make_shared<ClientGroup>(DEFAULT_DISPLAY_ID, nullptr);
289 int32_t ret = userSession->ShowKeyboard(imc->clientInfo_.client, clientGroup);
290 EXPECT_EQ(ret, ErrorCode::ERROR_CLIENT_NOT_FOUND);
291 ret = userSession->HideKeyboard(imc->clientInfo_.client, clientGroup);
292 EXPECT_EQ(ret, ErrorCode::ERROR_CLIENT_NOT_FOUND);
293 ret = userSession->InitInputControlChannel();
294 EXPECT_EQ(ret, ErrorCode::ERROR_IME_NOT_STARTED);
295 userSession->StopCurrentIme();
296 ret = userSession->SwitchSubtype({});
297 EXPECT_EQ(ret, ErrorCode::ERROR_IME_NOT_STARTED);
298 }
299
300 /**
301 * @tc.name: PerUserSessionClientError
302 * @tc.desc: Test PerUserSession with client error.
303 * @tc.type: FUNC
304 * @tc.require: issuesI794QF
305 * @tc.author: Zhaolinglan
306 */
307 HWTEST_F(InputMethodPrivateMemberTest, PerUserSessionClientError, TestSize.Level0)
308 {
309 IMSA_HILOGI("InputMethodPrivateMemberTest PerUserSessionClientError TEST START");
310 auto userSession = std::make_shared<PerUserSession>(MAIN_USER_ID);
311 auto clientGroup = std::make_shared<ClientGroup>(DEFAULT_DISPLAY_ID, nullptr);
312 auto imc = InputMethodController::GetInstance();
313
314 auto clientInfo = clientGroup->GetClientInfo(imc->clientInfo_.client->AsObject());
315 EXPECT_EQ(clientInfo, nullptr);
316
317 clientInfo = clientGroup->GetCurrentClientInfo();
318 EXPECT_EQ(clientInfo, nullptr);
319
320 bool clientInfoIsNull = clientGroup->IsCurClientFocused(INVALID_PROCESS_ID, INVALID_USER_ID);
321 EXPECT_FALSE(clientInfoIsNull);
322
323 clientInfo = clientGroup->GetClientInfo(INVALID_USER_ID);
324 EXPECT_EQ(clientInfo, nullptr);
325
326 clientGroup->SetCurrentClient(nullptr);
327 userSession->clientGroupMap_.clear();
328 userSession->OnUnfocused(DEFAULT_DISPLAY_ID, 0, 0);
329 int32_t ret = userSession->OnHideCurrentInput(DEFAULT_DISPLAY_ID);
330 EXPECT_EQ(ret, ErrorCode::ERROR_CLIENT_NOT_FOUND);
331 ret = userSession->OnShowCurrentInput(DEFAULT_DISPLAY_ID);
332 EXPECT_EQ(ret, ErrorCode::ERROR_CLIENT_NOT_FOUND);
333
334 clientGroup->SetCurrentClient(imc->clientInfo_.client);
335 ret = userSession->OnShowCurrentInput(DEFAULT_DISPLAY_ID);
336 EXPECT_EQ(ret, ErrorCode::ERROR_CLIENT_NOT_FOUND);
337 }
338
339 /**
340 * @tc.name: PerUserSessionParameterNullptr001
341 * @tc.desc: Test PerUserSession with parameter client nullptr.
342 * @tc.type: FUNC
343 * @tc.require: issuesI794QF
344 * @tc.author: Zhaolinglan
345 */
346 HWTEST_F(InputMethodPrivateMemberTest, PerUserSessionParameterNullptr001, TestSize.Level0)
347 {
348 IMSA_HILOGI("InputMethodPrivateMemberTest PerUserSessionParameterNullptr001 TEST START");
349 auto userSession = std::make_shared<PerUserSession>(MAIN_USER_ID);
350 InputClientInfo clientInfo;
351 clientInfo.client = nullptr;
352 std::vector<sptr<IRemoteObject>> agents;
353 std::vector<BindImeInfo> imeInfos;
354 int32_t ret = userSession->OnStartInput(clientInfo, agents, imeInfos);
355 EXPECT_EQ(ret, ErrorCode::ERROR_CLIENT_NULL_POINTER);
356 ret = userSession->OnReleaseInput(nullptr, 0);
357 EXPECT_EQ(ret, ErrorCode::ERROR_CLIENT_NULL_POINTER);
358 auto clientGroup = std::make_shared<ClientGroup>(DEFAULT_DISPLAY_ID, nullptr);
359 auto client = clientGroup->GetClientInfo(nullptr);
360 EXPECT_EQ(client, nullptr);
361 }
362
363 /**
364 * @tc.name: SA_ImeCfgManagerTest_002
365 * @tc.desc: getImeCfg failed
366 * @tc.type: FUNC
367 * @tc.require:
368 * @tc.author: chenyu
369 */
370 HWTEST_F(InputMethodPrivateMemberTest, SA_ImeCfgManagerTest_002, TestSize.Level0)
371 {
372 IMSA_HILOGI("InputMethodPrivateMemberTest SA_ImeCfgManagerTest_002 TEST START");
373 ImeCfgManager cfgManager;
374 auto cfg = cfgManager.GetImeCfg(100);
375 EXPECT_TRUE(cfg.currentSubName.empty());
376 EXPECT_TRUE(cfg.currentIme.empty());
377 }
378
379 /**
380 * @tc.name: SA_SwitchByCombinationKey_001
381 * @tc.desc: keycode = MMI::KeyEvent::KEYCODE_0
382 * @tc.type: FUNC
383 * @tc.require:
384 * @tc.author: chenyu
385 */
386 HWTEST_F(InputMethodPrivateMemberTest, SA_SwitchByCombinationKey_001, TestSize.Level0)
387 {
388 IMSA_HILOGI("InputMethodPrivateMemberTest SA_SwitchByCombinationKey_001 TEST START");
389 ImeCfgManager cfgManager;
390 auto ret = service_->SwitchByCombinationKey(0);
391 EXPECT_EQ(ret, ErrorCode::ERROR_EX_UNSUPPORTED_OPERATION);
392 }
393
394 /**
395 * @tc.name: SA_SwitchByCombinationKey_002
396 * @tc.desc: SwitchLanguage()/SwitchMode():GetImeInfo failed
397 * @tc.type: FUNC
398 * @tc.require:
399 * @tc.author: chenyu
400 */
401 HWTEST_F(InputMethodPrivateMemberTest, SA_SwitchByCombinationKey_002, TestSize.Level0)
402 {
403 IMSA_HILOGI("InputMethodPrivateMemberTest SA_SwitchByCombinationKey_002 TEST START");
404 ImeEnabledCfg cfg;
405 ImeEnabledInfo imeInfo;
406 imeInfo.bundleName = "bundleName";
407 imeInfo.extensionName = "extName";
408 imeInfo.extraInfo.isDefaultIme = true;
409 imeInfo.extraInfo.currentSubName = "subName";
410 cfg.enabledInfos.emplace_back(imeInfo);
411 ImeEnabledInfoManager::GetInstance().imeEnabledCfg_.insert({ MAIN_USER_ID, cfg });
412 auto ret = service_->SwitchByCombinationKey(KeyboardEvent::SHIFT_RIGHT_MASK);
413 EXPECT_EQ(ret, ErrorCode::ERROR_BAD_PARAMETERS);
414 ret = service_->SwitchByCombinationKey(KeyboardEvent::CAPS_MASK);
415 EXPECT_EQ(ret, ErrorCode::ERROR_BAD_PARAMETERS);
416 }
417
418 /**
419 * @tc.name: SA_SwitchByCombinationKey_003
420 * @tc.desc: SwitchLanguage()/SwitchMode():is newIme
421 * @tc.type: FUNC
422 * @tc.require:
423 * @tc.author: chenyu
424 */
425 HWTEST_F(InputMethodPrivateMemberTest, SA_SwitchByCombinationKey_003, TestSize.Level0)
426 {
427 IMSA_HILOGI("InputMethodPrivateMemberTest SA_SwitchByCombinationKey_003 TEST START");
428 ImeCfgManager cfgManager;
429 FullImeInfo info;
430 info.isNewIme = true;
431 info.prop.name = "testBundleName";
432 SubProperty sub;
433 sub.id = "testSubName";
434 info.subProps.push_back(sub);
435 FullImeInfoManager::GetInstance().fullImeInfos_.insert({ MAIN_USER_ID, { info } });
436 ImeEnabledCfg cfg;
437 ImeEnabledInfo imeInfo;
438 imeInfo.bundleName = "testBundleName";
439 imeInfo.extensionName = "testExtName";
440 imeInfo.extraInfo.isDefaultIme = true;
441 imeInfo.extraInfo.currentSubName = "testSubName";
442 cfg.enabledInfos.emplace_back(imeInfo);
443 ImeEnabledInfoManager::GetInstance().imeEnabledCfg_.insert({ MAIN_USER_ID, cfg });
444 auto ret = service_->SwitchByCombinationKey(KeyboardEvent::SHIFT_RIGHT_MASK);
445 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
446 ret = service_->SwitchByCombinationKey(KeyboardEvent::CAPS_MASK);
447 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
448 }
449
450 /**
451 * @tc.name: SA_SwitchByCombinationKey_004
452 * @tc.desc: SwitchLanguage():info.subProp.language == "French"
453 * @tc.type: FUNC
454 * @tc.require:
455 * @tc.author: chenyu
456 */
457 HWTEST_F(InputMethodPrivateMemberTest, SA_SwitchByCombinationKey_004, TestSize.Level0)
458 {
459 IMSA_HILOGI("InputMethodPrivateMemberTest SA_SwitchByCombinationKey_004 TEST START");
460 FullImeInfo info;
461 info.prop.name = "testBundleName";
462 info.prop.id = "testExtName";
463 SubProperty sub;
464 sub.name = "testBundleName";
465 sub.id = "testSubName";
466 sub.language = "French";
467 info.subProps.push_back(sub);
468 FullImeInfoManager::GetInstance().fullImeInfos_.insert({ MAIN_USER_ID, { info } });
469 ImeEnabledCfg cfg;
470 ImeEnabledInfo imeInfo;
471 imeInfo.bundleName = "testBundleName";
472 imeInfo.extensionName = "testExtName";
473 imeInfo.extraInfo.isDefaultIme = true;
474 imeInfo.extraInfo.currentSubName = "testSubName";
475 cfg.enabledInfos.emplace_back(imeInfo);
476 ImeEnabledInfoManager::GetInstance().imeEnabledCfg_.insert({ MAIN_USER_ID, cfg });
477 auto ret = service_->SwitchByCombinationKey(KeyboardEvent::SHIFT_RIGHT_MASK);
478 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
479 }
480
481 /**
482 * @tc.name: SA_SwitchByCombinationKey_005
483 * @tc.desc: SwitchLanguage()/SwitchMode():FindTargetSubtypeByCondition failed
484 * @tc.type: FUNC
485 * @tc.require:
486 * @tc.author: chenyu
487 */
488 HWTEST_F(InputMethodPrivateMemberTest, SA_SwitchByCombinationKey_005, TestSize.Level0)
489 {
490 IMSA_HILOGI("InputMethodPrivateMemberTest SA_SwitchByCombinationKey_005 TEST START");
491 FullImeInfo info;
492 info.prop.name = "testBundleName";
493 info.prop.id = "testExtName";
494 SubProperty sub;
495 sub.name = "testBundleName";
496 sub.id = "testSubName";
497 sub.mode = "upper";
498 sub.language = "english";
499 info.subProps.push_back(sub);
500 FullImeInfoManager::GetInstance().fullImeInfos_.insert({ MAIN_USER_ID, { info } });
501 ImeEnabledCfg cfg;
502 ImeEnabledInfo imeInfo;
503 imeInfo.bundleName = "testBundleName";
504 imeInfo.extensionName = "testExtName";
505 imeInfo.extraInfo.isDefaultIme = true;
506 imeInfo.extraInfo.currentSubName = "testSubName";
507 cfg.enabledInfos.emplace_back(imeInfo);
508 ImeEnabledInfoManager::GetInstance().imeEnabledCfg_.insert({ MAIN_USER_ID, cfg });
509 auto ret = service_->SwitchByCombinationKey(KeyboardEvent::SHIFT_RIGHT_MASK);
510 EXPECT_EQ(ret, ErrorCode::ERROR_BAD_PARAMETERS);
511 ret = service_->SwitchByCombinationKey(KeyboardEvent::CAPS_MASK);
512 EXPECT_EQ(ret, ErrorCode::ERROR_BAD_PARAMETERS);
513 }
514
515 /**
516 * @tc.name: SA_SwitchByCombinationKey_006
517 * @tc.desc: SwitchLanguage()/SwitchMode():StartInputService() failed
518 * @tc.type: FUNC
519 * @tc.require:
520 * @tc.author: chenyu
521 */
522 HWTEST_F(InputMethodPrivateMemberTest, SA_SwitchByCombinationKey_006, TestSize.Level0)
523 {
524 IMSA_HILOGI("InputMethodPrivateMemberTest SA_SwitchByCombinationKey_006 TEST START");
525 FullImeInfo info;
526 info.prop.name = "testBundleName";
527 info.prop.id = "testExtName";
528 SubProperty sub;
529 sub.name = "testBundleName";
530 sub.id = "testSubName";
531 sub.mode = "upper";
532 sub.language = "english";
533 info.subProps.push_back(sub);
534 SubProperty sub1;
535 sub1.name = "testBundleName";
536 sub1.id = "testSubName1";
537 sub1.mode = "lower";
538 sub1.language = "chinese";
539 info.subProps.push_back(sub1);
540 FullImeInfoManager::GetInstance().fullImeInfos_.insert({ MAIN_USER_ID, { info } });
541
542 ImeEnabledCfg cfg;
543 ImeEnabledInfo imeInfo;
544 imeInfo.bundleName = "testBundleName";
545 imeInfo.extensionName = "testExtName";
546 imeInfo.extraInfo.isDefaultIme = true;
547 imeInfo.extraInfo.currentSubName = "testSubName";
548 cfg.enabledInfos.emplace_back(imeInfo);
549 ImeEnabledInfoManager::GetInstance().imeEnabledCfg_.insert({ MAIN_USER_ID, cfg });
550 // english->chinese
551 auto ret = service_->SwitchByCombinationKey(KeyboardEvent::SHIFT_RIGHT_MASK);
552 EXPECT_EQ(ret, ErrorCode::ERROR_IMSA_REBOOT_OLD_IME_NOT_STOP);
553 // lower->upper
554 ret = service_->SwitchByCombinationKey(KeyboardEvent::CAPS_MASK);
555 EXPECT_EQ(ret, ErrorCode::ERROR_IMSA_REBOOT_OLD_IME_NOT_STOP);
556 }
557
558 /**
559 * @tc.name: SA_SwitchByCombinationKey_007
560 * @tc.desc: SwitchType():StartInputService() failed
561 * @tc.type: FUNC
562 * @tc.require:
563 * @tc.author: chenyu
564 */
565 HWTEST_F(InputMethodPrivateMemberTest, SA_SwitchByCombinationKey_007, TestSize.Level0)
566 {
567 IMSA_HILOGI("InputMethodPrivateMemberTest SA_SwitchByCombinationKey_007 TEST START");
568 auto userId = TddUtil::GetCurrentUserId();
569 service_->userId_ = userId;
570 std::vector<Property> props;
571 InputMethodController::GetInstance()->ListInputMethod(props);
572 if (props.size() == 1) {
573 auto ret = service_->SwitchByCombinationKey(KeyboardEvent::SHIFT_RIGHT_MASK | KeyboardEvent::CTRL_RIGHT_MASK);
574 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
575 }
576 }
577
578 /**
579 * @tc.name: SA_SwitchByCombinationKey_008
580 * @tc.desc: SwitchType():find_if failed
581 * @tc.type: FUNC
582 * @tc.require:
583 * @tc.author: chenyu
584 */
585 HWTEST_F(InputMethodPrivateMemberTest, SA_SwitchByCombinationKey_008, TestSize.Level0)
586 {
587 IMSA_HILOGI("InputMethodPrivateMemberTest SA_SwitchByCombinationKey_008 TEST START");
588 auto userId = TddUtil::GetCurrentUserId();
589 service_->userId_ = userId;
590 auto prop = InputMethodController::GetInstance()->GetCurrentInputMethod();
591 auto subProp = InputMethodController::GetInstance()->GetCurrentInputMethodSubtype();
592 ImeEnabledCfg cfg;
593 ImeEnabledInfo imeInfo;
594 imeInfo.bundleName = prop->name;
595 imeInfo.extensionName = prop->id;
596 imeInfo.extraInfo.isDefaultIme = true;
597 imeInfo.extraInfo.currentSubName = subProp->id;
598 cfg.enabledInfos.emplace_back(imeInfo);
599 ImeEnabledInfoManager::GetInstance().imeEnabledCfg_.insert({ userId, cfg });
600 std::vector<Property> props;
601 InputMethodController::GetInstance()->ListInputMethod(props);
602 if (props.size() == 1) {
603 auto ret = service_->SwitchByCombinationKey(KeyboardEvent::SHIFT_RIGHT_MASK | KeyboardEvent::CTRL_RIGHT_MASK);
604 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
605 }
606 }
607
608 /**
609 * @tc.name: SA_SwitchByCombinationKey_Handler
610 * @tc.desc: SwitchType():handler is nullptr
611 * @tc.type: FUNC
612 * @tc.require:
613 */
614 HWTEST_F(InputMethodPrivateMemberTest, SA_SwitchByCombinationKey_Handler, TestSize.Level0)
615 {
616 IMSA_HILOGI("InputMethodPrivateMemberTest SA_SwitchByCombinationKey_Handler TEST START");
617 auto userId = TddUtil::GetCurrentUserId();
618 service_->userId_ = userId;
619 service_->DealSwitchRequest();
620 EXPECT_NE(service_->serviceHandler_, nullptr);
621 std::shared_ptr<AppExecFwk::EventHandler> tempHandler = service_->serviceHandler_;
622 service_->serviceHandler_ = nullptr;
623 service_->DealSwitchRequest();
624 EXPECT_EQ(service_->serviceHandler_, nullptr);
625 service_->serviceHandler_ = tempHandler;
626 }
627
628 /**
629 * @tc.name: SA_testReleaseInput_001
630 * @tc.desc: client is nullptr
631 * @tc.type: FUNC
632 * @tc.require:
633 * @tc.author: chenyu
634 */
635 HWTEST_F(InputMethodPrivateMemberTest, SA_testReleaseInput_001, TestSize.Level0)
636 {
637 IMSA_HILOGI("InputMethodPrivateMemberTest SA_testReleaseInput_001 TEST START");
638 auto ret = service_->ReleaseInput(nullptr, 0);
639 EXPECT_EQ(ret, ErrorCode::ERROR_CLIENT_NULL_POINTER);
640 }
641
642 /**
643 * @tc.name: III_TestRestoreInputMethod_001
644 * @tc.desc:
645 * @tc.type: FUNC
646 * @tc.require:
647 * @tc.author: chenyu
648 */
649 HWTEST_F(InputMethodPrivateMemberTest, III_TestRestoreInputMethod_001, TestSize.Level0)
650 {
651 IMSA_HILOGI("InputMethodPrivateMemberTest III_TestRestoreInputMethod_001 TEST START");
652 std::string bundleName = "";
653 auto ret = service_->RestoreInputmethod(bundleName);
654 EXPECT_EQ(ret, ErrorCode::ERROR_ENABLE_IME);
655
656 auto userId = service_->GetCallingUserId();
657 auto currentProp = ImeInfoInquirer::GetInstance().GetCurrentInputMethod(userId);
658 ret = service_->RestoreInputmethod(currentProp->name);
659 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
660
661 auto defaultIme = ImeInfoInquirer::GetInstance().GetDefaultIme();
662 ret = service_->RestoreInputmethod(defaultIme.bundleName);
663 EXPECT_TRUE(ret == ErrorCode::NO_ERROR || ret == ErrorCode::ERROR_IMSA_REBOOT_OLD_IME_NOT_STOP);
664
665 bundleName = "com.example.newTestIme";
666 EnabledStatus status = EnabledStatus::DISABLED;
667 ImeInfoInquirer::GetInstance().systemConfig_.enableInputMethodFeature = true;
668 service_->EnableIme(userId, bundleName, "", status);
669 ImeEnabledInfoManager::GetInstance().GetEnabledStateInner(userId, bundleName, status);
670 EXPECT_EQ(status, EnabledStatus::DISABLED);
671 service_->RestoreInputmethod(bundleName);
672 ImeEnabledInfoManager::GetInstance().GetEnabledStateInner(userId, bundleName, status);
673 EXPECT_EQ(status, EnabledStatus::BASIC_MODE);
674 ImeInfoInquirer::GetInstance().systemConfig_.enableInputMethodFeature = false;
675
676 UserSessionManager::GetInstance().RemoveUserSession(userId);
677 ret = service_->RestoreInputmethod(defaultIme.bundleName);
678 EXPECT_EQ(ret, ErrorCode::ERROR_NULL_POINTER);
679 }
680
681 /**
682 * @tc.name: III_TestGetCurrentInputMethodSubtype_001
683 * @tc.desc:
684 * @tc.type: FUNC
685 * @tc.require:
686 * @tc.author: chenyu
687 */
688 HWTEST_F(InputMethodPrivateMemberTest, III_TestGetCurrentSubtype_001, TestSize.Level0)
689 {
690 IMSA_HILOGI("InputMethodPrivateMemberTest III_TestGetCurrentInputMethodSubtype_001 TEST START");
691 // currentIme is empty
692 auto currentUserId = TddUtil::GetCurrentUserId();
693 ImeEnabledCfg cfg;
694 ImeEnabledInfo imeInfo;
695 cfg.enabledInfos.push_back(imeInfo);
696 ImeEnabledInfoManager::GetInstance().imeEnabledCfg_.insert({ currentUserId, cfg });
697 auto subProp = ImeInfoInquirer::GetInstance().GetCurrentSubtype(currentUserId);
698 EXPECT_TRUE(subProp == nullptr);
699
700 // subName is not find
701 auto currentProp = InputMethodController::GetInstance()->GetCurrentInputMethod();
702 ImeEnabledInfoManager::GetInstance().imeEnabledCfg_.clear();
703 ImeEnabledInfo imeInfo1;
704 imeInfo1.bundleName = currentProp->name;
705 imeInfo1.extensionName = currentProp->id;
706 imeInfo1.extraInfo.isDefaultIme = true;
707 imeInfo1.extraInfo.currentSubName = "tt";
708 ImeEnabledCfg cfg1;
709 cfg1.enabledInfos.emplace_back(imeInfo1);
710 ImeEnabledInfoManager::GetInstance().imeEnabledCfg_.insert({ currentUserId, cfg1 });
711 subProp = ImeInfoInquirer::GetInstance().GetCurrentSubtype(currentUserId);
712 ASSERT_TRUE(subProp != nullptr);
713 EXPECT_TRUE(subProp->name == currentProp->name);
714
715 // get correct subProp
716 auto currentSubProp = InputMethodController::GetInstance()->GetCurrentInputMethodSubtype();
717 ImeEnabledInfoManager::GetInstance().imeEnabledCfg_.clear();
718 ImeEnabledInfo imeInfo2;
719 imeInfo2.bundleName = currentProp->name;
720 imeInfo2.extensionName = currentProp->id;
721 imeInfo2.extraInfo.isDefaultIme = true;
722 imeInfo2.extraInfo.currentSubName = currentSubProp->id;
723 ImeEnabledCfg cfg2;
724 cfg2.enabledInfos.emplace_back(imeInfo2);
725 ImeEnabledInfoManager::GetInstance().imeEnabledCfg_.insert({ currentUserId, cfg2 });
726 subProp = ImeInfoInquirer::GetInstance().GetCurrentSubtype(currentUserId);
727 ASSERT_TRUE(subProp != nullptr);
728 EXPECT_TRUE(subProp->id == currentSubProp->id);
729 }
730
731 /**
732 * @tc.name: III_TestGetCurrentInputMethod_001
733 * @tc.desc:
734 * @tc.type: FUNC
735 * @tc.require:
736 * @tc.author: chenyu
737 */
738 HWTEST_F(InputMethodPrivateMemberTest, III_TestGetCurrentIme_001, TestSize.Level0)
739 {
740 IMSA_HILOGI("InputMethodPrivateMemberTest III_TestGetCurrentInputMethod_001 TEST START");
741 // currentIme is empty
742 auto currentUserId = TddUtil::GetCurrentUserId();
743 ImeEnabledCfg cfg;
744 ImeEnabledInfo imeInfo;
745 cfg.enabledInfos.push_back(imeInfo);
746 ImeEnabledInfoManager::GetInstance().imeEnabledCfg_.insert({ currentUserId, cfg });
747 auto prop = ImeInfoInquirer::GetInstance().GetCurrentInputMethod(currentUserId);
748 EXPECT_TRUE(prop == nullptr);
749
750 // get correct prop
751 auto currentProp = InputMethodController::GetInstance()->GetCurrentInputMethod();
752 ImeEnabledInfoManager::GetInstance().imeEnabledCfg_.clear();
753 imeInfo.bundleName = currentProp->name;
754 imeInfo.extensionName = currentProp->id;
755 imeInfo.extraInfo.isDefaultIme = true;
756 imeInfo.extraInfo.currentSubName = currentProp->id;
757 cfg.enabledInfos.emplace_back(imeInfo);
758 ImeEnabledInfoManager::GetInstance().imeEnabledCfg_.insert({ currentUserId, cfg });
759 prop = ImeInfoInquirer::GetInstance().GetCurrentInputMethod(currentUserId);
760 ASSERT_TRUE(prop != nullptr);
761 EXPECT_TRUE(prop->id == currentProp->id);
762 }
763
764 /**
765 * @tc.name: III_TestListEnabledInputMethod_001
766 * @tc.desc:
767 * @tc.type: FUNC
768 * @tc.require:
769 * @tc.author: chenyu
770 */
771 HWTEST_F(InputMethodPrivateMemberTest, III_TestListEnabledInputMethod_001, TestSize.Level0)
772 {
773 IMSA_HILOGI("InputMethodPrivateMemberTest III_TestListEnabledInputMethod_001 TEST START");
774 // currentIme is empty
775 std::vector<Property> props;
776 auto currentUserId = TddUtil::GetCurrentUserId();
777 auto ret = ImeInfoInquirer::GetInstance().ListEnabledInputMethod(currentUserId, props);
778 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
779 }
780
781 /**
782 * @tc.name: III_TestListCurrentInputMethodSubtype_001
783 * @tc.desc:
784 * @tc.type: FUNC
785 * @tc.require:
786 * @tc.author: chenyu
787 */
788 HWTEST_F(InputMethodPrivateMemberTest, III_TestListCurrentInputMethodSubtype_001, TestSize.Level0)
789 {
790 IMSA_HILOGI("InputMethodPrivateMemberTest III_TestListCurrentInputMethodSubtype_001 TEST START");
791 // currentIme is empty
792 std::vector<SubProperty> subProps;
793 auto currentUserId = TddUtil::GetCurrentUserId();
794 ImeEnabledCfg cfg;
795 ImeEnabledInfo imeInfo;
796 cfg.enabledInfos.push_back(imeInfo);
797 ImeEnabledInfoManager::GetInstance().imeEnabledCfg_.insert({ currentUserId, cfg });
798 auto ret = ImeInfoInquirer::GetInstance().ListCurrentInputMethodSubtype(currentUserId, subProps);
799 EXPECT_EQ(ret, ErrorCode::ERROR_BAD_PARAMETERS);
800 }
801
802 /**
803 * @tc.name: III_TestListInputMethod_001
804 * @tc.desc: status is error
805 * @tc.type: FUNC
806 * @tc.require:
807 * @tc.author: chenyu
808 */
809 HWTEST_F(InputMethodPrivateMemberTest, III_TestListInputMethod_001, TestSize.Level0)
810 {
811 IMSA_HILOGI("InputMethodPrivateMemberTest III_TestListInputMethod_001 TEST START");
812 std::vector<Property> props;
813 auto ret = ImeInfoInquirer::GetInstance().ListInputMethod(60, InputMethodStatus(10), props);
814 EXPECT_EQ(ret, ErrorCode::ERROR_BAD_PARAMETERS);
815 }
816
817 /**
818 * @tc.name: III_TestIsNewExtInfos_001
819 * @tc.desc: has no metadata name = SUBTYPE_PROFILE_METADATA_NAME
820 * @tc.type: FUNC
821 * @tc.require:
822 * @tc.author: chenyu
823 */
824 HWTEST_F(InputMethodPrivateMemberTest, III_TestIsNewExtInfos_001, TestSize.Level0)
825 {
826 IMSA_HILOGI("InputMethodPrivateMemberTest III_TestIsNewExtInfos_001 TEST START");
827 ExtensionAbilityInfo extInfo;
828 std::vector<SubProperty> subProps;
829 auto ret = ImeInfoInquirer::GetInstance().ListInputMethodSubtype(50, extInfo, subProps);
830 EXPECT_EQ(ret, ErrorCode::ERROR_BAD_PARAMETERS);
831 }
832
833 /**
834 * @tc.name: ICM_TestDeleteImeCfg_001
835 * @tc.desc: delete ime cfg correctly
836 * @tc.type: FUNC
837 * @tc.require:
838 * @tc.author: chenyu
839 */
840 HWTEST_F(InputMethodPrivateMemberTest, ICM_TestDeleteImeCfg_001, TestSize.Level0)
841 {
842 IMSA_HILOGI("InputMethodPrivateMemberTest ICM_TestDeleteImeCfg_001 TEST START");
843 ImeCfgManager::GetInstance().imeConfigs_.push_back({ 100, "testBundleName", "testSubName", false });
844 ImeCfgManager::GetInstance().DeleteImeCfg(100);
845 EXPECT_TRUE(ImeCfgManager::GetInstance().imeConfigs_.empty());
846 }
847
848 /**
849 * @tc.name: WMSConnectObserver_001
850 * @tc.desc:
851 * @tc.type: FUNC
852 * @tc.require:
853 * @tc.author: chenyu
854 */
855 HWTEST_F(InputMethodPrivateMemberTest, WMSConnectObserver_001, TestSize.Level0)
856 {
857 IMSA_HILOGI("InputMethodPrivateMemberTest WMSConnectObserver_001 TEST START");
858 WmsConnectionObserver observer(nullptr);
859 WmsConnectionObserver::connectedUserId_.clear();
860 int32_t userId = 100;
861 int32_t screenId = 0;
862
863 observer.OnConnected(userId, screenId);
864 EXPECT_EQ(WmsConnectionObserver::connectedUserId_.size(), 1);
865 EXPECT_TRUE(WmsConnectionObserver::IsWmsConnected(userId));
866
867 int32_t userId1 = 102;
868 observer.OnConnected(userId1, screenId);
869 EXPECT_EQ(WmsConnectionObserver::connectedUserId_.size(), 2);
870 EXPECT_TRUE(WmsConnectionObserver::IsWmsConnected(userId1));
871
872 observer.OnConnected(userId, screenId);
873 EXPECT_EQ(WmsConnectionObserver::connectedUserId_.size(), 2);
874
875 observer.OnDisconnected(userId, screenId);
876 EXPECT_EQ(WmsConnectionObserver::connectedUserId_.size(), 1);
877 EXPECT_FALSE(WmsConnectionObserver::IsWmsConnected(userId));
878 }
879
880 /**
881 * @tc.name: IMC_testDeactivateClient
882 * @tc.desc: DeactivateClient
883 * @tc.type: FUNC
884 * @tc.require:
885 * @tc.author: chenyu
886 */
887 HWTEST_F(InputMethodPrivateMemberTest, IMC_testDeactivateClient, TestSize.Level0)
888 {
889 IMSA_HILOGI("InputMethodPrivateMemberTest IMC_testDeactivateClient Test START");
890 auto imc = InputMethodController::GetInstance();
891 imc->ClearAgentInfo();
892 sptr<IInputMethodAgent> agent = new (std::nothrow) InputMethodAgentServiceImpl();
893 imc->SetAgent(agent->AsObject(), "");
894 imc->clientInfo_.state = ClientState::ACTIVE;
895 imc->DeactivateClient();
896 EXPECT_EQ(imc->clientInfo_.state, ClientState::INACTIVE);
897 EXPECT_GE(imc->agentInfoList_.size(), 1);
898 EXPECT_NE(imc->agentInfoList_[0].agent, nullptr);
899 EXPECT_NE(imc->agentInfoList_[0].agentObject, nullptr);
900 imc->ClearAgentInfo();
901 }
902
903 /**
904 * @tc.name: testIsPanelShown
905 * @tc.desc: Test Panel Shown.
906 * @tc.type: FUNC
907 */
908 HWTEST_F(InputMethodPrivateMemberTest, testIsPanelShown, TestSize.Level0)
909 {
910 IMSA_HILOGI("InputMethodPrivateMemberTest testIsPanelShown TEST START");
911 auto userSession = std::make_shared<PerUserSession>(MAIN_USER_ID);
912 PanelInfo panelInfo;
913 panelInfo.panelType = SOFT_KEYBOARD;
914 panelInfo.panelFlag = FLG_FIXED;
915 bool flag = true;
916 auto ret = userSession->IsPanelShown(panelInfo, flag);
917 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
918 }
919
920 /**
921 * @tc.name: TestGetDefaultInputMethod_001
922 * @tc.desc: TestGetDefaultInputMethod
923 * @tc.type: FUNC
924 * @tc.require:
925 */
926 HWTEST_F(InputMethodPrivateMemberTest, TestGetDefaultInputMethod_001, TestSize.Level0)
927 {
928 IMSA_HILOGI("InputMethodPrivateMemberTest TestGetDefaultInputMethod_001 TEST START");
929 // currentIme is empty
930 std::shared_ptr<Property> prop;
931 auto currentUserId = TddUtil::GetCurrentUserId();
932 auto ret = ImeInfoInquirer::GetInstance().GetDefaultInputMethod(currentUserId, prop, false);
933 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
934 }
935
936 /**
937 * @tc.name: TestGetDefaultInputMethod_002
938 * @tc.desc: TestGetDefaultInputMethod
939 * @tc.type: FUNC
940 * @tc.require:
941 */
942 HWTEST_F(InputMethodPrivateMemberTest, TestGetDefaultInputMethod_002, TestSize.Level0)
943 {
944 IMSA_HILOGI("InputMethodPrivateMemberTest TestGetDefaultInputMethod_002 TEST START");
945 // currentIme is empty
946 std::shared_ptr<Property> prop;
947 auto currentUserId = TddUtil::GetCurrentUserId();
948 auto ret = ImeInfoInquirer::GetInstance().GetDefaultInputMethod(currentUserId, prop, true);
949 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
950 }
951
952 /**
953 * @tc.name: TestGetResMgr
954 * @tc.desc: GetResMgr
955 * @tc.type: FUNC
956 * @tc.require:
957 */
958 HWTEST_F(InputMethodPrivateMemberTest, TestGetResMgr, TestSize.Level0)
959 {
960 IMSA_HILOGI("InputMethodPrivateMemberTest TestGetResMgr TEST START");
961 // currentIme is empty
962 auto ret = ImeInfoInquirer::GetInstance().GetResMgr("/test");
963 EXPECT_TRUE(ret != nullptr);
964 }
965
966 /**
967 * @tc.name: TestQueryFullImeInfo
968 * @tc.desc: QueryFullImeInfo
969 * @tc.type: FUNC
970 * @tc.require:
971 */
972 HWTEST_F(InputMethodPrivateMemberTest, TestQueryFullImeInfo, TestSize.Level0)
973 {
974 IMSA_HILOGI("InputMethodPrivateMemberTest TestQueryFullImeInfo TEST START");
975 auto currentUserId = TddUtil::GetCurrentUserId();
976 std::vector<FullImeInfo> infos;
977 auto ret = ImeInfoInquirer::GetInstance().QueryFullImeInfo(currentUserId, infos);
978 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
979 }
980
981 /**
982 * @tc.name: TestIsInputMethod
983 * @tc.desc: IsInputMethod
984 * @tc.type: FUNC
985 * @tc.require:
986 */
987 HWTEST_F(InputMethodPrivateMemberTest, TestIsInputMethod, TestSize.Level0)
988 {
989 IMSA_HILOGI("InputMethodPrivateMemberTest TestIsInputMethod TEST START");
990 auto currentUserId = TddUtil::GetCurrentUserId();
991 auto bundleName = "testBundleName1";
992 auto ret = ImeInfoInquirer::GetInstance().IsInputMethod(currentUserId, bundleName);
993 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
994 }
995
996 /**
997 @tc.name: TestHandlePackageEvent
998 @tc.desc: TestHandlePackageEvent
999 @tc.type: FUNC
1000 @tc.require:
1001 */
1002 HWTEST_F(InputMethodPrivateMemberTest, TestHandlePackageEvent, TestSize.Level0)
1003 {
1004 // msg is nullptr
1005 auto *msg = new Message(MessageID::MSG_ID_PACKAGE_REMOVED, nullptr);
1006 auto ret = service_->HandlePackageEvent(msg);
1007 EXPECT_EQ(ret, ErrorCode::ERROR_NULL_POINTER);
1008 MessageHandler::Instance()->SendMessage(msg);
1009
1010 // PARCELABLE failed
1011 MessageParcel *parcel1 = new (std::nothrow) MessageParcel();
1012 auto bundleName = "testBundleName1";
1013 parcel1->WriteString(bundleName);
1014 auto msg1 = std::make_shared<Message>(MessageID::MSG_ID_PACKAGE_REMOVED, parcel1);
1015 auto ret1 = service_->HandlePackageEvent(msg1.get());
1016 EXPECT_EQ(ret1, ErrorCode::ERROR_EX_PARCELABLE);
1017
1018 // userId is not same
1019 auto parcel2 = new (std::nothrow) MessageParcel();
1020 auto userId = 50;
1021 service_->userId_ = 60;
1022 parcel2->WriteInt32(userId);
1023 parcel2->WriteString(bundleName);
1024 auto msg2 = std::make_shared<Message>(MessageID::MSG_ID_PACKAGE_REMOVED, parcel2);
1025 auto ret2 = service_->HandlePackageEvent(msg2.get());
1026 EXPECT_EQ(ret2, ErrorCode::NO_ERROR);
1027
1028 //remove bundle not current ime
1029 auto parcel3 = new (std::nothrow) MessageParcel();
1030 service_->userId_ = userId;
1031 ImeCfgManager::GetInstance().imeConfigs_.push_back({ 60, "testBundleName/testExtName", "testSubName", false });
1032 parcel3->WriteInt32(userId);
1033 parcel3->WriteString(bundleName);
1034 auto msg3 = std::make_shared<Message>(MessageID::MSG_ID_PACKAGE_REMOVED, parcel3);
1035 auto ret3 = service_->HandlePackageEvent(msg3.get());
1036 EXPECT_EQ(ret3, ErrorCode::NO_ERROR);
1037 }
1038
1039 /**
1040 * @tc.name: testGetSubProperty001
1041 * @tc.desc: Test testGetSubProperty
1042 * @tc.type: FUNC
1043 * @tc.require:
1044 */
1045 HWTEST_F(InputMethodPrivateMemberTest, testGetSubProperty001, TestSize.Level0)
1046 {
1047 IMSA_HILOGI("InputMethodPrivateMemberTest testGetSubProperty001 START");
1048 int32_t userId = 100;
1049 const std::string subName = "defaultImeId";
1050 SubProperty subProp;
1051 const std::vector<OHOS::AppExecFwk::ExtensionAbilityInfo> extInfos;
1052 auto ret = ImeInfoInquirer::GetInstance().GetSubProperty(userId, subName, extInfos, subProp);
1053 EXPECT_EQ(ret, ErrorCode::ERROR_PACKAGE_MANAGER);
1054 }
1055
1056 /**
1057 * @tc.name: testGetSubProperty002
1058 * @tc.desc: Test testGetSubProperty
1059 * @tc.type: FUNC
1060 * @tc.require:
1061 */
1062 HWTEST_F(InputMethodPrivateMemberTest, testGetSubProperty002, TestSize.Level0)
1063 {
1064 IMSA_HILOGI("InputMethodPrivateMemberTest testGetSubProperty002 START");
1065 int32_t userId = 100;
1066 const std::string subName = "defaultImeId";
1067 SubProperty subProp;
1068 ExtensionAbilityInfo extInfo;
1069 extInfo.name = "test";
1070 const std::vector<OHOS::AppExecFwk::ExtensionAbilityInfo> extInfos = { extInfo };
1071 auto ret = ImeInfoInquirer::GetInstance().GetSubProperty(userId, subName, extInfos, subProp);
1072 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
1073 }
1074
1075 /**
1076 * @tc.name: testListInputMethodSubtype
1077 * @tc.desc: Test ListInputMethodSubtype
1078 * @tc.type: FUNC
1079 * @tc.require:
1080 */
1081 HWTEST_F(InputMethodPrivateMemberTest, testListInputMethodSubtype, TestSize.Level0)
1082 {
1083 IMSA_HILOGI("InputMethodPrivateMemberTest testListInputMethodSubtype START");
1084 int32_t userId = 100;
1085 const std::string subName = "defaultImeId";
1086 std::vector<SubProperty> subProps;
1087 const std::vector<OHOS::AppExecFwk::ExtensionAbilityInfo> extInfos;
1088 auto ret = ImeInfoInquirer::GetInstance().ListInputMethodSubtype(userId, extInfos, subProps);
1089 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
1090 }
1091
1092 /**
1093 * @tc.name: testGetInputMethodConfig
1094 * @tc.desc: Test GetInputMethodConfig
1095 * @tc.type: FUNC
1096 * @tc.require:
1097 */
1098 HWTEST_F(InputMethodPrivateMemberTest, testGetInputMethodConfig, TestSize.Level0)
1099 {
1100 IMSA_HILOGI("InputMethodPrivateMemberTest testGetInputMethodConfig START");
1101 int32_t userId = 100;
1102 AppExecFwk::ElementName inputMethodConfig;
1103 auto ret = ImeInfoInquirer::GetInstance().GetInputMethodConfig(userId, inputMethodConfig);
1104 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
1105 }
1106
1107 /**
1108 * @tc.name: TestOnSecurityChange
1109 * @tc.desc: Test OnSecurityChange
1110 * @tc.type: FUNC
1111 * @tc.require: issuesI794QF
1112 */
1113 HWTEST_F(InputMethodPrivateMemberTest, TestOnSecurityChange, TestSize.Level0)
1114 {
1115 IMSA_HILOGI("InputMethodPrivateMemberTest TestOnSecurityChange TEST START");
1116 auto userSession = std::make_shared<PerUserSession>(MAIN_USER_ID);
1117 auto clientGroup = std::make_shared<ClientGroup>(DEFAULT_DISPLAY_ID, nullptr);
1118 auto imc = InputMethodController::GetInstance();
1119 int32_t ret = userSession->ShowKeyboard(imc->clientInfo_.client, clientGroup);
1120 userSession->OnSecurityChange(10);
1121 EXPECT_EQ(ret, ErrorCode::ERROR_CLIENT_NOT_FOUND);
1122 ret = userSession->ShowKeyboard(nullptr, nullptr);
1123 EXPECT_EQ(ret, ErrorCode::ERROR_IMSA_NULLPTR);
1124 }
1125
1126 /**
1127 * @tc.name: TestServiceStartInputType
1128 * @tc.desc: Test ServiceStartInputType
1129 * @tc.type: FUNC
1130 * @tc.require:
1131 */
1132 HWTEST_F(InputMethodPrivateMemberTest, TestServiceStartInputType, TestSize.Level0)
1133 {
1134 auto ret = service_->ExitCurrentInputType();
1135 EXPECT_NE(ret, ErrorCode::NO_ERROR);
1136 ret = service_->StartInputType(static_cast<int32_t>(InputType::NONE));
1137 EXPECT_NE(ret, ErrorCode::NO_ERROR);
1138 const PanelInfo panelInfo;
1139 bool isShown = false;
1140 ret = service_->IsPanelShown(panelInfo, isShown);
1141 EXPECT_EQ(ret, ErrorCode::ERROR_STATUS_SYSTEM_PERMISSION);
1142 }
1143
1144 /**
1145 * @tc.name: TestServiceStartInputType
1146 * @tc.desc: Test ServiceStartInputType
1147 * @tc.type: FUNC
1148 * @tc.require:
1149 */
1150 HWTEST_F(InputMethodPrivateMemberTest, TestIsSupported, TestSize.Level0)
1151 {
1152 auto ret = InputTypeManager::GetInstance().IsSupported(InputType::NONE);
1153 EXPECT_FALSE(ret);
1154 }
1155
1156 /**
1157 * @tc.name: TestOnUnRegisteredProxyIme
1158 * @tc.desc: Test OnUnRegisteredProxyIme
1159 * @tc.type: FUNC
1160 * @tc.require: issuesI794QF
1161 */
1162 HWTEST_F(InputMethodPrivateMemberTest, TestOnUnRegisteredProxyIme, TestSize.Level0)
1163 {
1164 IMSA_HILOGI("InputMethodPrivateMemberTest TestOnUnRegisteredProxyIme TEST START");
1165 auto userSession = std::make_shared<PerUserSession>(MAIN_USER_ID);
1166 UnRegisteredType type = UnRegisteredType::REMOVE_PROXY_IME;
1167 const sptr<IInputMethodCore> core;
1168 auto ret = userSession->OnUnRegisteredProxyIme(type, core, IPCSkeleton::GetCallingPid());
1169 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
1170 userSession->clientGroupMap_.clear();
1171 ret = userSession->RemoveAllCurrentClient();
1172 EXPECT_EQ(ret, ErrorCode::ERROR_CLIENT_NULL_POINTER);
1173 }
1174
1175 /**
1176 * @tc.name: TestStartInputType
1177 * @tc.desc: Test StartInputType
1178 * @tc.type: FUNC
1179 * @tc.require: issuesI794QF
1180 */
1181 HWTEST_F(InputMethodPrivateMemberTest, TestStartInputType, TestSize.Level0)
1182 {
1183 IMSA_HILOGI("InputMethodPrivateMemberTest TestStartInputType TEST START");
1184 InputType type = InputType::NONE;
1185 auto ret = service_->StartInputType(static_cast<int32_t>(type));
1186 EXPECT_NE(ret, ErrorCode::NO_ERROR);
1187 ret = service_->StartInputType(static_cast<int32_t>(InputType::VOICEKB_INPUT));
1188 EXPECT_NE(ret, ErrorCode::NO_ERROR);
1189 }
1190
1191 /**
1192 * @tc.name: TestStartInputTypeAsync
1193 * @tc.desc: Test StartInputTypeAsync
1194 * @tc.type: FUNC
1195 * @tc.require: issuesI794QF
1196 */
1197 HWTEST_F(InputMethodPrivateMemberTest, TestStartInputTypeAsync, TestSize.Level0)
1198 {
1199 IMSA_HILOGI("InputMethodPrivateMemberTest TestStartInputTypeAsync TEST START");
1200 InputType type = InputType::NONE;
1201 auto ret = service_->StartInputTypeAsync(static_cast<int32_t>(type));
1202 EXPECT_NE(ret, ErrorCode::NO_ERROR);
1203 ret = service_->StartInputTypeAsync(static_cast<int32_t>(InputType::VOICEKB_INPUT));
1204 EXPECT_NE(ret, ErrorCode::NO_ERROR);
1205 }
1206
1207 /**
1208 * @tc.name: TestFullImeInfoManager_Update001
1209 * @tc.desc: Test FullImeInfoManager_Update
1210 * @tc.type: FUNC
1211 * @tc.require:
1212 * @tc.author: chenyu
1213 */
1214 HWTEST_F(InputMethodPrivateMemberTest, TestFullImeInfoManager_Update001, TestSize.Level0)
1215 {
1216 IMSA_HILOGI("InputMethodPrivateMemberTest TestFullImeInfoManager_Update001 TEST START");
1217 std::string bundleName = "ttttttttt";
1218 auto ret = FullImeInfoManager::GetInstance().Update(MAIN_USER_ID, bundleName);
1219 EXPECT_EQ(ret, ErrorCode::ERROR_PACKAGE_MANAGER);
1220 }
1221
1222 /**
1223 * @tc.name: TestFullImeInfoManager_Update002
1224 * @tc.desc: Test FullImeInfoManager_Update
1225 * @tc.type: FUNC
1226 * @tc.require:
1227 * @tc.author: chenyu
1228 */
1229 HWTEST_F(InputMethodPrivateMemberTest, TestFullImeInfoManager_Update002, TestSize.Level0)
1230 {
1231 IMSA_HILOGI("InputMethodPrivateMemberTest TestFullImeInfoManager_Update002 TEST START");
1232 std::string bundleName = "testBundleName";
1233 auto ret = FullImeInfoManager::GetInstance().Update(MAIN_USER_ID, bundleName);
1234 EXPECT_EQ(ret, ErrorCode::ERROR_PACKAGE_MANAGER);
1235 }
1236
1237 /**
1238 * @tc.name: TestFullImeInfoManager_Has
1239 * @tc.desc: Test FullImeInfoManager_Has
1240 * @tc.type: FUNC
1241 * @tc.require:
1242 * @tc.author: chenyu
1243 */
1244 HWTEST_F(InputMethodPrivateMemberTest, TestFullImeInfoManager_Has, TestSize.Level0)
1245 {
1246 IMSA_HILOGI("InputMethodPrivateMemberTest TestFullImeInfoManager_Has TEST START");
1247 int32_t userId = 1234567890;
1248 std::string bundleName = "ttttttttttt";
1249 auto ret = FullImeInfoManager::GetInstance().Has(userId, bundleName);
1250 EXPECT_FALSE(ret);
1251 }
1252
1253 /**
1254 * @tc.name: TestFullImeInfoManager_Get
1255 * @tc.desc: Test FullImeInfoManager_Get
1256 * @tc.type: FUNC
1257 * @tc.require:
1258 * @tc.author: chenyu
1259 */
1260 HWTEST_F(InputMethodPrivateMemberTest, TestFullImeInfoManager_Get, TestSize.Level0)
1261 {
1262 IMSA_HILOGI("InputMethodPrivateMemberTest TestFullImeInfoManager_Get TEST START");
1263 FullImeInfo info;
1264 info.isNewIme = true;
1265 info.prop.name = "testBundleName";
1266 SubProperty sub;
1267 sub.id = "testSubName";
1268 info.subProps.push_back(sub);
1269 FullImeInfoManager::GetInstance().fullImeInfos_.insert({ MAIN_USER_ID, { info } });
1270 uint32_t invalidTokenId = 4294967295;
1271 auto ret = FullImeInfoManager::GetInstance().Get(MAIN_USER_ID, invalidTokenId);
1272 EXPECT_EQ(ret, "");
1273 }
1274
1275 /**
1276 * @tc.name: TestIsMatch
1277 * @tc.desc: CombinationKey IsMatch
1278 * @tc.type: FUNC
1279 * @tc.require:
1280 */
1281 HWTEST_F(InputMethodPrivateMemberTest, TestIsMatch, TestSize.Level0)
1282 {
1283 IMSA_HILOGI("InputMethodPrivateMemberTest CombinationKey::IsMatch TEST START");
1284 uint32_t state = 50; // Assuming 50 is a valid state for this combination key.
1285 int32_t value = 100;
1286 CombinationKeyFunction invliadCombinationKey = static_cast<CombinationKeyFunction>(value);
1287 auto ret = CombinationKey::IsMatch(invliadCombinationKey, state);
1288 EXPECT_FALSE(ret);
1289 }
1290
1291 /**
1292 * @tc.name: test_OnFocusedAndOnUnfocused001
1293 * @tc.desc: test OnFocusedAndOnUnfocused
1294 * @tc.type: FUNC
1295 */
1296 HWTEST_F(InputMethodPrivateMemberTest, test_OnFocusedAndOnUnfocused001, TestSize.Level0)
1297 {
1298 IMSA_HILOGI("test_OnFocusedAndOnUnfocused001 TEST START");
1299 const sptr<Rosen::FocusChangeInfo> focusChangeInfo = nullptr;
1300 FocusHandle handle;
1301 FocusChangedListener focusChangedListener(handle);
1302 focusChangedListener.OnFocused(focusChangeInfo);
1303 focusChangedListener.OnUnfocused(focusChangeInfo);
1304 EXPECT_EQ(focusChangeInfo, nullptr);
1305 }
1306
1307 /**
1308 * @tc.name: test_OnFocusedAndOnUnfocused002
1309 * @tc.desc: test KeyEvent Callback.
1310 * @tc.type: FUNC
1311 */
1312 HWTEST_F(InputMethodPrivateMemberTest, test_OnFocusedAndOnUnfocused002, TestSize.Level0)
1313 {
1314 IMSA_HILOGI("test_OnFocusedAndOnUnfocused002 TEST START");
1315 const sptr<Rosen::FocusChangeInfo> focusChangeInfo = new Rosen::FocusChangeInfo();
1316 FocusHandle handle = nullptr;
1317 FocusChangedListener focusChangedListener(handle);
1318 focusChangedListener.OnFocused(focusChangeInfo);
1319 focusChangedListener.OnUnfocused(focusChangeInfo);
1320 EXPECT_EQ(handle, nullptr);
1321 }
1322
1323 /**
1324 * @tc.name: test_WmsConnectionObserver
1325 * @tc.desc: test KeyEvent Callback.
1326 * @tc.type: FUNC
1327 */
1328 HWTEST_F(InputMethodPrivateMemberTest, test_WmsConnectionObserver, TestSize.Level0)
1329 {
1330 IMSA_HILOGI("test_WmsConnectionObserver TEST START");
1331 WmsConnectionObserver observer(nullptr);
1332 int32_t invalidUserId = 1234567890;
1333 observer.Remove(invalidUserId);
1334 ASSERT_EQ(observer.connectedUserId_.find(invalidUserId), observer.connectedUserId_.end());
1335 }
1336
1337 /**
1338 * @tc.name: BranchCoverage001
1339 * @tc.desc: BranchCoverage
1340 * @tc.type: FUNC
1341 */
1342 HWTEST_F(InputMethodPrivateMemberTest, BranchCoverage001, TestSize.Level0)
1343 {
1344 IMSA_HILOGI("InputMethodPrivateMemberTest BranchCoverage001 TEST START");
1345 auto userSession = std::make_shared<PerUserSession>(MAIN_USER_ID);
1346 sptr<IInputMethodCore> core = nullptr;
1347 sptr<IRemoteObject> agent = nullptr;
1348 pid_t pid { -1 };
1349 auto ret = userSession->UpdateImeData(core, agent, pid);
1350 EXPECT_EQ(ret, ErrorCode::ERROR_NULL_POINTER);
1351
1352 InputClientInfo clientInfo;
1353 auto ret2 = service_->PrepareInput(INVALID_USER_ID, clientInfo);
1354 EXPECT_NE(ret2, ErrorCode::NO_ERROR);
1355
1356 clientInfo.config.inputAttribute.inputPattern = 7;
1357 clientInfo.isNotifyInputStart = false;
1358 ret2 = service_->CheckInputTypeOption(INVALID_USER_ID, clientInfo);
1359 EXPECT_NE(ret2, ErrorCode::NO_ERROR);
1360
1361 clientInfo.isNotifyInputStart = true;
1362 ret2 = service_->CheckInputTypeOption(INVALID_USER_ID, clientInfo);
1363 EXPECT_EQ(ret2, ErrorCode::ERROR_IMSA_USER_SESSION_NOT_FOUND);
1364
1365 const std::string bundleName;
1366 const std::string subName;
1367 SwitchTrigger trigger = SwitchTrigger::IMSA;
1368 ret2 = service_->SwitchInputMethod(bundleName, subName, static_cast<uint32_t>(trigger));
1369 EXPECT_EQ(ret2, ErrorCode::ERROR_BAD_PARAMETERS);
1370
1371 const std::shared_ptr<ImeInfo> info = nullptr;
1372 ret2 = service_->SwitchSubType(INVALID_USER_ID, info);
1373 EXPECT_NE(ret2, ErrorCode::NO_ERROR);
1374
1375 const SwitchInfo switchInfo;
1376 ret2 = service_->SwitchInputType(INVALID_USER_ID, switchInfo);
1377 EXPECT_NE(ret2, ErrorCode::NO_ERROR);
1378 }
1379
1380 /**
1381 * @tc.name: BranchCoverage002
1382 * @tc.desc: BranchCoverage
1383 * @tc.type: FUNC
1384 */
1385 HWTEST_F(InputMethodPrivateMemberTest, BranchCoverage002, TestSize.Level0)
1386 {
1387 IMSA_HILOGI("InputMethodPrivateMemberTest BranchCoverage002 TEST START");
1388 auto msgPtr = std::make_shared<Message>(0, nullptr);
1389 const OHOS::MiscServices::Message* msg = msgPtr.get();
1390 auto ret = service_->OnUserRemoved(msg);
1391 EXPECT_EQ(ret, ErrorCode::ERROR_NULL_POINTER);
1392 ret = service_->OnUserStop(msg);
1393 EXPECT_EQ(ret, ErrorCode::ERROR_NULL_POINTER);
1394 ret = service_->OnHideKeyboardSelf(msg);
1395 EXPECT_EQ(ret, ErrorCode::ERROR_NULL_POINTER);
1396 ret = service_->HandlePackageEvent(msg);
1397 EXPECT_EQ(ret, ErrorCode::ERROR_NULL_POINTER);
1398
1399 service_->HandleUserSwitched(INVALID_USER_ID);
1400
1401 const SwitchInfo switchInfo;
1402 UserSessionManager::GetInstance().RemoveUserSession(INVALID_USER_ID);
1403 auto ret2 = service_->OnStartInputType(INVALID_USER_ID, switchInfo, false);
1404 EXPECT_EQ(ret2, ErrorCode::ERROR_IMSA_USER_SESSION_NOT_FOUND);
1405
1406 bool needHide = false;
1407 InputType type = InputType::NONE;
1408 auto ret3 = service_->IsCurrentIme(INVALID_USER_ID, 0);
1409 service_->NeedHideWhenSwitchInputType(INVALID_USER_ID, type, needHide);
1410 EXPECT_FALSE(ret3);
1411 }
1412
1413 /**
1414 * @tc.name: BranchCoverage003
1415 * @tc.desc: BranchCoverage
1416 * @tc.type: FUNC
1417 */
1418 HWTEST_F(InputMethodPrivateMemberTest, BranchCoverage003, TestSize.Level0)
1419 {
1420 IMSA_HILOGI("InputMethodPrivateMemberTest BranchCoverage003 TEST START");
1421 UserSessionManager::GetInstance().RemoveUserSession(INVALID_USER_ID);
1422 const std::string bundleName = "";
1423 std::vector<AppExecFwk::ExtensionAbilityInfo> extInfos;
1424 ImeInfoInquirer inquirer;
1425 auto ret = inquirer.GetExtInfosByBundleName(INVALID_USER_ID, bundleName, extInfos);
1426 EXPECT_EQ(ret, ErrorCode::ERROR_BAD_PARAMETERS);
1427
1428 auto ret2 = inquirer.ListInputMethodInfo(INVALID_USER_ID);
1429 EXPECT_TRUE(ret2.empty());
1430
1431 auto ret3 = inquirer.GetDumpInfo(INVALID_USER_ID);
1432 EXPECT_TRUE(ret3 == "");
1433
1434 std::vector<Property> props = {};
1435 ret = inquirer.ListEnabledInputMethod(INVALID_USER_ID, props);
1436 EXPECT_NE(ret, ErrorCode::NO_ERROR);
1437
1438 ret = inquirer.ListDisabledInputMethod(INVALID_USER_ID, props);
1439 EXPECT_NE(ret, ErrorCode::NO_ERROR);
1440
1441 SwitchInfo switchInfo;
1442 uint32_t cacheCount = -1;
1443 ret = inquirer.GetSwitchInfoBySwitchCount(switchInfo, INVALID_USER_ID, cacheCount);
1444 EXPECT_NE(ret, ErrorCode::NO_ERROR);
1445 }
1446
1447 /**
1448 * @tc.name: BranchCoverage004
1449 * @tc.desc: BranchCoverage
1450 * @tc.type: FUNC
1451 */
1452 HWTEST_F(InputMethodPrivateMemberTest, BranchCoverage004, TestSize.Level0)
1453 {
1454 IMSA_HILOGI("InputMethodPrivateMemberTest BranchCoverage003 TEST START");
1455 auto userSession = std::make_shared<PerUserSession>(MAIN_USER_ID);
1456 sptr<SettingsDataObserver> observer;
1457 std::shared_ptr<DataShare::DataShareHelper> helper;
1458 std::string invaildString;
1459 pid_t pid { -1 };
1460 auto ret = SettingsDataUtils::GetInstance().RegisterObserver(observer);
1461 EXPECT_EQ(ret, ErrorCode::ERROR_NULL_POINTER);
1462 ret = SettingsDataUtils::GetInstance().GetStringValue(invaildString, invaildString, invaildString);
1463 EXPECT_EQ(ret, ErrorCode::ERROR_NULL_POINTER);
1464 ret = userSession->OnHideInput(nullptr);
1465 EXPECT_EQ(ret, ErrorCode::ERROR_CLIENT_NOT_FOCUSED);
1466 ret = userSession->OnShowInput(nullptr);
1467 EXPECT_EQ(ret, ErrorCode::ERROR_CLIENT_NOT_FOCUSED);
1468
1469 sptr<IInputClient> client = new (std::nothrow) InputClientServiceImpl();
1470 ASSERT_NE(client, nullptr);
1471 auto clientGroup = std::make_shared<ClientGroup>(DEFAULT_DISPLAY_ID, nullptr);
1472 DetachOptions options = { .isUnbindFromClient = false, .isInactiveClient = false, .isNotifyClientAsync = false };
1473 ret = userSession->RemoveClient(nullptr, clientGroup, options);
1474 EXPECT_EQ(ret, ErrorCode::ERROR_CLIENT_NULL_POINTER);
1475 ret = userSession->RemoveClient(client, nullptr, options);
1476 EXPECT_EQ(ret, ErrorCode::ERROR_CLIENT_NULL_POINTER);
1477 ret = userSession->BindClientWithIme(nullptr, ImeType::IME, false);
1478 userSession->UnBindClientWithIme(nullptr, options);
1479 EXPECT_EQ(ret, ErrorCode::ERROR_IMSA_NULLPTR);
1480 ret = userSession->OnSetCallingWindow(0, 0, nullptr);
1481 EXPECT_EQ(ret, ErrorCode::ERROR_CLIENT_NOT_FOCUSED);
1482
1483 auto ret2 = SettingsDataUtils::GetInstance().ReleaseDataShareHelper(helper);
1484 EXPECT_TRUE(ret2);
1485 ret2 = SettingsDataUtils::GetInstance().SetStringValue(invaildString, invaildString, invaildString);
1486 EXPECT_FALSE(ret2);
1487 ret2 = clientGroup->IsCurClientFocused(-1, -1);
1488 EXPECT_FALSE(ret2);
1489 ret2 = clientGroup->IsCurClientUnFocused(-1, -1);
1490 EXPECT_FALSE(ret2);
1491 auto startRet = userSession->StartInputService(nullptr);
1492 EXPECT_EQ(startRet, ErrorCode::ERROR_IMSA_IME_TO_START_NULLPTR);
1493 startRet = userSession->StartIme(nullptr, false);
1494 EXPECT_EQ(startRet, ErrorCode::ERROR_IMSA_IME_TO_START_NULLPTR);
1495
1496 auto ret3 = clientGroup->GetClientInfo(nullptr);
1497 EXPECT_EQ(ret3, nullptr);
1498 ret3 = clientGroup->GetClientInfo(pid);
1499 EXPECT_EQ(ret3, nullptr);
1500 }
1501
1502 /**
1503 * @tc.name: SA_TestIMSAOnScreenUnlocked
1504 * @tc.desc: SA_TestIMSAOnScreenUnlocked.
1505 * @tc.type: FUNC
1506 * @tc.require:
1507 */
1508 HWTEST_F(InputMethodPrivateMemberTest, SA_TestIMSAOnScreenUnlocked, TestSize.Level0)
1509 {
1510 IMSA_HILOGI("InputMethodPrivateMemberTest::SA_TestIMSAOnScreenUnlocked start.");
1511 service_->OnScreenUnlock(nullptr);
1512
1513 MessageParcel *parcel = nullptr;
1514 auto msg = std::make_shared<Message>(MessageID::MSG_ID_SCREEN_UNLOCK, parcel);
1515 service_->OnScreenUnlock(msg.get());
1516
1517 int32_t userId = 1;
1518 InputMethodPrivateMemberTest::service_->userId_ = 2;
1519 parcel = new (std::nothrow) MessageParcel();
1520 ASSERT_NE(parcel, nullptr);
1521 EXPECT_TRUE(ITypesUtil::Marshal(*parcel, userId));
1522 msg = std::make_shared<Message>(MessageID::MSG_ID_SCREEN_UNLOCK, parcel);
1523 service_->OnScreenUnlock(msg.get());
1524
1525 UserSessionManager::GetInstance().userSessions_.clear();
1526 auto handler = UserSessionManager::GetInstance().eventHandler_;
1527 UserSessionManager::GetInstance().eventHandler_ = nullptr;
1528 InputMethodPrivateMemberTest::service_->userId_ = userId;
1529 MessageParcel *parcel1 = new (std::nothrow) MessageParcel();
1530 ASSERT_NE(parcel1, nullptr);
1531 EXPECT_TRUE(ITypesUtil::Marshal(*parcel1, userId));
1532 msg = std::make_shared<Message>(MessageID::MSG_ID_SCREEN_UNLOCK, parcel1);
1533 service_->OnScreenUnlock(msg.get());
1534 UserSessionManager::GetInstance().userSessions_.clear();
1535 std::this_thread::sleep_for(std::chrono::seconds(1));
1536 UserSessionManager::GetInstance().eventHandler_ = handler;
1537 }
1538
1539 /**
1540 * @tc.name: SA_OnScreenLock
1541 * @tc.desc: SA_OnScreenLock
1542 * @tc.type: FUNC
1543 * @tc.require:
1544 */
1545 HWTEST_F(InputMethodPrivateMemberTest, SA_OnScreenLock, TestSize.Level0)
1546 {
1547 IMSA_HILOGI("InputMethodPrivateMemberTest::SA_OnScreenLock start.");
1548 service_->OnScreenLock(nullptr);
1549
1550 MessageParcel *parcel = nullptr;
1551 auto msg = std::make_shared<Message>(MessageID::MSG_ID_SCREEN_LOCK, parcel);
1552 service_->OnScreenLock(msg.get());
1553
1554 int32_t userId = 1;
1555 InputMethodPrivateMemberTest::service_->userId_ = 2;
1556 parcel = new (std::nothrow) MessageParcel();
1557 ASSERT_NE(parcel, nullptr);
1558 EXPECT_TRUE(ITypesUtil::Marshal(*parcel, userId));
1559 msg = std::make_shared<Message>(MessageID::MSG_ID_SCREEN_LOCK, parcel);
1560 service_->OnScreenLock(msg.get());
1561
1562 UserSessionManager::GetInstance().userSessions_.clear();
1563 auto handler = UserSessionManager::GetInstance().eventHandler_;
1564 UserSessionManager::GetInstance().eventHandler_ = nullptr;
1565 InputMethodPrivateMemberTest::service_->userId_ = userId;
1566 MessageParcel *parcel1 = new (std::nothrow) MessageParcel();
1567 ASSERT_NE(parcel1, nullptr);
1568 EXPECT_TRUE(ITypesUtil::Marshal(*parcel1, userId));
1569 msg = std::make_shared<Message>(MessageID::MSG_ID_SCREEN_LOCK, parcel1);
1570 service_->OnScreenLock(msg.get());
1571 UserSessionManager::GetInstance().userSessions_.clear();
1572 std::this_thread::sleep_for(std::chrono::seconds(1));
1573 UserSessionManager::GetInstance().eventHandler_ = handler;
1574 }
1575
1576 /**
1577 * @tc.name: SA_TestPerUserSessionOnScreenUnlocked
1578 * @tc.desc: SA_TestPerUserSessionOnScreenUnlocked.
1579 * @tc.type: FUNC
1580 * @tc.require:
1581 */
1582 HWTEST_F(InputMethodPrivateMemberTest, SA_TestPerUserSessionOnScreenUnlocked, TestSize.Level0)
1583 {
1584 IMSA_HILOGI("InputMethodPrivateMemberTest::SA_TestPerUserSessionOnScreenUnlocked start.");
1585 auto userSession = std::make_shared<PerUserSession>(MAIN_USER_ID);
1586 userSession->imeData_.clear();
1587 userSession->OnScreenUnlock();
1588
1589 userSession->InitImeData({ "", "" });
1590 userSession->OnScreenUnlock();
1591
1592 auto imeCfg = ImeCfgManager::GetInstance().GetCurrentImeCfg(MAIN_USER_ID);
1593 EXPECT_NE(imeCfg, nullptr);
1594 userSession->imeData_.clear();
1595 userSession->InitImeData({ imeCfg->bundleName, imeCfg->extName });
1596 userSession->OnScreenUnlock();
1597 }
1598
1599 /**
1600 * @tc.name: SA_TestPerUserSessionOnScreenlocked
1601 * @tc.desc: SA_TestPerUserSessionOnScreenlocked.
1602 * @tc.type: FUNC
1603 * @tc.require:
1604 */
1605 HWTEST_F(InputMethodPrivateMemberTest, SA_TestPerUserSessionOnScreenlocked, TestSize.Level0)
1606 {
1607 IMSA_HILOGI("InputMethodPrivateMemberTest::SA_TestPerUserSessionOnScreenlocked start.");
1608 auto userSession = std::make_shared<PerUserSession>(MAIN_USER_ID);
1609 userSession->imeData_.clear();
1610 userSession->OnScreenLock();
1611 ImeIdentification currentIme;
1612 InputTypeManager::GetInstance().Set(false, currentIme);
1613 EXPECT_FALSE(InputTypeManager::GetInstance().IsStarted());
1614 }
1615
1616 /**
1617 * @tc.name: SA_TestPerUserSessionOnScreenUnlocked
1618 * @tc.desc: SA_TestPerUserSessionOnScreenUnlocked.
1619 * @tc.type: FUNC
1620 * @tc.require:
1621 */
1622 HWTEST_F(InputMethodPrivateMemberTest, SA_TestPerUserSessionOnScreenUnlocked001, TestSize.Level0)
1623 {
1624 IMSA_HILOGI("InputMethodPrivateMemberTest::SA_TestPerUserSessionOnScreenUnlocked001 start.");
1625 auto userSession = std::make_shared<PerUserSession>(MAIN_USER_ID);
1626 ImeIdentification currentIme;
1627 InputTypeManager::GetInstance().Set(false, currentIme);
1628 EXPECT_FALSE(InputTypeManager::GetInstance().IsStarted());
1629 userSession->OnScreenUnlock();
1630 }
1631
1632 /**
1633 * @tc.name: SA_TestGetScreenLockIme
1634 * @tc.desc: SA_TestGetScreenLockIme
1635 * @tc.type: FUNC
1636 * @tc.require:
1637 */
1638 HWTEST_F(InputMethodPrivateMemberTest, SA_TestGetScreenLockIme, TestSize.Level0)
1639 {
1640 IMSA_HILOGI("InputMethodPrivateMemberTest::SA_TestGetScreenLockIme start.");
1641 std::string ime;
1642 int32_t userId = MAIN_USER_ID;
1643 auto ret = InputMethodPrivateMemberTest::service_->GetScreenLockIme(userId, ime);
1644 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
1645
1646 ret = InputMethodPrivateMemberTest::service_->GetAlternativeIme(userId, ime);
1647 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
1648
1649 SystemConfig systemConfig_0 = ImeInfoInquirer::GetInstance().systemConfig_;
1650 ImeInfoInquirer::GetInstance().systemConfig_.defaultInputMethod = "abc";
1651 ret = InputMethodPrivateMemberTest::service_->GetScreenLockIme(userId, ime);
1652 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
1653 ImeInfoInquirer::GetInstance().systemConfig_ = systemConfig_0;
1654 }
1655
1656 /**
1657 * @tc.name: Test_PerUserSession_UpdateClientInfo
1658 * @tc.desc: Test UpdateClientInfo
1659 * @tc.type: FUNC
1660 * @tc.require:IBZ0Y6
1661 * @tc.author: chenyu
1662 */
1663 HWTEST_F(InputMethodPrivateMemberTest, Test_ClientGroup_UpdateClientInfo, TestSize.Level0)
1664 {
1665 IMSA_HILOGI("InputMethodPrivateMemberTest Test_ClientGroup_UpdateClientInfo TEST START");
1666 auto clientGroup = std::make_shared<ClientGroup>(DEFAULT_DISPLAY_ID, nullptr);
1667 clientGroup->mapClients_.clear();
1668 bool isShowKeyboard = true;
1669 sptr<IInputClient> client = new (std::nothrow) InputClientServiceImpl();
1670 ASSERT_NE(client, nullptr);
1671 // not find client
1672 clientGroup->UpdateClientInfo(client->AsObject(), { { UpdateFlag::ISSHOWKEYBOARD, isShowKeyboard } });
1673 clientGroup->mapClients_.insert({ client->AsObject(), nullptr });
1674 // client info is nullptr
1675 clientGroup->UpdateClientInfo(client->AsObject(), { { UpdateFlag::ISSHOWKEYBOARD, isShowKeyboard } });
1676
1677 auto info = std::make_shared<InputClientInfo>();
1678 clientGroup->mapClients_.insert_or_assign(client->AsObject(), info);
1679 // update abnormal
1680 clientGroup->UpdateClientInfo(client->AsObject(), { { UpdateFlag::CLIENT_TYPE, isShowKeyboard } });
1681 auto it = clientGroup->mapClients_.find(client->AsObject());
1682 ASSERT_NE(it, clientGroup->mapClients_.end());
1683 ASSERT_NE(it->second, nullptr);
1684 EXPECT_EQ(it->second->type, ClientType::INNER_KIT);
1685 // update correctly
1686 uint32_t eventFlag = 10;
1687 TextTotalConfig config;
1688 config.windowId = 1000;
1689 ImeType bindImeType = ImeType::PROXY_IME;
1690 ClientState state = ClientState::ACTIVE;
1691 uint32_t uiExtensionTokenId = 9999;
1692 ClientType type = ClientType::JS;
1693 clientGroup->UpdateClientInfo(client->AsObject(),
1694 { { UpdateFlag::BINDIMETYPE, bindImeType }, { UpdateFlag::ISSHOWKEYBOARD, isShowKeyboard },
1695 { UpdateFlag::EVENTFLAG, eventFlag }, { UpdateFlag::TEXT_CONFIG, config }, { UpdateFlag::STATE, state },
1696 { UpdateFlag::UIEXTENSION_TOKENID, uiExtensionTokenId }, { UpdateFlag::CLIENT_TYPE, type } });
1697 it = clientGroup->mapClients_.find(client->AsObject());
1698 ASSERT_NE(it, clientGroup->mapClients_.end());
1699 ASSERT_NE(it->second, nullptr);
1700 EXPECT_EQ(it->second->isShowKeyboard, isShowKeyboard);
1701 EXPECT_EQ(it->second->eventFlag, eventFlag);
1702 EXPECT_EQ(it->second->config.windowId, config.windowId);
1703 EXPECT_EQ(it->second->bindImeType, bindImeType);
1704 EXPECT_EQ(it->second->uiExtensionTokenId, uiExtensionTokenId);
1705 EXPECT_EQ(it->second->state, state);
1706 EXPECT_EQ(it->second->type, type);
1707 }
1708
1709 /**
1710 * @tc.name: SA_StartPreconfiguredDefaultIme
1711 * @tc.desc: SA_StartPreconfiguredDefaultIme
1712 * @tc.type: FUNC
1713 * @tc.require:
1714 */
1715 HWTEST_F(InputMethodPrivateMemberTest, SA_StartPreconfiguredDefaultIme, TestSize.Level0)
1716 {
1717 IMSA_HILOGI("InputMethodPrivateMemberTest::SA_StartPreconfiguredDefaultIme start.");
1718 PerUserSession session(MAIN_USER_ID);
1719 // not default displayId
1720 uint64_t otherDisplayId = 10000000;
1721 session.virtualScreenDisplayId_.insert(otherDisplayId);
1722 auto [ret, status] = session.StartPreconfiguredDefaultIme(otherDisplayId);
1723 EXPECT_EQ(status, StartPreDefaultImeStatus::NO_NEED);
1724
1725 // not has running ime
1726 session.imeData_.clear();
1727 auto [ret1, status1] = session.StartPreconfiguredDefaultIme(DEFAULT_DISPLAY_ID);
1728 EXPECT_EQ(status1, StartPreDefaultImeStatus::TO_START);
1729
1730 std::string bundleName = "bundleName";
1731 std::string extName = "extName";
1732 std::string bundleName1 = "bundleName1";
1733 std::string extName1 = "extName1";
1734 // running ime same with pre default ime
1735 auto imeData1 = std::make_shared<ImeData>(nullptr, nullptr, nullptr, 100);
1736 imeData1->imeStatus = ImeStatus::READY;
1737 imeData1->ime = std::make_pair(bundleName, extName);
1738 std::vector<std::shared_ptr<ImeData>> imeDataList;
1739 imeDataList.push_back(imeData1);
1740 session.imeData_.insert_or_assign(ImeType::IME, imeDataList);
1741 ImeInfoInquirer::GetInstance().systemConfig_.defaultInputMethod = bundleName + "/" + extName;
1742 auto [ret2, status2] = session.StartPreconfiguredDefaultIme(DEFAULT_DISPLAY_ID);
1743 EXPECT_EQ(status2, StartPreDefaultImeStatus::HAS_STARTED);
1744 // running ime extName not same with pre default ime
1745 ImeInfoInquirer::GetInstance().systemConfig_.defaultInputMethod = bundleName + "/" + extName1;
1746 auto [ret3, status3] = session.StartPreconfiguredDefaultIme(DEFAULT_DISPLAY_ID);
1747 EXPECT_EQ(status3, StartPreDefaultImeStatus::TO_START);
1748 // running ime bundleName not same with pre default ime
1749 ImeInfoInquirer::GetInstance().systemConfig_.defaultInputMethod = bundleName1 + "/" + extName;
1750 auto [ret4, status4] = session.StartPreconfiguredDefaultIme(DEFAULT_DISPLAY_ID);
1751 EXPECT_EQ(status4, StartPreDefaultImeStatus::TO_START);
1752 // running ime not same with pre default ime
1753 ImeInfoInquirer::GetInstance().systemConfig_.defaultInputMethod = bundleName1 + "/" + extName1;
1754 auto [ret5, status5] = session.StartPreconfiguredDefaultIme(DEFAULT_DISPLAY_ID);
1755 EXPECT_EQ(status5, StartPreDefaultImeStatus::TO_START);
1756 }
1757
1758 /**
1759 * @tc.name: SA_AllowSwitchImeByCombinationKey
1760 * @tc.desc: SA_AllowSwitchImeByCombinationKey
1761 * @tc.type: FUNC
1762 * @tc.require:
1763 */
1764 HWTEST_F(InputMethodPrivateMemberTest, SA_AllowSwitchImeByCombinationKey, TestSize.Level0)
1765 {
1766 IMSA_HILOGI("InputMethodPrivateMemberTest::SA_AllowSwitchImeByCombinationKey start.");
1767 PerUserSession session(MAIN_USER_ID);
1768 // not has current client info
1769 session.clientGroupMap_.clear();
1770 auto ret = session.IsImeSwitchForbidden();
1771 EXPECT_FALSE(ret);
1772
1773 // has current client info
1774 ImeInfoInquirer::GetInstance().systemConfig_.defaultImeScreenList.clear();
1775 auto group = std::make_shared<ClientGroup>(DEFAULT_DISPLAY_ID, nullptr);
1776 sptr<IInputClient> client = new (std::nothrow) InputClientServiceImpl();
1777 group->currentClient_ = client;
1778 auto info = std::make_shared<InputClientInfo>();
1779 info->config.isSimpleKeyboardEnabled = true;
1780 group->mapClients_.insert_or_assign(client->AsObject(), info);
1781 session.clientGroupMap_.insert_or_assign(DEFAULT_DISPLAY_ID, group);
1782 ret = session.IsImeSwitchForbidden();
1783 EXPECT_TRUE(ret);
1784 }
1785
1786 /**
1787 * @tc.name: SA_SpecialScenarioCheck
1788 * @tc.desc: SA_SpecialScenarioCheck
1789 * @tc.type: FUNC
1790 * @tc.require:
1791 */
1792 HWTEST_F(InputMethodPrivateMemberTest, SA_SpecialScenarioCheck, TestSize.Level0)
1793 {
1794 IMSA_HILOGI("InputMethodPrivateMemberTest::SA_SpecialScenarioCheck start.");
1795 PerUserSession session(MAIN_USER_ID);
1796 // has current client info
1797 auto group = std::make_shared<ClientGroup>(DEFAULT_DISPLAY_ID, nullptr);
1798 sptr<IInputClient> client = new (std::nothrow) InputClientServiceImpl();
1799 group->currentClient_ = client;
1800 auto info = std::make_shared<InputClientInfo>();
1801 info->config.isSimpleKeyboardEnabled = true;
1802 group->mapClients_.insert_or_assign(client->AsObject(), info);
1803 session.clientGroupMap_.insert_or_assign(DEFAULT_DISPLAY_ID, group);
1804 auto allow = session.SpecialScenarioCheck();
1805 EXPECT_FALSE(allow);
1806
1807 info->config.isSimpleKeyboardEnabled = false;
1808 group->mapClients_.insert_or_assign(client->AsObject(), info);
1809 session.clientGroupMap_.insert_or_assign(DEFAULT_DISPLAY_ID, group);
1810 allow = session.SpecialScenarioCheck();
1811 EXPECT_TRUE(allow);
1812
1813 info->config.inputAttribute.inputPattern = InputAttribute::PATTERN_ONE_TIME_CODE;
1814 group->mapClients_.insert_or_assign(client->AsObject(), info);
1815 session.clientGroupMap_.insert_or_assign(DEFAULT_DISPLAY_ID, group);
1816 allow = session.SpecialScenarioCheck();
1817 EXPECT_FALSE(allow);
1818
1819 info->config.inputAttribute.inputPattern = InputAttribute::PATTERN_PASSWORD;
1820 group->mapClients_.insert_or_assign(client->AsObject(), info);
1821 session.clientGroupMap_.insert_or_assign(DEFAULT_DISPLAY_ID, group);
1822 allow = session.SpecialScenarioCheck();
1823 EXPECT_FALSE(allow);
1824 }
1825
1826 /**
1827 * @tc.name: SA_IsScreenLockOrSecurityFlag
1828 * @tc.desc: SA_IsScreenLockOrSecurityFlag
1829 * @tc.type: FUNC
1830 * @tc.require:
1831 */
1832 HWTEST_F(InputMethodPrivateMemberTest, SA_IsScreenLockOrSecurityFlag, TestSize.Level0)
1833 {
1834 IMSA_HILOGI("InputMethodPrivateMemberTest::SA_IsScreenLockOrSecurityFlag start.");
1835 PerUserSession session(MAIN_USER_ID);
1836 // has current client info
1837 auto group = std::make_shared<ClientGroup>(DEFAULT_DISPLAY_ID, nullptr);
1838 sptr<IInputClient> client = new (std::nothrow) InputClientServiceImpl();
1839 group->currentClient_ = client;
1840 auto info = std::make_shared<InputClientInfo>();
1841 info->config.inputAttribute.inputPattern = InputAttribute::PATTERN_TEXT;
1842 group->mapClients_.insert_or_assign(client->AsObject(), info);
1843 session.clientGroupMap_.insert_or_assign(DEFAULT_DISPLAY_ID, group);
1844 auto ret = session.IsImeSwitchForbidden();
1845 EXPECT_FALSE(ret);
1846
1847
1848 info->config.inputAttribute.inputPattern = InputAttribute::PATTERN_ONE_TIME_CODE;
1849 group->mapClients_.insert_or_assign(client->AsObject(), info);
1850 session.clientGroupMap_.insert_or_assign(DEFAULT_DISPLAY_ID, group);
1851 ret = session.IsImeSwitchForbidden();
1852 EXPECT_FALSE(ret);
1853
1854 info->config.inputAttribute.inputPattern = InputAttribute::PATTERN_PASSWORD;
1855 group->mapClients_.insert_or_assign(client->AsObject(), info);
1856 session.clientGroupMap_.insert_or_assign(DEFAULT_DISPLAY_ID, group);
1857 ret = session.IsImeSwitchForbidden();
1858 EXPECT_TRUE(ret);
1859
1860 info->config.inputAttribute.inputPattern = InputAttribute::PATTERN_TEXT;
1861 info->config.isSimpleKeyboardEnabled = true;
1862 group->mapClients_.insert_or_assign(client->AsObject(), info);
1863 session.clientGroupMap_.insert_or_assign(DEFAULT_DISPLAY_ID, group);
1864 ret = session.IsImeSwitchForbidden();
1865 EXPECT_TRUE(ret);
1866 }
1867
1868 /**
1869 * @tc.name: SA_SpecialSendPrivateData
1870 * @tc.desc: SA_SpecialSendPrivateData
1871 * @tc.type: FUNC
1872 * @tc.require:
1873 */
1874 HWTEST_F(InputMethodPrivateMemberTest, SA_SpecialSendPrivateData, TestSize.Level0)
1875 {
1876 IMSA_HILOGI("InputMethodPrivateMemberTest::SA_SpecialSendPrivateData start.");
1877 PerUserSession session(MAIN_USER_ID);
1878 std::string bundleName = "bundleName";
1879 std::string extName = "extName";
1880 std::string bundleName1 = "bundleName1";
1881 std::string extName1 = "extName1";
1882 auto imeData1 = std::make_shared<ImeData>(nullptr, nullptr, nullptr, 100);
1883 imeData1->imeStatus = ImeStatus::READY;
1884 imeData1->ime = std::make_pair(bundleName, extName);
1885 std::vector<std::shared_ptr<ImeData>> imeDataList;
1886 imeDataList.push_back(imeData1);
1887 session.imeData_.insert_or_assign(ImeType::IME, imeDataList);
1888 std::unordered_map<std::string, PrivateDataValue> privateCommand;
1889 // running ime same with pre default ime, send directly
1890 ImeInfoInquirer::GetInstance().systemConfig_.defaultInputMethod = bundleName + "/" + extName;
1891 auto ret = session.SpecialSendPrivateData(privateCommand);
1892 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
1893 // running ime extName not same with pre default ime, start pre default ime failed
1894 ImeInfoInquirer::GetInstance().systemConfig_.defaultInputMethod = bundleName1 + "/" + extName1;
1895 ret = session.SpecialSendPrivateData(privateCommand);
1896 EXPECT_NE(ret, ErrorCode::NO_ERROR);
1897 }
1898
1899 /**
1900 * @tc.name: SA_CheckInputTypeOption
1901 * @tc.desc: SA_CheckInputTypeOption
1902 * @tc.type: FUNC
1903 * @tc.require:
1904 */
1905 HWTEST_F(InputMethodPrivateMemberTest, SA_CheckInputTypeOption, TestSize.Level0)
1906 {
1907 IMSA_HILOGI("InputMethodPrivateMemberTest::SA_CheckInputTypeOption start.");
1908 InputMethodSystemAbility systemAbility;
1909 auto session = std::make_shared<PerUserSession>(MAIN_USER_ID);
1910 std::string bundleName = "bundleName";
1911 std::string extName = "extName";
1912 auto imeData1 = std::make_shared<ImeData>(nullptr, nullptr, nullptr, 100);
1913 imeData1->imeStatus = ImeStatus::READY;
1914 imeData1->ime = std::make_pair(bundleName, extName);
1915 std::vector<std::shared_ptr<ImeData>> imeDataList;
1916 imeDataList.push_back(imeData1);
1917 session->imeData_.insert_or_assign(ImeType::IME, imeDataList);
1918 UserSessionManager::GetInstance().userSessions_.insert_or_assign(MAIN_USER_ID, session);
1919 InputClientInfo info;
1920 // same textField, input type started
1921 info.isNotifyInputStart = false;
1922 InputTypeManager::GetInstance().isStarted_ = true;
1923 auto ret = systemAbility.CheckInputTypeOption(MAIN_USER_ID, info);
1924 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
1925
1926 std::string bundleName1 = "bundleName1";
1927 std::string extName1 = "extName1";
1928 std::string bundleName2 = "bundleName2";
1929 std::string extName2 = "extName2";
1930 ImeInfoInquirer::GetInstance().systemConfig_.defaultInputMethod = bundleName1 + "/" + extName1;
1931 ImeEnabledCfg cfg;
1932 ImeEnabledInfo enabledInfo{ bundleName2, extName2, EnabledStatus::BASIC_MODE };
1933 enabledInfo.extraInfo.isDefaultIme = true;
1934 cfg.enabledInfos.push_back(enabledInfo);
1935 ImeEnabledInfoManager::GetInstance().imeEnabledCfg_.insert_or_assign(MAIN_USER_ID, cfg);
1936
1937 info.isNotifyInputStart = true;
1938 InputTypeManager::GetInstance().isStarted_ = true;
1939 ret = systemAbility.CheckInputTypeOption(MAIN_USER_ID, info);
1940 EXPECT_NE(ret, ErrorCode::NO_ERROR);
1941
1942 info.isNotifyInputStart = false;
1943 InputTypeManager::GetInstance().isStarted_ = false;
1944 ret = systemAbility.CheckInputTypeOption(MAIN_USER_ID, info);
1945 EXPECT_NE(ret, ErrorCode::NO_ERROR);
1946
1947 info.isNotifyInputStart = true;
1948 InputTypeManager::GetInstance().isStarted_ = false;
1949 ret = systemAbility.CheckInputTypeOption(MAIN_USER_ID, info);
1950 EXPECT_NE(ret, ErrorCode::NO_ERROR);
1951 }
1952
1953 /**
1954 * @tc.name: SA_GetRealCurrentIme_001
1955 * @tc.desc: SA_GetRealCurrentIme_001
1956 * @tc.type: FUNC
1957 * @tc.require:
1958 */
1959 HWTEST_F(InputMethodPrivateMemberTest, SA_GetRealCurrentIme_001, TestSize.Level0)
1960 {
1961 IMSA_HILOGI("InputMethodPrivateMemberTest::SA_GetRealCurrentIme_001 start.");
1962 std::shared_ptr<Property> realPreIme = nullptr;
1963 InputMethodController::GetInstance()->GetDefaultInputMethod(realPreIme);
1964 ASSERT_NE(realPreIme, nullptr);
1965 InputTypeManager::GetInstance().currentTypeIme_.bundleName = realPreIme->name;
1966
1967 std::string bundleName1 = "bundleName1";
1968 std::string extName1 = "extName1";
1969 ImeEnabledCfg cfg;
1970 ImeEnabledInfo enabledInfo{ bundleName1, extName1, EnabledStatus::BASIC_MODE };
1971 enabledInfo.extraInfo.isDefaultIme = true;
1972 ImeEnabledInfo enabledInfo1{ realPreIme->name, realPreIme->id, EnabledStatus::BASIC_MODE };
1973 cfg.enabledInfos.push_back(enabledInfo);
1974 cfg.enabledInfos.push_back(enabledInfo1);
1975 ImeEnabledInfoManager::GetInstance().imeEnabledCfg_.insert_or_assign(MAIN_USER_ID, cfg);
1976
1977 std::string bundleName2 = "bundleName2";
1978 std::string extName2 = "extName2";
1979 ImeInfoInquirer::GetInstance().systemConfig_.defaultInputMethod = bundleName2 + "/" + extName2;
1980 auto session = std::make_shared<PerUserSession>(MAIN_USER_ID);
1981
1982 // input type start
1983 InputTypeManager::GetInstance().isStarted_ = true;
1984 auto ime = session->GetRealCurrentIme(true);
1985 ASSERT_NE(ime, nullptr);
1986 EXPECT_EQ(ime->bundleName, realPreIme->name);
1987
1988 // input type not start, has no current client, needMinGuarantee is false
1989 InputTypeManager::GetInstance().isStarted_ = false;
1990 session->clientGroupMap_.clear();
1991 ime = session->GetRealCurrentIme(false);
1992 ASSERT_NE(ime, nullptr);
1993 EXPECT_EQ(ime->bundleName, bundleName1);
1994
1995 // input type not start, has no current client, needMinGuarantee is true
1996 ime = session->GetRealCurrentIme(true);
1997 ASSERT_NE(ime, nullptr);
1998 EXPECT_EQ(ime->bundleName, bundleName2);
1999 }
2000
2001 /**
2002 * @tc.name: SA_GetRealCurrentIme_002
2003 * @tc.desc: SA_GetRealCurrentIme_002
2004 * @tc.type: FUNC
2005 * @tc.require:
2006 */
2007 HWTEST_F(InputMethodPrivateMemberTest, SA_GetRealCurrentIme_002, TestSize.Level0)
2008 {
2009 IMSA_HILOGI("InputMethodPrivateMemberTest::SA_GetRealCurrentIme_002 start.");
2010 ImeInfoInquirer::GetInstance().systemConfig_.defaultImeScreenList.clear();
2011 std::shared_ptr<Property> realPreIme = nullptr;
2012 InputMethodController::GetInstance()->GetDefaultInputMethod(realPreIme);
2013 ASSERT_NE(realPreIme, nullptr);
2014 InputTypeManager::GetInstance().isTypeCfgReady_ = true;
2015 ImeIdentification inputTypeIme{ realPreIme->name, "" };
2016 InputTypeManager::GetInstance().inputTypes_.insert_or_assign(InputType::SECURITY_INPUT, inputTypeIme);
2017
2018 std::string bundleName1 = "bundleName1";
2019 std::string extName1 = "extName1";
2020 ImeEnabledCfg cfg;
2021 ImeEnabledInfo enabledInfo{ bundleName1, extName1, EnabledStatus::BASIC_MODE };
2022 enabledInfo.extraInfo.isDefaultIme = true;
2023 cfg.enabledInfos.push_back(enabledInfo);
2024 ImeEnabledInfoManager::GetInstance().imeEnabledCfg_.insert_or_assign(MAIN_USER_ID, cfg);
2025
2026 std::string bundleName2 = "bundleName2";
2027 std::string extName2 = "extName2";
2028 ImeInfoInquirer::GetInstance().systemConfig_.defaultInputMethod = bundleName2 + "/" + extName2;
2029
2030 InputTypeManager::GetInstance().isStarted_ = false;
2031 auto session = std::make_shared<PerUserSession>(MAIN_USER_ID);
2032 auto group = std::make_shared<ClientGroup>(DEFAULT_DISPLAY_ID, nullptr);
2033 sptr<IInputClient> client = new (std::nothrow) InputClientServiceImpl();
2034 group->currentClient_ = client;
2035 auto info = std::make_shared<InputClientInfo>();
2036 // input type not start, has current client, input type is security, isSimpleKeyboardEnabled is true
2037 info->config.inputAttribute.inputPattern = InputAttribute::PATTERN_PASSWORD;
2038 info->config.isSimpleKeyboardEnabled = true;
2039 group->mapClients_.insert_or_assign(client->AsObject(), info);
2040 session->clientGroupMap_.insert_or_assign(DEFAULT_DISPLAY_ID, group);
2041 auto ime = session->GetRealCurrentIme(true);
2042 ASSERT_NE(ime, nullptr);
2043 EXPECT_EQ(ime->bundleName, realPreIme->name);
2044 }
2045
2046 /**
2047 * @tc.name: SA_GetRealCurrentIme_003
2048 * @tc.desc: SA_GetRealCurrentIme_003
2049 * @tc.type: FUNC
2050 * @tc.require:
2051 */
2052 HWTEST_F(InputMethodPrivateMemberTest, SA_GetRealCurrentIme_003, TestSize.Level0)
2053 {
2054 IMSA_HILOGI("InputMethodPrivateMemberTest::SA_GetRealCurrentIme_003 start.");
2055 // input type not start, has current client, input type is NONE, isSimpleKeyboardEnabled is true
2056 InputTypeManager::GetInstance().isStarted_ = false;
2057 std::string bundleName1 = "bundleName1";
2058 std::string extName1 = "extName1";
2059 std::string subName1 = "subName1";
2060 ImeEnabledCfg cfg;
2061 ImeEnabledInfo enabledInfo{ bundleName1, extName1, EnabledStatus::BASIC_MODE };
2062 enabledInfo.extraInfo.isDefaultIme = true;
2063 enabledInfo.extraInfo.currentSubName = subName1;
2064 cfg.enabledInfos.push_back(enabledInfo);
2065 ImeEnabledInfoManager::GetInstance().imeEnabledCfg_.insert_or_assign(MAIN_USER_ID, cfg);
2066
2067 auto session = std::make_shared<PerUserSession>(MAIN_USER_ID);
2068 auto group = std::make_shared<ClientGroup>(DEFAULT_DISPLAY_ID, nullptr);
2069 sptr<IInputClient> client = new (std::nothrow) InputClientServiceImpl();
2070 group->currentClient_ = client;
2071 auto info = std::make_shared<InputClientInfo>();
2072 info->config.inputAttribute.inputPattern = 0;
2073 info->config.isSimpleKeyboardEnabled = true;
2074 group->mapClients_.insert_or_assign(client->AsObject(), info);
2075 session->clientGroupMap_.insert_or_assign(DEFAULT_DISPLAY_ID, group);
2076
2077 // preconfigured is nullptr
2078 ImeInfoInquirer::GetInstance().systemConfig_.defaultInputMethod = "abnormal";
2079 auto ime = session->GetRealCurrentIme(false);
2080 ASSERT_NE(ime, nullptr);
2081 EXPECT_EQ(ime->bundleName, bundleName1);
2082 EXPECT_EQ(ime->subName, subName1);
2083
2084 // preconfigured is not nullptr, preconfigured ime same with default ime
2085 ImeInfoInquirer::GetInstance().systemConfig_.defaultInputMethod = bundleName1 + "/" + extName1;
2086 ime = session->GetRealCurrentIme(true);
2087 ASSERT_NE(ime, nullptr);
2088 EXPECT_EQ(ime->bundleName, bundleName1);
2089 EXPECT_EQ(ime->subName, subName1);
2090
2091 // preconfigured is not nullptr, preconfigured ime not same with default ime
2092 std::string bundleName2 = "bundleName2";
2093 std::string extName2 = "extName2";
2094 ImeInfoInquirer::GetInstance().systemConfig_.defaultInputMethod = bundleName2 + "/" + extName2;
2095 ime = session->GetRealCurrentIme(true);
2096 ASSERT_NE(ime, nullptr);
2097 EXPECT_EQ(ime->bundleName, bundleName2);
2098 EXPECT_TRUE(ime->subName.empty());
2099 }
2100
2101 /**
2102 * @tc.name: SA_NotifySubTypeChangedToIme
2103 * @tc.desc: SA_NotifySubTypeChangedToIme
2104 * @tc.type: FUNC
2105 * @tc.require:
2106 */
2107 HWTEST_F(InputMethodPrivateMemberTest, SA_NotifySubTypeChangedToIme, TestSize.Level0)
2108 {
2109 IMSA_HILOGI("InputMethodPrivateMemberTest::SA_NotifySubTypeChangedToIme start.");
2110 std::string bundleName1 = "bundleName1";
2111 std::string subName1 = "extName1";
2112 std::string bundleName2 = "bundleName2";
2113 std::string subName2 = "subName2";
2114 InputTypeManager::GetInstance().inputTypeImeList_.clear();
2115 InputTypeManager::GetInstance().inputTypeImeList_.insert({ bundleName1, subName1 });
2116 auto session = std::make_shared<PerUserSession>(MAIN_USER_ID);
2117 auto ret = session->NotifySubTypeChangedToIme(bundleName1, "");
2118 EXPECT_EQ(ret, ErrorCode::ERROR_IME_NOT_STARTED);
2119 ret = session->NotifySubTypeChangedToIme(bundleName1, subName1);
2120 EXPECT_EQ(ret, ErrorCode::ERROR_IME_NOT_STARTED);
2121 ret = session->NotifySubTypeChangedToIme(bundleName2, subName2);
2122 EXPECT_EQ(ret, ErrorCode::ERROR_IME_NOT_STARTED);
2123 }
2124
2125 /**
2126 * @tc.name: StartImeTryLock
2127 * @tc.desc: StartImeTryLock
2128 * @tc.type: FUNC
2129 * @tc.require:
2130 */
2131 HWTEST_F(InputMethodPrivateMemberTest, StartImeTryLock001, TestSize.Level0)
2132 {
2133 IMSA_HILOGI("InputMethodPrivateMemberTest::StartImeTryLock001 start.");
2134 session_ = std::make_shared<PerUserSession>(MAIN_USER_ID);
2135 SET_THREAD_NUM(5);
2136 GTEST_RUN_TASK(TestImfStartIme);
2137 IMSA_HILOGI("InputMethodPrivateMemberTest::StartImeTryLock %{public}d.", tryLockFailCount_.load());
2138 EXPECT_GT(tryLockFailCount_, 0); // at least one thread try lock failed
2139 }
2140
2141 /**
2142 * @tc.name: TestCompareExchange_001
2143 * @tc.desc: TestCompareExchange.
2144 * @tc.type: FUNC
2145 * @tc.require: issuesIC7VH8
2146 * @tc.author:
2147 */
2148 HWTEST_F(InputMethodPrivateMemberTest, TestCompareExchange_001, TestSize.Level0)
2149 {
2150 IMSA_HILOGI("InputMethodPrivateMemberTest TestCompareExchange_001 TEST START");
2151 auto userSession = std::make_shared<PerUserSession>(MAIN_USER_ID);
2152 userSession->largeMemoryState_ = 2;
2153 auto ret = userSession->CompareExchange(2);
2154 EXPECT_TRUE(ret);
2155 ret = userSession->CompareExchange(3);
2156 EXPECT_FALSE(ret);
2157 }
2158
2159 /**
2160 * @tc.name: TestIsLargeMemoryStateNeed_001
2161 * @tc.desc: TestIsLargeMemoryStateNeed.
2162 * @tc.type: FUNC
2163 * @tc.require:
2164 * @tc.author:
2165 */
2166 HWTEST_F(InputMethodPrivateMemberTest, TestIsLargeMemoryStateNeed_001, TestSize.Level0)
2167 {
2168 IMSA_HILOGI("InputMethodPrivateMemberTest TestIsLargeMemoryStateNeed_001 TEST START");
2169 auto userSession = std::make_shared<PerUserSession>(MAIN_USER_ID);
2170 userSession->largeMemoryState_ = 2;
2171 auto ret = userSession->IsLargeMemoryStateNeed();
2172 EXPECT_TRUE(ret);
2173 userSession->largeMemoryState_ = 3;
2174 ret = userSession->IsLargeMemoryStateNeed();
2175 EXPECT_FALSE(ret);
2176 }
2177
2178 /**
2179 * @tc.name: TestIsLargeMemoryStateNeed_002
2180 * @tc.desc: Test IsLargeMemoryStateNeed.
2181 * @tc.type: FUNC
2182 * @tc.require:
2183 * @tc.author:
2184 */
2185 HWTEST_F(InputMethodPrivateMemberTest, TestIsLargeMemoryStateNeed_002, TestSize.Level0)
2186 {
2187 IMSA_HILOGI("InputMethodPrivateMemberTest TestIsLargeMemoryStateNeed_002 TEST START");
2188 auto userSession = std::make_shared<PerUserSession>(MAIN_USER_ID);
2189 auto ret = userSession->UpdateLargeMemorySceneState(2);
2190 userSession->StartImeInImeDied();
2191 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
2192 userSession->UpdateLargeMemorySceneState(3);
2193 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
2194 }
2195
2196 /**
2197 * @tc.name: TestHandleUpdateLargeMemoryState_001
2198 * @tc.desc: Test HandleUpdateLargeMemoryState.
2199 * @tc.type: FUNC
2200 * @tc.require:
2201 * @tc.author:
2202 */
2203 HWTEST_F(InputMethodPrivateMemberTest, TestHandleUpdateLargeMemoryState_001, TestSize.Level0)
2204 {
2205 // msg is nullptr
2206 int32_t uid = 1014;
2207 auto *msg = new Message(MessageID::MSG_ID_UPDATE_LARGE_MEMORY_STATE, nullptr);
2208 ASSERT_NE(service_, nullptr);
2209 auto ret = service_->HandleUpdateLargeMemoryState(msg);
2210 EXPECT_EQ(ret, ErrorCode::ERROR_NULL_POINTER);
2211 ASSERT_NE(MessageHandler::Instance(), nullptr);
2212 MessageHandler::Instance()->SendMessage(msg);
2213
2214 auto parcel1 = new (std::nothrow) MessageParcel();
2215 ASSERT_NE(parcel1, nullptr);
2216 parcel1->WriteInt32(uid);
2217 parcel1->WriteInt32(3);
2218 auto msg1 = std::make_shared<Message>(MessageID::MSG_ID_UPDATE_LARGE_MEMORY_STATE, parcel1);
2219 ASSERT_NE(msg1, nullptr);
2220 auto ret1 = service_->HandleUpdateLargeMemoryState(msg1.get());
2221 EXPECT_EQ(ret1, ErrorCode::NO_ERROR);
2222
2223 auto parcel2 = new (std::nothrow) MessageParcel();
2224 ASSERT_NE(parcel2, nullptr);
2225 parcel2->WriteInt32(uid);
2226 parcel2->WriteInt32(4);
2227 auto msg2 = std::make_shared<Message>(MessageID::MSG_ID_UPDATE_LARGE_MEMORY_STATE, parcel2);
2228 ASSERT_NE(msg2, nullptr);
2229 auto ret2 = service_->HandleUpdateLargeMemoryState(msg2.get());
2230 EXPECT_EQ(ret2, ErrorCode::ERROR_BAD_PARAMETERS);
2231
2232 auto parcel3 = new (std::nothrow) MessageParcel();
2233 ASSERT_NE(parcel3, nullptr);
2234 parcel3->WriteInt32(-1);
2235 parcel3->WriteInt32(3);
2236 auto msg3 = std::make_shared<Message>(MessageID::MSG_ID_UPDATE_LARGE_MEMORY_STATE, parcel3);
2237 ASSERT_NE(msg3, nullptr);
2238 auto ret3 = service_->HandleUpdateLargeMemoryState(msg3.get());
2239 EXPECT_EQ(ret3, ErrorCode::ERROR_NULL_POINTER);
2240 }
2241
2242 /**
2243 * @tc.name: TestEventUpdateLargeMemoryState_001
2244 * @tc.desc: Test EventUpdateLargeMemoryState.
2245 * @tc.type: FUNC
2246 * @tc.require:
2247 * @tc.author:
2248 */
2249 HWTEST_F(InputMethodPrivateMemberTest, TestEventUpdateLargeMemoryState_001, TestSize.Level0)
2250 {
2251 EventFwk::MatchingSkills matchingSkills;
2252 matchingSkills.AddEvent(EVENT_LARGE_MEMORY_STATUS_CHANGED);
2253 EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
2254 std::shared_ptr<ImCommonEventManager::EventSubscriber> subscriber =
2255 std::make_shared<ImCommonEventManager::EventSubscriber>(subscriberInfo);
2256 ASSERT_NE(subscriber, nullptr);
2257 EXPECT_NE(subscriber, nullptr);
2258
2259 AAFwk::Want want;
2260 int32_t uid = 1014;
2261 int32_t memoryState = 3;
2262 want.SetAction(EVENT_LARGE_MEMORY_STATUS_CHANGED);
2263 want.SetParam(EVENT_PARAM_UID, uid);
2264 want.SetParam(EVENT_MEMORY_STATE, memoryState);
2265 EventFwk::CommonEventData data;
2266 data.SetWant(want);
2267 subscriber->HandleLargeMemoryStateUpdate(data);
2268
2269 AAFwk::Want want1;
2270 uid = -1;
2271 memoryState = 3;
2272 want1.SetAction(EVENT_LARGE_MEMORY_STATUS_CHANGED);
2273 want1.SetParam(EVENT_PARAM_UID, uid);
2274 want1.SetParam(EVENT_MEMORY_STATE, memoryState);
2275 EventFwk::CommonEventData data1;
2276 data1.SetWant(want1);
2277 subscriber->HandleLargeMemoryStateUpdate(data1);
2278 }
2279
2280 /**
2281 * @tc.name: TestGetDisableNumKeyAppDeviceTypes
2282 * @tc.desc: Test GetDisableNumKeyAppDeviceTypes.
2283 * @tc.type: FUNC
2284 * @tc.require:
2285 */
2286 HWTEST_F(InputMethodPrivateMemberTest, TestGetDisableNumKeyAppDeviceTypes, TestSize.Level0)
2287 {
2288 IMSA_HILOGI("InputMethodPrivateMemberTest TestGetDisableNumKeyAppDeviceTypes START");
2289 std::string testDeviceType = "testDeviceType";
2290 ImeInfoInquirer::GetInstance().systemConfig_.disableNumKeyAppDeviceTypes.clear();
2291 ImeInfoInquirer::GetInstance().systemConfig_.disableNumKeyAppDeviceTypes.insert(testDeviceType);
2292 std::unordered_set<std::string> ret = ImeInfoInquirer::GetInstance().GetDisableNumKeyAppDeviceTypes();
2293 EXPECT_FALSE(ret.empty());
2294 EXPECT_EQ(ret.count(testDeviceType), 1);
2295 }
2296
2297 /**
2298 * @tc.name: TestGetCompatibleDeviceType
2299 * @tc.desc: Test GetCompatibleDeviceType.
2300 * @tc.type: FUNC
2301 * @tc.require:
2302 */
2303 HWTEST_F(InputMethodPrivateMemberTest, TestGetCompatibleDeviceType, TestSize.Level0)
2304 {
2305 IMSA_HILOGI("InputMethodPrivateMemberTest TestGetCompatibleDeviceType START");
2306 std::string testBundleName = "testBundleName";
2307 std::string testDeviceType = "testDeviceType";
2308 bool ret = ImeInfoInquirer::GetInstance().GetCompatibleDeviceType(testBundleName, testDeviceType);
2309 if (ret) {
2310 EXPECT_NE(testDeviceType, "testDeviceType");
2311 } else {
2312 EXPECT_EQ(testDeviceType, "testDeviceType");
2313 }
2314 }
2315
2316 /**
2317 * @tc.name: TestAttachCount001
2318 * @tc.desc: Test TestAttachCount001.
2319 * @tc.type: FUNC
2320 */
2321 HWTEST_F(InputMethodPrivateMemberTest, TestAttachCount001, TestSize.Level0)
2322 {
2323 IMSA_HILOGI("InputMethodPrivateMemberTest TestAttachCount001 TEST START");
2324 auto userSession = std::make_shared<PerUserSession>(MAIN_USER_ID);
2325 userSession->IncreaseAttachCount();
2326 EXPECT_EQ(userSession->GetAttachCount(), 1);
2327 userSession->DecreaseAttachCount();
2328 EXPECT_EQ(userSession->GetAttachCount(), 0);
2329 }
2330
2331 /**
2332 * @tc.name: TestAttachCount002
2333 * @tc.desc: Test TestAttachCount002
2334 * @tc.type: FUNC
2335 */
2336 HWTEST_F(InputMethodPrivateMemberTest, TestAttachCount002, TestSize.Level0)
2337 {
2338 IMSA_HILOGI("InputMethodPrivateMemberTest TestAttachCount002 TEST START");
2339 auto userSession = std::make_shared<PerUserSession>(MAIN_USER_ID);
2340 for (uint32_t i = 0; i < MAX_ATTACH_COUNT + 1; i++) {
2341 userSession->IncreaseAttachCount();
2342 }
2343 EXPECT_EQ(userSession->GetAttachCount(), MAX_ATTACH_COUNT);
2344 for (uint32_t i = 0; i < MAX_ATTACH_COUNT + 1; i++) {
2345 userSession->DecreaseAttachCount();
2346 }
2347 EXPECT_EQ(userSession->GetAttachCount(), 0);
2348 }
2349
2350 /**
2351 * @tc.name: SA_TestGetSecurityInputType
2352 * @tc.desc: SA_TestGetSecurityInputType
2353 * @tc.type: FUNC
2354 * @tc.require:
2355 */
2356 HWTEST_F(InputMethodPrivateMemberTest, SA_TestGetSecurityInputType, TestSize.Level0)
2357 {
2358 IMSA_HILOGI("InputMethodPrivateMemberTest::SA_TestGetSecurityInputType start.");
2359 InputClientInfo inputClientInfo;
2360 inputClientInfo.config.inputAttribute.inputPattern = InputAttribute::PATTERN_PASSWORD;
2361 auto ret = InputMethodPrivateMemberTest::service_->GetSecurityInputType(inputClientInfo);
2362 EXPECT_EQ(ret, InputType::SECURITY_INPUT);
2363
2364 inputClientInfo.config.inputAttribute.inputPattern = InputAttribute::PATTERN_TEXT;
2365 ret = InputMethodPrivateMemberTest::service_->GetSecurityInputType(inputClientInfo);
2366 EXPECT_EQ(ret, InputType::NONE);
2367 }
2368 /**
2369 * @tc.name: SA_TestRestartIme001
2370 * @tc.desc: restart request will be discarded, and reartTasks will be reset
2371 * @tc.type: FUNC
2372 * @tc.require:
2373 */
2374 HWTEST_F(InputMethodPrivateMemberTest, SA_TestRestartIme001, TestSize.Level0)
2375 {
2376 IMSA_HILOGI("InputMethodPrivateMemberTest::SA_TestRestartIme001 start.");
2377 auto runner = AppExecFwk::EventRunner::Create("test_RestartIme");
2378 auto eventHandler = std::make_shared<AppExecFwk::EventHandler>(runner);
2379 auto session = std::make_shared<PerUserSession>(MAIN_USER_ID, eventHandler);
2380
2381 // attach conflict with the first scb startup event
2382 // restart request will be discarded, and reartTasks will be reset
2383 session->IncreaseAttachCount();
2384 EXPECT_EQ(session->GetAttachCount(), 1);
2385 session->AddRestartIme();
2386 session->AddRestartIme();
2387 usleep(WAIT_FOR_THREAD_SCHEDULE * MS_TO_US);
2388 EXPECT_EQ(session->restartTasks_, 0);
2389 }
2390
2391 /**
2392 * @tc.name: SA_TestRestartIme002
2393 * @tc.desc: restart request will be delayed
2394 * @tc.type: FUNC
2395 * @tc.require:
2396 */
2397 HWTEST_F(InputMethodPrivateMemberTest, SA_TestRestartIme002, TestSize.Level0)
2398 {
2399 IMSA_HILOGI("InputMethodPrivateMemberTest::SA_TestRestartIme002 start.");
2400 auto runner = AppExecFwk::EventRunner::Create("test_RestartIme");
2401 auto eventHandler = std::make_shared<AppExecFwk::EventHandler>(runner);
2402 auto session = std::make_shared<PerUserSession>(MAIN_USER_ID, eventHandler);
2403
2404 // attach conflict with no first scb startup event
2405 // restart request will be delayed
2406 session->IncreaseAttachCount();
2407 session->IncreaseScbStartCount();
2408 session->IncreaseScbStartCount();
2409 EXPECT_EQ(session->GetAttachCount(), 1);
2410 EXPECT_EQ(session->GetScbStartCount(), 2);
2411 session->AddRestartIme();
2412 usleep(WAIT_FOR_THREAD_SCHEDULE * MS_TO_US);
2413 // restart request be delayed, restartTasks_ no change
2414 EXPECT_EQ(session->restartTasks_, 1);
2415
2416 // attach finished
2417 session->DecreaseAttachCount();
2418 usleep((WAIT_ATTACH_FINISH_DELAY + WAIT_FOR_THREAD_SCHEDULE) * MS_TO_US);
2419 EXPECT_EQ(session->restartTasks_, 0);
2420 }
2421
2422 /**
2423 * @tc.name: SA_TestRestartIme003
2424 * @tc.desc: attach finished, and execute restart immediately
2425 * @tc.type: FUNC
2426 * @tc.require:
2427 */
2428 HWTEST_F(InputMethodPrivateMemberTest, SA_TestRestartIme003, TestSize.Level0)
2429 {
2430 IMSA_HILOGI("InputMethodPrivateMemberTest::SA_TestRestartIme003 start.");
2431 auto runner = AppExecFwk::EventRunner::Create("test_RestartIme");
2432 auto eventHandler = std::make_shared<AppExecFwk::EventHandler>(runner);
2433 auto session = std::make_shared<PerUserSession>(MAIN_USER_ID, eventHandler);
2434
2435 // attach finished, and execute restart immediately
2436 EXPECT_EQ(session->GetAttachCount(), 0);
2437 session->AddRestartIme();
2438 usleep(WAIT_FOR_THREAD_SCHEDULE * MS_TO_US);
2439 EXPECT_EQ(session->restartTasks_, 0);
2440 }
2441
2442 /**
2443 * @tc.name: SA_RestoreCurrentImeSubType
2444 * @tc.desc: SA_RestoreCurrentImeSubType
2445 * @tc.type: FUNC
2446 * @tc.require:
2447 */
2448 HWTEST_F(InputMethodPrivateMemberTest, SA_RestoreCurrentImeSubType, TestSize.Level0)
2449 {
2450 IMSA_HILOGI("InputMethodPrivateMemberTest::SA_RestoreCurrentImeSubType start.");
2451 InputTypeManager::GetInstance().isStarted_ = true;
2452 std::string bundleName = "bundleName";
2453 std::string extName = "extName";
2454 std::string subName = "subName";
2455 ImeEnabledCfg cfg;
2456 ImeEnabledInfo enabledInfo{ bundleName, extName, EnabledStatus::BASIC_MODE };
2457 enabledInfo.extraInfo.isDefaultIme = true;
2458 enabledInfo.extraInfo.currentSubName = subName;
2459 cfg.enabledInfos.push_back(enabledInfo);
2460 ImeEnabledInfoManager::GetInstance().imeEnabledCfg_.insert_or_assign(MAIN_USER_ID, cfg);
2461
2462 auto session = std::make_shared<PerUserSession>(MAIN_USER_ID);
2463 // has no ready ime
2464 session->imeData_.clear();
2465 auto ret = session->RestoreCurrentImeSubType(0);
2466 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
2467 EXPECT_FALSE(InputTypeManager::GetInstance().isStarted_);
2468
2469 // has ready ime, ready ime not same with inputType ime
2470 InputTypeManager::GetInstance().isStarted_ = true;
2471 std::string bundleName1 = "bundleName1";
2472 std::string extName1 = "extName1";
2473 InputTypeManager::GetInstance().currentTypeIme_.bundleName = bundleName1;
2474 auto imeData = std::make_shared<ImeData>(nullptr, nullptr, nullptr, 10);
2475 imeData->imeStatus = ImeStatus::READY;
2476 imeData->ime = std::make_pair(bundleName, extName);
2477 std::vector<std::shared_ptr<ImeData>> imeDataList;
2478 imeDataList.push_back(imeData);
2479 session->imeData_.insert_or_assign(ImeType::IME, imeDataList);
2480 ret = session->RestoreCurrentImeSubType(0);
2481 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
2482 EXPECT_FALSE(InputTypeManager::GetInstance().isStarted_);
2483
2484 // has ready ime, ready ime same with inputType ime, ready ime same with default ime
2485 InputTypeManager::GetInstance().isStarted_ = true;
2486 InputTypeManager::GetInstance().currentTypeIme_.bundleName = bundleName;
2487 ret = session->RestoreCurrentImeSubType(0);
2488 EXPECT_EQ(ret, ErrorCode::ERROR_IME_NOT_STARTED);
2489 EXPECT_FALSE(InputTypeManager::GetInstance().isStarted_);
2490
2491 // has ready ime, ready ime same with inputType ime, ready ime not same with default ime
2492 InputTypeManager::GetInstance().isStarted_ = true;
2493 InputTypeManager::GetInstance().currentTypeIme_.bundleName = bundleName1;
2494 imeData->ime = std::make_pair(bundleName1, extName1);
2495 imeDataList.push_back(imeData);
2496 session->imeData_.insert_or_assign(ImeType::IME, imeDataList);
2497 ret = session->RestoreCurrentImeSubType(0);
2498 EXPECT_EQ(ret, ErrorCode::ERROR_IME_NOT_STARTED);
2499 EXPECT_FALSE(InputTypeManager::GetInstance().isStarted_);
2500 }
2501
2502 /**
2503 * @tc.name: SA_GetRealCurrentIme_004
2504 * @tc.desc: SA_GetRealCurrentIme_004
2505 * @tc.type: FUNC
2506 * @tc.require:
2507 */
2508 HWTEST_F(InputMethodPrivateMemberTest, SA_GetRealCurrentIme_004, TestSize.Level0)
2509 {
2510 IMSA_HILOGI("InputMethodPrivateMemberTest::SA_GetRealCurrentIme_004 start.");
2511 // input type not start, has no current client, screen locked
2512 std::string cmdResult;
2513 std::string cmd = "power-shell suspend";
2514 TddUtil::ExecuteCmd(cmd, cmdResult);
2515 sleep(1);
2516 InputTypeManager::GetInstance().isStarted_ = false;
2517 auto session = std::make_shared<PerUserSession>(MAIN_USER_ID);
2518 session->clientGroupMap_.clear();
2519
2520 std::string bundleName1 = "bundleName1";
2521 std::string extName1 = "extName1";
2522 std::string subName1 = "subName1";
2523 std::string bundleName2 = "bundleName2";
2524 std::string extName2 = "extName2";
2525 ImeEnabledCfg cfg;
2526 ImeEnabledInfo enabledInfo{ bundleName1, extName1, EnabledStatus::BASIC_MODE };
2527 ImeEnabledInfo enabledInfo1{ bundleName2, extName2, EnabledStatus::BASIC_MODE };
2528 enabledInfo.extraInfo.isDefaultIme = true;
2529 enabledInfo.extraInfo.currentSubName = subName1;
2530 cfg.enabledInfos.push_back(enabledInfo);
2531 cfg.enabledInfos.push_back(enabledInfo1);
2532 ImeEnabledInfoManager::GetInstance().imeEnabledCfg_.insert_or_assign(MAIN_USER_ID, cfg);
2533
2534 // preconfigured ime nullptr
2535 ImeInfoInquirer::GetInstance().systemConfig_.defaultInputMethod = "abnormal";
2536 auto ime = session->GetRealCurrentIme(false);
2537 ASSERT_NE(ime, nullptr);
2538 EXPECT_EQ(ime->bundleName, bundleName1);
2539 EXPECT_EQ(ime->subName, subName1);
2540
2541 // preconfigured ime exist, default ime exist, preconfigured ime same with default ime
2542 ImeInfoInquirer::GetInstance().systemConfig_.defaultInputMethod = bundleName1 + "/" + extName1;
2543 ime = session->GetRealCurrentIme(false);
2544 ASSERT_NE(ime, nullptr);
2545 EXPECT_EQ(ime->bundleName, bundleName1);
2546 EXPECT_EQ(ime->subName, subName1);
2547
2548 // preconfigured ime exist, default ime exist, preconfigured ime not same with default ime
2549 ImeInfoInquirer::GetInstance().systemConfig_.defaultInputMethod = bundleName2 + "/" + extName2;
2550 ime = session->GetRealCurrentIme(false);
2551 ASSERT_NE(ime, nullptr);
2552 EXPECT_EQ(ime->bundleName, bundleName2);
2553 EXPECT_TRUE(ime->subName.empty());
2554 }
2555
2556 /**
2557 * @tc.name: SA_TestSysParamChanged_001
2558 * @tc.desc: SA_TestSysParamChanged_001
2559 * @tc.type: FUNC
2560 * @tc.require:
2561 */
2562 HWTEST_F(InputMethodPrivateMemberTest, SA_TestSysParamChanged_001, TestSize.Level0)
2563 {
2564 IMSA_HILOGI("InputMethodPrivateMemberTest::SA_TestSysParamChanged_001 start.");
2565 auto ret = SystemParamAdapter::GetInstance().WatchParam("abnormal");
2566 EXPECT_EQ(ret, ErrorCode::ERROR_BAD_PARAMETERS);
2567 SystemParamAdapter::HandleSysParamChanged("key", "value", "key", 0);
2568 SystemParamAdapter::HandleSysParamChanged("key", "value", "abnormalKey", 0);
2569 InputMethodSystemAbility sysAbility;
2570 UserSessionManager::GetInstance().userSessions_.clear();
2571 sysAbility.OnSysMemChanged();
2572 auto userSession = std::make_shared<PerUserSession>(MAIN_USER_ID);
2573 UserSessionManager::GetInstance().userSessions_.insert_or_assign(MAIN_USER_ID, userSession);
2574 sysAbility.OnSysMemChanged();
2575 service_->userId_ = -1;
2576 ret = SystemParamAdapter::GetInstance().WatchParam(SystemParamAdapter::MEMORY_WATERMARK_KEY);
2577 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
2578 }
2579
2580 /**
2581 * @tc.name: SA_TryStartIme_001
2582 * @tc.desc: SA_TryStartIme_001
2583 * @tc.type: FUNC
2584 * @tc.require:
2585 */
2586 HWTEST_F(InputMethodPrivateMemberTest, SA_TryStartIme_001, TestSize.Level0)
2587 {
2588 IMSA_HILOGI("InputMethodPrivateMemberTest::SA_TryStartIme_001 start.");
2589 auto userSession = std::make_shared<PerUserSession>(MAIN_USER_ID);
2590 userSession->isBlockStartedByLowMem_ = false;
2591 auto ret = userSession->TryStartIme();
2592 EXPECT_EQ(ret, ErrorCode::ERROR_OPERATION_NOT_ALLOWED);
2593
2594 userSession->isBlockStartedByLowMem_ = true;
2595 auto imeData = std::make_shared<ImeData>(nullptr, nullptr, nullptr, 10);
2596 std::vector<std::shared_ptr<ImeData>> imeDataList;
2597 imeDataList.push_back(imeData);
2598 userSession->imeData_.insert_or_assign(ImeType::IME, imeDataList);
2599 ret = userSession->TryStartIme();
2600 EXPECT_EQ(ret, ErrorCode::ERROR_IME_HAS_STARTED);
2601
2602 userSession->imeData_.clear();
2603 std::string bundleName1 = "bundleName1";
2604 std::string extName1 = "extName1";
2605 ImeEnabledCfg cfg;
2606 ImeEnabledInfo enabledInfo{ bundleName1, extName1, EnabledStatus::BASIC_MODE };
2607 enabledInfo.extraInfo.isDefaultIme = true;
2608 cfg.enabledInfos.push_back(enabledInfo);
2609 ImeEnabledInfoManager::GetInstance().imeEnabledCfg_.insert_or_assign(MAIN_USER_ID, cfg);
2610
2611 std::string bundleName2 = "bundleName2";
2612 std::string extName2 = "extName2";
2613 ImeInfoInquirer::GetInstance().systemConfig_.defaultInputMethod = bundleName2 + "/" + extName2;
2614 userSession->isBlockStartedByLowMem_ = true;
2615 ret = userSession->TryStartIme();
2616 EXPECT_EQ(ret, ErrorCode::ERROR_OPERATION_NOT_ALLOWED);
2617
2618 ImeInfoInquirer::GetInstance().systemConfig_.defaultInputMethod = bundleName1 + "/" + extName1;
2619 userSession->isBlockStartedByLowMem_ = true;
2620 ImeStateManagerFactory::GetInstance().ifDynamicStartIme_ = false;
2621 ret = userSession->TryStartIme();
2622 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
2623 userSession->isBlockStartedByLowMem_ = true;
2624 ImeStateManagerFactory::GetInstance().ifDynamicStartIme_ = true;
2625 ret = userSession->TryStartIme();
2626 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
2627 }
2628
2629 /**
2630 * @tc.name: SA_TryDisconnectIme_001
2631 * @tc.desc: SA_TryDisconnectIme_001
2632 * @tc.type: FUNC
2633 * @tc.require:
2634 */
2635 HWTEST_F(InputMethodPrivateMemberTest, SA_TryDisconnectIme_001, TestSize.Level0)
2636 {
2637 IMSA_HILOGI("InputMethodPrivateMemberTest::SA_TryDisconnectIme_001 start.");
2638 auto userSession = std::make_shared<PerUserSession>(MAIN_USER_ID);
2639 userSession->imeData_.clear();
2640 auto ret = userSession->TryDisconnectIme();
2641 EXPECT_EQ(ret, ErrorCode::ERROR_IME_NOT_STARTED);
2642 auto imeData = std::make_shared<ImeData>(nullptr, nullptr, nullptr, 10);
2643 std::vector<std::shared_ptr<ImeData>> imeDataList;
2644 imeDataList.push_back(imeData);
2645 userSession->imeData_.insert_or_assign(ImeType::IME, imeDataList);
2646
2647 userSession->attachingCount_ = 1;
2648 ret = userSession->TryDisconnectIme();
2649 EXPECT_EQ(ret, ErrorCode::ERROR_OPERATION_NOT_ALLOWED);
2650
2651 userSession->attachingCount_ = 0;
2652 auto group = std::make_shared<ClientGroup>(DEFAULT_DISPLAY_ID, nullptr);
2653 sptr<IInputClient> client = new (std::nothrow) InputClientServiceImpl();
2654 group->currentClient_ = client;
2655 auto info = std::make_shared<InputClientInfo>();
2656 group->mapClients_.insert_or_assign(client->AsObject(), info);
2657 userSession->clientGroupMap_.insert_or_assign(DEFAULT_DISPLAY_ID, group);
2658 ret = userSession->TryDisconnectIme();
2659 EXPECT_EQ(ret, ErrorCode::ERROR_OPERATION_NOT_ALLOWED);
2660
2661 userSession->clientGroupMap_.clear();
2662 userSession->SetImeConnection(nullptr);
2663 ret = userSession->TryDisconnectIme();
2664 EXPECT_EQ(ret, ErrorCode::ERROR_IME_NOT_STARTED);
2665 sptr<AAFwk::IAbilityConnection> connection = new (std::nothrow) ImeConnection();
2666 userSession->SetImeConnection(connection);
2667 ret = userSession->TryDisconnectIme();
2668 EXPECT_EQ(ret, ErrorCode::ERROR_IMSA_IME_DISCONNECT_FAILED);
2669 }
2670
2671 /**
2672 * @tc.name: SA_TestClearImeConnection_001
2673 * @tc.desc: SA_TestClearImeConnection_001
2674 * @tc.type: FUNC
2675 * @tc.require:
2676 */
2677 HWTEST_F(InputMethodPrivateMemberTest, SA_TestClearImeConnection_001, TestSize.Level0)
2678 {
2679 IMSA_HILOGI("InputMethodPrivateMemberTest::SA_TestClearImeConnection_001 start.");
2680 sptr<AAFwk::IAbilityConnection> connection = new (std::nothrow) ImeConnection();
2681 sptr<AAFwk::IAbilityConnection> connection1 = new (std::nothrow) ImeConnection();
2682 auto userSession = std::make_shared<PerUserSession>(MAIN_USER_ID);
2683
2684 userSession->SetImeConnection(connection);
2685 EXPECT_EQ(userSession->GetImeConnection(), connection);
2686 userSession->ClearImeConnection(connection);
2687 EXPECT_EQ(userSession->GetImeConnection(), nullptr);
2688
2689 userSession->SetImeConnection(connection);
2690 EXPECT_EQ(userSession->GetImeConnection(), connection);
2691 userSession->ClearImeConnection(nullptr);
2692 EXPECT_EQ(userSession->GetImeConnection(), connection);
2693
2694 userSession->SetImeConnection(nullptr);
2695 EXPECT_EQ(userSession->GetImeConnection(), nullptr);
2696 userSession->ClearImeConnection(connection);
2697 EXPECT_EQ(userSession->GetImeConnection(), nullptr);
2698
2699 userSession->SetImeConnection(connection);
2700 EXPECT_EQ(userSession->GetImeConnection(), connection);
2701 userSession->ClearImeConnection(connection1);
2702 EXPECT_EQ(userSession->GetImeConnection(), connection);
2703 }
2704
2705 /**
2706 * @tc.name: IMSA_IsTmpIme
2707 * @tc.desc: IMSA_IsTmpIme
2708 * @tc.type: FUNC
2709 * @tc.require:
2710 */
2711 HWTEST_F(InputMethodPrivateMemberTest, IMSA_IsTmpIme, TestSize.Level0)
2712 {
2713 IMSA_HILOGI("InputMethodPrivateMemberTest::IMSA_IsTmpIme start.");
2714 InputMethodSystemAbility systemAbility;
2715 UserSessionManager::GetInstance().userSessions_.clear();
2716 uint32_t tokenId = 345;
2717 // not has MAIN_USER_ID userSession
2718 auto ret = systemAbility.IsTmpIme(MAIN_USER_ID, tokenId);
2719 EXPECT_FALSE(ret);
2720 auto userSession = std::make_shared<PerUserSession>(MAIN_USER_ID);
2721 UserSessionManager::GetInstance().userSessions_.insert_or_assign(MAIN_USER_ID, userSession);
2722 ImeEnabledCfg cfg;
2723 ImeEnabledInfo enabledInfo{ "", "extName1", EnabledStatus::BASIC_MODE };
2724 enabledInfo.extraInfo.isDefaultIme = true;
2725 cfg.enabledInfos.push_back(enabledInfo);
2726 ImeEnabledInfoManager::GetInstance().imeEnabledCfg_.insert_or_assign(MAIN_USER_ID, cfg);
2727 // has no running ime
2728 userSession->imeData_.clear();
2729 ret = systemAbility.IsTmpIme(MAIN_USER_ID, tokenId);
2730 EXPECT_FALSE(ret);
2731 auto imeData = std::make_shared<ImeData>(nullptr, nullptr, nullptr, 10);
2732 std::string bundleName2 = "bundleName2";
2733 imeData->ime.first = bundleName2;
2734 userSession->imeData_.insert_or_assign(ImeType::IME, std::vector<std::shared_ptr<ImeData>>{imeData});
2735 FullImeInfo info;
2736 info.tokenId = tokenId;
2737 info.prop.name = bundleName2;
2738 FullImeInfoManager::GetInstance().fullImeInfos_.insert({ MAIN_USER_ID, { info } });
2739 // caller is same with running ime, but the bundleName of default ime is empty
2740 ret = systemAbility.IsTmpIme(MAIN_USER_ID, tokenId);
2741 EXPECT_FALSE(ret);
2742 enabledInfo.bundleName = bundleName2;
2743 cfg.enabledInfos.clear();
2744 cfg.enabledInfos.push_back(enabledInfo);
2745 ImeEnabledInfoManager::GetInstance().imeEnabledCfg_.insert_or_assign(MAIN_USER_ID, cfg);
2746 // caller is same with running ime, the bundleName of default ime is also same with
2747 ret = systemAbility.IsTmpIme(MAIN_USER_ID, tokenId);
2748 EXPECT_FALSE(ret);
2749 enabledInfo.bundleName = "diffBundleName";
2750 cfg.enabledInfos.clear();
2751 cfg.enabledInfos.push_back(enabledInfo);
2752 ImeEnabledInfoManager::GetInstance().imeEnabledCfg_.insert_or_assign(MAIN_USER_ID, cfg);
2753 // caller is same with running ime, but the bundleName of default ime is not same with
2754 ret = systemAbility.IsTmpIme(MAIN_USER_ID, tokenId);
2755 EXPECT_TRUE(ret);
2756 SwitchInfo switchInfo;
2757 switchInfo.bundleName = bundleName2;
2758 ret = systemAbility.IsTmpImeSwitchSubtype(MAIN_USER_ID, tokenId, switchInfo);
2759 EXPECT_TRUE(ret);
2760 }
2761
2762 /**
2763 * @tc.name: PerUserSession_AddImeData_001
2764 * @tc.desc: PerUserSession_AddImeData_001
2765 * @tc.type: FUNC
2766 * @tc.require:
2767 */
2768 HWTEST_F(InputMethodPrivateMemberTest, PerUserSession_AddImeData_001, TestSize.Level0)
2769 {
2770 IMSA_HILOGI("InputMethodPrivateMemberTest::PerUserSession_AddImeData_001 start.");
2771 auto userSession = std::make_shared<PerUserSession>(MAIN_USER_ID);
2772 userSession->imeData_.clear();
2773 pid_t pid1 = 100;
2774 sptr<InputMethodCoreStub> coreStub1 = new (std::nothrow) InputMethodCoreServiceImpl();
2775 sptr<InputMethodAgentStub> agentStub1 = new (std::nothrow) InputMethodAgentServiceImpl();
2776 auto ret = userSession->AddImeData(ImeType::PROXY_IME, coreStub1, agentStub1->AsObject(), pid1);
2777 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
2778 auto it = userSession->imeData_.find(ImeType::PROXY_IME);
2779 ASSERT_NE(it, userSession->imeData_.end());
2780 EXPECT_EQ(it->second.size(), 1);
2781
2782 pid_t pid2 = 101;
2783 sptr<InputMethodCoreStub> coreStub2 = new (std::nothrow) InputMethodCoreServiceImpl();
2784 sptr<InputMethodAgentStub> agentStub2 = new (std::nothrow) InputMethodAgentServiceImpl();
2785 ret = userSession->AddImeData(ImeType::PROXY_IME, coreStub2, agentStub2->AsObject(), pid2);
2786 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
2787 it = userSession->imeData_.find(ImeType::PROXY_IME);
2788 ASSERT_NE(it, userSession->imeData_.end());
2789 EXPECT_EQ(it->second.size(), 2);
2790
2791 ret = userSession->AddImeData(ImeType::PROXY_IME, coreStub1, agentStub1->AsObject(), pid1);
2792 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
2793 it = userSession->imeData_.find(ImeType::PROXY_IME);
2794 ASSERT_NE(it, userSession->imeData_.end());
2795 ASSERT_EQ(it->second.size(), 2);
2796 EXPECT_EQ(it->second[1]->pid, pid1);
2797 }
2798
2799 /**
2800 * @tc.name: PerUserSession_AddImeData_002
2801 * @tc.desc: PerUserSession_AddImeData_002
2802 * @tc.type: FUNC
2803 * @tc.require:
2804 */
2805 HWTEST_F(InputMethodPrivateMemberTest, PerUserSession_AddImeData_002, TestSize.Level0)
2806 {
2807 IMSA_HILOGI("InputMethodPrivateMemberTest::PerUserSession_AddImeData_002 start.");
2808 auto userSession = std::make_shared<PerUserSession>(MAIN_USER_ID);
2809 userSession->imeData_.clear();
2810 pid_t pid1 = 100;
2811 sptr<InputMethodCoreStub> coreStub1 = new (std::nothrow) InputMethodCoreServiceImpl();
2812 sptr<InputMethodAgentStub> agentStub1 = new (std::nothrow) InputMethodAgentServiceImpl();
2813 userSession->isFirstPreemption_= true;
2814 auto ret = userSession->AddImeData(ImeType::PROXY_IME, coreStub1, agentStub1->AsObject(), pid1);
2815 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
2816 auto it = userSession->imeData_.find(ImeType::PROXY_IME);
2817 ASSERT_NE(it, userSession->imeData_.end());
2818 EXPECT_EQ(it->second.size(), 1);
2819
2820 userSession->isFirstPreemption_= false;
2821 pid_t pid2 = 101;
2822 sptr<InputMethodCoreStub> coreStub2 = new (std::nothrow) InputMethodCoreServiceImpl();
2823 sptr<InputMethodAgentStub> agentStub2 = new (std::nothrow) InputMethodAgentServiceImpl();
2824 auto imeData = std::make_shared<ImeData>(coreStub2, agentStub2, nullptr, pid2);
2825 ret = userSession->AddImeData(ImeType::PROXY_IME, coreStub2, agentStub2->AsObject(), pid2);
2826 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
2827 it = userSession->imeData_.find(ImeType::PROXY_IME);
2828 ASSERT_NE(it, userSession->imeData_.end());
2829 EXPECT_EQ(it->second.size(), 2);
2830
2831 userSession->isFirstPreemption_= false;
2832 ret = userSession->AddImeData(ImeType::PROXY_IME, coreStub1, agentStub1->AsObject(), pid1);
2833 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
2834 it = userSession->imeData_.find(ImeType::PROXY_IME);
2835 ASSERT_NE(it, userSession->imeData_.end());
2836 ASSERT_EQ(it->second.size(), 2);
2837 EXPECT_EQ(it->second[1]->pid, pid1);
2838
2839 sptr<InputMethodCoreStub> coreStub4 = new (std::nothrow) InputMethodCoreServiceImpl();
2840 sptr<InputMethodAgentStub> agentStub4 = new (std::nothrow) InputMethodAgentServiceImpl();
2841 userSession->isFirstPreemption_= true;
2842 pid_t pid4 = 104;
2843 ret = userSession->AddImeData(ImeType::PROXY_IME, coreStub4, agentStub4->AsObject(), pid4);
2844 EXPECT_EQ(ret, ErrorCode::NO_ERROR);
2845 it = userSession->imeData_.find(ImeType::PROXY_IME);
2846 ASSERT_NE(it, userSession->imeData_.end());
2847 ASSERT_EQ(it->second.size(), 3);
2848 EXPECT_EQ(it->second[2]->pid, pid4);
2849 }
2850
2851 /**
2852 * @tc.name: PerUserSession_GetImeData_001
2853 * @tc.desc: imeData_ info abnormal
2854 * @tc.type: FUNC
2855 * @tc.require:
2856 */
2857 HWTEST_F(InputMethodPrivateMemberTest, PerUserSession_GetImeData_001, TestSize.Level0)
2858 {
2859 IMSA_HILOGI("InputMethodPrivateMemberTest::PerUserSession_GetImeData_001 start.");
2860 auto userSession = std::make_shared<PerUserSession>(MAIN_USER_ID);
2861 userSession->imeData_.clear();
2862 auto imeData = userSession->GetImeData(ImeType::PROXY_IME);
2863 EXPECT_EQ(imeData, nullptr);
2864 pid_t pid1 = 101;
2865 imeData = userSession->GetImeData(pid1);
2866 EXPECT_EQ(imeData, nullptr);
2867
2868 userSession->imeData_.insert_or_assign(ImeType::IME, std::vector<std::shared_ptr<ImeData>>{});
2869 imeData = userSession->GetImeData(ImeType::PROXY_IME);
2870 EXPECT_EQ(imeData, nullptr);
2871 imeData = userSession->GetImeData(pid1);
2872 EXPECT_EQ(imeData, nullptr);
2873
2874 userSession->imeData_.insert_or_assign(ImeType::PROXY_IME, std::vector<std::shared_ptr<ImeData>>{});
2875 imeData = userSession->GetImeData(ImeType::PROXY_IME);
2876 EXPECT_EQ(imeData, nullptr);
2877 imeData = userSession->GetImeData(pid1);
2878 EXPECT_EQ(imeData, nullptr);
2879 }
2880
2881 /**
2882 * @tc.name: PerUserSession_GetImeData_002
2883 * @tc.desc: imeData_ normal
2884 * @tc.type: FUNC
2885 * @tc.require:
2886 */
2887 HWTEST_F(InputMethodPrivateMemberTest, PerUserSession_GetImeData_002, TestSize.Level0)
2888 {
2889 IMSA_HILOGI("InputMethodPrivateMemberTest::PerUserSession_GetImeData_002 start.");
2890 auto userSession = std::make_shared<PerUserSession>(MAIN_USER_ID);
2891 userSession->imeData_.clear();
2892 pid_t pid1 = 101;
2893 sptr<InputMethodCoreStub> coreStub1 = new (std::nothrow) InputMethodCoreServiceImpl();
2894 sptr<InputMethodAgentStub> agentStub1 = new (std::nothrow) InputMethodAgentServiceImpl();
2895 userSession->AddImeData(ImeType::PROXY_IME, coreStub1, agentStub1->AsObject(), pid1);
2896
2897 pid_t pid2 = 102;
2898 sptr<InputMethodCoreStub> coreStub2 = new (std::nothrow) InputMethodCoreServiceImpl();
2899 sptr<InputMethodAgentStub> agentStub2 = new (std::nothrow) InputMethodAgentServiceImpl();
2900 userSession->AddImeData(ImeType::PROXY_IME, coreStub2, agentStub2->AsObject(), pid2);
2901 auto it = userSession->imeData_.find(ImeType::PROXY_IME);
2902 ASSERT_NE(it, userSession->imeData_.end());
2903 EXPECT_EQ(it->second.size(), 2);
2904
2905 auto imeData = userSession->GetImeData(ImeType::PROXY_IME);
2906 ASSERT_NE(imeData, nullptr);
2907 EXPECT_EQ(imeData->pid, pid2);
2908
2909 pid_t pid3 = 103;
2910 imeData = userSession->GetImeData(pid3);
2911 EXPECT_EQ(imeData, nullptr);
2912 imeData = userSession->GetImeData(pid1);
2913 ASSERT_NE(imeData, nullptr);
2914 EXPECT_EQ(imeData->pid, pid1);
2915 }
2916
2917 /**
2918 * @tc.name: PerUserSession_RemoveImeData_001
2919 * @tc.desc: Remove imeData by pid
2920 * @tc.type: FUNC
2921 * @tc.require:
2922 */
2923 HWTEST_F(InputMethodPrivateMemberTest, PerUserSession_RemoveImeData_001, TestSize.Level0)
2924 {
2925 IMSA_HILOGI("InputMethodPrivateMemberTest::PerUserSession_RemoveImeData_001 start.");
2926 auto userSession = std::make_shared<PerUserSession>(MAIN_USER_ID);
2927 userSession->imeData_.clear();
2928 pid_t pid1 = 101;
2929 sptr<InputMethodCoreStub> coreStub1 = new (std::nothrow) InputMethodCoreServiceImpl();
2930 sptr<InputMethodAgentStub> agentStub1 = new (std::nothrow) InputMethodAgentServiceImpl();
2931 userSession->AddImeData(ImeType::PROXY_IME, coreStub1, agentStub1->AsObject(), pid1);
2932
2933 pid_t pid2 = 102;
2934 sptr<InputMethodCoreStub> coreStub2 = new (std::nothrow) InputMethodCoreServiceImpl();
2935 sptr<InputMethodAgentStub> agentStub2 = new (std::nothrow) InputMethodAgentServiceImpl();
2936 userSession->AddImeData(ImeType::PROXY_IME, coreStub2, agentStub2->AsObject(), pid2);
2937 auto it = userSession->imeData_.find(ImeType::PROXY_IME);
2938 ASSERT_NE(it, userSession->imeData_.end());
2939 EXPECT_EQ(it->second.size(), 2);
2940
2941 pid_t pid3 = 103;
2942 userSession->RemoveImeData(pid3);
2943 it = userSession->imeData_.find(ImeType::PROXY_IME);
2944 ASSERT_NE(it, userSession->imeData_.end());
2945 EXPECT_EQ(it->second.size(), 2);
2946
2947 userSession->RemoveImeData(pid2);
2948 it = userSession->imeData_.find(ImeType::PROXY_IME);
2949 ASSERT_NE(it, userSession->imeData_.end());
2950 ASSERT_EQ(it->second.size(), 1);
2951 EXPECT_EQ(it->second[0]->pid, pid1);
2952
2953 userSession->RemoveImeData(pid1);
2954 it = userSession->imeData_.find(ImeType::PROXY_IME);
2955 EXPECT_EQ(it, userSession->imeData_.end());
2956 }
2957
2958 /**
2959 * @tc.name: PerUserSession_RemoveImeData_002
2960 * @tc.desc: Remove imeData by imeType
2961 * @tc.type: FUNC
2962 * @tc.require:
2963 */
2964 HWTEST_F(InputMethodPrivateMemberTest, PerUserSession_RemoveImeData_002, TestSize.Level0)
2965 {
2966 IMSA_HILOGI("InputMethodPrivateMemberTest::PerUserSession_RemoveImeData_002 start.");
2967 auto userSession = std::make_shared<PerUserSession>(MAIN_USER_ID);
2968 userSession->imeData_.clear();
2969 pid_t pid1 = 101;
2970 sptr<InputMethodCoreStub> coreStub1 = new (std::nothrow) InputMethodCoreServiceImpl();
2971 sptr<InputMethodAgentStub> agentStub1 = new (std::nothrow) InputMethodAgentServiceImpl();
2972 userSession->AddImeData(ImeType::PROXY_IME, coreStub1, agentStub1->AsObject(), pid1);
2973
2974 pid_t pid2 = 102;
2975 sptr<InputMethodCoreStub> coreStub2 = new (std::nothrow) InputMethodCoreServiceImpl();
2976 sptr<InputMethodAgentStub> agentStub2 = new (std::nothrow) InputMethodAgentServiceImpl();
2977 userSession->AddImeData(ImeType::PROXY_IME, coreStub2, agentStub2->AsObject(), pid2);
2978 auto it = userSession->imeData_.find(ImeType::PROXY_IME);
2979 ASSERT_NE(it, userSession->imeData_.end());
2980 EXPECT_EQ(it->second.size(), 2);
2981
2982 it = userSession->imeData_.find(ImeType::PROXY_IME);
2983 ASSERT_NE(it, userSession->imeData_.end());
2984 EXPECT_EQ(it->second.size(), 2);
2985
2986 userSession->RemoveImeData(ImeType::PROXY_IME);
2987 it = userSession->imeData_.find(ImeType::PROXY_IME);
2988 EXPECT_EQ(it, userSession->imeData_.end());
2989 }
2990
2991 } // namespace MiscServices
2992 } // namespace OHOS