1 /*
2 * Copyright (C) 2022-2023 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
16 #define private public
17 #define protected public
18 #include "input_method_system_ability.h"
19 #undef private
20
21 #include <gtest/gtest.h>
22 #include <sys/time.h>
23 #include <unistd.h>
24
25 #include <cstdint>
26 #include <regex>
27 #include <sstream>
28 #include <string>
29
30 #include "global.h"
31 using namespace testing;
32 using namespace testing::ext;
33 namespace OHOS {
34 namespace MiscServices {
35 class IdentityCheckerTest : public testing::Test {
36 public:
37 class IdentityCheckerMock : public IdentityChecker {
38 public:
39 IdentityCheckerMock() = default;
40 virtual ~IdentityCheckerMock() = default;
IsFocused(int64_t callingPid,uint32_t callingTokenId,int64_t focusedPid=INVALID_PID,bool isAttach=false,sptr<IRemoteObject> abilityToken=nullptr)41 bool IsFocused(int64_t callingPid, uint32_t callingTokenId, int64_t focusedPid = INVALID_PID,
42 bool isAttach = false, sptr<IRemoteObject> abilityToken = nullptr) override
43 {
44 return isFocused_;
45 }
IsSystemApp(uint64_t fullTokenId)46 bool IsSystemApp(uint64_t fullTokenId) override
47 {
48 return isSystemApp_;
49 }
IsBundleNameValid(uint32_t tokenId,const std::string & validBundleName)50 bool IsBundleNameValid(uint32_t tokenId, const std::string &validBundleName) override
51 {
52 return isBundleNameValid_;
53 }
HasPermission(uint32_t tokenId,const std::string & permission)54 bool HasPermission(uint32_t tokenId, const std::string &permission) override
55 {
56 return hasPermission_;
57 }
IsBroker(Security::AccessToken::AccessTokenID tokenId)58 bool IsBroker(Security::AccessToken::AccessTokenID tokenId) override
59 {
60 return isBroker_;
61 }
IsNativeSa(Security::AccessToken::AccessTokenID tokenId)62 bool IsNativeSa(Security::AccessToken::AccessTokenID tokenId) override
63 {
64 return isNativeSa_;
65 }
IsFormShell(Security::AccessToken::AccessTokenID tokenId)66 bool IsFormShell(Security::AccessToken::AccessTokenID tokenId) override
67 {
68 return isFromShell_;
69 }
GetBundleNameByToken(uint32_t tokenId)70 std::string GetBundleNameByToken(uint32_t tokenId) override
71 {
72 return "";
73 }
IsSpecialSaUid()74 bool IsSpecialSaUid() override
75 {
76 return true;
77 }
78 static bool isFocused_;
79 static bool isSystemApp_;
80 static bool isBundleNameValid_;
81 static bool hasPermission_;
82 static bool isBroker_;
83 static bool isNativeSa_;
84 static bool isFromShell_;
85 };
86 static constexpr uint32_t MAIN_USER_ID = 100;
87 static const constexpr char *CURRENT_IME = "testBundleName/testExtname";
88 static const constexpr char *CURRENT_SUBNAME = "testSubName";
89 static const constexpr char *CURRENT_BUNDLENAME = "testBundleName";
90 static const constexpr char *CURRENT_EXTNAME = "testExtName";
91 static void SetUpTestCase(void);
92 static void TearDownTestCase(void);
93 void SetUp();
94 void TearDown();
95 static sptr<InputMethodSystemAbility> service_;
96 static std::shared_ptr<IdentityCheckerMock> identityCheckerMock_;
97 static std::shared_ptr<IdentityCheckerImpl> identityCheckerImpl_;
98 };
99 bool IdentityCheckerTest::IdentityCheckerMock::isFocused_ = false;
100 bool IdentityCheckerTest::IdentityCheckerMock::isSystemApp_ = false;
101 bool IdentityCheckerTest::IdentityCheckerMock::isBundleNameValid_ = false;
102 bool IdentityCheckerTest::IdentityCheckerMock::hasPermission_ = false;
103 bool IdentityCheckerTest::IdentityCheckerMock::isBroker_ = false;
104 bool IdentityCheckerTest::IdentityCheckerMock::isNativeSa_ = false;
105 bool IdentityCheckerTest::IdentityCheckerMock::isFromShell_ = false;
106
SetUpTestCase(void)107 void IdentityCheckerTest::SetUpTestCase(void)
108 {
109 IMSA_HILOGI("IdentityCheckerTest::SetUpTestCase");
110 service_ = new (std::nothrow) InputMethodSystemAbility();
111 if (service_ == nullptr) {
112 return;
113 }
114 service_->OnStart();
115 ImeCfgManager::GetInstance().imeConfigs_ = {
116 { MAIN_USER_ID, CURRENT_IME, CURRENT_SUBNAME, false }
117 };
118 identityCheckerImpl_ = std::make_shared<IdentityCheckerImpl>();
119 }
120
TearDownTestCase(void)121 void IdentityCheckerTest::TearDownTestCase(void)
122 {
123 IMSA_HILOGI("IdentityCheckerTest::TearDownTestCase");
124 service_->OnStop();
125 }
126
SetUp(void)127 void IdentityCheckerTest::SetUp(void)
128 {
129 identityCheckerMock_ = std::make_shared<IdentityCheckerMock>();
130 service_->identityChecker_ = identityCheckerMock_;
131 IMSA_HILOGI("IdentityCheckerTest::SetUp");
132 }
133
TearDown(void)134 void IdentityCheckerTest::TearDown(void)
135 {
136 service_->identityChecker_ = identityCheckerImpl_;
137 identityCheckerMock_ = nullptr;
138 IMSA_HILOGI("IdentityCheckerTest::TearDown");
139 }
140
141 sptr<InputMethodSystemAbility> IdentityCheckerTest::service_;
142 std::shared_ptr<IdentityCheckerTest::IdentityCheckerMock> IdentityCheckerTest::identityCheckerMock_;
143 std::shared_ptr<IdentityCheckerImpl> IdentityCheckerTest::identityCheckerImpl_;
144
145 /**
146 * @tc.name: testStartInput_001
147 * @tc.desc: not broker, not focused app
148 * @tc.type: FUNC
149 * @tc.require:
150 * @tc.author:
151 */
152 HWTEST_F(IdentityCheckerTest, testStartInput_001, TestSize.Level1)
153 {
154 IMSA_HILOGI("IdentityCheckerTest testStartInput_001 start");
155 service_->identityChecker_ = identityCheckerImpl_;
156 InputClientInfoInner inputClientInfo;
157 std::vector<sptr<IRemoteObject>> agents;
158 std::vector<BindImeInfo> imeInfos;
159 int32_t ret = IdentityCheckerTest::service_->StartInput(inputClientInfo, agents, imeInfos);
160 EXPECT_EQ(ret, ErrorCode::ERROR_CLIENT_NOT_FOCUSED);
161 }
162
163 /**
164 * @tc.name: testStartInput_002
165 * @tc.desc: is broker, not focused app
166 * @tc.type: FUNC
167 * @tc.require:
168 * @tc.author:
169 */
170 HWTEST_F(IdentityCheckerTest, testStartInput_002, TestSize.Level1)
171 {
172 IMSA_HILOGI("IdentityCheckerTest testStartInput_002 start");
173 IdentityCheckerTest::IdentityCheckerMock::isBroker_ = true;
174 IdentityCheckerTest::IdentityCheckerMock::isFocused_ = false;
175 InputClientInfoInner inputClientInfo;
176 std::vector<sptr<IRemoteObject>> agents;
177 std::vector<BindImeInfo> imeInfos;
178 int32_t ret = IdentityCheckerTest::service_->StartInput(inputClientInfo, agents, imeInfos);
179 EXPECT_EQ(ret, ErrorCode::ERROR_IMSA_REBOOT_OLD_IME_NOT_STOP);
180 }
181
182 /**
183 * @tc.name: testStartInput_003
184 * @tc.desc: is broker, is focused app
185 * @tc.type: FUNC
186 * @tc.require:
187 * @tc.author:
188 */
189 HWTEST_F(IdentityCheckerTest, testStartInput_003, TestSize.Level1)
190 {
191 IMSA_HILOGI("IdentityCheckerTest testStartInput_003 start");
192 IdentityCheckerTest::IdentityCheckerMock::isBroker_ = true;
193 IdentityCheckerTest::IdentityCheckerMock::isFocused_ = true;
194 InputClientInfoInner inputClientInfo;
195 std::vector<sptr<IRemoteObject>> agents;
196 std::vector<BindImeInfo> imeInfos;
197 int32_t ret = IdentityCheckerTest::service_->StartInput(inputClientInfo, agents, imeInfos);
198 EXPECT_EQ(ret, ErrorCode::ERROR_IMSA_REBOOT_OLD_IME_NOT_STOP);
199 }
200
201 /**
202 * @tc.name: testStartInput_004
203 * @tc.desc: not broker, is focused app
204 * @tc.type: FUNC
205 * @tc.require:
206 * @tc.author:
207 */
208 HWTEST_F(IdentityCheckerTest, testStartInput_004, TestSize.Level1)
209 {
210 IMSA_HILOGI("IdentityCheckerTest testStartInput_004 start");
211 IdentityCheckerTest::IdentityCheckerMock::isBroker_ = false;
212 IdentityCheckerTest::IdentityCheckerMock::isFocused_ = true;
213 InputClientInfoInner inputClientInfo;
214 std::vector<sptr<IRemoteObject>> agents;
215 std::vector<BindImeInfo> imeInfos;
216 int32_t ret = IdentityCheckerTest::service_->StartInput(inputClientInfo, agents, imeInfos);
217 EXPECT_EQ(ret, ErrorCode::ERROR_IMSA_REBOOT_OLD_IME_NOT_STOP);
218 }
219
220 /**
221 * @tc.name: testStopInput_001
222 * @tc.desc: not broker, not focused app
223 * @tc.type: FUNC
224 * @tc.require:
225 * @tc.author:
226 */
227 HWTEST_F(IdentityCheckerTest, testStopInput_001, TestSize.Level1)
228 {
229 IMSA_HILOGI("IdentityCheckerTest testStopInput_001 start");
230 service_->identityChecker_ = identityCheckerImpl_;
231 int32_t ret = IdentityCheckerTest::service_->HideInput(nullptr);
232 EXPECT_EQ(ret, ErrorCode::ERROR_CLIENT_NOT_FOCUSED);
233 }
234
235 /**
236 * @tc.name: testStopInput_002
237 * @tc.desc: is broker, not focused app
238 * @tc.type: FUNC
239 * @tc.require:
240 * @tc.author:
241 */
242 HWTEST_F(IdentityCheckerTest, testStopInput_002, TestSize.Level1)
243 {
244 IMSA_HILOGI("IdentityCheckerTest testStopInput_002 start");
245 IdentityCheckerTest::IdentityCheckerMock::isBroker_ = true;
246 IdentityCheckerTest::IdentityCheckerMock::isFocused_ = false;
247 int32_t ret = IdentityCheckerTest::service_->HideInput(nullptr);
248 EXPECT_EQ(ret, ErrorCode::ERROR_CLIENT_NULL_POINTER);
249 }
250
251 /**
252 * @tc.name: testStopInput_003
253 * @tc.desc: is broker, is focused app
254 * @tc.type: FUNC
255 * @tc.require:
256 * @tc.author:
257 */
258 HWTEST_F(IdentityCheckerTest, testStopInput_003, TestSize.Level1)
259 {
260 IMSA_HILOGI("IdentityCheckerTest testStopInput_003 start");
261 IdentityCheckerTest::IdentityCheckerMock::isBroker_ = true;
262 IdentityCheckerTest::IdentityCheckerMock::isFocused_ = true;
263 InputClientInfo clientInfo {};
264 int32_t ret = IdentityCheckerTest::service_->HideInput(nullptr);
265 EXPECT_EQ(ret, ErrorCode::ERROR_CLIENT_NULL_POINTER);
266 }
267
268 /**
269 * @tc.name: testStopInput_004
270 * @tc.desc: not broker, is focused app
271 * @tc.type: FUNC
272 * @tc.require:
273 * @tc.author:
274 */
275 HWTEST_F(IdentityCheckerTest, testStopInput_004, TestSize.Level1)
276 {
277 IMSA_HILOGI("IdentityCheckerTest testStopInput_004 start");
278 IdentityCheckerTest::IdentityCheckerMock::isBroker_ = false;
279 IdentityCheckerTest::IdentityCheckerMock::isFocused_ = true;
280 InputClientInfo clientInfo {};
281 int32_t ret = IdentityCheckerTest::service_->HideInput(nullptr);
282 EXPECT_EQ(ret, ErrorCode::ERROR_CLIENT_NULL_POINTER);
283 }
284
285 /**
286 * @tc.name: testStopInputSession_001
287 * @tc.desc: not broker, not focused app
288 * @tc.type: FUNC
289 * @tc.require:
290 * @tc.author:
291 */
292 HWTEST_F(IdentityCheckerTest, testStopInputSession_001, TestSize.Level1)
293 {
294 IMSA_HILOGI("IdentityCheckerTest testStopInputSession_001 start");
295 service_->identityChecker_ = identityCheckerImpl_;
296 int32_t ret = IdentityCheckerTest::service_->StopInputSession();
297 EXPECT_EQ(ret, ErrorCode::ERROR_CLIENT_NOT_FOCUSED);
298 }
299
300 /**
301 * @tc.name: testStopInputSession_002
302 * @tc.desc: is broker, not focused app
303 * @tc.type: FUNC
304 * @tc.require:
305 * @tc.author:
306 */
307 HWTEST_F(IdentityCheckerTest, testStopInputSession_002, TestSize.Level1)
308 {
309 IMSA_HILOGI("IdentityCheckerTest testStopInputSession_002 start");
310 IdentityCheckerTest::IdentityCheckerMock::isBroker_ = true;
311 IdentityCheckerTest::IdentityCheckerMock::isFocused_ = false;
312 int32_t ret = IdentityCheckerTest::service_->StopInputSession();
313 EXPECT_EQ(ret, ErrorCode::ERROR_CLIENT_NOT_FOUND);
314 }
315
316 /**
317 * @tc.name: testStopInputSession_003
318 * @tc.desc: is broker, is focused app
319 * @tc.type: FUNC
320 * @tc.require:
321 * @tc.author:
322 */
323 HWTEST_F(IdentityCheckerTest, testStopInputSession_003, TestSize.Level1)
324 {
325 IMSA_HILOGI("IdentityCheckerTest testStopInputSession_003 start");
326 IdentityCheckerTest::IdentityCheckerMock::isBroker_ = true;
327 IdentityCheckerTest::IdentityCheckerMock::isFocused_ = true;
328 InputClientInfo clientInfo {};
329 int32_t ret = IdentityCheckerTest::service_->StopInputSession();
330 EXPECT_EQ(ret, ErrorCode::ERROR_CLIENT_NOT_FOUND);
331 }
332
333 /**
334 * @tc.name: testStopInputSession_004
335 * @tc.desc: not broker, is focused app
336 * @tc.type: FUNC
337 * @tc.require:
338 * @tc.author:
339 */
340 HWTEST_F(IdentityCheckerTest, testStopInputSession_004, TestSize.Level1)
341 {
342 IMSA_HILOGI("IdentityCheckerTest testStopInputSession_004 start");
343 IdentityCheckerTest::IdentityCheckerMock::isBroker_ = false;
344 IdentityCheckerTest::IdentityCheckerMock::isFocused_ = true;
345 InputClientInfo clientInfo {};
346 int32_t ret = IdentityCheckerTest::service_->StopInputSession();
347 EXPECT_EQ(ret, ErrorCode::ERROR_CLIENT_NOT_FOUND);
348 }
349
350 /**
351 * @tc.name: testSetCoreAndAgent_001
352 * @tc.desc: not current ime
353 * @tc.type: FUNC
354 * @tc.require:
355 * @tc.author:
356 */
357 HWTEST_F(IdentityCheckerTest, testSetCoreAndAgent_001, TestSize.Level1)
358 {
359 IMSA_HILOGI("IdentityCheckerTest testSetCoreAndAgent_001 start");
360 service_->identityChecker_ = identityCheckerImpl_;
361 int32_t ret = IdentityCheckerTest::service_->SetCoreAndAgent(nullptr, nullptr);
362 EXPECT_EQ(ret, ErrorCode::ERROR_NOT_CURRENT_IME);
363 }
364
365 /**
366 * @tc.name: testSetCoreAndAgent_002
367 * @tc.desc: not current ime
368 * @tc.type: FUNC
369 * @tc.require:
370 * @tc.author:
371 */
372 HWTEST_F(IdentityCheckerTest, testSetCoreAndAgent_002, TestSize.Level1)
373 {
374 IMSA_HILOGI("IdentityCheckerTest testSetCoreAndAgent_002 start");
375 IdentityCheckerTest::IdentityCheckerMock::isBundleNameValid_ = true;
376 int32_t ret = IdentityCheckerTest::service_->SetCoreAndAgent(nullptr, nullptr);
377 EXPECT_EQ(ret, ErrorCode::ERROR_NOT_CURRENT_IME);
378 }
379
380 /**
381 * @tc.name: testUnRegisteredProxyIme_001
382 * @tc.desc: not a sys_basic native sa
383 * @tc.type: FUNC
384 * @tc.require:
385 * @tc.author:
386 */
387 HWTEST_F(IdentityCheckerTest, testUnRegisteredProxyIme_001, TestSize.Level1)
388 {
389 IMSA_HILOGI("IdentityCheckerTest testUnRegisteredProxyIme_001 start");
390 IdentityCheckerTest::IdentityCheckerMock::isNativeSa_ = false;
391 int32_t ret = IdentityCheckerTest::service_->UnRegisteredProxyIme(
392 static_cast<int32_t>(UnRegisteredType::REMOVE_PROXY_IME), nullptr);
393 EXPECT_EQ(ret, ErrorCode::ERROR_STATUS_PERMISSION_DENIED);
394 }
395
396 /**
397 * @tc.name: testIsCurrentIme_001
398 * @tc.desc: not current ime
399 * @tc.type: FUNC
400 * @tc.require:
401 * @tc.author:
402 */
403 HWTEST_F(IdentityCheckerTest, testIsCurrentIme_001, TestSize.Level1)
404 {
405 IMSA_HILOGI("IdentityCheckerTest testIsCurrentIme_001 start");
406 service_->identityChecker_ = identityCheckerImpl_;
407 bool ret = IdentityCheckerTest::service_->IsCurrentIme(MAIN_USER_ID, 0);
408 EXPECT_FALSE(ret);
409 }
410
411 /**
412 * @tc.name: testIsCurrentIme_002
413 * @tc.desc: not current ime
414 * @tc.type: FUNC
415 * @tc.require:
416 * @tc.author:
417 */
418 HWTEST_F(IdentityCheckerTest, testIsCurrentIme_002, TestSize.Level1)
419 {
420 IMSA_HILOGI("IdentityCheckerTest testIsCurrentIme_002 start");
421 IdentityCheckerTest::IdentityCheckerMock::isBundleNameValid_ = true;
422 bool ret = IdentityCheckerTest::service_->IsCurrentIme(MAIN_USER_ID, 0);
423 EXPECT_FALSE(ret);
424 }
425
426 /**
427 * @tc.name: testHideCurrentInput_001
428 * @tc.desc: is broker
429 * @tc.type: FUNC
430 * @tc.require:
431 * @tc.author:
432 */
433 HWTEST_F(IdentityCheckerTest, testHideCurrentInput_001, TestSize.Level1)
434 {
435 IMSA_HILOGI("IdentityCheckerTest testHideCurrentInput_001 start");
436 IdentityCheckerTest::IdentityCheckerMock::isBroker_ = true;
437 int32_t ret = IdentityCheckerTest::service_->HideCurrentInput();
438 EXPECT_EQ(ret, ErrorCode::ERROR_CLIENT_NOT_FOUND);
439 }
440
441 /**
442 * @tc.name: testHideCurrentInput_002
443 * @tc.desc: is not broker, has no PERMISSION_CONNECT_IME_ABILITY
444 * @tc.type: FUNC
445 * @tc.require:
446 * @tc.author:
447 */
448 HWTEST_F(IdentityCheckerTest, testHideCurrentInput_002, TestSize.Level1)
449 {
450 IMSA_HILOGI("IdentityCheckerTest testHideCurrentInput_002 start");
451 IdentityCheckerTest::IdentityCheckerMock::isBroker_ = false;
452 IdentityCheckerTest::IdentityCheckerMock::hasPermission_ = false;
453 int32_t ret = IdentityCheckerTest::service_->HideCurrentInput();
454 EXPECT_EQ(ret, ErrorCode::ERROR_STATUS_PERMISSION_DENIED);
455 }
456
457 /**
458 * @tc.name: testHideCurrentInput_003
459 * @tc.desc: is not broker, has PERMISSION_CONNECT_IME_ABILITY, not focused app
460 * @tc.type: FUNC
461 * @tc.require:
462 * @tc.author:
463 */
464 HWTEST_F(IdentityCheckerTest, testHideCurrentInput_003, TestSize.Level1)
465 {
466 IMSA_HILOGI("IdentityCheckerTest testHideCurrentInput_003 start");
467 IdentityCheckerTest::IdentityCheckerMock::isBroker_ = false;
468 IdentityCheckerTest::IdentityCheckerMock::hasPermission_ = true;
469 IdentityCheckerTest::IdentityCheckerMock::isFocused_ = false;
470 int32_t ret = IdentityCheckerTest::service_->HideCurrentInput();
471 EXPECT_EQ(ret, ErrorCode::ERROR_CLIENT_NOT_FOUND);
472 }
473
474 /**
475 * @tc.name: testShowCurrentInput_001
476 * @tc.desc: is broker
477 * @tc.type: FUNC
478 * @tc.require:
479 * @tc.author:
480 */
481 HWTEST_F(IdentityCheckerTest, testShowCurrentInput_001, TestSize.Level1)
482 {
483 IMSA_HILOGI("IdentityCheckerTest testShowCurrentInput_001 start");
484 IdentityCheckerTest::IdentityCheckerMock::isBroker_ = true;
485 int32_t ret = IdentityCheckerTest::service_->ShowCurrentInput();
486 EXPECT_EQ(ret, ErrorCode::ERROR_CLIENT_NOT_FOUND);
487 }
488
489 /**
490 * @tc.name: testShowCurrentInput_002
491 * @tc.desc: is not broker, has no PERMISSION_CONNECT_IME_ABILITY
492 * @tc.type: FUNC
493 * @tc.require:
494 * @tc.author:
495 */
496 HWTEST_F(IdentityCheckerTest, testShowCurrentInput_002, TestSize.Level1)
497 {
498 IMSA_HILOGI("IdentityCheckerTest testShowCurrentInput_002 start");
499 IdentityCheckerTest::IdentityCheckerMock::isBroker_ = false;
500 IdentityCheckerTest::IdentityCheckerMock::hasPermission_ = false;
501 int32_t ret = IdentityCheckerTest::service_->ShowCurrentInput();
502 EXPECT_EQ(ret, ErrorCode::ERROR_STATUS_PERMISSION_DENIED);
503 }
504
505 /**
506 * @tc.name: testShowCurrentInput_003
507 * @tc.desc: is not broker, has PERMISSION_CONNECT_IME_ABILITY, not focused app
508 * @tc.type: FUNC
509 * @tc.require:
510 * @tc.author:
511 */
512 HWTEST_F(IdentityCheckerTest, testShowCurrentInput_003, TestSize.Level1)
513 {
514 IMSA_HILOGI("IdentityCheckerTest testShowCurrentInput_003 start");
515 IdentityCheckerTest::IdentityCheckerMock::isBroker_ = false;
516 IdentityCheckerTest::IdentityCheckerMock::hasPermission_ = true;
517 IdentityCheckerTest::IdentityCheckerMock::isFocused_ = false;
518 int32_t ret = IdentityCheckerTest::service_->ShowCurrentInput();
519 EXPECT_EQ(ret, ErrorCode::ERROR_CLIENT_NOT_FOUND);
520 }
521
522 /**
523 * @tc.name: testPanelStatusChange_001
524 * @tc.desc: not current ime
525 * @tc.type: FUNC
526 * @tc.require:
527 * @tc.author:
528 */
529 HWTEST_F(IdentityCheckerTest, testPanelStatusChange_001, TestSize.Level1)
530 {
531 IMSA_HILOGI("IdentityCheckerTest testPanelStatusChange_001 start");
532 service_->identityChecker_ = identityCheckerImpl_;
533 InputWindowStatus status = InputWindowStatus::SHOW;
534 ImeWindowInfo info {};
535 int32_t ret = IdentityCheckerTest::service_->PanelStatusChange(static_cast<uint32_t>(status), info);
536 EXPECT_EQ(ret, ErrorCode::ERROR_NOT_CURRENT_IME);
537 }
538
539 /**
540 * @tc.name: testPanelStatusChange_002
541 * @tc.desc: not current ime
542 * @tc.type: FUNC
543 * @tc.require:
544 * @tc.author:
545 */
546 HWTEST_F(IdentityCheckerTest, testPanelStatusChange_002, TestSize.Level1)
547 {
548 IMSA_HILOGI("IdentityCheckerTest testPanelStatusChange_002 start");
549 IdentityCheckerTest::IdentityCheckerMock::isBundleNameValid_ = true;
550 InputWindowStatus status = InputWindowStatus::SHOW;
551 ImeWindowInfo info {};
552 int32_t ret = IdentityCheckerTest::service_->PanelStatusChange(static_cast<uint32_t>(status), info);
553 EXPECT_EQ(ret, ErrorCode::ERROR_NOT_CURRENT_IME);
554 }
555
556 /**
557 * @tc.name: testUpdateListenEventFlag_001
558 * @tc.desc: not system app, not native SA
559 * @tc.type: FUNC
560 * @tc.require:
561 * @tc.author:
562 */
563 HWTEST_F(IdentityCheckerTest, testUpdateListenEventFlag_001, TestSize.Level1)
564 {
565 IMSA_HILOGI("IdentityCheckerTest testUpdateListenEventFlag_001 start");
566 service_->identityChecker_ = identityCheckerImpl_;
567 InputClientInfoInner clientInfo {};
568 int32_t ret = IdentityCheckerTest::service_->UpdateListenEventFlag(clientInfo, EVENT_IME_SHOW_MASK);
569 EXPECT_EQ(ret, ErrorCode::ERROR_STATUS_SYSTEM_PERMISSION);
570
571 ret = IdentityCheckerTest::service_->UpdateListenEventFlag(clientInfo, EVENT_IME_HIDE_MASK);
572 EXPECT_EQ(ret, ErrorCode::ERROR_STATUS_SYSTEM_PERMISSION);
573
574 ret = IdentityCheckerTest::service_->UpdateListenEventFlag(clientInfo, EVENT_IME_CHANGE_MASK);
575 EXPECT_EQ(ret, ErrorCode::ERROR_IMSA_NULLPTR);
576 }
577
578 /**
579 * @tc.name: testUpdateListenEventFlag_002
580 * @tc.desc: is system app, not native SA
581 * @tc.type: FUNC
582 * @tc.require:
583 * @tc.author:
584 */
585 HWTEST_F(IdentityCheckerTest, testUpdateListenEventFlag_002, TestSize.Level1)
586 {
587 IMSA_HILOGI("IdentityCheckerTest testUpdateListenEventFlag_002 start");
588 IdentityCheckerTest::IdentityCheckerMock::isSystemApp_ = true;
589 IdentityCheckerTest::IdentityCheckerMock::isNativeSa_ = false;
590 InputClientInfoInner clientInfo {};
591 int32_t ret = IdentityCheckerTest::service_->UpdateListenEventFlag(clientInfo, EVENT_IME_SHOW_MASK);
592 EXPECT_EQ(ret, ErrorCode::ERROR_IMSA_NULLPTR);
593
594 ret = IdentityCheckerTest::service_->UpdateListenEventFlag(clientInfo, EVENT_IME_HIDE_MASK);
595 EXPECT_EQ(ret, ErrorCode::ERROR_IMSA_NULLPTR);
596
597 ret = IdentityCheckerTest::service_->UpdateListenEventFlag(clientInfo, EVENT_IME_CHANGE_MASK);
598 EXPECT_EQ(ret, ErrorCode::ERROR_IMSA_NULLPTR);
599 }
600
601 /**
602 * @tc.name: testUpdateListenEventFlag_003
603 * @tc.desc: is native SA, not system app
604 * @tc.type: FUNC
605 * @tc.require:
606 * @tc.author:
607 */
608 HWTEST_F(IdentityCheckerTest, testUpdateListenEventFlag_003, TestSize.Level1)
609 {
610 IMSA_HILOGI("IdentityCheckerTest testUpdateListenEventFlag_003 start");
611 IdentityCheckerTest::IdentityCheckerMock::isSystemApp_ = false;
612 IdentityCheckerTest::IdentityCheckerMock::isNativeSa_ = true;
613 InputClientInfoInner clientInfo {};
614 int32_t ret = IdentityCheckerTest::service_->UpdateListenEventFlag(clientInfo, EVENT_IME_SHOW_MASK);
615 EXPECT_EQ(ret, ErrorCode::ERROR_IMSA_NULLPTR);
616
617 ret = IdentityCheckerTest::service_->UpdateListenEventFlag(clientInfo, EVENT_IME_HIDE_MASK);
618 EXPECT_EQ(ret, ErrorCode::ERROR_IMSA_NULLPTR);
619
620 ret = IdentityCheckerTest::service_->UpdateListenEventFlag(clientInfo, EVENT_IME_CHANGE_MASK);
621 EXPECT_EQ(ret, ErrorCode::ERROR_IMSA_NULLPTR);
622 }
623
624 /**
625 * @tc.name: testDisplayOptionalInputMethod_001
626 * @tc.desc: has no PERMISSION
627 * @tc.type: FUNC
628 * @tc.require:
629 * @tc.author:
630 */
631 HWTEST_F(IdentityCheckerTest, testDisplayOptionalInputMethod_001, TestSize.Level1)
632 {
633 IMSA_HILOGI("IdentityCheckerTest testDisplayOptionalInputMethod_001 start");
634 service_->identityChecker_ = identityCheckerImpl_;
635 int32_t ret = IdentityCheckerTest::service_->DisplayOptionalInputMethod();
636 EXPECT_EQ(ret, ErrorCode::ERROR_EX_SERVICE_SPECIFIC);
637 }
638
639 /**
640 * @tc.name: testSwitchInputMethod_001
641 * @tc.desc: has no PERMISSION_CONNECT_IME_ABILITY, and not currentIme switch subtype
642 * @tc.type: FUNC
643 * @tc.require:
644 * @tc.author:
645 */
646 HWTEST_F(IdentityCheckerTest, testSwitchInputMethod_001, TestSize.Level1)
647 {
648 IMSA_HILOGI("IdentityCheckerTest testSwitchInputMethod_001 start");
649 ImeEnabledCfg cfg;
650 ImeEnabledInfo enabledInfo{ CURRENT_BUNDLENAME, CURRENT_EXTNAME, EnabledStatus::BASIC_MODE };
651 enabledInfo.extraInfo.isDefaultIme = true;
652 cfg.enabledInfos.push_back(enabledInfo);
653 ImeEnabledInfoManager::GetInstance().imeEnabledCfg_.insert_or_assign(MAIN_USER_ID, cfg);
654 service_->identityChecker_ = identityCheckerImpl_;
655 int32_t ret = IdentityCheckerTest::service_->SwitchInputMethod(
656 CURRENT_BUNDLENAME, CURRENT_SUBNAME, static_cast<uint32_t>(SwitchTrigger::CURRENT_IME));
657 EXPECT_EQ(ret, ErrorCode::ERROR_STATUS_PERMISSION_DENIED);
658 }
659
660 /**
661 * @tc.name: testSwitchInputMethod_003
662 * @tc.desc: has PERMISSION_CONNECT_IME_ABILITY, not currentIme switch subtype
663 * @tc.type: FUNC
664 * @tc.require:
665 * @tc.author:
666 */
667 HWTEST_F(IdentityCheckerTest, testSwitchInputMethod_003, TestSize.Level1)
668 {
669 IMSA_HILOGI("IdentityCheckerTest testSwitchInputMethod_003 start");
670 ImeEnabledCfg cfg;
671 ImeEnabledInfo enabledInfo{ CURRENT_BUNDLENAME, CURRENT_EXTNAME, EnabledStatus::BASIC_MODE };
672 enabledInfo.extraInfo.isDefaultIme = true;
673 cfg.enabledInfos.push_back(enabledInfo);
674 ImeEnabledInfoManager::GetInstance().imeEnabledCfg_.insert_or_assign(MAIN_USER_ID, cfg);
675 IdentityCheckerTest::IdentityCheckerMock::hasPermission_ = true;
676 IdentityCheckerTest::IdentityCheckerMock::isBundleNameValid_ = false;
677 int32_t ret = IdentityCheckerTest::service_->SwitchInputMethod(
678 CURRENT_BUNDLENAME, CURRENT_SUBNAME, static_cast<uint32_t>(SwitchTrigger::CURRENT_IME));
679 EXPECT_EQ(ret, ErrorCode::ERROR_IMSA_GET_IME_INFO_FAILED);
680 }
681
682 /**
683 * @tc.name: testSwitchInputMethod_004
684 * @tc.desc: has PERMISSION_CONNECT_IME_ABILITY, not currentIme switch subtype
685 * @tc.type: FUNC
686 * @tc.require:
687 * @tc.author:
688 */
689 HWTEST_F(IdentityCheckerTest, testSwitchInputMethod_004, TestSize.Level1)
690 {
691 IMSA_HILOGI("IdentityCheckerTest testSwitchInputMethod_004 start");
692 ImeEnabledCfg cfg;
693 ImeEnabledInfo enabledInfo{ CURRENT_BUNDLENAME, CURRENT_EXTNAME, EnabledStatus::BASIC_MODE };
694 enabledInfo.extraInfo.isDefaultIme = true;
695 cfg.enabledInfos.push_back(enabledInfo);
696 ImeEnabledInfoManager::GetInstance().imeEnabledCfg_.insert_or_assign(MAIN_USER_ID, cfg);
697 service_->identityChecker_ = identityCheckerImpl_;
698 IdentityCheckerTest::IdentityCheckerMock::isFromShell_ = true;
699 IdentityCheckerTest::IdentityCheckerMock::isBundleNameValid_ = false;
700 int32_t ret = IdentityCheckerTest::service_->SwitchInputMethod(
701 CURRENT_BUNDLENAME, CURRENT_SUBNAME, static_cast<uint32_t>(SwitchTrigger::NATIVE_SA));
702 EXPECT_EQ(ret, ErrorCode::ERROR_IMSA_GET_IME_INFO_FAILED);
703 }
704
705 /**
706 * @tc.name: testHideCurrentInputDeprecated_001
707 * @tc.desc: is broker
708 * @tc.type: FUNC
709 * @tc.require:
710 * @tc.author:
711 */
712 HWTEST_F(IdentityCheckerTest, testHideCurrentInputDeprecated_001, TestSize.Level1)
713 {
714 IMSA_HILOGI("IdentityCheckerTest testHideCurrentInputDeprecated_001 start");
715 IdentityCheckerTest::IdentityCheckerMock::isBroker_ = true;
716 int32_t ret = IdentityCheckerTest::service_->HideCurrentInputDeprecated();
717 EXPECT_EQ(ret, ErrorCode::ERROR_CLIENT_NOT_FOUND);
718 }
719
720 /**
721 * @tc.name: testHideCurrentInputDeprecated_002
722 * @tc.desc: is not broker, not focused app
723 * @tc.type: FUNC
724 * @tc.require:
725 * @tc.author:
726 */
727 HWTEST_F(IdentityCheckerTest, testHideCurrentInputDeprecated_002, TestSize.Level1)
728 {
729 IMSA_HILOGI("IdentityCheckerTest testHideCurrentInputDeprecated_002 start");
730 IdentityCheckerTest::IdentityCheckerMock::isBroker_ = false;
731 IdentityCheckerTest::IdentityCheckerMock::isFocused_ = false;
732 int32_t ret = IdentityCheckerTest::service_->HideCurrentInputDeprecated();
733 EXPECT_EQ(ret, ErrorCode::ERROR_CLIENT_NOT_FOCUSED);
734 }
735
736 /**
737 * @tc.name: testHideCurrentInputDeprecated_003
738 * @tc.desc: is not broker, is focused app
739 * @tc.type: FUNC
740 * @tc.require:
741 * @tc.author:
742 */
743 HWTEST_F(IdentityCheckerTest, testHideCurrentInputDeprecated_003, TestSize.Level1)
744 {
745 IMSA_HILOGI("IdentityCheckerTest testHideCurrentInputDeprecated_003 start");
746 IdentityCheckerTest::IdentityCheckerMock::isBroker_ = false;
747 IdentityCheckerTest::IdentityCheckerMock::isFocused_ = true;
748 int32_t ret = IdentityCheckerTest::service_->HideCurrentInputDeprecated();
749 EXPECT_EQ(ret, ErrorCode::ERROR_CLIENT_NOT_FOUND);
750 }
751
752 /**
753 * @tc.name: testShowCurrentInputDeprecated_001
754 * @tc.desc: is broker
755 * @tc.type: FUNC
756 * @tc.require:
757 * @tc.author:
758 */
759 HWTEST_F(IdentityCheckerTest, testShowCurrentInputDeprecated_001, TestSize.Level1)
760 {
761 IMSA_HILOGI("IdentityCheckerTest testShowCurrentInputDeprecated_001 start");
762 IdentityCheckerTest::IdentityCheckerMock::isBroker_ = true;
763 int32_t ret = IdentityCheckerTest::service_->ShowCurrentInputDeprecated();
764 EXPECT_EQ(ret, ErrorCode::ERROR_CLIENT_NOT_FOUND);
765 }
766
767 /**
768 * @tc.name: testShowCurrentInputDeprecated_002
769 * @tc.desc: is not broker, not focused app
770 * @tc.type: FUNC
771 * @tc.require:
772 * @tc.author:
773 */
774 HWTEST_F(IdentityCheckerTest, testShowCurrentInputDeprecated_002, TestSize.Level1)
775 {
776 IMSA_HILOGI("IdentityCheckerTest testShowCurrentInputDeprecated_002 start");
777 IdentityCheckerTest::IdentityCheckerMock::isBroker_ = false;
778 IdentityCheckerTest::IdentityCheckerMock::isFocused_ = false;
779 int32_t ret = IdentityCheckerTest::service_->ShowCurrentInputDeprecated();
780 EXPECT_EQ(ret, ErrorCode::ERROR_CLIENT_NOT_FOCUSED);
781 }
782
783 /**
784 * @tc.name: testShowCurrentInputDeprecated_003
785 * @tc.desc: is not broker, is focused app
786 * @tc.type: FUNC
787 * @tc.require:
788 * @tc.author:
789 */
790 HWTEST_F(IdentityCheckerTest, testShowCurrentInputDeprecated_003, TestSize.Level1)
791 {
792 IMSA_HILOGI("IdentityCheckerTest testShowCurrentInputDeprecated_003 start");
793 IdentityCheckerTest::IdentityCheckerMock::isBroker_ = false;
794 IdentityCheckerTest::IdentityCheckerMock::isFocused_ = true;
795 int32_t ret = IdentityCheckerTest::service_->ShowCurrentInputDeprecated();
796 EXPECT_EQ(ret, ErrorCode::ERROR_CLIENT_NOT_FOUND);
797 }
798
TEST_F(IdentityCheckerTest,OnExtension_extensionIsEmpty_ReturnsOK)799 TEST_F(IdentityCheckerTest, OnExtension_extensionIsEmpty_ReturnsOK)
800 {
801 MessageParcel data;
802 MessageParcel reply;
803 EXPECT_EQ(service_->OnExtension("", data, reply), 0);
804 }
805
TEST_F(IdentityCheckerTest,OnExtension_dataIsEmpty_ReturnsBadParam)806 TEST_F(IdentityCheckerTest, OnExtension_dataIsEmpty_ReturnsBadParam)
807 {
808 MessageParcel data;
809 MessageParcel reply;
810 EXPECT_EQ(service_->OnExtension("restore", data, reply), ErrorCode::ERROR_BAD_PARAMETERS);
811 }
812
TEST_F(IdentityCheckerTest,OnExtension_BundleNameIsInvalid_ReturnsBadParam)813 TEST_F(IdentityCheckerTest, OnExtension_BundleNameIsInvalid_ReturnsBadParam)
814 {
815 MessageParcel data;
816 data.WriteFileDescriptor(1);
817 data.WriteString("[{\"type\":\"default_input_method\",\"detail\":\"com.invalid.bundleName\"}]");
818 MessageParcel reply;
819 EXPECT_EQ(service_->OnExtension("restore", data, reply), ErrorCode::ERROR_BAD_PARAMETERS);
820 }
821
TEST_F(IdentityCheckerTest,GetRestoreBundleName_EmptyJsonString_ReturnsEmpty)822 TEST_F(IdentityCheckerTest, GetRestoreBundleName_EmptyJsonString_ReturnsEmpty)
823 {
824 MessageParcel data;
825 data.WriteString("");
826 std::string bundleName = service_->GetRestoreBundleName(data);
827 EXPECT_EQ(bundleName, "");
828 }
829
TEST_F(IdentityCheckerTest,GetRestoreBundleName_InvalidJsonString_ReturnsEmpty)830 TEST_F(IdentityCheckerTest, GetRestoreBundleName_InvalidJsonString_ReturnsEmpty)
831 {
832 MessageParcel data;
833 data.WriteString("{invalid json}");
834 std::string bundleName = service_->GetRestoreBundleName(data);
835 EXPECT_EQ(bundleName, "");
836 }
837
TEST_F(IdentityCheckerTest,GetRestoreBundleName_ValidJsonWithoutDefaultInputMethod_ReturnsEmpty)838 TEST_F(IdentityCheckerTest, GetRestoreBundleName_ValidJsonWithoutDefaultInputMethod_ReturnsEmpty)
839 {
840 MessageParcel data;
841 data.WriteString("[{\"type\":\"other_type\",\"detail\":\"some_detail\"}]");
842 std::string bundleName = service_->GetRestoreBundleName(data);
843 EXPECT_EQ(bundleName, "");
844 }
845
TEST_F(IdentityCheckerTest,GetRestoreBundleName_ValidJsonWithDefaultInputMethod_ReturnsBundleName)846 TEST_F(IdentityCheckerTest, GetRestoreBundleName_ValidJsonWithDefaultInputMethod_ReturnsBundleName)
847 {
848 MessageParcel data;
849 data.WriteString("[{\"type\":\"default_input_method\",\"detail\":\"com.example.inputmethod\"}]");
850 std::string bundleName = service_->GetRestoreBundleName(data);
851 EXPECT_EQ(bundleName, "com.example.inputmethod");
852 }
853
TEST_F(IdentityCheckerTest,GetRestoreBundleName_MissingTypeOrDetail_ReturnsEmpty)854 TEST_F(IdentityCheckerTest, GetRestoreBundleName_MissingTypeOrDetail_ReturnsEmpty)
855 {
856 MessageParcel data;
857 data.WriteString("[{\"type\":\"default_input_method\"}]");
858 std::string bundleName = service_->GetRestoreBundleName(data);
859 EXPECT_EQ(bundleName, "");
860 }
861 } // namespace MiscServices
862 } // namespace OHOS