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_common_helper.h"
18 #include "accessibility_display_manager.h"
19 #include "accessibility_element_operator_stub.h"
20 #include "accessibility_mt_helper.h"
21 #include "accessible_ability_channel.h"
22 #include "accessible_ability_manager_service.h"
23 #include "display_manager.h"
24 #include "iservice_registry.h"
25 #include "mock_accessibility_element_operator_callback.h"
26 #include "mock_accessibility_element_operator_impl.h"
27 #include "mock_accessibility_element_operator_proxy.h"
28
29 using namespace testing;
30 using namespace testing::ext;
31
32 namespace OHOS {
33 namespace Accessibility {
34 class MockAamsAccessibleAbilityChannelTest : public testing::Test {
35 public:
MockAamsAccessibleAbilityChannelTest()36 MockAamsAccessibleAbilityChannelTest()
37 {}
~MockAamsAccessibleAbilityChannelTest()38 ~MockAamsAccessibleAbilityChannelTest()
39 {}
40
41 static void SetUpTestCase();
42 static void TearDownTestCase();
43 void SetUp() override;
44 void TearDown() override;
45
46 void WritefileAll(const char* fname, const char* data);
47 void AddAccessibleAbilityConnection(bool isNoCapability = false);
48 void AddAccessibilityWindowConnection();
49 sptr<AccessibilityAccountData> accountData_ = nullptr;
50 sptr<AccessibleAbilityChannel> aastub_ = nullptr;
51 sptr<AppExecFwk::ElementName> elementName_ = nullptr;
52 sptr<AccessibleAbilityConnection> AAConnection_ = nullptr;
53 sptr<MockAccessibilityElementOperatorProxy> proxy_ = nullptr;
54 };
55
SetUpTestCase()56 void MockAamsAccessibleAbilityChannelTest::SetUpTestCase()
57 {
58 GTEST_LOG_(INFO) << "MockAamsAccessibleAbilityChannelTest SetUpTestCase";
59
60 // Start AAMS
61 Singleton<AccessibleAbilityManagerService>::GetInstance().OnStart();
62 AccessibilityCommonHelper::GetInstance().WaitForServicePublish();
63 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(AccessibilityHelper::accountId_);
64 GTEST_LOG_(INFO) << "AccessibleAbilityManagerService is published";
65 }
66
TearDownTestCase()67 void MockAamsAccessibleAbilityChannelTest::TearDownTestCase()
68 {
69 GTEST_LOG_(INFO) << "MockAamsAccessibleAbilityChannelTest TearDownTestCase";
70
71 // Stop AAMS
72 Singleton<AccessibleAbilityManagerService>::GetInstance().OnStop();
73 }
74
SetUp()75 void MockAamsAccessibleAbilityChannelTest::SetUp()
76 {
77 GTEST_LOG_(INFO) << "MockAamsAccessibleAbilityChannelTest SetUp";
78 }
79
TearDown()80 void MockAamsAccessibleAbilityChannelTest::TearDown()
81 {
82 GTEST_LOG_(INFO) << "MockAamsAccessibleAbilityChannelTest TearDown";
83
84 Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData()->OnAccountSwitched();
85 // Deregister ElementOperator
86 Singleton<AccessibleAbilityManagerService>::GetInstance().DeregisterElementOperator(0);
87 bool ret = AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([=]() -> bool {
88 auto &aams = Singleton<AccessibleAbilityManagerService>::GetInstance();
89 if (aams.GetMainRunner()->GetEventQueue()->IsIdle()) {
90 return true;
91 } else {
92 return false;
93 }
94 }), 1);
95 if (!ret) {
96 GTEST_LOG_(INFO) << "MockAamsAccessibleAbilityChannelTest TearDown EventQueue is not empty";
97 }
98 accountData_ = nullptr;
99 aastub_ = nullptr;
100 elementName_ = nullptr;
101 AAConnection_ = nullptr;
102 proxy_ = nullptr;
103 }
104
WritefileAll(const char* fname, const char* data)105 void MockAamsAccessibleAbilityChannelTest::WritefileAll(const char* fname, const char* data)
106 {
107 FILE* fp = nullptr;
108 if (!(fp = fopen(fname, "w"))) {
109 printf("open file %s fail \n", fname);
110 return;
111 }
112
113 (void)fprintf(fp, "%s", data);
114 (void)fclose(fp);
115 }
116
AddAccessibleAbilityConnection(bool isNoCapability)117 void MockAamsAccessibleAbilityChannelTest::AddAccessibleAbilityConnection(bool isNoCapability)
118 {
119 GTEST_LOG_(INFO) << "MockAamsAccessibleAbilityChannelTest AddAccessibleAbilityConnection";
120 AAFwk::Want want;
121 AppExecFwk::ElementName name;
122 std::string deviceId;
123 name.SetAbilityName("com.example.aalisttest.MainAbility");
124 name.SetBundleName("com.example.aalisttest");
125 want.SetElement(name);
126
127 AccessibilityAbilityInitParams initParams;
128 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
129 abilityInfo->SetAccessibilityAbilityType(AccessibilityAbilityTypes::ACCESSIBILITY_ABILITY_TYPE_ALL);
130 uint32_t capabilities = 0;
131 if (!isNoCapability) {
132 capabilities = Capability::CAPABILITY_RETRIEVE | Capability::CAPABILITY_TOUCH_GUIDE |
133 Capability::CAPABILITY_GESTURE | Capability::CAPABILITY_KEY_EVENT_OBSERVER;
134 }
135 abilityInfo->SetCapabilityValues(capabilities);
136 accountData_ = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
137 accountData_->Init();
138 AAConnection_ = new AccessibleAbilityConnection(accountData_->GetAccountId(), 0, *abilityInfo);
139 elementName_ = new AppExecFwk::ElementName(deviceId, initParams.bundleName, initParams.name);
140 aastub_ = new AccessibleAbilityChannel(accountData_->GetAccountId(), abilityInfo->GetId());
141 AAConnection_->OnAbilityConnectDoneSync(*elementName_, aastub_);
142 accountData_->AddInstalledAbility(*abilityInfo);
143 sleep(1);
144 }
145
AddAccessibilityWindowConnection()146 void MockAamsAccessibleAbilityChannelTest::AddAccessibilityWindowConnection()
147 {
148 GTEST_LOG_(INFO) << "MockAamsAccessibleAbilityChannelTest AddAccessibilityWindowConnection";
149 // accessibility interaction connection
150 int32_t windowId = 0;
151 std::shared_ptr<MockAccessibilityElementOperatorCallback> mockCallback =
152 std::make_shared<MockAccessibilityElementOperatorCallback>();
153 sptr<AccessibilityElementOperatorStub> stub =
154 new MockAccessibilityElementOperatorImpl(windowId, nullptr, *mockCallback);
155 sptr<MockAccessibilityElementOperatorProxy> proxy = new MockAccessibilityElementOperatorProxy(stub);
156 proxy_ = proxy;
157 Singleton<AccessibleAbilityManagerService>::GetInstance().RegisterElementOperator(windowId, proxy, true);
158 bool ret = AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([=]() -> bool {
159 auto &aams = Singleton<AccessibleAbilityManagerService>::GetInstance();
160 if (aams.GetMainRunner()->GetEventQueue()->IsIdle()) {
161 return true;
162 } else {
163 return false;
164 }
165 }), 1);
166 if (!ret) {
167 GTEST_LOG_(INFO) << "MockAamsAccessibleAbilityChannelTest EventQueue is not empty";
168 }
169 }
170
171 /**
172 * @tc.number: AccessibleAbilityChannel_ModuleTest_SearchElementInfoByAccessibilityId_001
173 * @tc.name: SearchElementInfoByAccessibilityId
174 * @tc.desc: AccessibilityWindowId is accessibility interaction connection windowId,
175 * check SearchElementInfoByAccessibilityId.
176 */
HWTEST_F(MockAamsAccessibleAbilityChannelTest, AccessibleAbilityChannel_ModuleTest_SearchElementInfoByAccessibilityId_001, TestSize.Level1)177 HWTEST_F(MockAamsAccessibleAbilityChannelTest, AccessibleAbilityChannel_ModuleTest_SearchElementInfoByAccessibilityId_001,
178 TestSize.Level1)
179 {
180 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_ModuleTest_SearchElementInfoByAccessibilityId_001 start";
181
182 // Add connection
183 AddAccessibilityWindowConnection();
184 AddAccessibleAbilityConnection();
185 ASSERT_TRUE(AccessibilityHelper::GetInstance().GetTestStub());
186 ElementBasicInfo info = {};
187 RetError result =
188 AccessibilityHelper::GetInstance().GetTestStub()->SearchElementInfoByAccessibilityId(info, 0, nullptr, 0, true);
189 sleep(2);
190 GTEST_LOG_(INFO) << "Test result";
191 EXPECT_EQ(-1, proxy_->testChannelElementId_);
192 EXPECT_EQ(-1, proxy_->testChannelRequestId_);
193 EXPECT_EQ(-1, proxy_->testChannelMode_);
194 EXPECT_EQ(result, RET_ERR_NULLPTR);
195 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_ModuleTest_SearchElementInfoByAccessibilityId_001 end";
196 }
197
198 /**
199 * @tc.number: AccessibleAbilityChannel_ModuleTest_SearchElementInfoByAccessibilityId_002
200 * @tc.name: SearchElementInfoByAccessibilityId
201 * @tc.desc: AccessibilityWindowId not accessibility interaction connection windowId,
202 * check SearchElementInfoByAccessibilityId.
203 */
HWTEST_F(MockAamsAccessibleAbilityChannelTest, AccessibleAbilityChannel_ModuleTest_SearchElementInfoByAccessibilityId_002, TestSize.Level1)204 HWTEST_F(MockAamsAccessibleAbilityChannelTest, AccessibleAbilityChannel_ModuleTest_SearchElementInfoByAccessibilityId_002,
205 TestSize.Level1)
206 {
207 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_ModuleTest_SearchElementInfoByAccessibilityId_002 start";
208
209 // Add connection
210 AddAccessibilityWindowConnection();
211 AddAccessibleAbilityConnection();
212 ASSERT_TRUE(AccessibilityHelper::GetInstance().GetTestStub());
213 ElementBasicInfo info = {};
214 RetError result = AccessibilityHelper::GetInstance().GetTestStub()->SearchElementInfoByAccessibilityId(
215 info, 0, nullptr, 0, true);
216 sleep(2);
217 GTEST_LOG_(INFO) << "Test result";
218 EXPECT_EQ(-1, proxy_->testChannelElementId_);
219 EXPECT_EQ(-1, proxy_->testChannelRequestId_);
220 EXPECT_EQ(-1, proxy_->testChannelMode_);
221 EXPECT_EQ(result, RET_ERR_NULLPTR);
222 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_ModuleTest_SearchElementInfoByAccessibilityId_002 end";
223 }
224
225 /**
226 * @tc.number: AccessibleAbilityChannel_ModuleTest_SearchElementInfosByText_001
227 * @tc.name: SearchElementInfosByText
228 * @tc.desc: AccessibilityWindowId is accessibility interaction connection windowId, check SearchElementInfosByText.
229 */
HWTEST_F( MockAamsAccessibleAbilityChannelTest, AccessibleAbilityChannel_ModuleTest_SearchElementInfosByText_001, TestSize.Level1)230 HWTEST_F(
231 MockAamsAccessibleAbilityChannelTest, AccessibleAbilityChannel_ModuleTest_SearchElementInfosByText_001, TestSize.Level1)
232 {
233 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_ModuleTest_SearchElementInfosByText_001 start";
234
235 // Add connection
236 AddAccessibilityWindowConnection();
237 AddAccessibleAbilityConnection();
238 ASSERT_TRUE(AccessibilityHelper::GetInstance().GetTestStub());
239 string text = "text";
240 RetError result =
241 AccessibilityHelper::GetInstance().GetTestStub()->SearchElementInfosByText(0, 0, text, 0, nullptr);
242 sleep(2);
243 GTEST_LOG_(INFO) << "Test result";
244 EXPECT_EQ(-1, proxy_->testChannelElementId_);
245 EXPECT_EQ(-1, proxy_->testChannelRequestId_);
246 EXPECT_EQ("", proxy_->testText_);
247 EXPECT_EQ(result, RET_ERR_NULLPTR);
248 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_ModuleTest_SearchElementInfosByText_001 end";
249 }
250
251 /**
252 * @tc.number: AccessibleAbilityChannel_ModuleTest_SearchElementInfosByText_002
253 * @tc.name: SearchElementInfosByText
254 * @tc.desc: AccessibilityWindowId not accessibility interaction connection windowId, check SearchElementInfosByText.
255 */
HWTEST_F( MockAamsAccessibleAbilityChannelTest, AccessibleAbilityChannel_ModuleTest_SearchElementInfosByText_002, TestSize.Level1)256 HWTEST_F(
257 MockAamsAccessibleAbilityChannelTest, AccessibleAbilityChannel_ModuleTest_SearchElementInfosByText_002, TestSize.Level1)
258 {
259 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_ModuleTest_SearchElementInfosByText_002 start";
260
261 // Add connection
262 AddAccessibilityWindowConnection();
263 AddAccessibleAbilityConnection();
264 ASSERT_TRUE(AccessibilityHelper::GetInstance().GetTestStub());
265 string text = "text";
266 RetError result = AccessibilityHelper::GetInstance().GetTestStub()->SearchElementInfosByText(
267 ACTIVE_WINDOW_ID, 0, text, 0, nullptr);
268 sleep(2);
269 GTEST_LOG_(INFO) << "Test result";
270 EXPECT_EQ(-1, proxy_->testChannelElementId_);
271 EXPECT_EQ(-1, proxy_->testChannelRequestId_);
272 EXPECT_NE(text, proxy_->testText_);
273 EXPECT_EQ(result, RET_ERR_NULLPTR);
274 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_ModuleTest_SearchElementInfosByText_002 end";
275 }
276
277 /**
278 * @tc.number: AccessibleAbilityChannel_ModuleTest_FindFocusedElementInfo_001
279 * @tc.name: FindFocusedElementInfo
280 * @tc.desc: AccessibilityWindowId is accessibility interaction connection windowId, check FindFocusedElementInfo.
281 */
HWTEST_F( MockAamsAccessibleAbilityChannelTest, AccessibleAbilityChannel_ModuleTest_FindFocusedElementInfo_001, TestSize.Level1)282 HWTEST_F(
283 MockAamsAccessibleAbilityChannelTest, AccessibleAbilityChannel_ModuleTest_FindFocusedElementInfo_001, TestSize.Level1)
284 {
285 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_ModuleTest_FindFocusedElementInfo_001 start";
286
287 // Add connection
288 AddAccessibilityWindowConnection();
289 AddAccessibleAbilityConnection();
290 ASSERT_TRUE(AccessibilityHelper::GetInstance().GetTestStub());
291 int32_t focusType = OHOS::Accessibility::FOCUS_TYPE_INPUT;
292 RetError result =
293 AccessibilityHelper::GetInstance().GetTestStub()->FindFocusedElementInfo(0, 0, focusType, 0, nullptr);
294 sleep(2);
295 GTEST_LOG_(INFO) << "Test result";
296 EXPECT_EQ(-1, proxy_->testChannelElementId_);
297 EXPECT_EQ(-1, proxy_->testChannelRequestId_);
298 EXPECT_EQ(0, proxy_->testFocusType_);
299 EXPECT_EQ(result, RET_ERR_NULLPTR);
300 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_ModuleTest_FindFocusedElementInfo_001 end";
301 }
302
303 /**
304 * @tc.number: AccessibleAbilityChannel_ModuleTest_FindFocusedElementInfo_002
305 * @tc.name: FindFocusedElementInfo
306 * @tc.desc: AccessibilityWindowId not accessibility interaction connection windowId, check FindFocusedElementInfo.
307 */
HWTEST_F( MockAamsAccessibleAbilityChannelTest, AccessibleAbilityChannel_ModuleTest_FindFocusedElementInfo_002, TestSize.Level1)308 HWTEST_F(
309 MockAamsAccessibleAbilityChannelTest, AccessibleAbilityChannel_ModuleTest_FindFocusedElementInfo_002, TestSize.Level1)
310 {
311 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_ModuleTest_FindFocusedElementInfo_002 start";
312
313 // Add connection
314 AddAccessibilityWindowConnection();
315 AddAccessibleAbilityConnection();
316 ASSERT_TRUE(AccessibilityHelper::GetInstance().GetTestStub());
317 int32_t focusType = OHOS::Accessibility::FOCUS_TYPE_INPUT;
318 RetError result = AccessibilityHelper::GetInstance().GetTestStub()->FindFocusedElementInfo(
319 ACTIVE_WINDOW_ID, 0, focusType, 0, nullptr);
320 sleep(2);
321 GTEST_LOG_(INFO) << "Test result";
322 EXPECT_EQ(-1, proxy_->testChannelElementId_);
323 EXPECT_EQ(-1, proxy_->testChannelRequestId_);
324 EXPECT_NE(focusType, proxy_->testFocusType_);
325 EXPECT_EQ(result, RET_ERR_NULLPTR);
326 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_ModuleTest_FindFocusedElementInfo_002 end";
327 }
328
329 /**
330 * @tc.number: AccessibleAbilityChannel_ModuleTest_FindFocusedElementInfo_003
331 * @tc.name: FindFocusedElementInfo
332 * @tc.desc: FocusType is FOCUS_TYPE_ACCESSIBILITY, check FindFocusedElementInfo.
333 */
HWTEST_F( MockAamsAccessibleAbilityChannelTest, AccessibleAbilityChannel_ModuleTest_FindFocusedElementInfo_003, TestSize.Level1)334 HWTEST_F(
335 MockAamsAccessibleAbilityChannelTest, AccessibleAbilityChannel_ModuleTest_FindFocusedElementInfo_003, TestSize.Level1)
336 {
337 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_ModuleTest_FindFocusedElementInfo_003 start";
338
339 // Add connection
340 AddAccessibilityWindowConnection();
341 AddAccessibleAbilityConnection();
342 ASSERT_TRUE(AccessibilityHelper::GetInstance().GetTestStub());
343 int32_t focusType = OHOS::Accessibility::FOCUS_TYPE_ACCESSIBILITY;
344 RetError result =
345 AccessibilityHelper::GetInstance().GetTestStub()->FindFocusedElementInfo(0, 0, focusType, 1, nullptr);
346 sleep(2);
347 GTEST_LOG_(INFO) << "Test result";
348 EXPECT_EQ(-1, proxy_->testChannelElementId_);
349 EXPECT_EQ(-1, proxy_->testChannelRequestId_);
350 EXPECT_EQ(0, proxy_->testFocusType_);
351 EXPECT_EQ(result, RET_ERR_NULLPTR);
352 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_ModuleTest_FindFocusedElementInfo_003 end";
353 }
354
355 /**
356 * @tc.number: AccessibleAbilityChannel_ModuleTest_FocusMoveSearch_001
357 * @tc.name: FocusMoveSearch
358 * @tc.desc: AccessibilityWindowId is accessibility interaction connection windowId, check FocusMoveSearch.
359 */
HWTEST_F(MockAamsAccessibleAbilityChannelTest, AccessibleAbilityChannel_ModuleTest_FocusMoveSearch_001, TestSize.Level1)360 HWTEST_F(MockAamsAccessibleAbilityChannelTest, AccessibleAbilityChannel_ModuleTest_FocusMoveSearch_001, TestSize.Level1)
361 {
362 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_ModuleTest_FocusMoveSearch_001 start";
363
364 // Add connection
365 AddAccessibilityWindowConnection();
366 AddAccessibleAbilityConnection();
367 ASSERT_TRUE(AccessibilityHelper::GetInstance().GetTestStub());
368 int32_t direction = FocusMoveDirection::UP;
369 RetError result = AccessibilityHelper::GetInstance().GetTestStub()->FocusMoveSearch(0, 0, direction, 0, nullptr);
370 sleep(2);
371 GTEST_LOG_(INFO) << "Test result";
372 EXPECT_EQ(-1, proxy_->testChannelElementId_);
373 EXPECT_EQ(-1, proxy_->testChannelRequestId_);
374 EXPECT_EQ(0, proxy_->testDirection_);
375 EXPECT_EQ(result, RET_ERR_NULLPTR);
376 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_ModuleTest_FocusMoveSearch_001 end";
377 }
378
379 /**
380 * @tc.number: AccessibleAbilityChannel_ModuleTest_FocusMoveSearch_002
381 * @tc.name: FocusMoveSearch
382 * @tc.desc: AccessibilityWindowId not accessibility interaction connection windowId, check FocusMoveSearch.
383 */
HWTEST_F(MockAamsAccessibleAbilityChannelTest, AccessibleAbilityChannel_ModuleTest_FocusMoveSearch_002, TestSize.Level1)384 HWTEST_F(MockAamsAccessibleAbilityChannelTest, AccessibleAbilityChannel_ModuleTest_FocusMoveSearch_002, TestSize.Level1)
385 {
386 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_ModuleTest_FocusMoveSearch_002 start";
387
388 // Add connection
389 AddAccessibilityWindowConnection();
390 AddAccessibleAbilityConnection();
391 ASSERT_TRUE(AccessibilityHelper::GetInstance().GetTestStub());
392 int32_t direction = FocusMoveDirection::UP;
393 RetError result =
394 AccessibilityHelper::GetInstance().GetTestStub()->FocusMoveSearch(ACTIVE_WINDOW_ID, 0, direction, 0, nullptr);
395 sleep(2);
396 GTEST_LOG_(INFO) << "Test result";
397 EXPECT_EQ(-1, proxy_->testChannelElementId_);
398 EXPECT_EQ(-1, proxy_->testChannelRequestId_);
399 EXPECT_NE(direction, proxy_->testDirection_);
400 EXPECT_EQ(result, RET_ERR_NULLPTR);
401 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_ModuleTest_FocusMoveSearch_002 end";
402 }
403
404 /**
405 * @tc.number: AccessibleAbilityChannel_ModuleTest_ExecuteAction_001
406 * @tc.name: ExecuteAction
407 * @tc.desc: AccessibilityWindowId is accessibility interaction connection windowId, check ExecuteAction.
408 */
HWTEST_F(MockAamsAccessibleAbilityChannelTest, AccessibleAbilityChannel_ModuleTest_ExecuteAction_001, TestSize.Level1)409 HWTEST_F(MockAamsAccessibleAbilityChannelTest, AccessibleAbilityChannel_ModuleTest_ExecuteAction_001, TestSize.Level1)
410 {
411 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_ModuleTest_ExecuteAction_001 start";
412
413 // Add connection
414 AddAccessibilityWindowConnection();
415 AddAccessibleAbilityConnection();
416 std::map<std::string, std::string> actionArguments;
417 actionArguments.insert(std::make_pair("invalid", "invalid"));
418
419 ASSERT_TRUE(AccessibilityHelper::GetInstance().GetTestStub());
420 RetError result =
421 AccessibilityHelper::GetInstance().GetTestStub()->ExecuteAction(0, 4, 3, actionArguments, 0, nullptr);
422 sleep(2);
423 GTEST_LOG_(INFO) << "Test result";
424 EXPECT_EQ(-1, proxy_->testChannelElementId_);
425 EXPECT_EQ(-1, proxy_->testChannelRequestId_);
426 EXPECT_EQ(0, proxy_->testAction_);
427 EXPECT_TRUE(proxy_->testActionArguments_.empty());
428 EXPECT_EQ(result, RET_ERR_NULLPTR);
429 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_ModuleTest_ExecuteAction_001 end";
430 }
431
432 /**
433 * @tc.number: AccessibleAbilityChannel_ModuleTest_ExecuteAction_002
434 * @tc.name: ExecuteAction
435 * @tc.desc: AccessibilityWindowId not accessibility interaction connection windowId, check ExecuteAction.
436 */
HWTEST_F(MockAamsAccessibleAbilityChannelTest, AccessibleAbilityChannel_ModuleTest_ExecuteAction_002, TestSize.Level1)437 HWTEST_F(MockAamsAccessibleAbilityChannelTest, AccessibleAbilityChannel_ModuleTest_ExecuteAction_002, TestSize.Level1)
438 {
439 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_ModuleTest_ExecuteAction_002 start";
440
441 // Add connection
442 AddAccessibilityWindowConnection();
443 AddAccessibleAbilityConnection();
444 std::map<std::string, std::string> actionArguments;
445 actionArguments.insert(std::make_pair("invalid", "invalid"));
446
447 ASSERT_TRUE(AccessibilityHelper::GetInstance().GetTestStub());
448 RetError result = AccessibilityHelper::GetInstance().GetTestStub()->ExecuteAction(
449 ACTIVE_WINDOW_ID, 4, 3, actionArguments, 0, nullptr);
450 sleep(2);
451 GTEST_LOG_(INFO) << "Test result";
452 EXPECT_EQ(-1, proxy_->testChannelElementId_);
453 EXPECT_EQ(-1, proxy_->testChannelRequestId_);
454 EXPECT_EQ(0, proxy_->testAction_);
455 EXPECT_EQ(result, RET_ERR_NULLPTR);
456 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_ModuleTest_ExecuteAction_002 end";
457 }
458
459 /**
460 * @tc.number: AccessibleAbilityChannel_ModuleTest_GetWindows_002
461 * @tc.name: GetWindows
462 * @tc.desc: Not add interaction connection check get windows.
463 */
HWTEST_F(MockAamsAccessibleAbilityChannelTest, AccessibleAbilityChannel_ModuleTest_GetWindows_002, TestSize.Level1)464 HWTEST_F(MockAamsAccessibleAbilityChannelTest, AccessibleAbilityChannel_ModuleTest_GetWindows_002, TestSize.Level1)
465 {
466 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_ModuleTest_GetWindows_002 start";
467
468 // Not add interaction connection,add accessibleAbility connection
469 AddAccessibleAbilityConnection();
470 ASSERT_TRUE(AccessibilityHelper::GetInstance().GetTestStub());
471 uint64_t displayId = Rosen::DisplayManager::GetInstance().GetDefaultDisplayId();
472 std::vector<AccessibilityWindowInfo> windows;
473 AccessibilityHelper::GetInstance().GetTestStub()->GetWindowsByDisplayId(displayId, windows);
474 sleep(2);
475 GTEST_LOG_(INFO) << "Test result";
476 EXPECT_GE(windows.size(), 0);
477 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_ModuleTest_GetWindows_002 end";
478 }
479
480 /**
481 * @tc.number: AccessibleAbilityChannel_ModuleTest_SendSimulateGesture_001
482 * @tc.name: SendSimulateGesture
483 * @tc.desc: Add connection check send simulate gesture.
484 */
HWTEST_F(MockAamsAccessibleAbilityChannelTest, AccessibleAbilityChannel_ModuleTest_SendSimulateGesture_001, TestSize.Level1)485 HWTEST_F(MockAamsAccessibleAbilityChannelTest, AccessibleAbilityChannel_ModuleTest_SendSimulateGesture_001, TestSize.Level1)
486 {
487 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_ModuleTest_SendSimulateGesture_001 start";
488
489 // Add connection
490 AddAccessibilityWindowConnection();
491 AddAccessibleAbilityConnection();
492
493 AccessibilityGesturePosition point {10.0f, 10.0f};
494 std::shared_ptr<AccessibilityGestureInjectPath> gesturePath = std::make_shared<AccessibilityGestureInjectPath>();
495 gesturePath->AddPosition(point);
496 gesturePath->SetDurationTime(100);
497
498 ASSERT_TRUE(AccessibilityHelper::GetInstance().GetTestStub());
499 RetError result = AccessibilityHelper::GetInstance().GetTestStub()->SendSimulateGesture(gesturePath);
500 EXPECT_EQ(result, RET_OK);
501 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_ModuleTest_SendSimulateGesture_001 end";
502 }
503
504 /***********************************************************************************************************/
505
506 /**
507 * @tc.number: AccessibleAbilityChannel_ModuleTest_SearchElementInfoByAccessibilityId_NoCapability_001
508 * @tc.name: SearchElementInfoByAccessibilityId
509 * @tc.desc: No retrieve capability, check SearchElementInfoByAccessibilityId.
510 */
HWTEST_F(MockAamsAccessibleAbilityChannelTest, AccessibleAbilityChannel_ModuleTest_SearchElementInfoByAccessibilityId_NoCapability_001, TestSize.Level1)511 HWTEST_F(MockAamsAccessibleAbilityChannelTest,
512 AccessibleAbilityChannel_ModuleTest_SearchElementInfoByAccessibilityId_NoCapability_001, TestSize.Level1)
513 {
514 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_ModuleTest_SearchElementInfoByAccessibilityId_NoCapability_001 start";
515
516 // Add connection
517 AddAccessibilityWindowConnection();
518 AddAccessibleAbilityConnection(true);
519 ASSERT_TRUE(AccessibilityHelper::GetInstance().GetTestStub());
520 ElementBasicInfo info = {};
521 RetError result =
522 AccessibilityHelper::GetInstance().GetTestStub()->SearchElementInfoByAccessibilityId(info, 0, nullptr, 0, true);
523 sleep(2);
524 GTEST_LOG_(INFO) << "Test result";
525 EXPECT_EQ(-1, proxy_->testChannelElementId_);
526 EXPECT_EQ(-1, proxy_->testChannelRequestId_);
527 EXPECT_EQ(-1, proxy_->testChannelMode_);
528 EXPECT_EQ(result, RET_ERR_NULLPTR);
529 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_ModuleTest_SearchElementInfoByAccessibilityId_NoCapability_001 end";
530 }
531
532 /**
533 * @tc.number: AccessibleAbilityChannel_ModuleTest_SearchElementInfosByText_NoCapability_001
534 * @tc.name: SearchElementInfosByText
535 * @tc.desc: No retrieve capability, check SearchElementInfosByText.
536 */
HWTEST_F(MockAamsAccessibleAbilityChannelTest, AccessibleAbilityChannel_ModuleTest_SearchElementInfosByText_NoCapability_001, TestSize.Level1)537 HWTEST_F(MockAamsAccessibleAbilityChannelTest,
538 AccessibleAbilityChannel_ModuleTest_SearchElementInfosByText_NoCapability_001, TestSize.Level1)
539 {
540 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_ModuleTest_SearchElementInfosByText_NoCapability_001 start";
541
542 // Add connection
543 AddAccessibilityWindowConnection();
544 AddAccessibleAbilityConnection(true);
545 ASSERT_TRUE(AccessibilityHelper::GetInstance().GetTestStub());
546 string text = "text";
547 RetError result =
548 AccessibilityHelper::GetInstance().GetTestStub()->SearchElementInfosByText(0, 0, text, 0, nullptr);
549 sleep(2);
550 GTEST_LOG_(INFO) << "Test result";
551 EXPECT_EQ(-1, proxy_->testChannelElementId_);
552 EXPECT_EQ(-1, proxy_->testChannelRequestId_);
553 EXPECT_NE(text, proxy_->testText_);
554 EXPECT_EQ(result, RET_ERR_NULLPTR);
555 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_ModuleTest_SearchElementInfosByText_NoCapability_001 end";
556 }
557
558 /**
559 * @tc.number: AccessibleAbilityChannel_ModuleTest_FindFocusedElementInfo_NoCapability_001
560 * @tc.name: FindFocusedElementInfo
561 * @tc.desc: No retrieve capability, check FindFocusedElementInfo.
562 */
HWTEST_F(MockAamsAccessibleAbilityChannelTest, AccessibleAbilityChannel_ModuleTest_FindFocusedElementInfo_NoCapability_001, TestSize.Level1)563 HWTEST_F(MockAamsAccessibleAbilityChannelTest, AccessibleAbilityChannel_ModuleTest_FindFocusedElementInfo_NoCapability_001,
564 TestSize.Level1)
565 {
566 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_ModuleTest_FindFocusedElementInfo_NoCapability_001 start";
567
568 // Add connection
569 AddAccessibilityWindowConnection();
570 AddAccessibleAbilityConnection(true);
571 ASSERT_TRUE(AccessibilityHelper::GetInstance().GetTestStub());
572 int32_t focusType = OHOS::Accessibility::FOCUS_TYPE_INPUT;
573 RetError result =
574 AccessibilityHelper::GetInstance().GetTestStub()->FindFocusedElementInfo(0, 0, focusType, 0, nullptr);
575 sleep(2);
576 GTEST_LOG_(INFO) << "Test result";
577 EXPECT_EQ(-1, proxy_->testChannelElementId_);
578 EXPECT_EQ(-1, proxy_->testChannelRequestId_);
579 EXPECT_NE(focusType, proxy_->testFocusType_);
580 EXPECT_EQ(result, RET_ERR_NULLPTR);
581 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_ModuleTest_FindFocusedElementInfo_NoCapability_001 end";
582 }
583
584 /**
585 * @tc.number: AccessibleAbilityChannel_ModuleTest_FocusMoveSearch_NoCapability_001
586 * @tc.name: FocusMoveSearch
587 * @tc.desc: No retrieve capability, check FocusMoveSearch.
588 */
HWTEST_F(MockAamsAccessibleAbilityChannelTest, AccessibleAbilityChannel_ModuleTest_FocusMoveSearch_NoCapability_001, TestSize.Level1)589 HWTEST_F(MockAamsAccessibleAbilityChannelTest, AccessibleAbilityChannel_ModuleTest_FocusMoveSearch_NoCapability_001,
590 TestSize.Level1)
591 {
592 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_ModuleTest_FocusMoveSearch_NoCapability_001 start";
593
594 // Add connection
595 AddAccessibilityWindowConnection();
596 AddAccessibleAbilityConnection(true);
597 ASSERT_TRUE(AccessibilityHelper::GetInstance().GetTestStub());
598 int32_t direction = FocusMoveDirection::UP;
599 RetError result = AccessibilityHelper::GetInstance().GetTestStub()->FocusMoveSearch(0, 0, direction, 0, nullptr);
600 sleep(2);
601 GTEST_LOG_(INFO) << "Test result";
602 EXPECT_EQ(-1, proxy_->testChannelElementId_);
603 EXPECT_EQ(-1, proxy_->testChannelRequestId_);
604 EXPECT_NE(direction, proxy_->testDirection_);
605 EXPECT_EQ(result, RET_ERR_NULLPTR);
606 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_ModuleTest_FocusMoveSearch_NoCapability_001 end";
607 }
608
609 /**
610 * @tc.number: AccessibleAbilityChannel_ModuleTest_ExecuteAction_NoCapability_001
611 * @tc.name: ExecuteAction
612 * @tc.desc: No retrieve capability, check ExecuteAction.
613 */
HWTEST_F(MockAamsAccessibleAbilityChannelTest, AccessibleAbilityChannel_ModuleTest_ExecuteAction_NoCapability_001, TestSize.Level1)614 HWTEST_F(MockAamsAccessibleAbilityChannelTest, AccessibleAbilityChannel_ModuleTest_ExecuteAction_NoCapability_001,
615 TestSize.Level1)
616 {
617 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_ModuleTest_ExecuteAction_NoCapability_001 start";
618
619 // Add connection
620 AddAccessibilityWindowConnection();
621 AddAccessibleAbilityConnection(true);
622 std::map<std::string, std::string> actionArguments;
623 actionArguments.insert(std::make_pair("invalid", "invalid"));
624
625 ASSERT_TRUE(AccessibilityHelper::GetInstance().GetTestStub());
626 RetError result =
627 AccessibilityHelper::GetInstance().GetTestStub()->ExecuteAction(0, 4, 3, actionArguments, 0, nullptr);
628 sleep(2);
629 GTEST_LOG_(INFO) << "Test result";
630 EXPECT_EQ(-1, proxy_->testChannelElementId_);
631 EXPECT_EQ(-1, proxy_->testChannelRequestId_);
632 EXPECT_EQ(0, proxy_->testAction_);
633 EXPECT_NE(actionArguments, proxy_->testActionArguments_);
634 EXPECT_EQ(result, RET_ERR_NULLPTR);
635 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_ModuleTest_ExecuteAction_NoCapability_001 end";
636 }
637
638 /**
639 * @tc.number: AccessibleAbilityChannel_ModuleTest_GetWindows_NoCapability_001
640 * @tc.name: GetWindows
641 * @tc.desc: No retrieve capability, check get windows.
642 */
HWTEST_F( MockAamsAccessibleAbilityChannelTest, AccessibleAbilityChannel_ModuleTest_GetWindows_NoCapability_001, TestSize.Level1)643 HWTEST_F(
644 MockAamsAccessibleAbilityChannelTest, AccessibleAbilityChannel_ModuleTest_GetWindows_NoCapability_001, TestSize.Level1)
645 {
646 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_ModuleTest_GetWindows_NoCapability_001 start";
647
648 // Add connection
649 AddAccessibilityWindowConnection();
650 AddAccessibleAbilityConnection();
651 ASSERT_TRUE(AccessibilityHelper::GetInstance().GetTestStub());
652 uint64_t displayId = Rosen::DisplayManager::GetInstance().GetDefaultDisplayId();
653 std::vector<AccessibilityWindowInfo> windows;
654 AccessibilityHelper::GetInstance().GetTestStub()->GetWindowsByDisplayId(displayId, windows);
655
656 GTEST_LOG_(INFO) << "Test result";
657 EXPECT_GE(windows.size(), 0);
658 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_ModuleTest_GetWindows_NoCapability_001 end";
659 }
660
661 /**
662 * @tc.number: AccessibleAbilityChannel_ModuleTest_SendSimulateGesture_NoCapability_001
663 * @tc.name: SendSimulateGesture
664 * @tc.desc: No gesture capability, check send simulate gesture.
665 */
HWTEST_F(MockAamsAccessibleAbilityChannelTest, AccessibleAbilityChannel_ModuleTest_SendSimulateGesture_NoCapability_001, TestSize.Level1)666 HWTEST_F(MockAamsAccessibleAbilityChannelTest, AccessibleAbilityChannel_ModuleTest_SendSimulateGesture_NoCapability_001,
667 TestSize.Level1)
668 {
669 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_ModuleTest_SendSimulateGesture_NoCapability_001 start";
670
671 // Add connection
672 AddAccessibilityWindowConnection();
673 AddAccessibleAbilityConnection(true);
674
675 AccessibilityGesturePosition point {10.0f, 10.0f};
676 std::shared_ptr<AccessibilityGestureInjectPath> gesturePath = std::make_shared<AccessibilityGestureInjectPath>();
677 gesturePath->AddPosition(point);
678 gesturePath->SetDurationTime(100);
679
680 ASSERT_TRUE(AccessibilityHelper::GetInstance().GetTestStub());
681 RetError result = AccessibilityHelper::GetInstance().GetTestStub()->SendSimulateGesture(gesturePath);
682 EXPECT_EQ(result, RET_ERR_NO_CAPABILITY);
683 GTEST_LOG_(INFO) << "AccessibleAbilityChannel_ModuleTest_SendSimulateGesture_NoCapability_001 end";
684 }
685 } // namespace Accessibility
686 } // namespace OHOS