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