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 channel_->SearchElementInfosByText(WINDOW_ID, ELEMENT_ID, "test", 0, nullptr);
156 bool result = TestElementId();
157 EXPECT_TRUE(result);
158 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_SearchElementInfosByText_001 end";
159 }
160
161 /**
162 * @tc.number: AccessibleAbilityChannel_Unittest_FindFocusedElementInfo_001
163 * @tc.name: FindFocusedElementInfo
164 * @tc.desc: Test function FindFocusedElementInfo
165 */
166 HWTEST_F(AccessibleAbilityChannelUnitTest,
167 AccessibleAbilityChannel_Unittest_FindFocusedElementInfo_001, TestSize.Level1)
168 {
169 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_FindFocusedElementInfo_001 start";
170 channel_->FindFocusedElementInfo(WINDOW_ID, ELEMENT_ID, FOCUS_TYPE_INPUT, 0, nullptr);
171 bool result = TestElementId();
172 EXPECT_TRUE(result);
173 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_FindFocusedElementInfo_001 end";
174 }
175
176 /**
177 * @tc.number: AccessibleAbilityChannel_Unittest_FocusMoveSearch_001
178 * @tc.name: FocusMoveSearch
179 * @tc.desc: Test function FocusMoveSearch
180 */
181 HWTEST_F(AccessibleAbilityChannelUnitTest,
182 AccessibleAbilityChannel_Unittest_FocusMoveSearch_001, TestSize.Level1)
183 {
184 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_FocusMoveSearch_001 start";
185 channel_->FocusMoveSearch(WINDOW_ID, ELEMENT_ID, UP, 0, nullptr);
186 bool result = TestElementId();
187 EXPECT_TRUE(result);
188 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_FocusMoveSearch_001 end";
189 }
190
191 /**
192 * @tc.number: AccessibleAbilityChannel_Unittest_ExecuteAction_001
193 * @tc.name: ExecuteAction
194 * @tc.desc: Test function ExecuteAction
195 */
196 HWTEST_F(AccessibleAbilityChannelUnitTest,
197 AccessibleAbilityChannel_Unittest_ExecuteAction_001, TestSize.Level1)
198 {
199 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_ExecuteAction_001 start";
200 std::map<std::string, std::string> actionArguments;
201 channel_->ExecuteAction(WINDOW_ID, ELEMENT_ID, 1, actionArguments, 0, nullptr);
202 bool result = TestElementId();
203 EXPECT_TRUE(result);
204 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_ExecuteAction_001 end";
205 }
206
207 /**
208 * @tc.number: AccessibleAbilityChannel_Unittest_GetWindow_001
209 * @tc.name: GetWindow
210 * @tc.desc: Test function GetWindow
211 */
212 HWTEST_F(AccessibleAbilityChannelUnitTest,
213 AccessibleAbilityChannel_Unittest_GetWindow_001, TestSize.Level1)
214 {
215 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_GetWindow_001 start";
216 AccessibilityWindowInfo windowInfo;
217 EXPECT_EQ(channel_->GetWindow(WINDOW_ID, windowInfo), RET_ERR_NO_WINDOW_CONNECTION);
218 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_GetWindow_001 end";
219 }
220
221 /**
222 * @tc.number: AccessibleAbilityChannel_Unittest_GetWindow_002
223 * @tc.name: GetWindow
224 * @tc.desc: Test function GetWindow
225 */
226 HWTEST_F(AccessibleAbilityChannelUnitTest,
227 AccessibleAbilityChannel_Unittest_GetWindow_002, TestSize.Level1)
228 {
229 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_GetWindow_002 start";
230 sptr<AccessibilityAccountData> accountData =
231 Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
232 ASSERT_TRUE(accountData);
233 std::string ability = "testGetWindow";
234 EXPECT_FALSE(accountData->GetAccessibleAbilityConnection(ability));
235
236 sptr<AccessibleAbilityChannel> channel = new AccessibleAbilityChannel(accountData->GetAccountId(), ability);
237 AccessibilityWindowInfo windowInfo;
238 EXPECT_EQ(channel->GetWindow(WINDOW_ID, windowInfo), RET_ERR_NO_CONNECTION);
239 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_GetWindow_002 end";
240 }
241
242 /**
243 * @tc.number: AccessibleAbilityChannel_Unittest_GetWindow_003
244 * @tc.name: GetWindow
245 * @tc.desc: Test function GetWindow
246 */
247 HWTEST_F(AccessibleAbilityChannelUnitTest,
248 AccessibleAbilityChannel_Unittest_GetWindow_003, TestSize.Level1)
249 {
250 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_GetWindow_003 start";
251 sptr<AccessibilityAccountData> accountData =
252 Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
253 ASSERT_TRUE(accountData);
254
255 // add a client which has no retieve capability
256 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>();
257 sptr<AccessibleAbilityConnection> connection =
258 new AccessibleAbilityConnection(accountData->GetAccountId(), 0, *abilityInfo);
259 AppExecFwk::ElementName elementName("device", "bundle", "ability");
260 std::string ability = "bundle/ability";
261 sptr<AccessibleAbilityChannel> channel = new AccessibleAbilityChannel(accountData->GetAccountId(), ability);
262 connection->OnAbilityConnectDoneSync(elementName, channel);
263 EXPECT_TRUE(accountData->GetAccessibleAbilityConnection(ability));
264
265 AccessibilityWindowInfo windowInfo;
266 EXPECT_EQ(channel->GetWindow(WINDOW_ID, windowInfo), RET_ERR_NO_CAPABILITY);
267 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_GetWindow_003 end";
268 }
269
270 /**
271 * @tc.number: AccessibleAbilityChannel_Unittest_GetWindows_001
272 * @tc.name: GetWindows
273 * @tc.desc: Test function GetWindows
274 */
275 HWTEST_F(AccessibleAbilityChannelUnitTest,
276 AccessibleAbilityChannel_Unittest_GetWindows_001, TestSize.Level1)
277 {
278 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_GetWindows_001 start";
279 std::vector<AccessibilityWindowInfo> windows;
280 EXPECT_EQ(channel_->GetWindows(windows), RET_OK);
281 EXPECT_EQ(static_cast<int>(windows.size()), 0);
282 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_GetWindows_001 end";
283 }
284
285 /**
286 * @tc.number: AccessibleAbilityChannel_Unittest_GetWindows_002
287 * @tc.name: GetWindows
288 * @tc.desc: Test function GetWindows
289 */
290 HWTEST_F(AccessibleAbilityChannelUnitTest,
291 AccessibleAbilityChannel_Unittest_GetWindows_002, TestSize.Level1)
292 {
293 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_GetWindows_002 start";
294 std::string abilityName = "testGetWindows";
295 sptr<AccessibilityAccountData> accountData =
296 Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
297 ASSERT_TRUE(accountData);
298 EXPECT_FALSE(accountData->GetAccessibleAbilityConnection(abilityName));
299 sptr<AccessibleAbilityChannel> channel = new AccessibleAbilityChannel(accountData->GetAccountId(), abilityName);
300
301 std::vector<AccessibilityWindowInfo> windows;
302 EXPECT_EQ(channel->GetWindows(windows), RET_ERR_NO_CONNECTION);
303 EXPECT_EQ(static_cast<int>(windows.size()), 0);
304 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_GetWindows_002 end";
305 }
306
307 /**
308 * @tc.number: AccessibleAbilityChannel_Unittest_GetWindows_003
309 * @tc.name: GetWindows
310 * @tc.desc: Test function GetWindows
311 */
312 HWTEST_F(AccessibleAbilityChannelUnitTest,
313 AccessibleAbilityChannel_Unittest_GetWindows_003, TestSize.Level1)
314 {
315 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_GetWindows_003 start";
316 sptr<AccessibilityAccountData> accountData =
317 Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
318 ASSERT_TRUE(accountData);
319
320 // Add AA client which has no retieve capability
321 AccessibilityAbilityInitParams initParams;
322 initParams.bundleName = "bundle";
323 initParams.name = "ability";
324 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
325 sptr<AccessibleAbilityConnection> connection =
326 new AccessibleAbilityConnection(accountData->GetAccountId(), 0, *abilityInfo);
327 AppExecFwk::ElementName elementName("device", "bundle", "ability");
328 sptr<AccessibleAbilityChannel> channel =
329 new AccessibleAbilityChannel(accountData->GetAccountId(), abilityInfo->GetId());
330 connection->OnAbilityConnectDoneSync(elementName, channel);
331 EXPECT_TRUE(accountData->GetAccessibleAbilityConnection(abilityInfo->GetId()));
332
333 std::vector<AccessibilityWindowInfo> windows;
334 EXPECT_EQ(channel->GetWindows(windows), RET_ERR_NO_CAPABILITY);
335 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_GetWindows_003 end";
336 }
337
338 /**
339 * @tc.number: AccessibleAbilityChannel_Unittest_GetWindowsByDisplayId_001
340 * @tc.name: GetWindowsByDisplayId
341 * @tc.desc: Test function GetWindowsByDisplayId
342 */
343 HWTEST_F(AccessibleAbilityChannelUnitTest,
344 AccessibleAbilityChannel_Unittest_GetWindowsByDisplayId_001, TestSize.Level1)
345 {
346 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_GetWindowsByDisplayId_001 start";
347 std::vector<AccessibilityWindowInfo> windows;
348 EXPECT_EQ(channel_->GetWindowsByDisplayId(DISPLAY_ID, windows), RET_OK);
349 EXPECT_EQ(static_cast<int>(windows.size()), 0);
350 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_GetWindowsByDisplayId_001 end";
351 }
352
353 /**
354 * @tc.number: AccessibleAbilityChannel_Unittest_SetOnKeyPressEventResult_001
355 * @tc.name: SetOnKeyPressEventResult
356 * @tc.desc: Test function SetOnKeyPressEventResult
357 */
358 HWTEST_F(AccessibleAbilityChannelUnitTest,
359 AccessibleAbilityChannel_Unittest_SetOnKeyPressEventResult_001, TestSize.Level1)
360 {
361 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_SetOnKeyPressEventResult_001 start";
362 AccessibilityAbilityHelper::GetInstance().SetTestSequence(INVALID_SEQUENCE);
363 EXPECT_EQ(AccessibilityAbilityHelper::GetInstance().GetTestSequence(), INVALID_SEQUENCE);
364 sptr<KeyEventFilter> keyEventFilter = new KeyEventFilter();
365 ASSERT_TRUE(keyEventFilter);
366 Singleton<AccessibleAbilityManagerService>::GetInstance().SetKeyEventFilter(keyEventFilter);
367
368 uint32_t sequence = 1;
369 channel_->SetOnKeyPressEventResult(true, sequence);
370
371 int retryCount = 0;
372 bool result = false;
373 while (retryCount < RETRY_TIMES) {
374 sleep(1);
375 uint32_t sequenceNum = AccessibilityAbilityHelper::GetInstance().GetTestSequence();
376 GTEST_LOG_(INFO) << "sequence is : " << sequenceNum;
377 if (sequenceNum == sequence) {
378 GTEST_LOG_(INFO) << "sequence is true";
379 result = true;
380 break;
381 }
382 retryCount++;
383 }
384 EXPECT_TRUE(result);
385 AccessibilityAbilityHelper::GetInstance().SetTestSequence(INVALID_SEQUENCE);
386 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_SetOnKeyPressEventResult_001 end";
387 }
388
389 /**
390 * @tc.number: AccessibleAbilityChannel_Unittest_SendSimulateGesture_001
391 * @tc.name: SendSimulateGesture
392 * @tc.desc: Test function SendSimulateGesture
393 */
394 HWTEST_F(AccessibleAbilityChannelUnitTest,
395 AccessibleAbilityChannel_Unittest_SendSimulateGesture_001, TestSize.Level1)
396 {
397 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_SendSimulateGesture_001 start";
398 EXPECT_EQ(channel_->SendSimulateGesture(nullptr), RET_ERR_NO_INJECTOR);
399 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_SendSimulateGesture_001 end";
400 }
401
402 /**
403 * @tc.number: AccessibleAbilityChannel_Unittest_SendSimulateGesture_002
404 * @tc.name: SendSimulateGesture
405 * @tc.desc: Test function SendSimulateGesture
406 */
407 HWTEST_F(AccessibleAbilityChannelUnitTest,
408 AccessibleAbilityChannel_Unittest_SendSimulateGesture_002, TestSize.Level1)
409 {
410 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_SendSimulateGesture_002 start";
411 std::string abilityName = "testGesture";
412 sptr<AccessibilityAccountData> accountData =
413 Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
414 ASSERT_TRUE(accountData);
415 EXPECT_FALSE(accountData->GetAccessibleAbilityConnection(abilityName));
416 sptr<AccessibleAbilityChannel> channel = new AccessibleAbilityChannel(accountData->GetAccountId(), abilityName);
417 EXPECT_EQ(channel->SendSimulateGesture(nullptr), RET_ERR_NO_CONNECTION);
418 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_SendSimulateGesture_002 end";
419 }
420
421 /**
422 * @tc.number: AccessibleAbilityChannel_Unittest_SendSimulateGesture_003
423 * @tc.name: SendSimulateGesture
424 * @tc.desc: Test function SendSimulateGesture
425 */
426 HWTEST_F(AccessibleAbilityChannelUnitTest,
427 AccessibleAbilityChannel_Unittest_SendSimulateGesture_003, TestSize.Level1)
428 {
429 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_SendSimulateGesture_003 start";
430 sptr<AccessibilityAccountData> accountData =
431 Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
432 // add a client which has no retieve capability
433 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>();
434 sptr<AccessibleAbilityConnection> connection =
435 new AccessibleAbilityConnection(accountData->GetAccountId(), 0, *abilityInfo);
436 AppExecFwk::ElementName elementName("device", "bundle", "ability");
437 std::string ability = "bundle/ability";
438 sptr<AccessibleAbilityChannel> channel = new AccessibleAbilityChannel(accountData->GetAccountId(), ability);
439 connection->OnAbilityConnectDoneSync(elementName, channel);
440 EXPECT_TRUE(accountData->GetAccessibleAbilityConnection(ability));
441 EXPECT_EQ(channel->SendSimulateGesture(nullptr), RET_ERR_NO_CAPABILITY);
442 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_SendSimulateGesture_003 end";
443 }
444
445 /**
446 * @tc.number: AccessibleAbilityChannel_Unittest_SetTargetBundleName_001
447 * @tc.name: SetTargetBundleName
448 * @tc.desc: Test function SetTargetBundleName
449 */
450 HWTEST_F(AccessibleAbilityChannelUnitTest,
451 AccessibleAbilityChannel_Unittest_SetTargetBundleName_001, TestSize.Level1)
452 {
453 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_SetTargetBundleName_001 start";
454 std::vector<std::string> targetBundleNames;
455 EXPECT_EQ(channel_->SetTargetBundleName(targetBundleNames), RET_OK);
456 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_SetTargetBundleName_001 end";
457 }
458
459 /**
460 * @tc.number: AccessibleAbilityChannel_Unittest_SetTargetBundleName_002
461 * @tc.name: SetTargetBundleName
462 * @tc.desc: Test function SetTargetBundleName
463 */
464 HWTEST_F(AccessibleAbilityChannelUnitTest,
465 AccessibleAbilityChannel_Unittest_SetTargetBundleName_002, TestSize.Level1)
466 {
467 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_SetTargetBundleName_002 start";
468 sptr<AccessibilityAccountData> accountData =
469 Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
470 ASSERT_TRUE(accountData);
471 std::string abilityName = "testSetTargetBundleName";
472 EXPECT_FALSE(accountData->GetAccessibleAbilityConnection(abilityName));
473 sptr<AccessibleAbilityChannel> channel = new AccessibleAbilityChannel(accountData->GetAccountId(), abilityName);
474 std::vector<std::string> targetBundleNames;
475 EXPECT_EQ(channel->SetTargetBundleName(targetBundleNames), RET_ERR_NO_CONNECTION);
476 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_SetTargetBundleName_002 end";
477 }
478 } // namespace Accessibility
479 } // namespace OHOS