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