1 /*
2 * Copyright (c) 2024 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
18 #include "frameworks/core/accessibility/accessibility_node.h"
19 #include "frameworks/core/accessibility/accessibility_utils.h"
20 #include "frameworks/core/accessibility/native_interface_accessibility_provider.h"
21
22 using namespace testing;
23 using namespace testing::ext;
24
25 namespace OHOS::Ace {
26 class MockOhAccessibilityProvider : public AccessibilityProvider {
27 DECLARE_ACE_TYPE(MockOhAccessibilityProvider, AccessibilityProvider);
28 public:
29 MockOhAccessibilityProvider() = default;
FindAccessibilityNodeInfosById(const int64_t elementId,const int32_t mode,const int32_t requestId,std::vector<ArkUI_AccessibilityElementInfo> & infos)30 int32_t FindAccessibilityNodeInfosById(
31 const int64_t elementId, const int32_t mode, const int32_t requestId,
32 std::vector<ArkUI_AccessibilityElementInfo>& infos) override
33 {
34 return 0;
35 }
FindAccessibilityNodeInfosByText(const int64_t elementId,std::string text,const int32_t requestId,std::vector<ArkUI_AccessibilityElementInfo> & infos)36 int32_t FindAccessibilityNodeInfosByText(
37 const int64_t elementId, std::string text, const int32_t requestId,
38 std::vector<ArkUI_AccessibilityElementInfo>& infos) override
39 {
40 return 0;
41 }
FindFocusedAccessibilityNode(const int64_t elementId,int32_t focusType,const int32_t requestId,ArkUI_AccessibilityElementInfo & elementInfo)42 int32_t FindFocusedAccessibilityNode(
43 const int64_t elementId, int32_t focusType, const int32_t requestId,
44 ArkUI_AccessibilityElementInfo& elementInfo) override
45 {
46 return 0;
47 }
FindNextFocusAccessibilityNode(const int64_t elementId,int32_t direction,const int32_t requestId,ArkUI_AccessibilityElementInfo & elementInfo)48 int32_t FindNextFocusAccessibilityNode(
49 const int64_t elementId, int32_t direction, const int32_t requestId,
50 ArkUI_AccessibilityElementInfo& elementInfo) override
51 {
52 return 0;
53 }
ExecuteAccessibilityAction(const int64_t elementId,int32_t action,const int32_t requestId,const std::map<std::string,std::string> & actionArguments)54 int32_t ExecuteAccessibilityAction(
55 const int64_t elementId, int32_t action, const int32_t requestId,
56 const std::map<std::string, std::string>& actionArguments) override
57 {
58 return 0;
59 }
ClearFocusedAccessibilityNode()60 int32_t ClearFocusedAccessibilityNode() override
61 {
62 return 0;
63 }
GetAccessibilityNodeCursorPosition(const int64_t elementId,const int32_t requestId,int32_t & cursorPosition)64 int32_t GetAccessibilityNodeCursorPosition(
65 const int64_t elementId,
66 const int32_t requestId,
67 int32_t &cursorPosition) override
68 {
69 return 0;
70 }
SendAccessibilityAsyncEvent(const ArkUI_AccessibilityEventInfo & accessibilityEvent,void (* callback)(int32_t errorCode))71 int32_t SendAccessibilityAsyncEvent(
72 const ArkUI_AccessibilityEventInfo& accessibilityEvent,
73 void (*callback)(int32_t errorCode)) override
74 {
75 GTEST_LOG_(INFO) << "SendAccessibilityAsyncEvent";
76 return 0;
77 }
SendThirdAccessibilityProvider(const std::weak_ptr<ThirdAccessibilityManager> & thirdAccessibilityManager)78 void SendThirdAccessibilityProvider(
79 const std::weak_ptr<ThirdAccessibilityManager>& thirdAccessibilityManager)
80 override {}
81 };
82 } // namespace OHOS::Ace
83
84 namespace OHOS::Ace::NG {
85 namespace {
86 std::string TEST_CONTENT_STR = "testForFindByText";
87 constexpr const char* INSTANCE_ID = "fake_instance_id";
88 constexpr int32_t MAX_TEST_PARAMETER = 20;
89 constexpr int32_t MAX_TEST_ELEMENT_COUNT = 10;
90 constexpr int32_t SEND_EVENT_FAILED = -1;
91 constexpr int32_t SEND_EVENT_SUCCESS = 0;
92 constexpr int32_t TEST_PARAMETER_OFFSET1 = 1;
93 constexpr int32_t TEST_PARAMETER_OFFSET2 = 2;
94 constexpr int32_t TEST_PARAMETER_OFFSET3 = 3;
95
96 class ProviderMockResult {
97 public:
ProviderMockResult()98 ProviderMockResult()
99 {
100 for (int32_t i = 0; i < MAX_TEST_ELEMENT_COUNT; i++) {
101 ArkUI_AccessibilityElementInfo tempElementInfo;
102 tempElementInfo.SetElementId(i);
103 tempElementInfo.SetContents(TEST_CONTENT_STR);
104 elementInfosList_.push_back(tempElementInfo);
105 }
106
107 focusElementInfo_.SetElementId(
108 MAX_TEST_ELEMENT_COUNT + TEST_PARAMETER_OFFSET1);
109 nextFocusElementInfo_.SetElementId(
110 MAX_TEST_ELEMENT_COUNT + TEST_PARAMETER_OFFSET2);
111
112 originActionArguments_.emplace("action0", "1");
113 originActionArguments_.emplace("action1", "2");
114 cursorPosition_ = MAX_TEST_ELEMENT_COUNT + TEST_PARAMETER_OFFSET3;
115 }
116 ~ProviderMockResult() = default;
117
Reset()118 void Reset()
119 {
120 elementId_ = 0;
121 mode_ = ARKUI_ACCESSIBILITY_NATIVE_SEARCH_MODE_PREFETCH_CURRENT;
122 requestId_ = 0;
123 focusType_ = ARKUI_ACCESSIBILITY_NATIVE_FOCUS_TYPE_INVALID;
124 direction_ = ARKUI_ACCESSIBILITY_NATIVE_DIRECTION_INVALID;
125 action_ = ARKUI_ACCESSIBILITY_NATIVE_ACTION_TYPE_INVALID;
126 receiveClear_ = false;
127 errorCode_ = 0;
128 instanceId_ = "";
129 }
130
131 public:
132 int64_t elementId_;
133 ArkUI_AccessibilitySearchMode mode_;
134 int32_t requestId_;
135 std::vector<ArkUI_AccessibilityElementInfo> elementInfosList_;
136 ArkUI_AccessibilityFocusType focusType_;
137 ArkUI_AccessibilityElementInfo focusElementInfo_;
138 ArkUI_AccessibilityElementInfo nextFocusElementInfo_;
139 ArkUI_AccessibilityFocusMoveDirection direction_;
140 ArkUI_Accessibility_ActionType action_;
141 std::map<std::string, std::string> originActionArguments_;
142 std::map<std::string, std::string> resultActionArguments_;
143 int32_t cursorPosition_;
144 bool receiveClear_;
145
146 bool registerResult_;
147
148 int32_t errorCode_;
149 std::string instanceId_;
150 };
151
152 ProviderMockResult g_providerMockResult;
153
MockFindAccessibilityNodeInfosById(int64_t elementId,ArkUI_AccessibilitySearchMode mode,int32_t requestId,ArkUI_AccessibilityElementInfoList * elementList)154 int32_t MockFindAccessibilityNodeInfosById(
155 int64_t elementId,
156 ArkUI_AccessibilitySearchMode mode,
157 int32_t requestId,
158 ArkUI_AccessibilityElementInfoList* elementList)
159 {
160 g_providerMockResult.elementId_ = elementId;
161 g_providerMockResult.mode_ = mode;
162 g_providerMockResult.requestId_ = requestId;
163
164 ArkUI_AccessibilityElementInfo* tempElementInfo;
165 for (const auto &elementInfo: g_providerMockResult.elementInfosList_) {
166 tempElementInfo = elementList->AddAndGetElementInfo();
167 tempElementInfo->SetElementId(elementInfo.GetElementId());
168 }
169
170 return ARKUI_ACCESSIBILITY_NATIVE_RESULT_SUCCESSFUL;
171 }
172
MockFindAccessibilityNodeInfosByIdWithInstance(const char * instanceId,int64_t elementId,ArkUI_AccessibilitySearchMode mode,int32_t requestId,ArkUI_AccessibilityElementInfoList * elementList)173 int32_t MockFindAccessibilityNodeInfosByIdWithInstance(
174 const char* instanceId,
175 int64_t elementId,
176 ArkUI_AccessibilitySearchMode mode,
177 int32_t requestId,
178 ArkUI_AccessibilityElementInfoList* elementList)
179 {
180 g_providerMockResult.instanceId_ = instanceId;
181 return MockFindAccessibilityNodeInfosById(elementId, mode, requestId, elementList);
182 }
183
MockFindAccessibilityNodeInfosByIdCopyFail(int64_t elementId,ArkUI_AccessibilitySearchMode mode,int32_t requestId,ArkUI_AccessibilityElementInfoList * elementList)184 int32_t MockFindAccessibilityNodeInfosByIdCopyFail(
185 int64_t elementId,
186 ArkUI_AccessibilitySearchMode mode,
187 int32_t requestId,
188 ArkUI_AccessibilityElementInfoList* elementList)
189 {
190 g_providerMockResult.elementId_ = elementId;
191 g_providerMockResult.mode_ = mode;
192 g_providerMockResult.requestId_ = requestId;
193 return ARKUI_ACCESSIBILITY_NATIVE_RESULT_SUCCESSFUL;
194 }
195
MockFindAccessibilityNodeInfosByText(int64_t elementId,const char * text,int32_t requestId,ArkUI_AccessibilityElementInfoList * elementList)196 int32_t MockFindAccessibilityNodeInfosByText(
197 int64_t elementId,
198 const char* text,
199 int32_t requestId,
200 ArkUI_AccessibilityElementInfoList* elementList)
201 {
202 g_providerMockResult.elementId_ = elementId;
203 g_providerMockResult.requestId_ = requestId;
204
205 ArkUI_AccessibilityElementInfo* tempElementInfo;
206 std::string textStr(text);
207 for (const auto &elementInfo: g_providerMockResult.elementInfosList_) {
208 if (elementInfo.GetContents() == textStr) {
209 tempElementInfo = elementList->AddAndGetElementInfo();
210 tempElementInfo->SetElementId(elementInfo.GetElementId());
211 }
212 }
213 return ARKUI_ACCESSIBILITY_NATIVE_RESULT_SUCCESSFUL;
214 }
215
MockFindAccessibilityNodeInfosByTextWithInstanceId(const char * instanceId,int64_t elementId,const char * text,int32_t requestId,ArkUI_AccessibilityElementInfoList * elementList)216 int32_t MockFindAccessibilityNodeInfosByTextWithInstanceId(
217 const char* instanceId,
218 int64_t elementId,
219 const char* text,
220 int32_t requestId,
221 ArkUI_AccessibilityElementInfoList* elementList)
222 {
223 g_providerMockResult.instanceId_ = instanceId;
224 return MockFindAccessibilityNodeInfosByText(elementId, text, requestId, elementList);
225 }
226
MockFindAccessibilityNodeInfosByTextCopyFail(int64_t elementId,const char * text,int32_t requestId,ArkUI_AccessibilityElementInfoList * elementList)227 int32_t MockFindAccessibilityNodeInfosByTextCopyFail(
228 int64_t elementId,
229 const char* text,
230 int32_t requestId,
231 ArkUI_AccessibilityElementInfoList* elementList)
232 {
233 g_providerMockResult.elementId_ = elementId;
234 g_providerMockResult.requestId_ = requestId;
235 return ARKUI_ACCESSIBILITY_NATIVE_RESULT_SUCCESSFUL;
236 }
237
MockFindFocusedAccessibilityNode(int64_t elementId,ArkUI_AccessibilityFocusType focusType,int32_t requestId,ArkUI_AccessibilityElementInfo * elementInfo)238 int32_t MockFindFocusedAccessibilityNode(
239 int64_t elementId,
240 ArkUI_AccessibilityFocusType focusType,
241 int32_t requestId,
242 ArkUI_AccessibilityElementInfo* elementInfo)
243 {
244 g_providerMockResult.elementId_ = elementId;
245 g_providerMockResult.focusType_ = focusType;
246 g_providerMockResult.requestId_ = requestId;
247 elementInfo->SetElementId(
248 g_providerMockResult.focusElementInfo_.GetElementId());
249 return ARKUI_ACCESSIBILITY_NATIVE_RESULT_SUCCESSFUL;
250 }
251
MockFindFocusedAccessibilityNodeWithInstance(const char * instanceId,int64_t elementId,ArkUI_AccessibilityFocusType focusType,int32_t requestId,ArkUI_AccessibilityElementInfo * elementInfo)252 int32_t MockFindFocusedAccessibilityNodeWithInstance(
253 const char* instanceId,
254 int64_t elementId,
255 ArkUI_AccessibilityFocusType focusType,
256 int32_t requestId,
257 ArkUI_AccessibilityElementInfo* elementInfo)
258 {
259 g_providerMockResult.instanceId_ = instanceId;
260 return MockFindFocusedAccessibilityNode(elementId, focusType, requestId, elementInfo);
261 }
262
MockFindNextFocusAccessibilityNode(int64_t elementId,ArkUI_AccessibilityFocusMoveDirection direction,int32_t requestId,ArkUI_AccessibilityElementInfo * elementInfo)263 int32_t MockFindNextFocusAccessibilityNode(
264 int64_t elementId,
265 ArkUI_AccessibilityFocusMoveDirection direction,
266 int32_t requestId,
267 ArkUI_AccessibilityElementInfo* elementInfo)
268 {
269 g_providerMockResult.elementId_ = elementId;
270 g_providerMockResult.direction_ = direction;
271 g_providerMockResult.requestId_ = requestId;
272 elementInfo->SetElementId(
273 g_providerMockResult.nextFocusElementInfo_.GetElementId());
274 return ARKUI_ACCESSIBILITY_NATIVE_RESULT_SUCCESSFUL;
275 }
276
MockFindNextFocusAccessibilityNodeWithInstance(const char * instanceId,int64_t elementId,ArkUI_AccessibilityFocusMoveDirection direction,int32_t requestId,ArkUI_AccessibilityElementInfo * elementInfo)277 int32_t MockFindNextFocusAccessibilityNodeWithInstance(
278 const char* instanceId,
279 int64_t elementId,
280 ArkUI_AccessibilityFocusMoveDirection direction,
281 int32_t requestId,
282 ArkUI_AccessibilityElementInfo* elementInfo)
283 {
284 g_providerMockResult.instanceId_ = instanceId;
285 return MockFindNextFocusAccessibilityNode(elementId, direction, requestId, elementInfo);
286 }
287
MockExecuteAccessibilityAction(int64_t elementId,ArkUI_Accessibility_ActionType action,ArkUI_AccessibilityActionArguments * actionArguments,int32_t requestId)288 int32_t MockExecuteAccessibilityAction(
289 int64_t elementId,
290 ArkUI_Accessibility_ActionType action,
291 ArkUI_AccessibilityActionArguments *actionArguments,
292 int32_t requestId)
293 {
294 g_providerMockResult.action_ = action;
295 g_providerMockResult.requestId_ = requestId;
296
297 g_providerMockResult.resultActionArguments_.clear();
298 for (auto &pair: g_providerMockResult.originActionArguments_) {
299 auto value = actionArguments->FindValueByKey(pair.first.c_str());
300 if (value) {
301 std::string textStr(value);
302 g_providerMockResult.resultActionArguments_.emplace(
303 pair.first, textStr);
304 }
305 }
306
307 return ARKUI_ACCESSIBILITY_NATIVE_RESULT_SUCCESSFUL;
308 }
309
MockExecuteAccessibilityActionWithInstance(const char * instanceId,int64_t elementId,ArkUI_Accessibility_ActionType action,ArkUI_AccessibilityActionArguments * actionArguments,int32_t requestId)310 int32_t MockExecuteAccessibilityActionWithInstance(
311 const char* instanceId,
312 int64_t elementId,
313 ArkUI_Accessibility_ActionType action,
314 ArkUI_AccessibilityActionArguments *actionArguments,
315 int32_t requestId)
316 {
317 g_providerMockResult.instanceId_ = instanceId;
318 return MockExecuteAccessibilityAction(elementId, action, actionArguments, requestId);
319 }
320
MockClearFocusedFocusAccessibilityNode()321 int32_t MockClearFocusedFocusAccessibilityNode()
322 {
323 g_providerMockResult.receiveClear_ = true;
324 return ARKUI_ACCESSIBILITY_NATIVE_RESULT_SUCCESSFUL;
325 }
326
MockClearFocusedFocusAccessibilityNodeWithInstance(const char * instanceId)327 int32_t MockClearFocusedFocusAccessibilityNodeWithInstance(const char* instanceId)
328 {
329 g_providerMockResult.instanceId_ = instanceId;
330 return MockClearFocusedFocusAccessibilityNode();
331 }
332
MockGetAccessibilityNodeCursorPosition(int64_t elementId,int32_t requestId,int32_t * index)333 int32_t MockGetAccessibilityNodeCursorPosition(
334 int64_t elementId,
335 int32_t requestId,
336 int32_t* index)
337 {
338 g_providerMockResult.elementId_ = elementId;
339 g_providerMockResult.requestId_ = requestId;
340 *index = g_providerMockResult.cursorPosition_;
341 return ARKUI_ACCESSIBILITY_NATIVE_RESULT_SUCCESSFUL;
342 }
343
MockGetAccessibilityNodeCursorPositionWithInstance(const char * instanceId,int64_t elementId,int32_t requestId,int32_t * index)344 int32_t MockGetAccessibilityNodeCursorPositionWithInstance(
345 const char* instanceId,
346 int64_t elementId,
347 int32_t requestId,
348 int32_t* index)
349 {
350 g_providerMockResult.instanceId_ = instanceId;
351 return MockGetAccessibilityNodeCursorPosition(elementId, requestId, index);
352 }
353
MockRegisterCallback(bool isRegistered)354 void MockRegisterCallback(bool isRegistered)
355 {
356 g_providerMockResult.registerResult_ = isRegistered;
357 }
358
MockEventCallBack(int32_t errorCode)359 void MockEventCallBack(int32_t errorCode)
360 {
361 g_providerMockResult.errorCode_ = errorCode;
362 }
363
BuildMockCallBack(ArkUI_AccessibilityProviderCallbacks & callBacks)364 void BuildMockCallBack(ArkUI_AccessibilityProviderCallbacks &callBacks)
365 {
366 // register success
367 callBacks.findAccessibilityNodeInfosById =
368 MockFindAccessibilityNodeInfosById;
369 callBacks.findAccessibilityNodeInfosByText =
370 MockFindAccessibilityNodeInfosByText;
371 callBacks.findFocusedAccessibilityNode =
372 MockFindFocusedAccessibilityNode;
373 callBacks.findNextFocusAccessibilityNode =
374 MockFindNextFocusAccessibilityNode;
375 callBacks.executeAccessibilityAction =
376 MockExecuteAccessibilityAction;
377 callBacks.clearFocusedFocusAccessibilityNode =
378 MockClearFocusedFocusAccessibilityNode;
379 callBacks.getAccessibilityNodeCursorPosition =
380 MockGetAccessibilityNodeCursorPosition;
381 }
382
BuildMockCallBackWithInstance(ArkUI_AccessibilityProviderCallbacksWithInstance & callBacks)383 void BuildMockCallBackWithInstance(ArkUI_AccessibilityProviderCallbacksWithInstance &callBacks)
384 {
385 // register success
386 callBacks.findAccessibilityNodeInfosById = MockFindAccessibilityNodeInfosByIdWithInstance;
387 callBacks.findAccessibilityNodeInfosByText = MockFindAccessibilityNodeInfosByTextWithInstanceId;
388 callBacks.findFocusedAccessibilityNode = MockFindFocusedAccessibilityNodeWithInstance;
389 callBacks.findNextFocusAccessibilityNode = MockFindNextFocusAccessibilityNodeWithInstance;
390 callBacks.executeAccessibilityAction = MockExecuteAccessibilityActionWithInstance;
391 callBacks.clearFocusedFocusAccessibilityNode = MockClearFocusedFocusAccessibilityNodeWithInstance;
392 callBacks.getAccessibilityNodeCursorPosition = MockGetAccessibilityNodeCursorPositionWithInstance;
393 }
394 } // namespace
395
396 class AccessibilityProviderTestNg : public testing::Test {
397 public:
SetUpTestCase()398 static void SetUpTestCase()
399 {
400 g_providerMockResult.Reset();
401 }
TearDownTestCase()402 static void TearDownTestCase() {};
403 };
404
405
406 /**
407 * @tc.name: accessibilityTest001
408 * @tc.desc: AccessibilityProviderRegisterCallback abnormal
409 * @tc.type: FUNC
410 */
411 HWTEST_F(AccessibilityProviderTestNg, AccessibilityProviderTest001, TestSize.Level1)
412 {
413 g_providerMockResult.Reset();
414 ArkUI_AccessibilityProvider accessibilityProvider;
415 int32_t ret;
416 ArkUI_AccessibilityProviderCallbacks callBacks;
417 // callback null
418 ret = accessibilityProvider.AccessibilityProviderRegisterCallback(nullptr);
419 EXPECT_EQ(ret, ARKUI_ACCESSIBILITY_NATIVE_RESULT_BAD_PARAMETER);
420 EXPECT_EQ(accessibilityProvider.IsRegister(), false);
421 // findAccessibilityNodeInfosById null
422 ret = accessibilityProvider.AccessibilityProviderRegisterCallback(&callBacks);
423 EXPECT_EQ(ret, ARKUI_ACCESSIBILITY_NATIVE_RESULT_BAD_PARAMETER);
424 EXPECT_EQ(accessibilityProvider.IsRegister(), false);
425 // findAccessibilityNodeInfosByText null
426 callBacks.findAccessibilityNodeInfosById = MockFindAccessibilityNodeInfosById;
427 ret = accessibilityProvider.AccessibilityProviderRegisterCallback(&callBacks);
428 EXPECT_EQ(ret, ARKUI_ACCESSIBILITY_NATIVE_RESULT_BAD_PARAMETER);
429 EXPECT_EQ(accessibilityProvider.IsRegister(), false);
430 // findFocusedAccessibilityNode null
431 callBacks.findAccessibilityNodeInfosByText =
432 MockFindAccessibilityNodeInfosByText;
433 ret = accessibilityProvider.AccessibilityProviderRegisterCallback(&callBacks);
434 EXPECT_EQ(ret, ARKUI_ACCESSIBILITY_NATIVE_RESULT_BAD_PARAMETER);
435 EXPECT_EQ(accessibilityProvider.IsRegister(), false);
436 // findNextFocusAccessibilityNode null
437 callBacks.findFocusedAccessibilityNode = MockFindFocusedAccessibilityNode;
438 ret = accessibilityProvider.AccessibilityProviderRegisterCallback(&callBacks);
439 EXPECT_EQ(ret, ARKUI_ACCESSIBILITY_NATIVE_RESULT_BAD_PARAMETER);
440 EXPECT_EQ(accessibilityProvider.IsRegister(), false);
441
442 // executeAccessibilityAction null
443 callBacks.findNextFocusAccessibilityNode = MockFindNextFocusAccessibilityNode;
444 ret = accessibilityProvider.AccessibilityProviderRegisterCallback(&callBacks);
445 EXPECT_EQ(ret, ARKUI_ACCESSIBILITY_NATIVE_RESULT_BAD_PARAMETER);
446 EXPECT_EQ(accessibilityProvider.IsRegister(), false);
447 // clearFocusedFocusAccessibilityNode null
448 callBacks.executeAccessibilityAction = MockExecuteAccessibilityAction;
449 ret = accessibilityProvider.AccessibilityProviderRegisterCallback(&callBacks);
450 EXPECT_EQ(ret, ARKUI_ACCESSIBILITY_NATIVE_RESULT_BAD_PARAMETER);
451 EXPECT_EQ(accessibilityProvider.IsRegister(), false);
452 // getAccessibilityNodeCursorPosition null
453 callBacks.clearFocusedFocusAccessibilityNode =
454 MockClearFocusedFocusAccessibilityNode;
455 ret = accessibilityProvider.AccessibilityProviderRegisterCallback(&callBacks);
456 EXPECT_EQ(ret, ARKUI_ACCESSIBILITY_NATIVE_RESULT_BAD_PARAMETER);
457 EXPECT_EQ(accessibilityProvider.IsRegister(), false);
458 callBacks.getAccessibilityNodeCursorPosition =
459 MockGetAccessibilityNodeCursorPosition;
460 }
461
462 /**
463 * @tc.name: accessibilityTest002
464 * @tc.desc: AccessibilityProviderRegisterCallback abnormal
465 * @tc.type: FUNC
466 */
467 HWTEST_F(AccessibilityProviderTestNg, AccessibilityProviderTest002, TestSize.Level1)
468 {
469 g_providerMockResult.Reset();
470 ArkUI_AccessibilityProvider accessibilityProvider;
471 int32_t ret;
472 ArkUI_AccessibilityProviderCallbacks callBacks;
473 accessibilityProvider.SetRegisterCallback(MockRegisterCallback);
474 // register success
475 BuildMockCallBack(callBacks);
476 ret = accessibilityProvider.AccessibilityProviderRegisterCallback(&callBacks);
477 EXPECT_EQ(ret, ARKUI_ACCESSIBILITY_NATIVE_RESULT_SUCCESSFUL);
478 EXPECT_EQ(g_providerMockResult.registerResult_, true);
479 EXPECT_EQ(accessibilityProvider.IsRegister(), true);
480
481 // then register fail, call registercallback false
482 callBacks.findAccessibilityNodeInfosById = nullptr;
483 ret = accessibilityProvider.AccessibilityProviderRegisterCallback(&callBacks);
484 EXPECT_EQ(ret, ARKUI_ACCESSIBILITY_NATIVE_RESULT_BAD_PARAMETER);
485 EXPECT_EQ(g_providerMockResult.registerResult_, false);
486 }
487
488 /**
489 * @tc.name: accessibilityTest003
490 * @tc.desc: FindAccessibilityNodeInfosById
491 * @tc.type: FUNC
492 */
493 HWTEST_F(AccessibilityProviderTestNg, AccessibilityProviderTest003, TestSize.Level1)
494 {
495 g_providerMockResult.Reset();
496 ArkUI_AccessibilityProvider accessibilityProvider;
497 int32_t ret;
498 ArkUI_AccessibilityProviderCallbacks callBacks;
499 accessibilityProvider.SetRegisterCallback(MockRegisterCallback);
500
501 auto now = std::chrono::system_clock::now();
502 int32_t testParameter =
503 std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch())
504 .count();
505 testParameter = testParameter % MAX_TEST_PARAMETER;
506 int64_t elementId = testParameter;
507 int32_t mode = testParameter + TEST_PARAMETER_OFFSET1;
508 int32_t requestId = testParameter + TEST_PARAMETER_OFFSET2;
509 std::vector<ArkUI_AccessibilityElementInfo> infos;
510
511 // register fail
512 ret = accessibilityProvider.FindAccessibilityNodeInfosById(
513 elementId, mode, requestId, infos);
514 EXPECT_EQ(ret, AccessibilityProviderOperatorErrorCode::NOT_REGISTERED);
515
516 // register success
517 BuildMockCallBack(callBacks);
518 ret = accessibilityProvider.AccessibilityProviderRegisterCallback(&callBacks);
519 EXPECT_EQ(ret, ARKUI_ACCESSIBILITY_NATIVE_RESULT_SUCCESSFUL);
520
521 ret = accessibilityProvider.FindAccessibilityNodeInfosById(
522 elementId, mode, requestId, infos);
523 EXPECT_EQ(ret, ARKUI_ACCESSIBILITY_NATIVE_RESULT_SUCCESSFUL);
524 EXPECT_EQ(g_providerMockResult.elementId_, elementId);
525 EXPECT_EQ(g_providerMockResult.mode_, mode);
526 EXPECT_EQ(g_providerMockResult.requestId_, requestId);
527 // id equals to prepared ids
528 for (int64_t i = 0; i < g_providerMockResult.elementInfosList_.size(); i++) {
529 EXPECT_EQ(g_providerMockResult.elementInfosList_[i].GetElementId(),
530 infos[i].GetElementId());
531 }
532
533 // copy fail
534 ArkUI_AccessibilityProvider accessibilityProvider2;
535 accessibilityProvider2.SetRegisterCallback(MockRegisterCallback);
536 callBacks.findAccessibilityNodeInfosById =
537 MockFindAccessibilityNodeInfosByIdCopyFail;
538 ret = accessibilityProvider2.AccessibilityProviderRegisterCallback(&callBacks);
539 EXPECT_EQ(ret, ARKUI_ACCESSIBILITY_NATIVE_RESULT_SUCCESSFUL);
540 ret = accessibilityProvider2.FindAccessibilityNodeInfosById(
541 elementId, mode, requestId, infos);
542 EXPECT_EQ(ret, AccessibilityProviderOperatorErrorCode::COPY_FAILED);
543 }
544
545 /**
546 * @tc.name: accessibilityTest004
547 * @tc.desc: FindAccessibilityNodeInfosByText
548 * @tc.type: FUNC
549 */
550 HWTEST_F(AccessibilityProviderTestNg, AccessibilityProviderTest004, TestSize.Level1)
551 {
552 g_providerMockResult.Reset();
553 ArkUI_AccessibilityProvider accessibilityProvider;
554 int32_t ret;
555 ArkUI_AccessibilityProviderCallbacks callBacks;
556 accessibilityProvider.SetRegisterCallback(MockRegisterCallback);
557
558 auto now = std::chrono::system_clock::now();
559 int32_t testParameter =
560 std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch())
561 .count();
562 testParameter = testParameter % MAX_TEST_PARAMETER;
563 int64_t elementId = testParameter;
564 int32_t requestId = testParameter + TEST_PARAMETER_OFFSET1;
565 std::vector<ArkUI_AccessibilityElementInfo> infos;
566 std::string text = TEST_CONTENT_STR;
567
568 // register fail
569 ret = accessibilityProvider.FindAccessibilityNodeInfosByText(
570 elementId, text, requestId, infos);
571 EXPECT_EQ(ret, AccessibilityProviderOperatorErrorCode::NOT_REGISTERED);
572
573 // register success
574 BuildMockCallBack(callBacks);
575 ret = accessibilityProvider.AccessibilityProviderRegisterCallback(&callBacks);
576 EXPECT_EQ(ret, ARKUI_ACCESSIBILITY_NATIVE_RESULT_SUCCESSFUL);
577
578 ret = accessibilityProvider.FindAccessibilityNodeInfosByText(
579 elementId, text, requestId, infos);
580 EXPECT_EQ(ret, ARKUI_ACCESSIBILITY_NATIVE_RESULT_SUCCESSFUL);
581 EXPECT_EQ(g_providerMockResult.elementId_, elementId);
582 EXPECT_EQ(g_providerMockResult.requestId_, requestId);
583 // all elementInfo's text matched
584 for (int64_t i = 0; i < g_providerMockResult.elementInfosList_.size(); i++) {
585 EXPECT_EQ(g_providerMockResult.elementInfosList_[i].GetElementId(),
586 infos[i].GetElementId());
587 }
588
589 // copy fail
590 ArkUI_AccessibilityProvider accessibilityProvider2;
591 accessibilityProvider2.SetRegisterCallback(MockRegisterCallback);
592 callBacks.findAccessibilityNodeInfosByText =
593 MockFindAccessibilityNodeInfosByTextCopyFail;
594 ret = accessibilityProvider2.AccessibilityProviderRegisterCallback(&callBacks);
595 EXPECT_EQ(ret, ARKUI_ACCESSIBILITY_NATIVE_RESULT_SUCCESSFUL);
596 ret = accessibilityProvider2.FindAccessibilityNodeInfosByText(
597 elementId, text, requestId, infos);
598 EXPECT_EQ(ret, AccessibilityProviderOperatorErrorCode::COPY_FAILED);
599
600 // register with instance
601 ArkUI_AccessibilityProviderCallbacksWithInstance callBacksWithInstance;
602 BuildMockCallBackWithInstance(callBacksWithInstance);
603 ret = accessibilityProvider.AccessibilityProviderRegisterCallbackWithInstance(INSTANCE_ID, &callBacksWithInstance);
604 EXPECT_EQ(ret, ARKUI_ACCESSIBILITY_NATIVE_RESULT_SUCCESSFUL);
605 ret = accessibilityProvider.FindAccessibilityNodeInfosByText(
606 elementId, text, requestId, infos);
607 EXPECT_EQ(ret, ARKUI_ACCESSIBILITY_NATIVE_RESULT_SUCCESSFUL);
608 }
609
610 /**
611 * @tc.name: accessibilityTest005
612 * @tc.desc: FindFocusedAccessibilityNode and FindNextFocusAccessibilityNode
613 * @tc.type: FUNC
614 */
615 HWTEST_F(AccessibilityProviderTestNg, AccessibilityProviderTest005, TestSize.Level1)
616 {
617 g_providerMockResult.Reset();
618 ArkUI_AccessibilityProvider accessibilityProvider;
619 int32_t ret;
620 ArkUI_AccessibilityProviderCallbacks callBacks;
621 accessibilityProvider.SetRegisterCallback(MockRegisterCallback);
622
623 auto now = std::chrono::system_clock::now();
624 int32_t testParameter =
625 std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch())
626 .count();
627 testParameter = testParameter % MAX_TEST_PARAMETER;
628 int64_t elementId = testParameter;
629 int32_t focusType = testParameter + TEST_PARAMETER_OFFSET1;
630 int32_t requestId = testParameter + TEST_PARAMETER_OFFSET2;
631 int32_t direction = testParameter + TEST_PARAMETER_OFFSET3;
632 ArkUI_AccessibilityElementInfo elementInfo;
633
634 // register fail
635 ret = accessibilityProvider.FindFocusedAccessibilityNode(
636 elementId, focusType, requestId, elementInfo);
637 EXPECT_EQ(ret, AccessibilityProviderOperatorErrorCode::NOT_REGISTERED);
638 ret = accessibilityProvider.FindNextFocusAccessibilityNode(
639 elementId, direction, requestId, elementInfo);
640 EXPECT_EQ(ret, AccessibilityProviderOperatorErrorCode::NOT_REGISTERED);
641
642
643 // register success
644 BuildMockCallBack(callBacks);
645 ret = accessibilityProvider.AccessibilityProviderRegisterCallback(&callBacks);
646 EXPECT_EQ(ret, ARKUI_ACCESSIBILITY_NATIVE_RESULT_SUCCESSFUL);
647
648 ret = accessibilityProvider.FindFocusedAccessibilityNode(
649 elementId, focusType, requestId, elementInfo);
650 EXPECT_EQ(ret, ARKUI_ACCESSIBILITY_NATIVE_RESULT_SUCCESSFUL);
651 EXPECT_EQ(g_providerMockResult.elementId_, elementId);
652 EXPECT_EQ(g_providerMockResult.focusType_, focusType);
653 EXPECT_EQ(g_providerMockResult.requestId_, requestId);
654 EXPECT_EQ(g_providerMockResult.focusElementInfo_.GetElementId(),
655 elementInfo.GetElementId());
656
657 ret = accessibilityProvider.FindNextFocusAccessibilityNode(
658 elementId, direction, requestId, elementInfo);
659 EXPECT_EQ(ret, ARKUI_ACCESSIBILITY_NATIVE_RESULT_SUCCESSFUL);
660 EXPECT_EQ(g_providerMockResult.elementId_, elementId);
661 EXPECT_EQ(g_providerMockResult.direction_, direction);
662 EXPECT_EQ(g_providerMockResult.requestId_, requestId);
663 EXPECT_EQ(g_providerMockResult.nextFocusElementInfo_.GetElementId(),
664 elementInfo.GetElementId());
665
666 // register with instance
667 ArkUI_AccessibilityProviderCallbacksWithInstance callBacksWithInstance;
668 BuildMockCallBackWithInstance(callBacksWithInstance);
669 ret = accessibilityProvider.AccessibilityProviderRegisterCallbackWithInstance(INSTANCE_ID, &callBacksWithInstance);
670 EXPECT_EQ(ret, ARKUI_ACCESSIBILITY_NATIVE_RESULT_SUCCESSFUL);
671 ret = accessibilityProvider.FindFocusedAccessibilityNode(
672 elementId, focusType, requestId, elementInfo);
673 EXPECT_EQ(ret, ARKUI_ACCESSIBILITY_NATIVE_RESULT_SUCCESSFUL);
674 ret = accessibilityProvider.FindNextFocusAccessibilityNode(
675 elementId, direction, requestId, elementInfo);
676 EXPECT_EQ(ret, ARKUI_ACCESSIBILITY_NATIVE_RESULT_SUCCESSFUL);
677 }
678
679 /**
680 * @tc.name: accessibilityTest006
681 * @tc.desc: ExecuteAccessibilityAction
682 * @tc.type: FUNC
683 */
684 HWTEST_F(AccessibilityProviderTestNg, AccessibilityProviderTest006, TestSize.Level1)
685 {
686 g_providerMockResult.Reset();
687 ArkUI_AccessibilityProvider accessibilityProvider;
688 int32_t ret;
689 ArkUI_AccessibilityProviderCallbacks callBacks;
690 accessibilityProvider.SetRegisterCallback(MockRegisterCallback);
691
692 auto now = std::chrono::system_clock::now();
693 int32_t testParameter =
694 std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch())
695 .count();
696 testParameter = testParameter % MAX_TEST_PARAMETER;
697 int64_t elementId = testParameter;
698 int32_t action = testParameter + TEST_PARAMETER_OFFSET1;
699 int32_t requestId = testParameter + TEST_PARAMETER_OFFSET2;
700 std::map<std::string, std::string> actionArguments =
701 g_providerMockResult.originActionArguments_;
702 // register fail
703 ret = accessibilityProvider.ExecuteAccessibilityAction(
704 elementId, action, requestId, actionArguments);
705 EXPECT_EQ(ret, AccessibilityProviderOperatorErrorCode::NOT_REGISTERED);
706
707 // register success
708 BuildMockCallBack(callBacks);
709 ret = accessibilityProvider.AccessibilityProviderRegisterCallback(&callBacks);
710 EXPECT_EQ(ret, ARKUI_ACCESSIBILITY_NATIVE_RESULT_SUCCESSFUL);
711
712 ret = accessibilityProvider.ExecuteAccessibilityAction(
713 elementId, action, requestId, actionArguments);
714 EXPECT_EQ(ret, ARKUI_ACCESSIBILITY_NATIVE_RESULT_SUCCESSFUL);
715 EXPECT_EQ(actionArguments, g_providerMockResult.resultActionArguments_);
716
717 // register with instance
718 ArkUI_AccessibilityProviderCallbacksWithInstance callBacksWithInstance;
719 BuildMockCallBackWithInstance(callBacksWithInstance);
720 ret = accessibilityProvider.AccessibilityProviderRegisterCallbackWithInstance(INSTANCE_ID, &callBacksWithInstance);
721 EXPECT_EQ(ret, ARKUI_ACCESSIBILITY_NATIVE_RESULT_SUCCESSFUL);
722 ret = accessibilityProvider.ExecuteAccessibilityAction(
723 elementId, action, requestId, actionArguments);
724 EXPECT_EQ(ret, ARKUI_ACCESSIBILITY_NATIVE_RESULT_SUCCESSFUL);
725 }
726
727 /**
728 * @tc.name: accessibilityTest007
729 * @tc.desc: ClearFocusedAccessibilityNode
730 * @tc.type: FUNC
731 */
732 HWTEST_F(AccessibilityProviderTestNg, AccessibilityProviderTest007, TestSize.Level1)
733 {
734 g_providerMockResult.Reset();
735 ArkUI_AccessibilityProvider accessibilityProvider;
736 int32_t ret;
737 ArkUI_AccessibilityProviderCallbacks callBacks;
738 accessibilityProvider.SetRegisterCallback(MockRegisterCallback);
739
740 // register fail
741 ret = accessibilityProvider.ClearFocusedAccessibilityNode();
742 EXPECT_EQ(ret, AccessibilityProviderOperatorErrorCode::NOT_REGISTERED);
743
744 // register success
745 BuildMockCallBack(callBacks);
746 ret = accessibilityProvider.AccessibilityProviderRegisterCallback(&callBacks);
747 EXPECT_EQ(ret, ARKUI_ACCESSIBILITY_NATIVE_RESULT_SUCCESSFUL);
748
749 ret = accessibilityProvider.ClearFocusedAccessibilityNode();
750 EXPECT_EQ(ret, ARKUI_ACCESSIBILITY_NATIVE_RESULT_SUCCESSFUL);
751 EXPECT_EQ(g_providerMockResult.receiveClear_, true);
752
753 // register with instance
754 ArkUI_AccessibilityProviderCallbacksWithInstance callBacksWithInstance;
755 BuildMockCallBackWithInstance(callBacksWithInstance);
756 ret = accessibilityProvider.AccessibilityProviderRegisterCallbackWithInstance(INSTANCE_ID, &callBacksWithInstance);
757 EXPECT_EQ(ret, ARKUI_ACCESSIBILITY_NATIVE_RESULT_SUCCESSFUL);
758 accessibilityProvider.ClearFocusedAccessibilityNode();
759 }
760
761 /**
762 * @tc.name: accessibilityTest008
763 * @tc.desc: GetAccessibilityNodeCursorPosition
764 * @tc.type: FUNC
765 */
766 HWTEST_F(AccessibilityProviderTestNg, AccessibilityProviderTest008, TestSize.Level1)
767 {
768 g_providerMockResult.Reset();
769 ArkUI_AccessibilityProvider accessibilityProvider;
770 int32_t ret;
771 ArkUI_AccessibilityProviderCallbacks callBacks;
772 accessibilityProvider.SetRegisterCallback(MockRegisterCallback);
773
774 auto now = std::chrono::system_clock::now();
775 int32_t testParameter =
776 std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch())
777 .count();
778 testParameter = testParameter % MAX_TEST_PARAMETER;
779 int64_t elementId = testParameter;
780 int32_t requestId = testParameter + TEST_PARAMETER_OFFSET1;
781 int32_t cursorPosition;
782 std::map<std::string, std::string> actionArguments =
783 g_providerMockResult.originActionArguments_;
784 // register fail
785 ret = accessibilityProvider.GetAccessibilityNodeCursorPosition(
786 elementId, requestId, cursorPosition);
787 EXPECT_EQ(ret, AccessibilityProviderOperatorErrorCode::NOT_REGISTERED);
788
789 // register success
790 BuildMockCallBack(callBacks);
791 ret = accessibilityProvider.AccessibilityProviderRegisterCallback(&callBacks);
792 EXPECT_EQ(ret, ARKUI_ACCESSIBILITY_NATIVE_RESULT_SUCCESSFUL);
793
794 ret = accessibilityProvider.GetAccessibilityNodeCursorPosition(
795 elementId, requestId, cursorPosition);
796 EXPECT_EQ(ret, ARKUI_ACCESSIBILITY_NATIVE_RESULT_SUCCESSFUL);
797 EXPECT_EQ(cursorPosition, g_providerMockResult.cursorPosition_);
798
799 // register with instance
800 ArkUI_AccessibilityProviderCallbacksWithInstance callBacksWithInstance;
801 BuildMockCallBackWithInstance(callBacksWithInstance);
802 ret = accessibilityProvider.AccessibilityProviderRegisterCallbackWithInstance(INSTANCE_ID, &callBacksWithInstance);
803 EXPECT_EQ(ret, ARKUI_ACCESSIBILITY_NATIVE_RESULT_SUCCESSFUL);
804 ret = accessibilityProvider.GetAccessibilityNodeCursorPosition(
805 elementId, requestId, cursorPosition);
806 EXPECT_EQ(ret, ARKUI_ACCESSIBILITY_NATIVE_RESULT_SUCCESSFUL);
807 }
808
809 /**
810 * @tc.name: accessibilityTest009
811 * @tc.desc: SendAccessibilityAsyncEvent
812 * @tc.type: FUNC
813 */
814 HWTEST_F(AccessibilityProviderTestNg, AccessibilityProviderTest009, TestSize.Level1)
815 {
816 g_providerMockResult.Reset();
817 ArkUI_AccessibilityProvider accessibilityProvider;
818 int32_t ret;
819
820 // 1.1 event null and callback null
821 ret = accessibilityProvider.SendAccessibilityAsyncEvent(nullptr, nullptr);
822 EXPECT_EQ(ret, SEND_EVENT_FAILED);
823
824 // 1.2 event null and callback not null
825 ret = accessibilityProvider.SendAccessibilityAsyncEvent(
826 nullptr, MockEventCallBack);
827 EXPECT_EQ(ret, SEND_EVENT_FAILED);
828 EXPECT_EQ(g_providerMockResult.errorCode_, SEND_EVENT_FAILED);
829
830 // 2.1 event not null and OH accessibilityProvider null and callback null
831 ArkUI_AccessibilityEventInfo accessibilityEvent;
832 ret = accessibilityProvider.SendAccessibilityAsyncEvent(
833 &accessibilityEvent, nullptr);
834 EXPECT_EQ(ret, SEND_EVENT_FAILED);
835 // 2.2 event not null and accessibilityProvider null and callback not null
836 ret = accessibilityProvider.SendAccessibilityAsyncEvent(
837 &accessibilityEvent, MockEventCallBack);
838 EXPECT_EQ(ret, SEND_EVENT_FAILED);
839 EXPECT_EQ(g_providerMockResult.errorCode_, SEND_EVENT_FAILED);
840
841
842 // 3 event not null and OH accessibilityProvider not null
843 auto ohAccessibilityProvider
844 = AceType::MakeRefPtr<MockOhAccessibilityProvider>();
845 accessibilityProvider.SetInnerAccessibilityProvider(ohAccessibilityProvider);
846 ret = accessibilityProvider.SendAccessibilityAsyncEvent(
847 &accessibilityEvent, MockEventCallBack);
848 EXPECT_EQ(ret, SEND_EVENT_SUCCESS);
849 }
850
851 /**
852 * @tc.name: accessibilityTest010
853 * @tc.desc: AccessibilityProviderRegisterCallbackWithInstance test
854 * @tc.type: FUNC
855 */
856 HWTEST_F(AccessibilityProviderTestNg, AccessibilityProviderTest010, TestSize.Level1)
857 {
858 ArkUI_AccessibilityProvider accessibilityProvider;
859 int32_t ret = 0;
860 ArkUI_AccessibilityProviderCallbacksWithInstance callBacks;
861 // callback null
862 ret = accessibilityProvider.AccessibilityProviderRegisterCallback(nullptr);
863 EXPECT_EQ(ret, ARKUI_ACCESSIBILITY_NATIVE_RESULT_BAD_PARAMETER);
864 EXPECT_EQ(accessibilityProvider.IsRegister(), false);
865 // findAccessibilityNodeInfosById null
866 ret = accessibilityProvider.AccessibilityProviderRegisterCallbackWithInstance(INSTANCE_ID, &callBacks);
867 EXPECT_EQ(ret, ARKUI_ACCESSIBILITY_NATIVE_RESULT_BAD_PARAMETER);
868 EXPECT_EQ(accessibilityProvider.IsRegister(), false);
869 // findAccessibilityNodeInfosByText null
870 callBacks.findAccessibilityNodeInfosById = MockFindAccessibilityNodeInfosByIdWithInstance;
871 ret = accessibilityProvider.AccessibilityProviderRegisterCallbackWithInstance(INSTANCE_ID, &callBacks);
872 EXPECT_EQ(ret, ARKUI_ACCESSIBILITY_NATIVE_RESULT_BAD_PARAMETER);
873 EXPECT_EQ(accessibilityProvider.IsRegister(), false);
874 // findFocusedAccessibilityNode null
875 callBacks.findAccessibilityNodeInfosByText =MockFindAccessibilityNodeInfosByTextWithInstanceId;
876 ret = accessibilityProvider.AccessibilityProviderRegisterCallbackWithInstance(INSTANCE_ID, &callBacks);
877 EXPECT_EQ(ret, ARKUI_ACCESSIBILITY_NATIVE_RESULT_BAD_PARAMETER);
878 EXPECT_EQ(accessibilityProvider.IsRegister(), false);
879 // findNextFocusAccessibilityNode null
880 callBacks.findFocusedAccessibilityNode = MockFindFocusedAccessibilityNodeWithInstance;
881 ret = accessibilityProvider.AccessibilityProviderRegisterCallbackWithInstance(INSTANCE_ID, &callBacks);
882 EXPECT_EQ(ret, ARKUI_ACCESSIBILITY_NATIVE_RESULT_BAD_PARAMETER);
883 EXPECT_EQ(accessibilityProvider.IsRegister(), false);
884
885 // executeAccessibilityAction null
886 callBacks.findNextFocusAccessibilityNode = MockFindNextFocusAccessibilityNodeWithInstance;
887 ret = accessibilityProvider.AccessibilityProviderRegisterCallbackWithInstance(INSTANCE_ID, &callBacks);
888 EXPECT_EQ(ret, ARKUI_ACCESSIBILITY_NATIVE_RESULT_BAD_PARAMETER);
889 EXPECT_EQ(accessibilityProvider.IsRegister(), false);
890 // clearFocusedFocusAccessibilityNode null
891 callBacks.executeAccessibilityAction = MockExecuteAccessibilityActionWithInstance;
892 ret = accessibilityProvider.AccessibilityProviderRegisterCallbackWithInstance(INSTANCE_ID, &callBacks);
893 EXPECT_EQ(ret, ARKUI_ACCESSIBILITY_NATIVE_RESULT_BAD_PARAMETER);
894 EXPECT_EQ(accessibilityProvider.IsRegister(), false);
895 // getAccessibilityNodeCursorPosition null
896 callBacks.clearFocusedFocusAccessibilityNode = MockClearFocusedFocusAccessibilityNodeWithInstance;
897 ret = accessibilityProvider.AccessibilityProviderRegisterCallbackWithInstance(INSTANCE_ID, &callBacks);
898 EXPECT_EQ(ret, ARKUI_ACCESSIBILITY_NATIVE_RESULT_BAD_PARAMETER);
899 EXPECT_EQ(accessibilityProvider.IsRegister(), false);
900 callBacks.getAccessibilityNodeCursorPosition = MockGetAccessibilityNodeCursorPositionWithInstance;
901 ret = accessibilityProvider.AccessibilityProviderRegisterCallbackWithInstance(INSTANCE_ID, &callBacks);
902 EXPECT_EQ(ret, ARKUI_ACCESSIBILITY_NATIVE_RESULT_SUCCESSFUL);
903 EXPECT_EQ(accessibilityProvider.IsRegister(), true);
904 EXPECT_EQ(g_providerMockResult.registerResult_, true);
905 }
906
907 /**
908 * @tc.name: accessibilityTest011
909 * @tc.desc: FindAccessibilityNodeInfosByIdWithInstance
910 * @tc.type: FUNC
911 */
912 HWTEST_F(AccessibilityProviderTestNg, AccessibilityProviderTest011, TestSize.Level1)
913 {
914 ArkUI_AccessibilityProvider accessibilityProvider;
915 int32_t ret;
916 ArkUI_AccessibilityProviderCallbacks callBacks;
917 ArkUI_AccessibilityProviderCallbacksWithInstance callBacksWithInstance;
918 accessibilityProvider.SetRegisterCallback(MockRegisterCallback);
919
920 auto now = std::chrono::system_clock::now();
921 int32_t testParameter =
922 std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch())
923 .count();
924 testParameter = testParameter % MAX_TEST_PARAMETER;
925 int64_t elementId = testParameter;
926 int32_t mode = testParameter + TEST_PARAMETER_OFFSET1;
927 int32_t requestId = testParameter + TEST_PARAMETER_OFFSET2;
928 std::vector<ArkUI_AccessibilityElementInfo> infos;
929
930 // register fail
931 ret = accessibilityProvider.FindAccessibilityNodeInfosById(
932 elementId, mode, requestId, infos);
933 EXPECT_EQ(ret, AccessibilityProviderOperatorErrorCode::NOT_REGISTERED);
934
935 // register success
936 BuildMockCallBack(callBacks);
937 BuildMockCallBackWithInstance(callBacksWithInstance);
938
939 ret = accessibilityProvider.AccessibilityProviderRegisterCallback(&callBacks);
940 EXPECT_EQ(ret, ARKUI_ACCESSIBILITY_NATIVE_RESULT_SUCCESSFUL);
941 ret = accessibilityProvider.AccessibilityProviderRegisterCallbackWithInstance(INSTANCE_ID, &callBacksWithInstance);
942 EXPECT_EQ(ret, ARKUI_ACCESSIBILITY_NATIVE_RESULT_SUCCESSFUL);
943
944 ret = accessibilityProvider.FindAccessibilityNodeInfosById(
945 elementId, mode, requestId, infos);
946 EXPECT_EQ(ret, ARKUI_ACCESSIBILITY_NATIVE_RESULT_SUCCESSFUL);
947 EXPECT_EQ(g_providerMockResult.elementId_, elementId);
948 EXPECT_EQ(g_providerMockResult.mode_, mode);
949 EXPECT_EQ(g_providerMockResult.requestId_, requestId);
950 EXPECT_EQ(g_providerMockResult.instanceId_, INSTANCE_ID);
951 }
952 } // namespace OHOS::Ace::NG
953