1 /*
2  * Copyright (C) 2022 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include <gtest/gtest.h>
17 #include <memory>
18 #include "accessibility_common_helper.h"
19 #include "accessibility_system_ability_client_impl.h"
20 #include "mock_accessibility_element_operator.h"
21 
22 using namespace testing;
23 using namespace testing::ext;
24 
25 namespace OHOS {
26 namespace Accessibility {
27 namespace {
28     constexpr int32_t WINDOW_ID = 1;
29     constexpr int32_t REQUEST_ID = 1;
30     constexpr int64_t COMPONENT_ID = 1;
31     constexpr uint32_t WINDOW_ID_MASK = 16;
32 } // namespace
33 
34 class AccessibilitySystemAbilityClientImplTest : public ::testing::Test {
35 public:
AccessibilitySystemAbilityClientImplTest()36     AccessibilitySystemAbilityClientImplTest()
37     {}
~AccessibilitySystemAbilityClientImplTest()38     ~AccessibilitySystemAbilityClientImplTest()
39     {}
40     std::shared_ptr<AccessibilitySystemAbilityClientImpl> impl_ = nullptr;
41 
SetUpTestCase()42     static void SetUpTestCase()
43     {
44         GTEST_LOG_(INFO) << "AccessibilitySystemAbilityClientImplTest Start";
45     }
TearDownTestCase()46     static void TearDownTestCase()
47     {
48         GTEST_LOG_(INFO) << "AccessibilitySystemAbilityClientImplTest End";
49     }
SetUp()50     void SetUp()
51     {
52         GTEST_LOG_(INFO) << "AccessibilitySystemAbilityClientImplTest SetUp()";
53     };
TearDown()54     void TearDown()
55     {
56         GTEST_LOG_(INFO) << "AccessibilitySystemAbilityClientImplTest TearDown()";
57     }
58 };
59 
60 
61 /**
62  * @tc.number: RegisterElementOperator_001
63  * @tc.name: RegisterElementOperator
64  * @tc.desc: Test function RegisterElementOperator(parameter is null)
65  */
66 HWTEST_F(AccessibilitySystemAbilityClientImplTest, RegisterElementOperator_001, TestSize.Level1)
67 {
68     GTEST_LOG_(INFO) << "RegisterElementOperator_001 start";
69     impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>();
70     if (!impl_) {
71         GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_";
72         return;
73     }
74     EXPECT_EQ(RET_ERR_INVALID_PARAM, impl_->RegisterElementOperator(WINDOW_ID, nullptr));
75     impl_ = nullptr;
76     GTEST_LOG_(INFO) << "RegisterElementOperator_001 end";
77 }
78 
79 /**
80  * @tc.number: RegisterElementOperator_002
81  * @tc.name: RegisterElementOperator
82  * @tc.desc: Test function RegisterElementOperator(parameter is not null, proxy is null)
83  */
84 HWTEST_F(AccessibilitySystemAbilityClientImplTest, RegisterElementOperator_002, TestSize.Level1)
85 {
86     GTEST_LOG_(INFO) << "RegisterElementOperator_002 start";
87     impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>();
88     if (!impl_) {
89         GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_";
90         return;
91     }
92     std::shared_ptr<AccessibilityElementOperator> mockOperator = std::make_shared<MockAccessibilityElementOperator>();
93     EXPECT_EQ(RET_ERR_SAMGR, impl_->RegisterElementOperator(WINDOW_ID, mockOperator));
94     impl_ = nullptr;
95     GTEST_LOG_(INFO) << "RegisterElementOperator_002 end";
96 }
97 
98 /**
99  * @tc.number: RegisterElementOperator_003
100  * @tc.name: RegisterElementOperator
101  * @tc.desc: Test function RegisterElementOperator(register success)
102  */
103 HWTEST_F(AccessibilitySystemAbilityClientImplTest, RegisterElementOperator_003, TestSize.Level1)
104 {
105     GTEST_LOG_(INFO) << "RegisterElementOperator_003 start";
106     AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(true);
107     impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>();
108     AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(false);
109     if (!impl_) {
110         GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_";
111         return;
112     }
113     std::shared_ptr<AccessibilityElementOperator> mockOperator = std::make_shared<MockAccessibilityElementOperator>();
114     EXPECT_EQ(RET_OK, impl_->RegisterElementOperator(WINDOW_ID, mockOperator));
115     impl_ = nullptr;
116     GTEST_LOG_(INFO) << "RegisterElementOperator_003 end";
117 }
118 
119 /**
120  * @tc.number: RegisterElementOperator_004
121  * @tc.name: RegisterElementOperator
122  * @tc.desc: Test function RegisterElementOperator(register fail)
123  */
124 HWTEST_F(AccessibilitySystemAbilityClientImplTest, RegisterElementOperator_004, TestSize.Level1)
125 {
126     GTEST_LOG_(INFO) << "RegisterElementOperator_004 start";
127     AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(true);
128     impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>();
129     AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(false);
130     if (!impl_) {
131         GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_";
132         return;
133     }
134     std::shared_ptr<AccessibilityElementOperator> mockOperator = std::make_shared<MockAccessibilityElementOperator>();
135     EXPECT_EQ(RET_OK, impl_->RegisterElementOperator(WINDOW_ID, mockOperator));
136     impl_ = nullptr;
137     GTEST_LOG_(INFO) << "RegisterElementOperator_004 end";
138 }
139 
140 /**
141  * @tc.number: DeregisterElementOperator_001
142  * @tc.name: DeregisterElementOperator
143  * @tc.desc: Test function DeregisterElementOperator
144  */
145 HWTEST_F(AccessibilitySystemAbilityClientImplTest, DeregisterElementOperator_001, TestSize.Level1)
146 {
147     GTEST_LOG_(INFO) << "DeregisterElementOperator_001 start";
148     impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>();
149     if (!impl_) {
150         GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_";
151         return;
152     }
153     EXPECT_EQ(RET_ERR_SAMGR, impl_->DeregisterElementOperator(WINDOW_ID));
154     impl_ = nullptr;
155     GTEST_LOG_(INFO) << "DeregisterElementOperator_001 end";
156 }
157 
158 /**
159  * @tc.number: DeregisterElementOperator_002
160  * @tc.name: DeregisterElementOperator
161  * @tc.desc: Test function DeregisterElementOperator
162  */
163 HWTEST_F(AccessibilitySystemAbilityClientImplTest, DeregisterElementOperator_002, TestSize.Level1)
164 {
165     GTEST_LOG_(INFO) << "DeregisterElementOperator_002 start";
166     AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(true);
167     impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>();
168     AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(false);
169     if (!impl_) {
170         GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_";
171         return;
172     }
173     std::shared_ptr<AccessibilityElementOperator> mockOperator = std::make_shared<MockAccessibilityElementOperator>();
174     EXPECT_EQ(RET_OK, impl_->RegisterElementOperator(WINDOW_ID, mockOperator));
175     EXPECT_EQ(RET_OK, impl_->DeregisterElementOperator(WINDOW_ID));
176     impl_ = nullptr;
177     GTEST_LOG_(INFO) << "DeregisterElementOperator_002 end";
178 }
179 
180 /**
181  * @tc.number: GetAbilityList_001
182  * @tc.name: GetAbilityList
183  * @tc.desc: Test function GetAbilityList
184  */
185 HWTEST_F(AccessibilitySystemAbilityClientImplTest, GetAbilityList_001, TestSize.Level1)
186 {
187     GTEST_LOG_(INFO) << "GetAbilityList_001 start";
188     impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>();
189     if (!impl_) {
190         GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_";
191         return;
192     }
193 
194     std::vector<AccessibilityAbilityInfo> infos {};
195     auto ret = impl_->GetAbilityList(ACCESSIBILITY_ABILITY_TYPE_ALL, ABILITY_STATE_INVALID, infos);
196     EXPECT_EQ(RET_ERR_INVALID_PARAM, ret);
197     impl_ = nullptr;
198     GTEST_LOG_(INFO) << "GetAbilityList_001 end";
199 }
200 
201 /**
202  * @tc.number: GetAbilityList_002
203  * @tc.name: GetAbilityList
204  * @tc.desc: Test function GetAbilityList(proxy is null)
205  */
206 HWTEST_F(AccessibilitySystemAbilityClientImplTest, GetAbilityList_002, TestSize.Level1)
207 {
208     GTEST_LOG_(INFO) << "GetAbilityList_002 start";
209     impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>();
210     if (!impl_) {
211         GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_";
212         return;
213     }
214 
215     std::vector<AccessibilityAbilityInfo> infos {};
216     auto ret = impl_->GetAbilityList(ACCESSIBILITY_ABILITY_TYPE_ALL, ABILITY_STATE_ENABLE, infos);
217     EXPECT_EQ(RET_ERR_SAMGR, ret);
218     impl_ = nullptr;
219     GTEST_LOG_(INFO) << "GetAbilityList_002 end";
220 }
221 
222 /**
223  * @tc.number: GetAbilityList_003
224  * @tc.name: GetAbilityList
225  * @tc.desc: Test function GetAbilityList(proxy is not null)
226  */
227 HWTEST_F(AccessibilitySystemAbilityClientImplTest, GetAbilityList_003, TestSize.Level1)
228 {
229     GTEST_LOG_(INFO) << "GetAbilityList_003 start";
230     AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(true);
231     impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>();
232     AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(false);
233     if (!impl_) {
234         GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_";
235         return;
236     }
237 
238     std::vector<AccessibilityAbilityInfo> infos {};
239     auto ret = impl_->GetAbilityList(ACCESSIBILITY_ABILITY_TYPE_ALL, ABILITY_STATE_ENABLE, infos);
240     EXPECT_EQ(RET_OK, ret);
241     impl_ = nullptr;
242     GTEST_LOG_(INFO) << "GetAbilityList_003 end";
243 }
244 
245 /**
246  * @tc.number: IsEnabled_001
247  * @tc.name: IsEnabled
248  * @tc.desc: Test function IsEnabled
249  */
250 HWTEST_F(AccessibilitySystemAbilityClientImplTest, IsEnabled_001, TestSize.Level1)
251 {
252     GTEST_LOG_(INFO) << "IsEnabled_001 start";
253     impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>();
254     if (!impl_) {
255         GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_";
256         return;
257     }
258     bool isEnable = false;
259     impl_->IsEnabled(isEnable);
260     EXPECT_FALSE(isEnable);
261     impl_ = nullptr;
262     GTEST_LOG_(INFO) << "IsEnabled_001 end";
263 }
264 
265 /**
266  * @tc.number: IsTouchExplorationEnabled_001
267  * @tc.name: IsTouchExplorationEnabled
268  * @tc.desc: Test function IsTouchExplorationEnabled
269  */
270 HWTEST_F(AccessibilitySystemAbilityClientImplTest, IsTouchExplorationEnabled_001, TestSize.Level1)
271 {
272     GTEST_LOG_(INFO) << "IsTouchExplorationEnabled_001 start";
273     impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>();
274     if (!impl_) {
275         GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_";
276         return;
277     }
278     bool isEnable = false;
279     impl_->IsTouchExplorationEnabled(isEnable);
280     EXPECT_FALSE(isEnable);
281     impl_ = nullptr;
282     GTEST_LOG_(INFO) << "IsTouchExplorationEnabled_001 end";
283 }
284 
285 /**
286  * @tc.number: SendEvent_001
287  * @tc.name: SendEvent
288  * @tc.desc: Test function SendEvent(proxy is null)
289  */
290 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SendEvent_001, TestSize.Level1)
291 {
292     GTEST_LOG_(INFO) << "SendEvent_001 start";
293     impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>();
294     if (!impl_) {
295         GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_";
296         return;
297     }
298     EXPECT_EQ(RET_ERR_SAMGR, impl_->SendEvent(TYPE_VIEW_LONG_CLICKED_EVENT, COMPONENT_ID));
299     impl_ = nullptr;
300     GTEST_LOG_(INFO) << "SendEvent_001 end";
301 }
302 
303 /**
304  * @tc.number: SendEvent_002
305  * @tc.name: SendEvent
306  * @tc.desc: Test function SendEvent(invalid type)
307  */
308 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SendEvent_002, TestSize.Level1)
309 {
310     GTEST_LOG_(INFO) << "SendEvent_002 start";
311     impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>();
312     if (!impl_) {
313         GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_";
314         return;
315     }
316     EXPECT_EQ(RET_ERR_INVALID_PARAM, impl_->SendEvent(TYPE_VIEW_INVALID, COMPONENT_ID));
317     impl_ = nullptr;
318     GTEST_LOG_(INFO) << "SendEvent_002 end";
319 }
320 
321 /**
322  * @tc.number: SendEvent_003
323  * @tc.name: SendEvent
324  * @tc.desc: Test function SendEvent(proxy is not null)
325  */
326 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SendEvent_003, TestSize.Level1)
327 {
328     GTEST_LOG_(INFO) << "SendEvent_003 start";
329     AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(true);
330     impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>();
331     AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(false);
332     if (!impl_) {
333         GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_";
334         return;
335     }
336     EXPECT_EQ(RET_OK, impl_->SendEvent(TYPE_VIEW_LONG_CLICKED_EVENT, COMPONENT_ID));
337     impl_ = nullptr;
338     GTEST_LOG_(INFO) << "SendEvent_003 end";
339 }
340 
341 /**
342  * @tc.number: SendEvent_004
343  * @tc.name: SendEvent
344  * @tc.desc: Test function SendEvent(proxy is null)
345  */
346 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SendEvent_004, TestSize.Level1)
347 {
348     GTEST_LOG_(INFO) << "SendEvent_004 start";
349     impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>();
350     if (!impl_) {
351         GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_";
352         return;
353     }
354     AccessibilityEventInfo event {};
355     event.SetEventType(TYPE_VIEW_LONG_CLICKED_EVENT);
356     EXPECT_EQ(RET_ERR_SAMGR, impl_->SendEvent(event));
357     impl_ = nullptr;
358     GTEST_LOG_(INFO) << "SendEvent_004 end";
359 }
360 
361 /**
362  * @tc.number: SendEvent_005
363  * @tc.name: SendEvent
364  * @tc.desc: Test function SendEvent(invalid type)
365  */
366 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SendEvent_005, TestSize.Level1)
367 {
368     GTEST_LOG_(INFO) << "SendEvent_005 start";
369     impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>();
370     if (!impl_) {
371         GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_";
372         return;
373     }
374     AccessibilityEventInfo event {};
375     event.SetEventType(TYPE_VIEW_INVALID);
376     EXPECT_EQ(RET_ERR_INVALID_PARAM, impl_->SendEvent(event));
377     impl_ = nullptr;
378     GTEST_LOG_(INFO) << "SendEvent_005 end";
379 }
380 
381 /**
382  * @tc.number: SendEvent_006
383  * @tc.name: SendEvent
384  * @tc.desc: Test function SendEvent(proxy is not null)
385  */
386 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SendEvent_006, TestSize.Level1)
387 {
388     GTEST_LOG_(INFO) << "SendEvent_006 start";
389     AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(true);
390     impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>();
391     AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(false);
392     if (!impl_) {
393         GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_";
394         return;
395     }
396     AccessibilityEventInfo event {};
397     event.SetEventType(TYPE_VIEW_LONG_CLICKED_EVENT);
398     EXPECT_EQ(RET_OK, impl_->SendEvent(event));
399     impl_ = nullptr;
400     GTEST_LOG_(INFO) << "SendEvent_006 end";
401 }
402 
403 /**
404  * @tc.number: SendEvent_007
405  * @tc.name: SendEvent
406  * @tc.desc: Test function SendEvent(proxy is null)
407  */
408 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SendEvent_007, TestSize.Level1)
409 {
410     GTEST_LOG_(INFO) << "SendEvent_007 start";
411     impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>();
412     if (!impl_) {
413         GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_";
414         return;
415     }
416     AccessibilityEventInfo event {};
417     event.SetEventType(TYPE_VIEW_FOCUSED_EVENT);
418     EXPECT_EQ(RET_ERR_SAMGR, impl_->SendEvent(event));
419     impl_ = nullptr;
420     GTEST_LOG_(INFO) << "SendEvent_007 end";
421 }
422 
423 /**
424  * @tc.number: SubscribeStateObserver_001
425  * @tc.name: SubscribeStateObserver
426  * @tc.desc: Test function SubscribeStateObserver
427  */
428 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SubscribeStateObserver_001, TestSize.Level1)
429 {
430     GTEST_LOG_(INFO) << "SubscribeStateObserver_001 start";
431     impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>();
432     if (!impl_) {
433         GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_";
434         return;
435     }
436     EXPECT_EQ(RET_ERR_INVALID_PARAM, impl_->SubscribeStateObserver(nullptr, EVENT_TOUCH_GUIDE_STATE_CHANGED));
437     impl_ = nullptr;
438     GTEST_LOG_(INFO) << "SubscribeStateObserver_001 end";
439 }
440 
441 /**
442  * @tc.number: SubscribeStateObserver_002
443  * @tc.name: SubscribeStateObserver
444  * @tc.desc: Test function SubscribeStateObserver
445  */
446 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SubscribeStateObserver_002, TestSize.Level1)
447 {
448     GTEST_LOG_(INFO) << "SubscribeStateObserver_002 start";
449     impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>();
450     if (!impl_) {
451         GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_";
452         return;
453     }
454     EXPECT_EQ(RET_ERR_INVALID_PARAM, impl_->SubscribeStateObserver(nullptr, EVENT_TYPE_MAX));
455     impl_ = nullptr;
456     GTEST_LOG_(INFO) << "SubscribeStateObserver_002 end";
457 }
458 
459 /**
460  * @tc.number: UnsubscribeStateObserver_001
461  * @tc.name: UnsubscribeStateObserver
462  * @tc.desc: Test function UnsubscribeStateObserver(invalid parameter)
463  */
464 HWTEST_F(AccessibilitySystemAbilityClientImplTest, UnsubscribeStateObserver_001, TestSize.Level1)
465 {
466     GTEST_LOG_(INFO) << "UnsubscribeStateObserver_001 start";
467     impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>();
468     if (!impl_) {
469         GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_";
470         return;
471     }
472     EXPECT_EQ(RET_ERR_INVALID_PARAM, impl_->UnsubscribeStateObserver(nullptr, EVENT_TYPE_MAX));
473     impl_ = nullptr;
474     GTEST_LOG_(INFO) << "UnsubscribeStateObserver_001 end";
475 }
476 
477 /**
478  * @tc.number: UnsubscribeStateObserver_002
479  * @tc.name: UnsubscribeStateObserver
480  * @tc.desc: Test function UnsubscribeStateObserver(invalid parameter)
481  */
482 HWTEST_F(AccessibilitySystemAbilityClientImplTest, UnsubscribeStateObserver_002, TestSize.Level1)
483 {
484     GTEST_LOG_(INFO) << "UnsubscribeStateObserver_002 start";
485     impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>();
486     if (!impl_) {
487         GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_";
488         return;
489     }
490     EXPECT_EQ(RET_ERR_INVALID_PARAM, impl_->UnsubscribeStateObserver(nullptr, EVENT_KEVEVENT_STATE_CHANGED));
491     impl_ = nullptr;
492     GTEST_LOG_(INFO) << "UnsubscribeStateObserver_002 end";
493 }
494 
495 /**
496  * @tc.number: ResetService_001
497  * @tc.name: ResetService
498  * @tc.desc: Test function ResetService
499  */
500 HWTEST_F(AccessibilitySystemAbilityClientImplTest, ResetService_001, TestSize.Level1)
501 {
502     GTEST_LOG_(INFO) << "ResetService_001 start";
503     AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(true);
504     impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>();
505     AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(false);
506     if (!impl_) {
507         GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_";
508         return;
509     }
510     impl_->ResetService(nullptr);
511     EXPECT_NE(impl_.get(), nullptr);
512     impl_ = nullptr;
513     GTEST_LOG_(INFO) << "ResetService_001 end";
514 }
515 
516 /**
517  * @tc.number: ResetService_002
518  * @tc.name: ResetService
519  * @tc.desc: Test function ResetService
520  */
521 HWTEST_F(AccessibilitySystemAbilityClientImplTest, ResetService_002, TestSize.Level1)
522 {
523     GTEST_LOG_(INFO) << "ResetService_002 start";
524     AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(true);
525     impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>();
526     AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(false);
527     if (!impl_) {
528         GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_";
529         return;
530     }
531     wptr<IRemoteObject> object;
532     impl_->ResetService(object);
533     EXPECT_NE(impl_.get(), nullptr);
534     impl_ = nullptr;
535     GTEST_LOG_(INFO) << "ResetService_002 end";
536 }
537 
538 /**
539  * @tc.number: OnAccessibleAbilityManagerStateChanged_001
540  * @tc.name: OnAccessibleAbilityManagerStateChanged
541  * @tc.desc: Test function OnAccessibleAbilityManagerStateChanged
542  */
543 HWTEST_F(AccessibilitySystemAbilityClientImplTest, OnAccessibleAbilityManagerStateChanged_001, TestSize.Level1)
544 {
545     GTEST_LOG_(INFO) << "OnAccessibleAbilityManagerStateChanged_001 start";
546     impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>();
547     if (!impl_) {
548         GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_";
549         return;
550     }
551     uint32_t stateType = STATE_ACCESSIBILITY_ENABLED | STATE_EXPLORATION_ENABLED |
552         STATE_KEYEVENT_ENABLED | STATE_GESTURE_ENABLED;
553     impl_->OnAccessibleAbilityManagerStateChanged(stateType);
554     EXPECT_NE(impl_.get(), nullptr);
555     impl_ = nullptr;
556     GTEST_LOG_(INFO) << "OnAccessibleAbilityManagerStateChanged_001 end";
557 }
558 
559 /**
560  * @tc.number: OnAccessibleAbilityManagerStateChanged_002
561  * @tc.name: OnAccessibleAbilityManagerStateChanged
562  * @tc.desc: Test function OnAccessibleAbilityManagerStateChanged
563  */
564 HWTEST_F(AccessibilitySystemAbilityClientImplTest, OnAccessibleAbilityManagerStateChanged_002, TestSize.Level1)
565 {
566     GTEST_LOG_(INFO) << "OnAccessibleAbilityManagerStateChanged_002 start";
567     impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>();
568     if (!impl_) {
569         GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_";
570         return;
571     }
572     impl_->OnAccessibleAbilityManagerStateChanged(0);
573     EXPECT_NE(impl_.get(), nullptr);
574     impl_ = nullptr;
575     GTEST_LOG_(INFO) << "OnAccessibleAbilityManagerStateChanged_002 end";
576 }
577 
578 /**
579  * @tc.number: GetEnabledAbilities_001
580  * @tc.name: GetEnabledAbilities
581  * @tc.desc: Test function GetEnabledAbilities
582  */
583 HWTEST_F(AccessibilitySystemAbilityClientImplTest, GetEnabledAbilities_001, TestSize.Level1)
584 {
585     GTEST_LOG_(INFO) << "GetEnabledAbilities_001 start";
586     impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>();
587     if (!impl_) {
588         GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_";
589         return;
590     }
591     std::vector<std::string> enabledAbilities;
592     EXPECT_EQ(RET_ERR_SAMGR, impl_->GetEnabledAbilities(enabledAbilities));
593     impl_ = nullptr;
594     GTEST_LOG_(INFO) << "GetEnabledAbilities_001 end";
595 }
596 
597 /**
598  * @tc.number: GetEnabledAbilities_002
599  * @tc.name: GetEnabledAbilities
600  * @tc.desc: Test function GetEnabledAbilities
601  */
602 HWTEST_F(AccessibilitySystemAbilityClientImplTest, GetEnabledAbilities_002, TestSize.Level1)
603 {
604     GTEST_LOG_(INFO) << "GetEnabledAbilities_002 start";
605     AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(true);
606     impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>();
607     AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(false);
608     if (!impl_) {
609         GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_";
610         return;
611     }
612     std::vector<std::string> enabledAbilities;
613     EXPECT_EQ(RET_OK, impl_->GetEnabledAbilities(enabledAbilities));
614     impl_ = nullptr;
615     GTEST_LOG_(INFO) << "GetEnabledAbilities_002 end";
616 }
617 
618 /**
619  * @tc.number: SetSearchElementInfoByAccessibilityIdResult_001
620  * @tc.name: SetSearchElementInfoByAccessibilityIdResult
621  * @tc.desc: Test function SetSearchElementInfoByAccessibilityIdResult(success)
622  */
623 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetSearchElementInfoByAccessibilityIdResult_001, TestSize.Level1)
624 {
625     GTEST_LOG_(INFO) << "SetSearchElementInfoByAccessibilityIdResult_001 start";
626     AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(true);
627     impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>();
628     AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(false);
629     if (!impl_) {
630         GTEST_LOG_(INFO) << "SetSearchElementInfoByAccessibilityIdResult_001"
631             "Cann't get AccessibilitySystemAbilityClientImpl impl_";
632         return;
633     }
634     std::shared_ptr<AccessibilityElementOperator> mockOperator = std::make_shared<MockAccessibilityElementOperator>();
635     EXPECT_EQ(0, impl_->RegisterElementOperator(WINDOW_ID, mockOperator));
636     int32_t requestId = REQUEST_ID;
637     requestId |= static_cast<uint32_t>(WINDOW_ID) << WINDOW_ID_MASK;
638     std::list<AccessibilityElementInfo> infos;
639     impl_->SetSearchElementInfoByAccessibilityIdResult(infos, requestId);
640     EXPECT_EQ(0, infos.size());
641     impl_ = nullptr;
642     GTEST_LOG_(INFO) << "SetSearchElementInfoByAccessibilityIdResult_001 end";
643 }
644 
645 /**
646  * @tc.number: SetSearchElementInfoByAccessibilityIdResult_002
647  * @tc.name: SetSearchElementInfoByAccessibilityIdResult
648  * @tc.desc: Test function SetSearchElementInfoByAccessibilityIdResult(no operator)
649  */
650 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetSearchElementInfoByAccessibilityIdResult_002, TestSize.Level1)
651 {
652     GTEST_LOG_(INFO) << "SetSearchElementInfoByAccessibilityIdResult_002 start";
653     impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>();
654     if (!impl_) {
655         GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_";
656         return;
657     }
658     int32_t requestId = REQUEST_ID;
659     requestId |= static_cast<uint32_t>(WINDOW_ID) << WINDOW_ID_MASK;
660     std::list<AccessibilityElementInfo> infos;
661     impl_->SetSearchElementInfoByAccessibilityIdResult(infos, requestId);
662     EXPECT_EQ(0, infos.size());
663     impl_ = nullptr;
664     GTEST_LOG_(INFO) << "SetSearchElementInfoByAccessibilityIdResult_002 end";
665 }
666 
667 /**
668  * @tc.number: SetSearchElementInfoByAccessibilityIdResult_003
669  * @tc.name: SetSearchElementInfoByAccessibilityIdResult
670  * @tc.desc: Test function SetSearchElementInfoByAccessibilityIdResult(invalid requestId)
671  */
672 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetSearchElementInfoByAccessibilityIdResult_003, TestSize.Level1)
673 {
674     GTEST_LOG_(INFO) << "SetSearchElementInfoByAccessibilityIdResult_003 start";
675     impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>();
676     if (!impl_) {
677         GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_";
678         return;
679     }
680     std::list<AccessibilityElementInfo> infos;
681     impl_->SetSearchElementInfoByAccessibilityIdResult(infos, -1);
682     EXPECT_EQ(0, infos.size());
683     impl_ = nullptr;
684     GTEST_LOG_(INFO) << "SetSearchElementInfoByAccessibilityIdResult_003 end";
685 }
686 
687 /**
688  * @tc.number: SetSearchElementInfoByTextResult_001
689  * @tc.name: SetSearchElementInfoByTextResult
690  * @tc.desc: Test function SetSearchElementInfoByTextResult(success)
691  */
692 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetSearchElementInfoByTextResult_001, TestSize.Level1)
693 {
694     GTEST_LOG_(INFO) << "SetSearchElementInfoByTextResult_001 start";
695     AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(true);
696     impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>();
697     AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(false);
698     if (!impl_) {
699         GTEST_LOG_(INFO) << "Cann't get SetSearchElementInfoByTextResult_001 impl_";
700         return;
701     }
702     std::shared_ptr<AccessibilityElementOperator> mockOperator = std::make_shared<MockAccessibilityElementOperator>();
703     EXPECT_EQ(0, impl_->RegisterElementOperator(WINDOW_ID, mockOperator));
704     int32_t requestId = REQUEST_ID;
705     requestId |= static_cast<uint32_t>(WINDOW_ID) << WINDOW_ID_MASK;
706     std::list<AccessibilityElementInfo> infos;
707     impl_->SetSearchElementInfoByTextResult(infos, requestId);
708     EXPECT_EQ(0, infos.size());
709     impl_ = nullptr;
710     GTEST_LOG_(INFO) << "SetSearchElementInfoByTextResult_001 end";
711 }
712 
713 /**
714  * @tc.number: SetSearchElementInfoByTextResult_002
715  * @tc.name: SetSearchElementInfoByTextResult
716  * @tc.desc: Test function SetSearchElementInfoByTextResult(no operator)
717  */
718 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetSearchElementInfoByTextResult_002, TestSize.Level1)
719 {
720     GTEST_LOG_(INFO) << "SetSearchElementInfoByTextResult_002 start";
721     impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>();
722     if (!impl_) {
723         GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_";
724         return;
725     }
726     int32_t requestId = REQUEST_ID;
727     requestId |= static_cast<uint32_t>(WINDOW_ID) << WINDOW_ID_MASK;
728     std::list<AccessibilityElementInfo> infos;
729     impl_->SetSearchElementInfoByTextResult(infos, requestId);
730     EXPECT_EQ(0, infos.size());
731     impl_ = nullptr;
732     GTEST_LOG_(INFO) << "SetSearchElementInfoByTextResult_002 end";
733 }
734 
735 /**
736  * @tc.number: SetSearchElementInfoByTextResult_003
737  * @tc.name: SetSearchElementInfoByTextResult
738  * @tc.desc: Test function SetSearchElementInfoByTextResult(invalid requestId)
739  */
740 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetSearchElementInfoByTextResult_003, TestSize.Level1)
741 {
742     GTEST_LOG_(INFO) << "SetSearchElementInfoByTextResult_003 start";
743     impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>();
744     if (!impl_) {
745         GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_";
746         return;
747     }
748     std::list<AccessibilityElementInfo> infos;
749     impl_->SetSearchElementInfoByTextResult(infos, -1);
750     EXPECT_EQ(0, infos.size());
751     impl_ = nullptr;
752     GTEST_LOG_(INFO) << "SetSearchElementInfoByTextResult_003 end";
753 }
754 
755 /**
756  * @tc.number: SetFindFocusedElementInfoResult_001
757  * @tc.name: SetFindFocusedElementInfoResult
758  * @tc.desc: Test function SetFindFocusedElementInfoResult(success)
759  */
760 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetFindFocusedElementInfoResult_001, TestSize.Level1)
761 {
762     GTEST_LOG_(INFO) << "SetFindFocusedElementInfoResult_001 start";
763     AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(true);
764     impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>();
765     AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(false);
766     if (!impl_) {
767         GTEST_LOG_(INFO) << "SetFindFocusedElementInfoResult_001"
768             "Cann't get AccessibilitySystemAbilityClientImpl impl_";
769         return;
770     }
771     std::shared_ptr<AccessibilityElementOperator> mockOperator = std::make_shared<MockAccessibilityElementOperator>();
772     EXPECT_EQ(0, impl_->RegisterElementOperator(WINDOW_ID, mockOperator));
773     int32_t requestId = REQUEST_ID;
774     requestId |= static_cast<uint32_t>(WINDOW_ID) << WINDOW_ID_MASK;
775     AccessibilityElementInfo info;
776     impl_->SetFindFocusedElementInfoResult(info, requestId);
777     impl_ = nullptr;
778     GTEST_LOG_(INFO) << "SetFindFocusedElementInfoResult_001 end";
779 }
780 
781 /**
782  * @tc.number: SetFindFocusedElementInfoResult_002
783  * @tc.name: SetFindFocusedElementInfoResult
784  * @tc.desc: Test function SetFindFocusedElementInfoResult(no operator)
785  */
786 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetFindFocusedElementInfoResult_002, TestSize.Level1)
787 {
788     GTEST_LOG_(INFO) << "SetFindFocusedElementInfoResult_002 start";
789     impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>();
790     if (!impl_) {
791         GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_";
792         return;
793     }
794     int32_t requestId = REQUEST_ID;
795     requestId |= static_cast<uint32_t>(WINDOW_ID) << WINDOW_ID_MASK;
796     AccessibilityElementInfo info;
797     impl_->SetFindFocusedElementInfoResult(info, requestId);
798     EXPECT_NE(impl_.get(), nullptr);
799     impl_ = nullptr;
800     GTEST_LOG_(INFO) << "SetFindFocusedElementInfoResult_002 end";
801 }
802 
803 /**
804  * @tc.number: SetFindFocusedElementInfoResult_003
805  * @tc.name: SetFindFocusedElementInfoResult
806  * @tc.desc: Test function SetFindFocusedElementInfoResult(invalid requestId)
807  */
808 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetFindFocusedElementInfoResult_003, TestSize.Level1)
809 {
810     GTEST_LOG_(INFO) << "SetFindFocusedElementInfoResult_003 start";
811     impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>();
812     if (!impl_) {
813         GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_";
814         return;
815     }
816     AccessibilityElementInfo info;
817     impl_->SetFindFocusedElementInfoResult(info, -1);
818     EXPECT_NE(impl_.get(), nullptr);
819     impl_ = nullptr;
820     GTEST_LOG_(INFO) << "SetFindFocusedElementInfoResult_003 end";
821 }
822 
823 /**
824  * @tc.number: SetFocusMoveSearchResult_001
825  * @tc.name: SetFocusMoveSearchResult
826  * @tc.desc: Test function SetFocusMoveSearchResult(success)
827  */
828 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetFocusMoveSearchResult_001, TestSize.Level1)
829 {
830     GTEST_LOG_(INFO) << "SetFocusMoveSearchResult_001 start";
831     AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(true);
832     impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>();
833     AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(false);
834     if (!impl_) {
835         GTEST_LOG_(INFO) << "SetFocusMoveSearchResult_001 Cann't get AccessibilitySystemAbilityClientImpl impl_";
836         return;
837     }
838     std::shared_ptr<AccessibilityElementOperator> mockOperator = std::make_shared<MockAccessibilityElementOperator>();
839     EXPECT_EQ(0, impl_->RegisterElementOperator(WINDOW_ID, mockOperator));
840     int32_t requestId = REQUEST_ID;
841     requestId |= static_cast<uint32_t>(WINDOW_ID) << WINDOW_ID_MASK;
842     AccessibilityElementInfo info;
843     impl_->SetFocusMoveSearchResult(info, requestId);
844     impl_ = nullptr;
845     GTEST_LOG_(INFO) << "SetFocusMoveSearchResult_001 end";
846 }
847 
848 /**
849  * @tc.number: SetFocusMoveSearchResult_002
850  * @tc.name: SetFocusMoveSearchResult
851  * @tc.desc: Test function SetFocusMoveSearchResult(no operator)
852  */
853 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetFocusMoveSearchResult_002, TestSize.Level1)
854 {
855     GTEST_LOG_(INFO) << "SetFocusMoveSearchResult_002 start";
856     impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>();
857     if (!impl_) {
858         GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_";
859         return;
860     }
861     int32_t requestId = REQUEST_ID;
862     requestId |= static_cast<uint32_t>(WINDOW_ID) << WINDOW_ID_MASK;
863     AccessibilityElementInfo info;
864     impl_->SetFocusMoveSearchResult(info, requestId);
865     EXPECT_NE(impl_.get(), nullptr);
866     impl_ = nullptr;
867     GTEST_LOG_(INFO) << "SetFocusMoveSearchResult_002 end";
868 }
869 
870 /**
871  * @tc.number: SetFocusMoveSearchResult_003
872  * @tc.name: SetFocusMoveSearchResult
873  * @tc.desc: Test function SetFocusMoveSearchResult(invalid requestId)
874  */
875 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetFocusMoveSearchResult_003, TestSize.Level1)
876 {
877     GTEST_LOG_(INFO) << "SetFocusMoveSearchResult_003 start";
878     impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>();
879     if (!impl_) {
880         GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_";
881         return;
882     }
883     AccessibilityElementInfo info;
884     impl_->SetFocusMoveSearchResult(info, -1);
885     EXPECT_NE(impl_.get(), nullptr);
886     impl_ = nullptr;
887     GTEST_LOG_(INFO) << "SetFocusMoveSearchResult_003 end";
888 }
889 
890 /**
891  * @tc.number: SetExecuteActionResult_001
892  * @tc.name: SetExecuteActionResult
893  * @tc.desc: Test function SetExecuteActionResult(success)
894  */
895 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetExecuteActionResult_001, TestSize.Level1)
896 {
897     GTEST_LOG_(INFO) << "SetExecuteActionResult_001 start";
898     AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(true);
899     impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>();
900     AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(false);
901     if (!impl_) {
902         GTEST_LOG_(INFO) << "SetExecuteActionResult_001 Cann't get AccessibilitySystemAbilityClientImpl impl_";
903         return;
904     }
905     std::shared_ptr<AccessibilityElementOperator> mockOperator = std::make_shared<MockAccessibilityElementOperator>();
906     EXPECT_EQ(0, impl_->RegisterElementOperator(WINDOW_ID, mockOperator));
907     int32_t requestId = REQUEST_ID;
908     requestId |= static_cast<uint32_t>(WINDOW_ID) << WINDOW_ID_MASK;
909     impl_->SetExecuteActionResult(true, requestId);
910     impl_ = nullptr;
911     GTEST_LOG_(INFO) << "SetExecuteActionResult_001 end";
912 }
913 
914 /**
915  * @tc.number: SetExecuteActionResult_002
916  * @tc.name: SetExecuteActionResult
917  * @tc.desc: Test function SetExecuteActionResult(no operator)
918  */
919 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetExecuteActionResult_002, TestSize.Level1)
920 {
921     GTEST_LOG_(INFO) << "SetExecuteActionResult_002 start";
922     impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>();
923     if (!impl_) {
924         GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_";
925         return;
926     }
927     int32_t requestId = REQUEST_ID;
928     requestId |= static_cast<uint32_t>(WINDOW_ID) << WINDOW_ID_MASK;
929     impl_->SetExecuteActionResult(true, requestId);
930     EXPECT_NE(impl_.get(), nullptr);
931     impl_ = nullptr;
932     GTEST_LOG_(INFO) << "SetExecuteActionResult_002 end";
933 }
934 
935 /**
936  * @tc.number: SetExecuteActionResult_003
937  * @tc.name: SetExecuteActionResult
938  * @tc.desc: Test function SetExecuteActionResult(invalid requestId)
939  */
940 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetExecuteActionResult_003, TestSize.Level1)
941 {
942     GTEST_LOG_(INFO) << "SetExecuteActionResult_003 start";
943     impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>();
944     if (!impl_) {
945         GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_";
946         return;
947     }
948     impl_->SetExecuteActionResult(true, -1);
949     EXPECT_NE(impl_.get(), nullptr);
950     impl_ = nullptr;
951     GTEST_LOG_(INFO) << "SetExecuteActionResult_003 end";
952 }
953 
954 /**
955  * @tc.number: SetCursorPositionResult_001
956  * @tc.name: SetCursorPositionResult
957  * @tc.desc: Test function SetCursorPositionResult(cursorPosition,requestId)
958  */
959 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetCursorPositionResult_001, TestSize.Level1)
960 {
961     GTEST_LOG_(INFO) << "SetCursorPositionResult_001 start";
962     impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>();
963     if (!impl_) {
964         GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_";
965         return;
966     }
967     int32_t cursorPosition = 0;
968     int32_t requestId = REQUEST_ID;
969     requestId |= static_cast<uint32_t>(WINDOW_ID) << WINDOW_ID_MASK;
970     impl_->SetCursorPositionResult(cursorPosition, requestId);
971     EXPECT_NE(impl_.get(), nullptr);
972     impl_ = nullptr;
973     GTEST_LOG_(INFO) << "SetCursorPositionResult_001 end";
974 }
975 
976 /**
977  * @tc.number: SetCursorPositionResult_002
978  * @tc.name: SetCursorPositionResult
979  * @tc.desc: Test function SetCursorPositionResult(cursorPosition,requestId)
980  */
981 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetCursorPositionResult_002, TestSize.Level1)
982 {
983     GTEST_LOG_(INFO) << "SetCursorPositionResult_001 start";
984     impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>();
985     if (!impl_) {
986         GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_";
987         return;
988     }
989     int32_t cursorPosition = 0;
990     impl_->SetCursorPositionResult(cursorPosition, -1);
991     EXPECT_NE(impl_.get(), nullptr);
992     impl_ = nullptr;
993     GTEST_LOG_(INFO) << "SetCursorPositionResult_001 end";
994 }
995 
996 /**
997  * @tc.number: SetAccessibilityState_001
998  * @tc.name: SetAccessibilityState
999  * @tc.desc: Test function SetAccessibilityState
1000  */
1001 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetAccessibilityState_001, TestSize.Level1)
1002 {
1003     GTEST_LOG_(INFO) << "SetAccessibilityState_001 start";
1004     impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>();
1005     if (!impl_) {
1006         GTEST_LOG_(INFO) << "Cann't get SetAccessibilityState impl_";
1007         return;
1008     }
1009     impl_->SetAccessibilityState(0);
1010     EXPECT_NE(impl_.get(), nullptr);
1011     impl_ = nullptr;
1012     GTEST_LOG_(INFO) << "SetAccessibilityState_001 end";
1013 }
1014 
1015 /**
1016  * @tc.number: SetFindAccessibilityNodeInfoResult_001
1017  * @tc.name: SetFindAccessibilityNodeInfoResult
1018  * @tc.desc: Test function SetFindAccessibilityNodeInfoResult(elementInfo,requestId,requestCode)
1019  */
1020 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetFindAccessibilityNodeInfoResult_001, TestSize.Level1)
1021 {
1022     GTEST_LOG_(INFO) << "SetFindAccessibilityNodeInfoResult_001 start";
1023     impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>();
1024     if (!impl_) {
1025         GTEST_LOG_(INFO) << "Cann't get SetFindAccessibilityNodeInfoResult impl_";
1026         return;
1027     }
1028     AccessibilityElementInfo elementInfo;
1029     int32_t requestId = -1;
1030     int32_t requestCode = FIND_ACCESSIBILITY_NODE_BY_ACCESSIBILITY_ID;
1031     impl_->SetFindAccessibilityNodeInfoResult(elementInfo, requestId, requestCode);
1032     EXPECT_NE(impl_.get(), nullptr);
1033     impl_ = nullptr;
1034     GTEST_LOG_(INFO) << "SetFindAccessibilityNodeInfoResult_001 end";
1035 }
1036 
1037 /**
1038  * @tc.number: SetFindAccessibilityNodeInfoResult_002
1039  * @tc.name: SetFindAccessibilityNodeInfoResult
1040  * @tc.desc: Test function SetFindAccessibilityNodeInfoResult(elementInfo,requestId,requestCode)
1041  */
1042 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetFindAccessibilityNodeInfoResult_002, TestSize.Level1)
1043 {
1044     GTEST_LOG_(INFO) << "SetFindAccessibilityNodeInfoResult_002 start";
1045     impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>();
1046     if (!impl_) {
1047         GTEST_LOG_(INFO) << "Cann't get SetFindAccessibilityNodeInfoResult impl_";
1048         return;
1049     }
1050     AccessibilityElementInfo elementInfo;
1051     int32_t requestId = -1;
1052     int32_t requestCode = FIND_FOCUS;
1053     impl_->SetFindAccessibilityNodeInfoResult(elementInfo, requestId, requestCode);
1054     EXPECT_NE(impl_.get(), nullptr);
1055     impl_ = nullptr;
1056     GTEST_LOG_(INFO) << "SetFindAccessibilityNodeInfoResult_002 end";
1057 }
1058 
1059 /**
1060  * @tc.number: SetFindAccessibilityNodeInfoResult_003
1061  * @tc.name: SetFindAccessibilityNodeInfoResult
1062  * @tc.desc: Test function SetFindAccessibilityNodeInfoResult(elementInfo,requestId,requestCode)
1063  */
1064 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetFindAccessibilityNodeInfoResult_003, TestSize.Level1)
1065 {
1066     GTEST_LOG_(INFO) << "SetFindAccessibilityNodeInfoResult_003 start";
1067     impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>();
1068     if (!impl_) {
1069         GTEST_LOG_(INFO) << "Cann't get SetFindAccessibilityNodeInfoResult impl_";
1070         return;
1071     }
1072     AccessibilityElementInfo elementInfo;
1073     int32_t requestId = -1;
1074     int32_t requestCode = FIND_FOCUS_SEARCH;
1075     impl_->SetFindAccessibilityNodeInfoResult(elementInfo, requestId, requestCode);
1076     EXPECT_NE(impl_.get(), nullptr);
1077     impl_ = nullptr;
1078     GTEST_LOG_(INFO) << "SetFindAccessibilityNodeInfoResult_003 end";
1079 }
1080 
1081 /**
1082  * @tc.number: SetFindAccessibilityNodeInfoResult_004
1083  * @tc.name: SetFindAccessibilityNodeInfoResult
1084  * @tc.desc: Test function SetFindAccessibilityNodeInfoResult(elementInfo,requestId,requestCode)
1085  */
1086 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetFindAccessibilityNodeInfoResult_004, TestSize.Level1)
1087 {
1088     GTEST_LOG_(INFO) << "SetFindAccessibilityNodeInfoResult_004 start";
1089     impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>();
1090     if (!impl_) {
1091         GTEST_LOG_(INFO) << "Cann't get SetFindAccessibilityNodeInfoResult impl_";
1092         return;
1093     }
1094     AccessibilityElementInfo elementInfo;
1095     int32_t requestId = -1;
1096     int32_t requestCode = FIND_ACCESSIBILITY_NODE_BY_TEXT;
1097     impl_->SetFindAccessibilityNodeInfoResult(elementInfo, requestId, requestCode);
1098     EXPECT_NE(impl_.get(), nullptr);
1099     impl_ = nullptr;
1100     GTEST_LOG_(INFO) << "SetFindAccessibilityNodeInfoResult_004 end";
1101 }
1102 
1103 /**
1104  * @tc.number: SetFindAccessibilityNodeInfosResult_001
1105  * @tc.name: SetFindAccessibilityNodeInfosResult
1106  * @tc.desc: Test function SetFindAccessibilityNodeInfosResult(elementInfos,requestId,requestCode)
1107  */
1108 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetFindAccessibilityNodeInfosResult_001, TestSize.Level1)
1109 {
1110     GTEST_LOG_(INFO) << "SetFindAccessibilityNodeInfosResult_001 start";
1111     impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>();
1112     if (!impl_) {
1113         GTEST_LOG_(INFO) << "Cann't get SetFindAccessibilityNodeInfosResult_001 impl_";
1114         return;
1115     }
1116     std::list<AccessibilityElementInfo> elementInfos;
1117     int32_t requestId = -1;
1118     int32_t requestCode = FIND_ACCESSIBILITY_NODE_BY_ACCESSIBILITY_ID;
1119     impl_->SetFindAccessibilityNodeInfosResult(elementInfos, requestId, requestCode);
1120     EXPECT_NE(impl_.get(), nullptr);
1121     impl_ = nullptr;
1122     GTEST_LOG_(INFO) << "SetFindAccessibilityNodeInfosResult_001 end";
1123 }
1124 
1125 /**
1126  * @tc.number: SetFindAccessibilityNodeInfosResult_002
1127  * @tc.name: SetFindAccessibilityNodeInfosResult
1128  * @tc.desc: Test function SetFindAccessibilityNodeInfosResult(elementInfos,requestId,requestCode)
1129  */
1130 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetFindAccessibilityNodeInfosResult_002, TestSize.Level1)
1131 {
1132     GTEST_LOG_(INFO) << "SetFindAccessibilityNodeInfosResult_002 start";
1133     impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>();
1134     if (!impl_) {
1135         GTEST_LOG_(INFO) << "Cann't get SetFindAccessibilityNodeInfosResult_002 impl_";
1136         return;
1137     }
1138     std::list<AccessibilityElementInfo> elementInfos;
1139     int32_t requestId = -1;
1140     int32_t requestCode = FIND_ACCESSIBILITY_NODE_BY_TEXT;
1141     impl_->SetFindAccessibilityNodeInfosResult(elementInfos, requestId, requestCode);
1142     EXPECT_NE(impl_.get(), nullptr);
1143     impl_ = nullptr;
1144     GTEST_LOG_(INFO) << "SetFindAccessibilityNodeInfosResult_002 end";
1145 }
1146 
1147 /**
1148  * @tc.number: SetFindAccessibilityNodeInfosResult_003
1149  * @tc.name: SetFindAccessibilityNodeInfosResult
1150  * @tc.desc: Test function SetFindAccessibilityNodeInfosResult(elementInfos,requestId,requestCode)
1151  */
1152 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetFindAccessibilityNodeInfosResult_003, TestSize.Level1)
1153 {
1154     GTEST_LOG_(INFO) << "SetFindAccessibilityNodeInfosResult_003 start";
1155     impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>();
1156     if (!impl_) {
1157         GTEST_LOG_(INFO) << "Cann't get SetFindAccessibilityNodeInfosResult_003 impl_";
1158         return;
1159     }
1160     std::list<AccessibilityElementInfo> elementInfos;
1161     int32_t requestId = -1;
1162     int32_t requestCode = FIND_FOCUS_SEARCH;
1163     impl_->SetFindAccessibilityNodeInfosResult(elementInfos, requestId, requestCode);
1164     EXPECT_NE(impl_.get(), nullptr);
1165     impl_ = nullptr;
1166     GTEST_LOG_(INFO) << "SetFindAccessibilityNodeInfosResult_003 end";
1167 }
1168 
1169 /**
1170  * @tc.number: GetFocusedWindowId_001
1171  * @tc.name: GetFocusedWindowId
1172  * @tc.desc: Test function GetFocusedWindowId
1173  */
1174 HWTEST_F(AccessibilitySystemAbilityClientImplTest, GetFocusedWindowId_001, TestSize.Level1)
1175 {
1176     GTEST_LOG_(INFO) << "GetFocusedWindowId_001 start";
1177     impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>();
1178     if (!impl_) {
1179         GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_";
1180         return;
1181     }
1182     int32_t windowId = 0;
1183     impl_->GetFocusedWindowId(windowId);
1184     EXPECT_NE(impl_.get(), nullptr);
1185     impl_ = nullptr;
1186     GTEST_LOG_(INFO) << "GetFocusedWindowId_001 end";
1187 }
1188 
1189 /**
1190  * @tc.number: LoadAccessibilityService_001
1191  * @tc.name: LoadAccessibilityService
1192  * @tc.desc: Test function LoadAccessibilityService (false)
1193  */
1194 HWTEST_F(AccessibilitySystemAbilityClientImplTest, LoadAccessibilityService_001, TestSize.Level1)
1195 {
1196     GTEST_LOG_(INFO) << "LoadAccessibilityService_001 start";
1197     impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>();
1198     if (!impl_) {
1199         GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_";
1200         return;
1201     }
1202     EXPECT_EQ(false, impl_->LoadAccessibilityService());
1203     impl_ = nullptr;
1204     GTEST_LOG_(INFO) << "LoadAccessibilityService_001 end";
1205 }
1206 
1207 /**
1208  * @tc.number: LoadSystemAbilitySuccess_001
1209  * @tc.name: LoadSystemAbilitySuccess
1210  * @tc.desc: Test function LoadSystemAbilitySuccess
1211  */
1212 HWTEST_F(AccessibilitySystemAbilityClientImplTest, LoadSystemAbilitySuccess_001, TestSize.Level1)
1213 {
1214     GTEST_LOG_(INFO) << "LoadSystemAbilitySuccess_001 start";
1215     impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>();
1216     if (!impl_) {
1217         GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_";
1218         return;
1219     }
1220     sptr<IRemoteObject> object;
1221     impl_->LoadSystemAbilitySuccess(object);
1222     EXPECT_NE(impl_.get(), nullptr);
1223     impl_ = nullptr;
1224     GTEST_LOG_(INFO) << "LoadSystemAbilitySuccess_001 end";
1225 }
1226 
1227 /**
1228  * @tc.number: LoadSystemAbilitySuccess_002
1229  * @tc.name: LoadSystemAbilitySuccess
1230  * @tc.desc: Test function LoadSystemAbilitySuccess
1231  */
1232 HWTEST_F(AccessibilitySystemAbilityClientImplTest, LoadSystemAbilitySuccess_002, TestSize.Level1)
1233 {
1234     GTEST_LOG_(INFO) << "LoadSystemAbilitySuccess_002 start";
1235     impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>();
1236     if (!impl_) {
1237         GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_";
1238         return;
1239     }
1240     impl_->LoadSystemAbilitySuccess(nullptr);
1241     EXPECT_NE(impl_.get(), nullptr);
1242     impl_ = nullptr;
1243     GTEST_LOG_(INFO) << "LoadSystemAbilitySuccess_002 end";
1244 }
1245 
1246 /**
1247  * @tc.number: LoadSystemAbilityFail_001
1248  * @tc.name: LoadSystemAbilityFail
1249  * @tc.desc: Test function LoadSystemAbilityFail
1250  */
1251 HWTEST_F(AccessibilitySystemAbilityClientImplTest, LoadSystemAbilityFail_001, TestSize.Level1)
1252 {
1253     GTEST_LOG_(INFO) << "LoadSystemAbilityFail_001 start";
1254     impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>();
1255     if (!impl_) {
1256         GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_";
1257         return;
1258     }
1259     impl_->LoadSystemAbilityFail();
1260     impl_ = nullptr;
1261     GTEST_LOG_(INFO) << "LoadSystemAbilityFail_001 end";
1262 }
1263 
1264 /**
1265  * @tc.number: Init_001
1266  * @tc.name: Init
1267  * @tc.desc: Test function Init AccessibilitySystemAbilityClientImpl
1268  */
1269 HWTEST_F(AccessibilitySystemAbilityClientImplTest, Init_001, TestSize.Level1)
1270 {
1271     GTEST_LOG_(INFO) << "Init_001 start";
1272     impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>();
1273     if (!impl_) {
1274         GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_";
1275         return;
1276     }
1277     impl_->LoadSystemAbilityFail();
1278     impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>();
1279     impl_ = nullptr;
1280     GTEST_LOG_(INFO) << "Init_001 end";
1281 }
1282 
1283 /**
1284  * @tc.number: CheckEventType_001
1285  * @tc.name: CheckEventType
1286  * @tc.desc: Test function CheckEventType SendEvent (false: TYPE_VIEW_INVALID)
1287  */
1288 HWTEST_F(AccessibilitySystemAbilityClientImplTest, CheckEventType_001, TestSize.Level1)
1289 {
1290     GTEST_LOG_(INFO) << "CheckEventType_001 start";
1291     impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>();
1292     if (!impl_) {
1293         GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_";
1294         return;
1295     }
1296     EventType eventType = TYPE_VIEW_INVALID;
1297     EXPECT_EQ(RET_ERR_INVALID_PARAM, impl_->SendEvent(eventType, 0));
1298     impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>();
1299     impl_ = nullptr;
1300     GTEST_LOG_(INFO) << "CheckEventType_001 end";
1301 }
1302 
1303 /**
1304  * @tc.number: CheckEventType_002
1305  * @tc.name: CheckEventType
1306  * @tc.desc: Test function CheckEventType SendEvent (false: TYPE_MAX_NUM)
1307  */
1308 HWTEST_F(AccessibilitySystemAbilityClientImplTest, CheckEventType_002, TestSize.Level1)
1309 {
1310     GTEST_LOG_(INFO) << "CheckEventType_002 start";
1311     impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>();
1312     if (!impl_) {
1313         GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_";
1314         return;
1315     }
1316     EventType eventType = TYPE_MAX_NUM;
1317     EXPECT_EQ(RET_ERR_INVALID_PARAM, impl_->SendEvent(eventType, 0));
1318     impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>();
1319     impl_ = nullptr;
1320     GTEST_LOG_(INFO) << "CheckEventType_002 end";
1321 }
1322 
1323 /**
1324  * @tc.number: CheckEventType_003
1325  * @tc.name: CheckEventType
1326  * @tc.desc: Test function CheckEventType SendEvent (false: TYPE_VIEW_FOCUSED_EVENT)
1327  */
1328 HWTEST_F(AccessibilitySystemAbilityClientImplTest, CheckEventType_003, TestSize.Level1)
1329 {
1330     GTEST_LOG_(INFO) << "CheckEventType_003 start";
1331     impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>();
1332     if (!impl_) {
1333         GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_";
1334         return;
1335     }
1336     EventType eventType = TYPE_VIEW_FOCUSED_EVENT;
1337     EXPECT_EQ(RET_ERR_SAMGR, impl_->SendEvent(eventType, 0));
1338     impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>();
1339     impl_ = nullptr;
1340     GTEST_LOG_(INFO) << "CheckEventType_003 end";
1341 }
1342 
1343 /**
1344  * @tc.number: CheckEventType_004
1345  * @tc.name: CheckEventType
1346  * @tc.desc: Test function CheckEventType SendEvent (false: TYPE_PAGE_STATE_UPDATE)
1347  */
1348 HWTEST_F(AccessibilitySystemAbilityClientImplTest, CheckEventType_004, TestSize.Level1)
1349 {
1350     GTEST_LOG_(INFO) << "CheckEventType_004 start";
1351     impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>();
1352     if (!impl_) {
1353         GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_";
1354         return;
1355     }
1356     EventType eventType = TYPE_PAGE_STATE_UPDATE;
1357     EXPECT_EQ(RET_ERR_SAMGR, impl_->SendEvent(eventType, 0));
1358     impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>();
1359     impl_ = nullptr;
1360     GTEST_LOG_(INFO) << "CheckEventType_004 end";
1361 }
1362 
1363 /**
1364  * @tc.number: CheckEventType_005
1365  * @tc.name: CheckEventType
1366  * @tc.desc: Test function CheckEventType SendEvent (false: TYPE_VIEW_SCROLLED_EVENT)
1367  */
1368 HWTEST_F(AccessibilitySystemAbilityClientImplTest, CheckEventType_005, TestSize.Level1)
1369 {
1370     GTEST_LOG_(INFO) << "CheckEventType_005 start";
1371     impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>();
1372     if (!impl_) {
1373         GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_";
1374         return;
1375     }
1376     EventType eventType = TYPE_VIEW_SCROLLED_EVENT;
1377     EXPECT_EQ(RET_ERR_SAMGR, impl_->SendEvent(eventType, 0));
1378     impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>();
1379     impl_ = nullptr;
1380     GTEST_LOG_(INFO) << "CheckEventType_005 end";
1381 }
1382 } // namespace Accessibility
1383 } // namespace OHOS