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