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