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 "accessibility_ability_info.h"
18 #include "accessibility_account_data.h"
19 #include "accessibility_element_operator_proxy.h"
20 #include "accessibility_ut_helper.h"
21 #include "accessible_ability_channel.h"
22 #include "accessible_ability_connection.h"
23 #include "accessible_ability_manager_service.h"
24 #include "mock_accessibility_element_operator_stub.h"
25 #include "mock_accessibility_setting_provider.h"
26 
27 using namespace testing;
28 using namespace testing::ext;
29 
30 namespace OHOS {
31 namespace Accessibility {
32 namespace {
33     constexpr int RETRY_TIMES = 10;
34     constexpr int ELEMENT_ID = 0;
35     constexpr int INVALID_ELEMENT_ID = -1;
36     constexpr uint32_t INVALID_SEQUENCE = 0;
37     constexpr uint64_t DISPLAY_ID = 0;
38     constexpr int32_t WINDOW_ID = 0;
39     constexpr int32_t ACCOUNT_ID = 0;
40 } // namespace
41 
42 class AccessibleAbilityChannelUnitTest : public ::testing::Test {
43 public:
AccessibleAbilityChannelUnitTest()44     AccessibleAbilityChannelUnitTest()
45     {}
~AccessibleAbilityChannelUnitTest()46     ~AccessibleAbilityChannelUnitTest()
47     {}
48 
49     static void SetUpTestCase();
50     static void TearDownTestCase();
51     void SetUp() override;
52     void TearDown() override;
53 
54     bool TestElementId();
55     sptr<AccessibleAbilityChannel> channel_ = nullptr;
56     sptr<AccessibleAbilityConnection> connection_ = nullptr;
57 };
58 
SetUpTestCase()59 void AccessibleAbilityChannelUnitTest::SetUpTestCase()
60 {
61     GTEST_LOG_(INFO) << "###################### AccessibleAbilityChannelUnitTest Start ######################";
62     Singleton<AccessibleAbilityManagerService>::GetInstance().OnStart();
63 }
64 
TearDownTestCase()65 void AccessibleAbilityChannelUnitTest::TearDownTestCase()
66 {
67     GTEST_LOG_(INFO) << "###################### AccessibleAbilityChannelUnitTest End ######################";
68     Singleton<AccessibleAbilityManagerService>::GetInstance().OnStop();
69 }
70 
SetUp()71 void AccessibleAbilityChannelUnitTest::SetUp()
72 {
73     GTEST_LOG_(INFO) << "SetUp";
74     // Add AA client
75     AccessibilityAbilityInitParams initParams;
76     initParams.bundleName = "testBundleName";
77     initParams.name = "testAbilityName";
78     std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
79     ASSERT_TRUE(abilityInfo);
80     abilityInfo->SetEventTypes(EventType::TYPES_ALL_MASK);
81     abilityInfo->SetCapabilityValues(CAPABILITY_RETRIEVE | CAPABILITY_GESTURE);
82     sptr<AccessibilityAccountData> accountData =
83         Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
84     ASSERT_TRUE(accountData);
85     connection_ = new AccessibleAbilityConnection(accountData->GetAccountId(), 0, *abilityInfo);
86     ASSERT_TRUE(connection_);
87     AppExecFwk::ElementName elementName("testDeviceId", "testBundleName", "testAbilityName");
88     channel_ = new AccessibleAbilityChannel(accountData->GetAccountId(), abilityInfo->GetId());
89     ASSERT_TRUE(channel_);
90     connection_->OnAbilityConnectDoneSync(elementName, channel_);
91 
92     // Add window connection
93     sptr<AccessibilityElementOperatorStub> stub = new MockAccessibilityElementOperatorStub();
94     ASSERT_TRUE(stub);
95     sptr<IAccessibilityElementOperator> proxy = new AccessibilityElementOperatorProxy(stub);
96     ASSERT_TRUE(proxy);
97     sptr<AccessibilityWindowConnection> connection = new AccessibilityWindowConnection(WINDOW_ID, proxy, ACCOUNT_ID);
98     ASSERT_TRUE(connection);
99     accountData->AddAccessibilityWindowConnection(WINDOW_ID, connection);
100 
101     EXPECT_EQ(AccessibilityAbilityHelper::GetInstance().GetTestChannelElementId(), INVALID_ELEMENT_ID);
102 }
103 
TearDown()104 void AccessibleAbilityChannelUnitTest::TearDown()
105 {
106     GTEST_LOG_(INFO) << "TearDown";
107     connection_ = nullptr;
108     channel_ = nullptr;
109     AccessibilityAbilityHelper::GetInstance().SetTestChannelElementId(INVALID_ELEMENT_ID);
110 }
111 
TestElementId()112 bool AccessibleAbilityChannelUnitTest::TestElementId()
113 {
114     int retryCount = 0;
115     while (retryCount < RETRY_TIMES) {
116         sleep(1);
117         int elementId = AccessibilityAbilityHelper::GetInstance().GetTestChannelElementId();
118         GTEST_LOG_(INFO) << "element id is : " << elementId;
119         if (elementId == ELEMENT_ID) {
120             GTEST_LOG_(INFO) << "element id is true";
121             return true;
122         }
123         retryCount++;
124     }
125     return false;
126 }
127 
128 /**
129  * @tc.number: AccessibleAbilityChannel_Unittest_SearchElementInfoByAccessibilityId_001
130  * @tc.name: SearchElementInfoByAccessibilityId
131  * @tc.desc: Test function SearchElementInfoByAccessibilityId
132  */
133 HWTEST_F(AccessibleAbilityChannelUnitTest,
134     AccessibleAbilityChannel_Unittest_SearchElementInfoByAccessibilityId_001, TestSize.Level1)
135 {
136     GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_SearchElementInfoByAccessibilityId_001 start";
137     ElementBasicInfo elementBasicInfo;
138     elementBasicInfo.windowId = 0;
139     elementBasicInfo.treeId = 0;
140     elementBasicInfo.elementId = 0;
141     EXPECT_EQ(channel_->SearchElementInfoByAccessibilityId(elementBasicInfo, 0, nullptr, 0, true),
142         RET_ERR_NULLPTR);
143     GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_SearchElementInfoByAccessibilityId_001 end";
144 }
145 
146 /**
147  * @tc.number: AccessibleAbilityChannel_Unittest_SearchElementInfosByText_001
148  * @tc.name: SearchElementInfosByText
149  * @tc.desc: Test function SearchElementInfosByText
150  */
151 HWTEST_F(AccessibleAbilityChannelUnitTest,
152     AccessibleAbilityChannel_Unittest_SearchElementInfosByText_001, TestSize.Level1)
153 {
154     GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_SearchElementInfosByText_001 start";
155     EXPECT_EQ(channel_->SearchElementInfosByText(WINDOW_ID, ELEMENT_ID, "test", 0, nullptr), RET_ERR_NULLPTR);
156     GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_SearchElementInfosByText_001 end";
157 }
158 
159 /**
160  * @tc.number: AccessibleAbilityChannel_Unittest_FindFocusedElementInfo_001
161  * @tc.name: FindFocusedElementInfo
162  * @tc.desc: Test function FindFocusedElementInfo
163  */
164 HWTEST_F(AccessibleAbilityChannelUnitTest,
165     AccessibleAbilityChannel_Unittest_FindFocusedElementInfo_001, TestSize.Level1)
166 {
167     GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_FindFocusedElementInfo_001 start";
168     EXPECT_EQ(channel_->FindFocusedElementInfo(WINDOW_ID, ELEMENT_ID, FOCUS_TYPE_INPUT, 0, nullptr), RET_ERR_NULLPTR);
169     GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_FindFocusedElementInfo_001 end";
170 }
171 
172 /**
173  * @tc.number: AccessibleAbilityChannel_Unittest_FocusMoveSearch_001
174  * @tc.name: FocusMoveSearch
175  * @tc.desc: Test function FocusMoveSearch
176  */
177 HWTEST_F(AccessibleAbilityChannelUnitTest,
178     AccessibleAbilityChannel_Unittest_FocusMoveSearch_001, TestSize.Level1)
179 {
180     GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_FocusMoveSearch_001 start";
181     EXPECT_EQ(channel_->FocusMoveSearch(WINDOW_ID, ELEMENT_ID, UP, 0, nullptr), RET_ERR_NULLPTR);
182     GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_FocusMoveSearch_001 end";
183 }
184 
185 /**
186  * @tc.number: AccessibleAbilityChannel_Unittest_ExecuteAction_001
187  * @tc.name: ExecuteAction
188  * @tc.desc: Test function ExecuteAction
189  */
190 HWTEST_F(AccessibleAbilityChannelUnitTest,
191     AccessibleAbilityChannel_Unittest_ExecuteAction_001, TestSize.Level1)
192 {
193     GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_ExecuteAction_001 start";
194     std::map<std::string, std::string> actionArguments;
195     EXPECT_EQ(channel_->ExecuteAction(WINDOW_ID, ELEMENT_ID, 1, actionArguments, 0, nullptr), RET_ERR_NULLPTR);
196     GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_ExecuteAction_001 end";
197 }
198 
199 /**
200  * @tc.number: AccessibleAbilityChannel_Unittest_GetWindow_001
201  * @tc.name: GetWindow
202  * @tc.desc: Test function GetWindow
203  */
204 HWTEST_F(AccessibleAbilityChannelUnitTest,
205     AccessibleAbilityChannel_Unittest_GetWindow_001, TestSize.Level1)
206 {
207     GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_GetWindow_001 start";
208     AccessibilityWindowInfo windowInfo;
209     EXPECT_EQ(channel_->GetWindow(WINDOW_ID, windowInfo), RET_ERR_NO_WINDOW_CONNECTION);
210     GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_GetWindow_001 end";
211 }
212 
213 /**
214  * @tc.number: AccessibleAbilityChannel_Unittest_GetWindow_002
215  * @tc.name: GetWindow
216  * @tc.desc: Test function GetWindow
217  */
218 HWTEST_F(AccessibleAbilityChannelUnitTest,
219     AccessibleAbilityChannel_Unittest_GetWindow_002, TestSize.Level1)
220 {
221     GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_GetWindow_002 start";
222     sptr<AccessibilityAccountData> accountData =
223         Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
224     ASSERT_TRUE(accountData);
225     std::string ability = "testGetWindow";
226     EXPECT_FALSE(accountData->GetAccessibleAbilityConnection(ability));
227 
228     sptr<AccessibleAbilityChannel> channel = new AccessibleAbilityChannel(accountData->GetAccountId(), ability);
229     AccessibilityWindowInfo windowInfo;
230     EXPECT_EQ(channel->GetWindow(WINDOW_ID, windowInfo), RET_ERR_NO_CONNECTION);
231     GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_GetWindow_002 end";
232 }
233 
234 /**
235  * @tc.number: AccessibleAbilityChannel_Unittest_GetWindow_003
236  * @tc.name: GetWindow
237  * @tc.desc: Test function GetWindow
238  */
239 HWTEST_F(AccessibleAbilityChannelUnitTest,
240     AccessibleAbilityChannel_Unittest_GetWindow_003, TestSize.Level1)
241 {
242     GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_GetWindow_003 start";
243     sptr<AccessibilityAccountData> accountData =
244         Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
245     ASSERT_TRUE(accountData);
246 
247     // add a client which has no retieve capability
248     std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>();
249     sptr<AccessibleAbilityConnection> connection =
250         new AccessibleAbilityConnection(accountData->GetAccountId(), 0, *abilityInfo);
251     AppExecFwk::ElementName elementName("device", "bundle", "ability");
252     std::string ability = "bundle/ability";
253     sptr<AccessibleAbilityChannel> channel = new AccessibleAbilityChannel(accountData->GetAccountId(), ability);
254     connection->OnAbilityConnectDoneSync(elementName, channel);
255     EXPECT_TRUE(accountData->GetAccessibleAbilityConnection(ability));
256 
257     AccessibilityWindowInfo windowInfo;
258     EXPECT_EQ(channel->GetWindow(WINDOW_ID, windowInfo), RET_ERR_NO_CAPABILITY);
259     GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_GetWindow_003 end";
260 }
261 
262 /**
263  * @tc.number: AccessibleAbilityChannel_Unittest_GetWindows_001
264  * @tc.name: GetWindows
265  * @tc.desc: Test function GetWindows
266  */
267 HWTEST_F(AccessibleAbilityChannelUnitTest,
268     AccessibleAbilityChannel_Unittest_GetWindows_001, TestSize.Level1)
269 {
270     GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_GetWindows_001 start";
271     std::vector<AccessibilityWindowInfo> windows;
272     EXPECT_EQ(channel_->GetWindows(windows), RET_OK);
273     EXPECT_EQ(static_cast<int>(windows.size()), 0);
274     GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_GetWindows_001 end";
275 }
276 
277 /**
278  * @tc.number: AccessibleAbilityChannel_Unittest_GetWindows_002
279  * @tc.name: GetWindows
280  * @tc.desc: Test function GetWindows
281  */
282 HWTEST_F(AccessibleAbilityChannelUnitTest,
283     AccessibleAbilityChannel_Unittest_GetWindows_002, TestSize.Level1)
284 {
285     GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_GetWindows_002 start";
286     std::string abilityName = "testGetWindows";
287     sptr<AccessibilityAccountData> accountData =
288         Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
289     ASSERT_TRUE(accountData);
290     EXPECT_FALSE(accountData->GetAccessibleAbilityConnection(abilityName));
291     sptr<AccessibleAbilityChannel> channel = new AccessibleAbilityChannel(accountData->GetAccountId(), abilityName);
292 
293     std::vector<AccessibilityWindowInfo> windows;
294     EXPECT_EQ(channel->GetWindows(windows), RET_ERR_NO_CONNECTION);
295     EXPECT_EQ(static_cast<int>(windows.size()), 0);
296     GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_GetWindows_002 end";
297 }
298 
299 /**
300  * @tc.number: AccessibleAbilityChannel_Unittest_GetWindows_003
301  * @tc.name: GetWindows
302  * @tc.desc: Test function GetWindows
303  */
304 HWTEST_F(AccessibleAbilityChannelUnitTest,
305     AccessibleAbilityChannel_Unittest_GetWindows_003, TestSize.Level1)
306 {
307     GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_GetWindows_003 start";
308     sptr<AccessibilityAccountData> accountData =
309         Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
310     ASSERT_TRUE(accountData);
311 
312     // Add AA client which has no retieve capability
313     AccessibilityAbilityInitParams initParams;
314     initParams.bundleName = "bundle";
315     initParams.name = "ability";
316     std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
317     sptr<AccessibleAbilityConnection> connection =
318         new AccessibleAbilityConnection(accountData->GetAccountId(), 0, *abilityInfo);
319     AppExecFwk::ElementName elementName("device", "bundle", "ability");
320     sptr<AccessibleAbilityChannel> channel =
321         new AccessibleAbilityChannel(accountData->GetAccountId(), abilityInfo->GetId());
322     connection->OnAbilityConnectDoneSync(elementName, channel);
323     EXPECT_TRUE(accountData->GetAccessibleAbilityConnection(abilityInfo->GetId()));
324 
325     std::vector<AccessibilityWindowInfo> windows;
326     EXPECT_EQ(channel->GetWindows(windows), RET_ERR_NO_CAPABILITY);
327     GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_GetWindows_003 end";
328 }
329 
330 /**
331  * @tc.number: AccessibleAbilityChannel_Unittest_GetWindowsByDisplayId_001
332  * @tc.name: GetWindowsByDisplayId
333  * @tc.desc: Test function GetWindowsByDisplayId
334  */
335 HWTEST_F(AccessibleAbilityChannelUnitTest,
336     AccessibleAbilityChannel_Unittest_GetWindowsByDisplayId_001, TestSize.Level1)
337 {
338     GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_GetWindowsByDisplayId_001 start";
339     std::vector<AccessibilityWindowInfo> windows;
340     EXPECT_EQ(channel_->GetWindowsByDisplayId(DISPLAY_ID, windows), RET_OK);
341     EXPECT_EQ(static_cast<int>(windows.size()), 0);
342     GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_GetWindowsByDisplayId_001 end";
343 }
344 
345 /**
346  * @tc.number: AccessibleAbilityChannel_Unittest_SetOnKeyPressEventResult_001
347  * @tc.name: SetOnKeyPressEventResult
348  * @tc.desc: Test function SetOnKeyPressEventResult
349  */
350 HWTEST_F(AccessibleAbilityChannelUnitTest,
351     AccessibleAbilityChannel_Unittest_SetOnKeyPressEventResult_001, TestSize.Level1)
352 {
353     GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_SetOnKeyPressEventResult_001 start";
354     AccessibilityAbilityHelper::GetInstance().SetTestSequence(INVALID_SEQUENCE);
355     EXPECT_EQ(AccessibilityAbilityHelper::GetInstance().GetTestSequence(), INVALID_SEQUENCE);
356     sptr<KeyEventFilter> keyEventFilter = new KeyEventFilter();
357     ASSERT_TRUE(keyEventFilter);
358     Singleton<AccessibleAbilityManagerService>::GetInstance().SetKeyEventFilter(keyEventFilter);
359 
360     uint32_t sequence = 1;
361     channel_->SetOnKeyPressEventResult(true, sequence);
362 
363     int retryCount = 0;
364     bool result = false;
365     while (retryCount < RETRY_TIMES) {
366         sleep(1);
367         uint32_t sequenceNum = AccessibilityAbilityHelper::GetInstance().GetTestSequence();
368         GTEST_LOG_(INFO) << "sequence is : " << sequenceNum;
369         if (sequenceNum == sequence) {
370             GTEST_LOG_(INFO) << "sequence is true";
371             result = true;
372             break;
373         }
374         retryCount++;
375     }
376     EXPECT_TRUE(result);
377     AccessibilityAbilityHelper::GetInstance().SetTestSequence(INVALID_SEQUENCE);
378     GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_SetOnKeyPressEventResult_001 end";
379 }
380 
381 /**
382  * @tc.number: AccessibleAbilityChannel_Unittest_SendSimulateGesture_001
383  * @tc.name: SendSimulateGesture
384  * @tc.desc: Test function SendSimulateGesture
385  */
386 HWTEST_F(AccessibleAbilityChannelUnitTest,
387     AccessibleAbilityChannel_Unittest_SendSimulateGesture_001, TestSize.Level1)
388 {
389     GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_SendSimulateGesture_001 start";
390     EXPECT_EQ(channel_->SendSimulateGesture(nullptr), RET_ERR_NO_INJECTOR);
391     GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_SendSimulateGesture_001 end";
392 }
393 
394 /**
395  * @tc.number: AccessibleAbilityChannel_Unittest_SendSimulateGesture_002
396  * @tc.name: SendSimulateGesture
397  * @tc.desc: Test function SendSimulateGesture
398  */
399 HWTEST_F(AccessibleAbilityChannelUnitTest,
400     AccessibleAbilityChannel_Unittest_SendSimulateGesture_002, TestSize.Level1)
401 {
402     GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_SendSimulateGesture_002 start";
403     std::string abilityName = "testGesture";
404     sptr<AccessibilityAccountData> accountData =
405         Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
406     ASSERT_TRUE(accountData);
407     EXPECT_FALSE(accountData->GetAccessibleAbilityConnection(abilityName));
408     sptr<AccessibleAbilityChannel> channel = new AccessibleAbilityChannel(accountData->GetAccountId(), abilityName);
409     EXPECT_EQ(channel->SendSimulateGesture(nullptr), RET_ERR_NO_CONNECTION);
410     GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_SendSimulateGesture_002 end";
411 }
412 
413 /**
414  * @tc.number: AccessibleAbilityChannel_Unittest_SendSimulateGesture_003
415  * @tc.name: SendSimulateGesture
416  * @tc.desc: Test function SendSimulateGesture
417  */
418 HWTEST_F(AccessibleAbilityChannelUnitTest,
419     AccessibleAbilityChannel_Unittest_SendSimulateGesture_003, TestSize.Level1)
420 {
421     GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_SendSimulateGesture_003 start";
422     sptr<AccessibilityAccountData> accountData =
423         Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
424     // add a client which has no retieve capability
425     std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>();
426     sptr<AccessibleAbilityConnection> connection =
427         new AccessibleAbilityConnection(accountData->GetAccountId(), 0, *abilityInfo);
428     AppExecFwk::ElementName elementName("device", "bundle", "ability");
429     std::string ability = "bundle/ability";
430     sptr<AccessibleAbilityChannel> channel = new AccessibleAbilityChannel(accountData->GetAccountId(), ability);
431     connection->OnAbilityConnectDoneSync(elementName, channel);
432     EXPECT_TRUE(accountData->GetAccessibleAbilityConnection(ability));
433     EXPECT_EQ(channel->SendSimulateGesture(nullptr), RET_ERR_NO_CAPABILITY);
434     GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_SendSimulateGesture_003 end";
435 }
436 
437 /**
438  * @tc.number: AccessibleAbilityChannel_Unittest_SetTargetBundleName_001
439  * @tc.name: SetTargetBundleName
440  * @tc.desc: Test function SetTargetBundleName
441  */
442 HWTEST_F(AccessibleAbilityChannelUnitTest,
443     AccessibleAbilityChannel_Unittest_SetTargetBundleName_001, TestSize.Level1)
444 {
445     GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_SetTargetBundleName_001 start";
446     std::vector<std::string> targetBundleNames;
447     EXPECT_EQ(channel_->SetTargetBundleName(targetBundleNames), RET_OK);
448     GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_SetTargetBundleName_001 end";
449 }
450 
451 /**
452  * @tc.number: AccessibleAbilityChannel_Unittest_SetTargetBundleName_002
453  * @tc.name: SetTargetBundleName
454  * @tc.desc: Test function SetTargetBundleName
455  */
456 HWTEST_F(AccessibleAbilityChannelUnitTest,
457     AccessibleAbilityChannel_Unittest_SetTargetBundleName_002, TestSize.Level1)
458 {
459     GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_SetTargetBundleName_002 start";
460     sptr<AccessibilityAccountData> accountData =
461         Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
462     ASSERT_TRUE(accountData);
463     std::string abilityName = "testSetTargetBundleName";
464     EXPECT_FALSE(accountData->GetAccessibleAbilityConnection(abilityName));
465     sptr<AccessibleAbilityChannel> channel = new AccessibleAbilityChannel(accountData->GetAccountId(), abilityName);
466     std::vector<std::string> targetBundleNames;
467     EXPECT_EQ(channel->SetTargetBundleName(targetBundleNames), RET_ERR_NO_CONNECTION);
468     GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_SetTargetBundleName_002 end";
469 }
470 } // namespace Accessibility
471 } // namespace OHOS