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 <thread>
18 #include <chrono>
19 #include "accessibility_ability_info.h"
20 #include "accessibility_account_data.h"
21 #include "accessibility_element_operator_proxy.h"
22 #include "accessibility_ut_helper.h"
23 #include "accessible_ability_channel.h"
24 #include "accessibility_def.h"
25 #include "accessible_ability_connection.h"
26 #include "accessible_ability_manager_service.h"
27 #include "accessibility_window_manager.h"
28 #include "mock_accessibility_element_operator_stub.h"
29 #include "mock_accessibility_setting_provider.h"
30
31 using namespace testing;
32 using namespace testing::ext;
33
34 namespace OHOS {
35 namespace Accessibility {
36 class MockAccessibilityElementOperatorCallbackStub : public AccessibilityElementOperatorCallbackStub {
37 public:
38 MockAccessibilityElementOperatorCallbackStub() = default;
39 virtual ~MockAccessibilityElementOperatorCallbackStub() = default;
40
SetSearchElementInfoByAccessibilityIdResult(const std::vector<AccessibilityElementInfo> & infos,const int32_t requestId)41 void SetSearchElementInfoByAccessibilityIdResult(const std::vector<AccessibilityElementInfo> &infos,
42 const int32_t requestId) override {}
SetSearchDefaultFocusByWindowIdResult(const std::vector<AccessibilityElementInfo> & infos,const int32_t requestId)43 void SetSearchDefaultFocusByWindowIdResult(const std::vector<AccessibilityElementInfo> &infos,
44 const int32_t requestId) override {}
SetSearchElementInfoByTextResult(const std::vector<AccessibilityElementInfo> & infos,const int32_t requestId)45 void SetSearchElementInfoByTextResult(const std::vector<AccessibilityElementInfo> &infos,
46 const int32_t requestId) override {}
SetFindFocusedElementInfoResult(const AccessibilityElementInfo & info,const int32_t requestId)47 void SetFindFocusedElementInfoResult(const AccessibilityElementInfo &info, const int32_t requestId) override {}
SetFocusMoveSearchResult(const AccessibilityElementInfo & info,const int32_t requestId)48 void SetFocusMoveSearchResult(const AccessibilityElementInfo &info, const int32_t requestId) override {}
SetExecuteActionResult(const bool succeeded,const int32_t requestId)49 void SetExecuteActionResult(const bool succeeded, const int32_t requestId) override {}
SetCursorPositionResult(const int32_t cursorPosition,const int32_t requestId)50 void SetCursorPositionResult(const int32_t cursorPosition, const int32_t requestId) override {}
SetSearchElementInfoBySpecificPropertyResult(const std::list<AccessibilityElementInfo> & infos,const std::list<AccessibilityElementInfo> & treeInfos,const int32_t requestId)51 void SetSearchElementInfoBySpecificPropertyResult(const std::list<AccessibilityElementInfo> &infos,
52 const std::list<AccessibilityElementInfo> &treeInfos, const int32_t requestId) override
53 {
54 receivedInfos_.assign(infos.begin(), infos.end());
55 receivedTreeInfos_.assign(treeInfos.begin(), treeInfos.end());
56 receivedRequestId_ = requestId;
57 callbackCalled_ = true;
58
59 GTEST_LOG_(INFO) << "SetSearchElementInfoBySpecificPropertyResult called: requestId=" << requestId
60 << ", infos.size=" << infos.size() << ", treeInfos.size=" << treeInfos.size();
61 }
62
IsCallbackCalled() const63 bool IsCallbackCalled() const { return callbackCalled_; }
GetReceivedInfos() const64 const std::vector<AccessibilityElementInfo>& GetReceivedInfos() const { return receivedInfos_; }
GetReceivedTreeInfos() const65 const std::vector<AccessibilityElementInfo>& GetReceivedTreeInfos() const { return receivedTreeInfos_; }
GetReceivedRequestId() const66 int32_t GetReceivedRequestId() const { return receivedRequestId_; }
67
68 private:
69 bool callbackCalled_ = false;
70 std::vector<AccessibilityElementInfo> receivedInfos_;
71 std::vector<AccessibilityElementInfo> receivedTreeInfos_;
72 int32_t receivedRequestId_ = -1;
73 };
74 namespace {
75 constexpr int RETRY_TIMES = 10;
76 constexpr int ELEMENT_ID = 0;
77 constexpr int INVALID_ELEMENT_ID = -1;
78 constexpr uint32_t INVALID_SEQUENCE = 0;
79 constexpr uint64_t DISPLAY_ID = 0;
80 constexpr int32_t WINDOW_ID = 0;
81 constexpr int32_t ACCOUNT_ID = 0;
82 } // namespace
83
84 class AccessibleAbilityChannelUnitTest : public ::testing::Test {
85 public:
AccessibleAbilityChannelUnitTest()86 AccessibleAbilityChannelUnitTest()
87 {}
~AccessibleAbilityChannelUnitTest()88 ~AccessibleAbilityChannelUnitTest()
89 {}
90
91 static void SetUpTestCase();
92 static void TearDownTestCase();
93 void SetUp() override;
94 void TearDown() override;
95
96 bool TestElementId();
97 sptr<AccessibleAbilityChannel> channel_ = nullptr;
98 sptr<AccessibleAbilityConnection> connection_ = nullptr;
99 };
100
SetUpTestCase()101 void AccessibleAbilityChannelUnitTest::SetUpTestCase()
102 {
103 GTEST_LOG_(INFO) << "###################### AccessibleAbilityChannelUnitTest Start ######################";
104 Singleton<AccessibleAbilityManagerService>::GetInstance().OnStart();
105 }
106
TearDownTestCase()107 void AccessibleAbilityChannelUnitTest::TearDownTestCase()
108 {
109 GTEST_LOG_(INFO) << "###################### AccessibleAbilityChannelUnitTest End ######################";
110 Singleton<AccessibleAbilityManagerService>::GetInstance().OnStop();
111 }
112
SetUp()113 void AccessibleAbilityChannelUnitTest::SetUp()
114 {
115 GTEST_LOG_(INFO) << "SetUp";
116 // Add AA client
117 AccessibilityAbilityInitParams initParams;
118 initParams.bundleName = "testBundleName";
119 initParams.name = "testAbilityName";
120 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
121 ASSERT_TRUE(abilityInfo);
122 abilityInfo->SetEventTypes(EventType::TYPES_ALL_MASK);
123 abilityInfo->SetCapabilityValues(CAPABILITY_RETRIEVE | CAPABILITY_GESTURE);
124 sptr<AccessibilityAccountData> accountData =
125 Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
126 ASSERT_TRUE(accountData);
127 connection_ = new AccessibleAbilityConnection(accountData->GetAccountId(), 0, *abilityInfo);
128 ASSERT_TRUE(connection_);
129 AppExecFwk::ElementName elementName("testDeviceId", "testBundleName", "testAbilityName");
130 channel_ = new AccessibleAbilityChannel(accountData->GetAccountId(), abilityInfo->GetId());
131 ASSERT_TRUE(channel_);
132 connection_->OnAbilityConnectDoneSync(elementName, channel_);
133
134 // Add window connection
135 sptr<AccessibilityElementOperatorStub> stub = new MockAccessibilityElementOperatorStub();
136 ASSERT_TRUE(stub);
137 sptr<IAccessibilityElementOperator> proxy = new AccessibilityElementOperatorProxy(stub);
138 ASSERT_TRUE(proxy);
139 sptr<AccessibilityWindowConnection> connection = new AccessibilityWindowConnection(WINDOW_ID, proxy, ACCOUNT_ID);
140 ASSERT_TRUE(connection);
141 accountData->AddAccessibilityWindowConnection(WINDOW_ID, connection);
142
143 EXPECT_EQ(AccessibilityAbilityHelper::GetInstance().GetTestChannelElementId(), INVALID_ELEMENT_ID);
144 }
145
TearDown()146 void AccessibleAbilityChannelUnitTest::TearDown()
147 {
148 GTEST_LOG_(INFO) << "TearDown";
149 connection_ = nullptr;
150 channel_ = nullptr;
151 AccessibilityAbilityHelper::GetInstance().SetTestChannelElementId(INVALID_ELEMENT_ID);
152 }
153
TestElementId()154 bool AccessibleAbilityChannelUnitTest::TestElementId()
155 {
156 int retryCount = 0;
157 while (retryCount < RETRY_TIMES) {
158 sleep(1);
159 int elementId = AccessibilityAbilityHelper::GetInstance().GetTestChannelElementId();
160 GTEST_LOG_(INFO) << "element id is : " << elementId;
161 if (elementId == ELEMENT_ID) {
162 GTEST_LOG_(INFO) << "element id is true";
163 return true;
164 }
165 retryCount++;
166 }
167 return false;
168 }
169
170 /**
171 * @tc.number: AccessibleAbilityChannel_Unittest_SearchElementInfoByAccessibilityId_001
172 * @tc.name: SearchElementInfoByAccessibilityId
173 * @tc.desc: Test function SearchElementInfoByAccessibilityId
174 */
175 HWTEST_F(AccessibleAbilityChannelUnitTest,
176 AccessibleAbilityChannel_Unittest_SearchElementInfoByAccessibilityId_001, TestSize.Level1)
177 {
178 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_SearchElementInfoByAccessibilityId_001 start";
179 ElementBasicInfo elementBasicInfo;
180 elementBasicInfo.windowId = 0;
181 elementBasicInfo.treeId = 0;
182 elementBasicInfo.elementId = 0;
183 EXPECT_EQ(channel_->SearchElementInfoByAccessibilityId(elementBasicInfo, 0, nullptr, 0, true),
184 RET_ERR_NULLPTR);
185 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_SearchElementInfoByAccessibilityId_001 end";
186 }
187
188 /**
189 * @tc.number: AccessibleAbilityChannel_Unittest_SearchElementInfosByText_001
190 * @tc.name: SearchElementInfosByText
191 * @tc.desc: Test function SearchElementInfosByText
192 */
193 HWTEST_F(AccessibleAbilityChannelUnitTest,
194 AccessibleAbilityChannel_Unittest_SearchElementInfosByText_001, TestSize.Level1)
195 {
196 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_SearchElementInfosByText_001 start";
197 EXPECT_EQ(channel_->SearchElementInfosByText(WINDOW_ID, ELEMENT_ID, "test", 0, nullptr), RET_ERR_NULLPTR);
198 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_SearchElementInfosByText_001 end";
199 }
200
201 /**
202 * @tc.number: AccessibleAbilityChannel_Unittest_FindFocusedElementInfo_001
203 * @tc.name: FindFocusedElementInfo
204 * @tc.desc: Test function FindFocusedElementInfo
205 */
206 HWTEST_F(AccessibleAbilityChannelUnitTest,
207 AccessibleAbilityChannel_Unittest_FindFocusedElementInfo_001, TestSize.Level1)
208 {
209 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_FindFocusedElementInfo_001 start";
210 EXPECT_EQ(channel_->FindFocusedElementInfo(WINDOW_ID, ELEMENT_ID, FOCUS_TYPE_INPUT, 0, nullptr), RET_ERR_NULLPTR);
211 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_FindFocusedElementInfo_001 end";
212 }
213
214 /**
215 * @tc.number: AccessibleAbilityChannel_Unittest_FocusMoveSearch_001
216 * @tc.name: FocusMoveSearch
217 * @tc.desc: Test function FocusMoveSearch
218 */
219 HWTEST_F(AccessibleAbilityChannelUnitTest,
220 AccessibleAbilityChannel_Unittest_FocusMoveSearch_001, TestSize.Level1)
221 {
222 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_FocusMoveSearch_001 start";
223 EXPECT_EQ(channel_->FocusMoveSearch(WINDOW_ID, ELEMENT_ID, UP, 0, nullptr), RET_ERR_NULLPTR);
224 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_FocusMoveSearch_001 end";
225 }
226
227 /**
228 * @tc.number: AccessibleAbilityChannel_Unittest_ExecuteAction_001
229 * @tc.name: ExecuteAction
230 * @tc.desc: Test function ExecuteAction
231 */
232 HWTEST_F(AccessibleAbilityChannelUnitTest,
233 AccessibleAbilityChannel_Unittest_ExecuteAction_001, TestSize.Level1)
234 {
235 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_ExecuteAction_001 start";
236 std::map<std::string, std::string> actionArguments;
237 EXPECT_EQ(channel_->ExecuteAction(WINDOW_ID, ELEMENT_ID, 1, actionArguments, 0, nullptr), RET_ERR_NULLPTR);
238 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_ExecuteAction_001 end";
239 }
240
241 /**
242 * @tc.number: AccessibleAbilityChannel_Unittest_GetWindow_001
243 * @tc.name: GetWindow
244 * @tc.desc: Test function GetWindow
245 */
246 HWTEST_F(AccessibleAbilityChannelUnitTest,
247 AccessibleAbilityChannel_Unittest_GetWindow_001, TestSize.Level1)
248 {
249 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_GetWindow_001 start";
250 AccessibilityWindowInfo windowInfo;
251 EXPECT_EQ(channel_->GetWindow(WINDOW_ID, windowInfo), RET_ERR_NO_WINDOW_CONNECTION);
252 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_GetWindow_001 end";
253 }
254
255 /**
256 * @tc.number: AccessibleAbilityChannel_Unittest_GetWindow_002
257 * @tc.name: GetWindow
258 * @tc.desc: Test function GetWindow
259 */
260 HWTEST_F(AccessibleAbilityChannelUnitTest,
261 AccessibleAbilityChannel_Unittest_GetWindow_002, TestSize.Level1)
262 {
263 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_GetWindow_002 start";
264 sptr<AccessibilityAccountData> accountData =
265 Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
266 ASSERT_TRUE(accountData);
267 std::string ability = "testGetWindow";
268 EXPECT_FALSE(accountData->GetAccessibleAbilityConnection(ability));
269
270 sptr<AccessibleAbilityChannel> channel = new AccessibleAbilityChannel(accountData->GetAccountId(), ability);
271 AccessibilityWindowInfo windowInfo;
272 EXPECT_EQ(channel->GetWindow(WINDOW_ID, windowInfo), RET_ERR_NO_CONNECTION);
273 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_GetWindow_002 end";
274 }
275
276 /**
277 * @tc.number: AccessibleAbilityChannel_Unittest_GetWindow_003
278 * @tc.name: GetWindow
279 * @tc.desc: Test function GetWindow
280 */
281 HWTEST_F(AccessibleAbilityChannelUnitTest,
282 AccessibleAbilityChannel_Unittest_GetWindow_003, TestSize.Level1)
283 {
284 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_GetWindow_003 start";
285 sptr<AccessibilityAccountData> accountData =
286 Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
287 ASSERT_TRUE(accountData);
288
289 // add a client which has no retieve capability
290 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>();
291 sptr<AccessibleAbilityConnection> connection =
292 new AccessibleAbilityConnection(accountData->GetAccountId(), 0, *abilityInfo);
293 AppExecFwk::ElementName elementName("device", "bundle", "ability");
294 std::string ability = "bundle/ability";
295 sptr<AccessibleAbilityChannel> channel = new AccessibleAbilityChannel(accountData->GetAccountId(), ability);
296 connection->OnAbilityConnectDoneSync(elementName, channel);
297 EXPECT_TRUE(accountData->GetAccessibleAbilityConnection(ability));
298
299 AccessibilityWindowInfo windowInfo;
300 EXPECT_EQ(channel->GetWindow(WINDOW_ID, windowInfo), RET_ERR_NO_CAPABILITY);
301 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_GetWindow_003 end";
302 }
303
304 /**
305 * @tc.number: AccessibleAbilityChannel_Unittest_GetWindows_001
306 * @tc.name: GetWindows
307 * @tc.desc: Test function GetWindows
308 */
309 HWTEST_F(AccessibleAbilityChannelUnitTest,
310 AccessibleAbilityChannel_Unittest_GetWindows_001, TestSize.Level1)
311 {
312 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_GetWindows_001 start";
313 std::vector<AccessibilityWindowInfo> windows;
314 EXPECT_EQ(channel_->GetWindows(windows), RET_OK);
315 EXPECT_EQ(static_cast<int>(windows.size()), 0);
316 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_GetWindows_001 end";
317 }
318
319 /**
320 * @tc.number: AccessibleAbilityChannel_Unittest_GetWindows_002
321 * @tc.name: GetWindows
322 * @tc.desc: Test function GetWindows
323 */
324 HWTEST_F(AccessibleAbilityChannelUnitTest,
325 AccessibleAbilityChannel_Unittest_GetWindows_002, TestSize.Level1)
326 {
327 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_GetWindows_002 start";
328 std::string abilityName = "testGetWindows";
329 sptr<AccessibilityAccountData> accountData =
330 Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
331 ASSERT_TRUE(accountData);
332 EXPECT_FALSE(accountData->GetAccessibleAbilityConnection(abilityName));
333 sptr<AccessibleAbilityChannel> channel = new AccessibleAbilityChannel(accountData->GetAccountId(), abilityName);
334
335 std::vector<AccessibilityWindowInfo> windows;
336 EXPECT_EQ(channel->GetWindows(windows), RET_ERR_NO_CONNECTION);
337 EXPECT_EQ(static_cast<int>(windows.size()), 0);
338 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_GetWindows_002 end";
339 }
340
341 /**
342 * @tc.number: AccessibleAbilityChannel_Unittest_GetWindows_003
343 * @tc.name: GetWindows
344 * @tc.desc: Test function GetWindows
345 */
346 HWTEST_F(AccessibleAbilityChannelUnitTest,
347 AccessibleAbilityChannel_Unittest_GetWindows_003, TestSize.Level1)
348 {
349 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_GetWindows_003 start";
350 sptr<AccessibilityAccountData> accountData =
351 Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
352 ASSERT_TRUE(accountData);
353
354 // Add AA client which has no retieve capability
355 AccessibilityAbilityInitParams initParams;
356 initParams.bundleName = "bundle";
357 initParams.name = "ability";
358 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
359 sptr<AccessibleAbilityConnection> connection =
360 new AccessibleAbilityConnection(accountData->GetAccountId(), 0, *abilityInfo);
361 AppExecFwk::ElementName elementName("device", "bundle", "ability");
362 sptr<AccessibleAbilityChannel> channel =
363 new AccessibleAbilityChannel(accountData->GetAccountId(), abilityInfo->GetId());
364 connection->OnAbilityConnectDoneSync(elementName, channel);
365 EXPECT_TRUE(accountData->GetAccessibleAbilityConnection(abilityInfo->GetId()));
366
367 std::vector<AccessibilityWindowInfo> windows;
368 EXPECT_EQ(channel->GetWindows(windows), RET_ERR_NO_CAPABILITY);
369 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_GetWindows_003 end";
370 }
371
372 /**
373 * @tc.number: AccessibleAbilityChannel_Unittest_GetWindowsByDisplayId_001
374 * @tc.name: GetWindowsByDisplayId
375 * @tc.desc: Test function GetWindowsByDisplayId
376 */
377 HWTEST_F(AccessibleAbilityChannelUnitTest,
378 AccessibleAbilityChannel_Unittest_GetWindowsByDisplayId_001, TestSize.Level1)
379 {
380 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_GetWindowsByDisplayId_001 start";
381 std::vector<AccessibilityWindowInfo> windows;
382 EXPECT_EQ(channel_->GetWindowsByDisplayId(DISPLAY_ID, windows), RET_OK);
383 EXPECT_EQ(static_cast<int>(windows.size()), 0);
384 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_GetWindowsByDisplayId_001 end";
385 }
386
387 /**
388 * @tc.number: AccessibleAbilityChannel_Unittest_SetOnKeyPressEventResult_001
389 * @tc.name: SetOnKeyPressEventResult
390 * @tc.desc: Test function SetOnKeyPressEventResult
391 */
392 HWTEST_F(AccessibleAbilityChannelUnitTest,
393 AccessibleAbilityChannel_Unittest_SetOnKeyPressEventResult_001, TestSize.Level1)
394 {
395 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_SetOnKeyPressEventResult_001 start";
396 AccessibilityAbilityHelper::GetInstance().SetTestSequence(INVALID_SEQUENCE);
397 EXPECT_EQ(AccessibilityAbilityHelper::GetInstance().GetTestSequence(), INVALID_SEQUENCE);
398 sptr<KeyEventFilter> keyEventFilter = new KeyEventFilter();
399 ASSERT_TRUE(keyEventFilter);
400 Singleton<AccessibleAbilityManagerService>::GetInstance().SetKeyEventFilter(keyEventFilter);
401
402 uint32_t sequence = 1;
403 channel_->SetOnKeyPressEventResult(true, sequence);
404
405 int retryCount = 0;
406 bool result = false;
407 while (retryCount < RETRY_TIMES) {
408 sleep(1);
409 uint32_t sequenceNum = AccessibilityAbilityHelper::GetInstance().GetTestSequence();
410 GTEST_LOG_(INFO) << "sequence is : " << sequenceNum;
411 if (sequenceNum == sequence) {
412 GTEST_LOG_(INFO) << "sequence is true";
413 result = true;
414 break;
415 }
416 retryCount++;
417 }
418 EXPECT_TRUE(result);
419 AccessibilityAbilityHelper::GetInstance().SetTestSequence(INVALID_SEQUENCE);
420 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_SetOnKeyPressEventResult_001 end";
421 }
422
423 /**
424 * @tc.number: AccessibleAbilityChannel_Unittest_SendSimulateGesture_001
425 * @tc.name: SendSimulateGesture
426 * @tc.desc: Test function SendSimulateGesture
427 */
428 HWTEST_F(AccessibleAbilityChannelUnitTest,
429 AccessibleAbilityChannel_Unittest_SendSimulateGesture_001, TestSize.Level1)
430 {
431 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_SendSimulateGesture_001 start";
432 EXPECT_EQ(channel_->SendSimulateGesture(nullptr), RET_ERR_NO_INJECTOR);
433 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_SendSimulateGesture_001 end";
434 }
435
436 /**
437 * @tc.number: AccessibleAbilityChannel_Unittest_SendSimulateGesture_002
438 * @tc.name: SendSimulateGesture
439 * @tc.desc: Test function SendSimulateGesture
440 */
441 HWTEST_F(AccessibleAbilityChannelUnitTest,
442 AccessibleAbilityChannel_Unittest_SendSimulateGesture_002, TestSize.Level1)
443 {
444 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_SendSimulateGesture_002 start";
445 std::string abilityName = "testGesture";
446 sptr<AccessibilityAccountData> accountData =
447 Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
448 ASSERT_TRUE(accountData);
449 EXPECT_FALSE(accountData->GetAccessibleAbilityConnection(abilityName));
450 sptr<AccessibleAbilityChannel> channel = new AccessibleAbilityChannel(accountData->GetAccountId(), abilityName);
451 EXPECT_EQ(channel->SendSimulateGesture(nullptr), RET_ERR_NO_CONNECTION);
452 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_SendSimulateGesture_002 end";
453 }
454
455 /**
456 * @tc.number: AccessibleAbilityChannel_Unittest_SendSimulateGesture_003
457 * @tc.name: SendSimulateGesture
458 * @tc.desc: Test function SendSimulateGesture
459 */
460 HWTEST_F(AccessibleAbilityChannelUnitTest,
461 AccessibleAbilityChannel_Unittest_SendSimulateGesture_003, TestSize.Level1)
462 {
463 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_SendSimulateGesture_003 start";
464 sptr<AccessibilityAccountData> accountData =
465 Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
466 // add a client which has no retieve capability
467 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>();
468 sptr<AccessibleAbilityConnection> connection =
469 new AccessibleAbilityConnection(accountData->GetAccountId(), 0, *abilityInfo);
470 AppExecFwk::ElementName elementName("device", "bundle", "ability");
471 std::string ability = "bundle/ability";
472 sptr<AccessibleAbilityChannel> channel = new AccessibleAbilityChannel(accountData->GetAccountId(), ability);
473 connection->OnAbilityConnectDoneSync(elementName, channel);
474 EXPECT_TRUE(accountData->GetAccessibleAbilityConnection(ability));
475 EXPECT_EQ(channel->SendSimulateGesture(nullptr), RET_ERR_NO_CAPABILITY);
476 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_SendSimulateGesture_003 end";
477 }
478
479 /**
480 * @tc.number: AccessibleAbilityChannel_Unittest_SetTargetBundleName_001
481 * @tc.name: SetTargetBundleName
482 * @tc.desc: Test function SetTargetBundleName
483 */
484 HWTEST_F(AccessibleAbilityChannelUnitTest,
485 AccessibleAbilityChannel_Unittest_SetTargetBundleName_001, TestSize.Level1)
486 {
487 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_SetTargetBundleName_001 start";
488 std::vector<std::string> targetBundleNames;
489 EXPECT_EQ(channel_->SetTargetBundleName(targetBundleNames), RET_OK);
490 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_SetTargetBundleName_001 end";
491 }
492
493 /**
494 * @tc.number: AccessibleAbilityChannel_Unittest_SetTargetBundleName_002
495 * @tc.name: SetTargetBundleName
496 * @tc.desc: Test function SetTargetBundleName
497 */
498 HWTEST_F(AccessibleAbilityChannelUnitTest,
499 AccessibleAbilityChannel_Unittest_SetTargetBundleName_002, TestSize.Level1)
500 {
501 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_SetTargetBundleName_002 start";
502 sptr<AccessibilityAccountData> accountData =
503 Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
504 ASSERT_TRUE(accountData);
505 std::string abilityName = "testSetTargetBundleName";
506 EXPECT_FALSE(accountData->GetAccessibleAbilityConnection(abilityName));
507 sptr<AccessibleAbilityChannel> channel = new AccessibleAbilityChannel(accountData->GetAccountId(), abilityName);
508 std::vector<std::string> targetBundleNames;
509 EXPECT_EQ(channel->SetTargetBundleName(targetBundleNames), RET_ERR_NO_CONNECTION);
510 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_SetTargetBundleName_002 end";
511 }
512
513 /**
514 * @tc.number: AccessibleAbilityChannel_Unittest_GetCursorPosition_001
515 * @tc.name: GetCursorPosition
516 * @tc.desc: Test function GetCursorPosition
517 */
518 HWTEST_F(AccessibleAbilityChannelUnitTest,
519 AccessibleAbilityChannel_Unittest_GetCursorPosition_001, TestSize.Level1)
520 {
521 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_GetCursorPosition_001 start";
522 sptr<AccessibilityAccountData> accountData =
523 Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
524 ASSERT_TRUE(accountData);
525 std::string abilityName = "testSetTargetBundleName";
526 EXPECT_FALSE(accountData->GetAccessibleAbilityConnection(abilityName));
527 sptr<AccessibleAbilityChannel> channel = new AccessibleAbilityChannel(accountData->GetAccountId(), abilityName);
528
529 EXPECT_EQ(channel->GetCursorPosition(WINDOW_ID, ELEMENT_ID, 0, nullptr), RET_ERR_NO_CONNECTION);
530 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_GetCursorPosition_001 end";
531 }
532
533 /**
534 * @tc.number: AccessibleAbilityChannel_Unittest_SearchElementInfoBySpecificProperty_001
535 * @tc.name: SearchElementInfoBySpecificProperty
536 * @tc.desc: Test function SearchElementInfoBySpecificProperty
537 */
538 HWTEST_F(AccessibleAbilityChannelUnitTest,
539 AccessibleAbilityChannel_Unittest_SearchElementInfoBySpecificProperty_001, TestSize.Level1)
540 {
541 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_SearchElementInfoBySpecificProperty_001 start";
542 ElementBasicInfo elementBasicInfo;
543 elementBasicInfo.windowId = 0;
544 elementBasicInfo.treeId = 0;
545 elementBasicInfo.elementId = 0;
546 SpecificPropertyParam param;
547 channel_->SearchElementInfoBySpecificProperty(elementBasicInfo, param, 0, nullptr);
548
549 EXPECT_NE(channel_, nullptr) << "channel_ should remain valid after method call";
550 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_SearchElementInfoBySpecificProperty_001 end";
551 }
552
553 /**
554 * @tc.number: AccessibleAbilityChannel_Unittest_SearchElementInfoBySpecificProperty_002
555 * @tc.name: SearchElementInfoBySpecificProperty
556 * @tc.desc: Test function SearchElementInfoBySpecificProperty with callback is nullptr
557 */
558 HWTEST_F(AccessibleAbilityChannelUnitTest,
559 AccessibleAbilityChannel_Unittest_SearchElementInfoBySpecificProperty_002, TestSize.Level1)
560 {
561 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_SearchElementInfoBySpecificProperty_002 start";
562 ElementBasicInfo elementBasicInfo;
563 elementBasicInfo.windowId = 1;
564 elementBasicInfo.treeId = 0;
565 elementBasicInfo.elementId = 1;
566 SpecificPropertyParam param;
567 channel_->SearchElementInfoBySpecificProperty(elementBasicInfo, param, 1, nullptr);
568 EXPECT_NE(channel_, nullptr) << "channel_ should remain valid after method call";
569 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_SearchElementInfoBySpecificProperty_002 end";
570 }
571
572 /**
573 * @tc.number: AccessibleAbilityChannel_Unittest_SearchElementInfoBySpecificProperty_003
574 * @tc.name: SearchElementInfoBySpecificProperty
575 * @tc.desc: Test function SearchElementInfoBySpecificProperty with valid callback
576 */
577 HWTEST_F(AccessibleAbilityChannelUnitTest,
578 AccessibleAbilityChannel_Unittest_SearchElementInfoBySpecificProperty_003, TestSize.Level1)
579 {
580 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_SearchElementInfoBySpecificProperty_003 start";
581 ElementBasicInfo elementBasicInfo;
582 elementBasicInfo.windowId = 1;
583 elementBasicInfo.treeId = 0;
584 elementBasicInfo.elementId = 1;
585 SpecificPropertyParam param;
586 param.propertyTarget = "test";
587 param.propertyType = SEARCH_TYPE::CUSTOMID;
588 sptr<MockAccessibilityElementOperatorCallbackStub> callback =
589 new MockAccessibilityElementOperatorCallbackStub();
590 channel_->SearchElementInfoBySpecificProperty(elementBasicInfo, param, 2, callback);
591 EXPECT_NE(channel_, nullptr) << "channel_ should remain valid after method call";
592 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_SearchElementInfoBySpecificProperty_003 end";
593 }
594
595 /**
596 * @tc.number: AccessibleAbilityChannel_Unittest_SearchElementInfoBySpecificProperty_004
597 * @tc.name: SearchElementInfoBySpecificProperty
598 * @tc.desc: Test function SearchElementInfoBySpecificProperty with invalid windowId
599 */
600 HWTEST_F(AccessibleAbilityChannelUnitTest,
601 AccessibleAbilityChannel_Unittest_SearchElementInfoBySpecificProperty_004, TestSize.Level1)
602 {
603 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_SearchElementInfoBySpecificProperty_004 start";
604 ElementBasicInfo elementBasicInfo;
605 elementBasicInfo.windowId = -1;
606 elementBasicInfo.treeId = 0;
607 elementBasicInfo.elementId = 1;
608 SpecificPropertyParam param;
609 param.propertyTarget = "test";
610 param.propertyType = SEARCH_TYPE::CUSTOMID;
611 sptr<MockAccessibilityElementOperatorCallbackStub> callback =
612 new MockAccessibilityElementOperatorCallbackStub();
613 channel_->SearchElementInfoBySpecificProperty(elementBasicInfo, param, 3, callback);
614 EXPECT_NE(channel_, nullptr) << "channel_ should remain valid after method call";
615 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_SearchElementInfoBySpecificProperty_004 end";
616 }
617
618 /**
619 * @tc.number: AccessibleAbilityChannel_Unittest_SearchElementInfoBySpecificProperty_005
620 * @tc.name: SearchElementInfoBySpecificProperty
621 * @tc.desc: Test function SearchElementInfoBySpecificProperty with GetElementOperator failure path
622 */
623 HWTEST_F(AccessibleAbilityChannelUnitTest,
624 AccessibleAbilityChannel_Unittest_SearchElementInfoBySpecificProperty_005, TestSize.Level1)
625 {
626 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_SearchElementInfoBySpecificProperty_005 start";
627 sptr<AccessibilityAccountData> accountData =
628 Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
629 ASSERT_TRUE(accountData);
630 accountData->RemoveAccessibilityWindowConnection(WINDOW_ID);
631 ElementBasicInfo elementBasicInfo;
632 elementBasicInfo.windowId = WINDOW_ID;
633 elementBasicInfo.treeId = 0;
634 elementBasicInfo.elementId = 1;
635 SpecificPropertyParam param;
636 param.propertyTarget = "test";
637 param.propertyType = SEARCH_TYPE::CUSTOMID;
638 sptr<MockAccessibilityElementOperatorCallbackStub> callback =
639 new MockAccessibilityElementOperatorCallbackStub();
640 channel_->SearchElementInfoBySpecificProperty(elementBasicInfo, param, 4, callback);
641 std::this_thread::sleep_for(std::chrono::milliseconds(200));
642 EXPECT_TRUE(callback->IsCallbackCalled());
643 EXPECT_TRUE(callback->GetReceivedInfos().empty());
644 EXPECT_TRUE(callback->GetReceivedTreeInfos().empty());
645 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_SearchElementInfoBySpecificProperty_005 end";
646 }
647
648 /**
649 * @tc.number: AccessibleAbilityChannel_Unittest_SearchElementInfoBySpecificProperty_006
650 * @tc.name: SearchElementInfoBySpecificProperty
651 * @tc.desc: Test function SearchElementInfoBySpecificProperty with SCENE_BOARD_WINDOW_ID and IsInnerWindowRootElement
652 */
653 HWTEST_F(AccessibleAbilityChannelUnitTest,
654 AccessibleAbilityChannel_Unittest_SearchElementInfoBySpecificProperty_006, TestSize.Level1)
655 {
656 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_SearchElementInfoBySpecificProperty_006 start";
657 sptr<AccessibilityAccountData> accountData =
658 Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
659 ASSERT_TRUE(accountData);
660 sptr<AccessibilityElementOperatorStub> stub = new MockAccessibilityElementOperatorStub();
661 ASSERT_TRUE(stub);
662 sptr<IAccessibilityElementOperator> proxy = new AccessibilityElementOperatorProxy(stub);
663 ASSERT_TRUE(proxy);
664 sptr<AccessibilityWindowConnection> connection = new AccessibilityWindowConnection(1, proxy, ACCOUNT_ID);
665 ASSERT_TRUE(connection);
666 accountData->AddAccessibilityWindowConnection(1, connection);
667 auto& awm = Singleton<AccessibilityWindowManager>::GetInstance();
668 int64_t testElementId = 12345;
669 awm.sceneBoardElementIdMap_.InsertPair(1, testElementId);
670 ElementBasicInfo elementBasicInfo;
671 elementBasicInfo.windowId = 1;
672 elementBasicInfo.treeId = 0;
673 elementBasicInfo.elementId = testElementId;
674 SpecificPropertyParam param;
675 param.propertyTarget = "test";
676 param.propertyType = SEARCH_TYPE::CUSTOMID;
677 sptr<MockAccessibilityElementOperatorCallbackStub> callback =
678 new MockAccessibilityElementOperatorCallbackStub();
679 channel_->SearchElementInfoBySpecificProperty(elementBasicInfo, param, 5, callback);
680 std::this_thread::sleep_for(std::chrono::milliseconds(200));
681 EXPECT_TRUE(callback->IsCallbackCalled());
682 EXPECT_TRUE(callback->GetReceivedInfos().empty());
683 EXPECT_TRUE(callback->GetReceivedTreeInfos().empty());
684 EXPECT_TRUE(awm.IsInnerWindowRootElement(testElementId));
685 awm.sceneBoardElementIdMap_.Clear();
686 accountData->RemoveAccessibilityWindowConnection(1);
687 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_SearchElementInfoBySpecificProperty_006 end";
688 }
689
690 /**
691 * @tc.number: AccessibleAbilityChannel_Unittest_SearchElementInfoBySpecificProperty_007
692 * @tc.name: SearchElementInfoBySpecificProperty
693 * @tc.desc: Test function SearchElementInfoBySpecificProperty with normal execution path (non-SCENE_BOARD_WINDOW_ID)
694 */
695 HWTEST_F(AccessibleAbilityChannelUnitTest,
696 AccessibleAbilityChannel_Unittest_SearchElementInfoBySpecificProperty_007, TestSize.Level1)
697 {
698 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_SearchElementInfoBySpecificProperty_007 start";
699 auto& awm = Singleton<AccessibilityWindowManager>::GetInstance();
700 awm.sceneBoardElementIdMap_.Clear();
701 sptr<AccessibilityAccountData> accountData =
702 Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
703 ASSERT_TRUE(accountData);
704
705 sptr<AccessibilityElementOperatorStub> stub = new MockAccessibilityElementOperatorStub();
706 ASSERT_TRUE(stub);
707 sptr<IAccessibilityElementOperator> proxy = new AccessibilityElementOperatorProxy(stub);
708 ASSERT_TRUE(proxy);
709 int32_t normalWindowId = 2;
710 sptr<AccessibilityWindowConnection> connection =
711 new AccessibilityWindowConnection(normalWindowId, proxy, ACCOUNT_ID);
712 ASSERT_TRUE(connection);
713 accountData->AddAccessibilityWindowConnection(normalWindowId, connection);
714 ElementBasicInfo elementBasicInfo;
715 elementBasicInfo.windowId = normalWindowId;
716 elementBasicInfo.treeId = 0;
717 elementBasicInfo.elementId = 12345;
718 SpecificPropertyParam param;
719 param.propertyTarget = "test";
720 param.propertyType = SEARCH_TYPE::CUSTOMID;
721 sptr<MockAccessibilityElementOperatorCallbackStub> callback =
722 new MockAccessibilityElementOperatorCallbackStub();
723 channel_->SearchElementInfoBySpecificProperty(elementBasicInfo, param, 6, callback);
724 std::this_thread::sleep_for(std::chrono::milliseconds(200));
725 std::list<AccessibilityElementInfo> mockInfos;
726 std::list<AccessibilityElementInfo> mockTreeInfos;
727 AccessibilityElementInfo mockInfo;
728 mockInfo.SetAccessibilityId(12345);
729 mockInfo.SetComponentType("normal_execution_test");
730 mockInfos.push_back(mockInfo);
731 AccessibilityElementInfo mockTreeInfo;
732 mockTreeInfo.SetAccessibilityId(12346);
733 mockTreeInfo.SetComponentType("tree_info_test");
734 mockTreeInfos.push_back(mockTreeInfo);
735 callback->SetSearchElementInfoBySpecificPropertyResult(mockInfos, mockTreeInfos, 6);
736 EXPECT_TRUE(callback->IsCallbackCalled());
737 EXPECT_FALSE(callback->GetReceivedInfos().empty());
738 EXPECT_FALSE(callback->GetReceivedTreeInfos().empty());
739 accountData->RemoveAccessibilityWindowConnection(normalWindowId);
740 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_SearchElementInfoBySpecificProperty_007 end";
741 }
742
743 /**
744 * @tc.number: AccessibleAbilityChannel_Unittest_SearchElementInfoBySpecificProperty_008
745 * @tc.name: SearchElementInfoBySpecificProperty
746 * @tc.desc: Test function SearchElementInfoBySpecificProperty with CheckWinFromAwm failure path
747 */
748 HWTEST_F(AccessibleAbilityChannelUnitTest,
749 AccessibleAbilityChannel_Unittest_SearchElementInfoBySpecificProperty_008, TestSize.Level1)
750 {
751 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_SearchElementInfoBySpecificProperty_008 start";
752 sptr<AccessibilityAccountData> accountData =
753 Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
754 ASSERT_TRUE(accountData);
755 int32_t invalidWindowId = 9999;
756 sptr<AccessibilityElementOperatorStub> stub = new MockAccessibilityElementOperatorStub();
757 ASSERT_TRUE(stub);
758 sptr<IAccessibilityElementOperator> proxy = new AccessibilityElementOperatorProxy(stub);
759 ASSERT_TRUE(proxy);
760 sptr<AccessibilityWindowConnection> connection = new AccessibilityWindowConnection(invalidWindowId, proxy,
761 ACCOUNT_ID);
762 ASSERT_TRUE(connection);
763 accountData->AddAccessibilityWindowConnection(invalidWindowId, connection);
764 ElementBasicInfo elementBasicInfo;
765 elementBasicInfo.windowId = invalidWindowId;
766 elementBasicInfo.treeId = 0;
767 elementBasicInfo.elementId = 1;
768 SpecificPropertyParam param;
769 param.propertyTarget = "test";
770 param.propertyType = SEARCH_TYPE::CUSTOMID;
771 sptr<MockAccessibilityElementOperatorCallbackStub> callback =
772 new MockAccessibilityElementOperatorCallbackStub();
773 channel_->SearchElementInfoBySpecificProperty(elementBasicInfo, param, 7, callback);
774 std::this_thread::sleep_for(std::chrono::milliseconds(200));
775 EXPECT_TRUE(callback->IsCallbackCalled());
776 EXPECT_TRUE(callback->GetReceivedInfos().empty());
777 EXPECT_TRUE(callback->GetReceivedTreeInfos().empty());
778 accountData->RemoveAccessibilityWindowConnection(invalidWindowId);
779 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_Unittest_SearchElementInfoBySpecificProperty_008 end";
780 }
781 } // namespace Accessibility
782 } // namespace OHOS