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
601 /**
602 * @tc.name: accessibilityTest005
603 * @tc.desc: FindFocusedAccessibilityNode and FindNextFocusAccessibilityNode
604 * @tc.type: FUNC
605 */
606 HWTEST_F(AccessibilityProviderTestNg, AccessibilityProviderTest005, TestSize.Level1)
607 {
608 g_providerMockResult.Reset();
609 ArkUI_AccessibilityProvider accessibilityProvider;
610 int32_t ret;
611 ArkUI_AccessibilityProviderCallbacks callBacks;
612 accessibilityProvider.SetRegisterCallback(MockRegisterCallback);
613
614 auto now = std::chrono::system_clock::now();
615 int32_t testParameter =
616 std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch())
617 .count();
618 testParameter = testParameter % MAX_TEST_PARAMETER;
619 int64_t elementId = testParameter;
620 int32_t focusType = testParameter + TEST_PARAMETER_OFFSET1;
621 int32_t requestId = testParameter + TEST_PARAMETER_OFFSET2;
622 int32_t direction = testParameter + TEST_PARAMETER_OFFSET3;
623 ArkUI_AccessibilityElementInfo elementInfo;
624
625 // register fail
626 ret = accessibilityProvider.FindFocusedAccessibilityNode(
627 elementId, focusType, requestId, elementInfo);
628 EXPECT_EQ(ret, AccessibilityProviderOperatorErrorCode::NOT_REGISTERED);
629 ret = accessibilityProvider.FindNextFocusAccessibilityNode(
630 elementId, direction, requestId, elementInfo);
631 EXPECT_EQ(ret, AccessibilityProviderOperatorErrorCode::NOT_REGISTERED);
632
633
634 // register success
635 BuildMockCallBack(callBacks);
636 ret = accessibilityProvider.AccessibilityProviderRegisterCallback(&callBacks);
637 EXPECT_EQ(ret, ARKUI_ACCESSIBILITY_NATIVE_RESULT_SUCCESSFUL);
638
639 ret = accessibilityProvider.FindFocusedAccessibilityNode(
640 elementId, focusType, requestId, elementInfo);
641 EXPECT_EQ(ret, ARKUI_ACCESSIBILITY_NATIVE_RESULT_SUCCESSFUL);
642 EXPECT_EQ(g_providerMockResult.elementId_, elementId);
643 EXPECT_EQ(g_providerMockResult.focusType_, focusType);
644 EXPECT_EQ(g_providerMockResult.requestId_, requestId);
645 EXPECT_EQ(g_providerMockResult.focusElementInfo_.GetElementId(),
646 elementInfo.GetElementId());
647
648 ret = accessibilityProvider.FindNextFocusAccessibilityNode(
649 elementId, direction, requestId, elementInfo);
650 EXPECT_EQ(ret, ARKUI_ACCESSIBILITY_NATIVE_RESULT_SUCCESSFUL);
651 EXPECT_EQ(g_providerMockResult.elementId_, elementId);
652 EXPECT_EQ(g_providerMockResult.direction_, direction);
653 EXPECT_EQ(g_providerMockResult.requestId_, requestId);
654 EXPECT_EQ(g_providerMockResult.nextFocusElementInfo_.GetElementId(),
655 elementInfo.GetElementId());
656 }
657
658 /**
659 * @tc.name: accessibilityTest006
660 * @tc.desc: ExecuteAccessibilityAction
661 * @tc.type: FUNC
662 */
663 HWTEST_F(AccessibilityProviderTestNg, AccessibilityProviderTest006, TestSize.Level1)
664 {
665 g_providerMockResult.Reset();
666 ArkUI_AccessibilityProvider accessibilityProvider;
667 int32_t ret;
668 ArkUI_AccessibilityProviderCallbacks callBacks;
669 accessibilityProvider.SetRegisterCallback(MockRegisterCallback);
670
671 auto now = std::chrono::system_clock::now();
672 int32_t testParameter =
673 std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch())
674 .count();
675 testParameter = testParameter % MAX_TEST_PARAMETER;
676 int64_t elementId = testParameter;
677 int32_t action = testParameter + TEST_PARAMETER_OFFSET1;
678 int32_t requestId = testParameter + TEST_PARAMETER_OFFSET2;
679 std::map<std::string, std::string> actionArguments =
680 g_providerMockResult.originActionArguments_;
681 // register fail
682 ret = accessibilityProvider.ExecuteAccessibilityAction(
683 elementId, action, requestId, actionArguments);
684 EXPECT_EQ(ret, AccessibilityProviderOperatorErrorCode::NOT_REGISTERED);
685
686 // register success
687 BuildMockCallBack(callBacks);
688 ret = accessibilityProvider.AccessibilityProviderRegisterCallback(&callBacks);
689 EXPECT_EQ(ret, ARKUI_ACCESSIBILITY_NATIVE_RESULT_SUCCESSFUL);
690
691 ret = accessibilityProvider.ExecuteAccessibilityAction(
692 elementId, action, requestId, actionArguments);
693 EXPECT_EQ(ret, ARKUI_ACCESSIBILITY_NATIVE_RESULT_SUCCESSFUL);
694 EXPECT_EQ(actionArguments, g_providerMockResult.resultActionArguments_);
695 }
696
697 /**
698 * @tc.name: accessibilityTest007
699 * @tc.desc: ClearFocusedAccessibilityNode
700 * @tc.type: FUNC
701 */
702 HWTEST_F(AccessibilityProviderTestNg, AccessibilityProviderTest007, TestSize.Level1)
703 {
704 g_providerMockResult.Reset();
705 ArkUI_AccessibilityProvider accessibilityProvider;
706 int32_t ret;
707 ArkUI_AccessibilityProviderCallbacks callBacks;
708 accessibilityProvider.SetRegisterCallback(MockRegisterCallback);
709
710 // register fail
711 ret = accessibilityProvider.ClearFocusedAccessibilityNode();
712 EXPECT_EQ(ret, AccessibilityProviderOperatorErrorCode::NOT_REGISTERED);
713
714 // register success
715 BuildMockCallBack(callBacks);
716 ret = accessibilityProvider.AccessibilityProviderRegisterCallback(&callBacks);
717 EXPECT_EQ(ret, ARKUI_ACCESSIBILITY_NATIVE_RESULT_SUCCESSFUL);
718
719 ret = accessibilityProvider.ClearFocusedAccessibilityNode();
720 EXPECT_EQ(ret, ARKUI_ACCESSIBILITY_NATIVE_RESULT_SUCCESSFUL);
721 EXPECT_EQ(g_providerMockResult.receiveClear_, true);
722 }
723
724 /**
725 * @tc.name: accessibilityTest008
726 * @tc.desc: GetAccessibilityNodeCursorPosition
727 * @tc.type: FUNC
728 */
729 HWTEST_F(AccessibilityProviderTestNg, AccessibilityProviderTest008, TestSize.Level1)
730 {
731 g_providerMockResult.Reset();
732 ArkUI_AccessibilityProvider accessibilityProvider;
733 int32_t ret;
734 ArkUI_AccessibilityProviderCallbacks callBacks;
735 accessibilityProvider.SetRegisterCallback(MockRegisterCallback);
736
737 auto now = std::chrono::system_clock::now();
738 int32_t testParameter =
739 std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch())
740 .count();
741 testParameter = testParameter % MAX_TEST_PARAMETER;
742 int64_t elementId = testParameter;
743 int32_t requestId = testParameter + TEST_PARAMETER_OFFSET1;
744 int32_t cursorPosition;
745 std::map<std::string, std::string> actionArguments =
746 g_providerMockResult.originActionArguments_;
747 // register fail
748 ret = accessibilityProvider.GetAccessibilityNodeCursorPosition(
749 elementId, requestId, cursorPosition);
750 EXPECT_EQ(ret, AccessibilityProviderOperatorErrorCode::NOT_REGISTERED);
751
752 // register success
753 BuildMockCallBack(callBacks);
754 ret = accessibilityProvider.AccessibilityProviderRegisterCallback(&callBacks);
755 EXPECT_EQ(ret, ARKUI_ACCESSIBILITY_NATIVE_RESULT_SUCCESSFUL);
756
757 ret = accessibilityProvider.GetAccessibilityNodeCursorPosition(
758 elementId, requestId, cursorPosition);
759 EXPECT_EQ(ret, ARKUI_ACCESSIBILITY_NATIVE_RESULT_SUCCESSFUL);
760 EXPECT_EQ(cursorPosition, g_providerMockResult.cursorPosition_);
761 }
762
763 /**
764 * @tc.name: accessibilityTest009
765 * @tc.desc: SendAccessibilityAsyncEvent
766 * @tc.type: FUNC
767 */
768 HWTEST_F(AccessibilityProviderTestNg, AccessibilityProviderTest009, TestSize.Level1)
769 {
770 g_providerMockResult.Reset();
771 ArkUI_AccessibilityProvider accessibilityProvider;
772 int32_t ret;
773
774 // 1.1 event null and callback null
775 ret = accessibilityProvider.SendAccessibilityAsyncEvent(nullptr, nullptr);
776 EXPECT_EQ(ret, SEND_EVENT_FAILED);
777
778 // 1.2 event null and callback not null
779 ret = accessibilityProvider.SendAccessibilityAsyncEvent(
780 nullptr, MockEventCallBack);
781 EXPECT_EQ(ret, SEND_EVENT_FAILED);
782 EXPECT_EQ(g_providerMockResult.errorCode_, SEND_EVENT_FAILED);
783
784 // 2.1 event not null and OH accessibilityProvider null and callback null
785 ArkUI_AccessibilityEventInfo accessibilityEvent;
786 ret = accessibilityProvider.SendAccessibilityAsyncEvent(
787 &accessibilityEvent, nullptr);
788 EXPECT_EQ(ret, SEND_EVENT_FAILED);
789 // 2.2 event not null and accessibilityProvider null and callback not null
790 ret = accessibilityProvider.SendAccessibilityAsyncEvent(
791 &accessibilityEvent, MockEventCallBack);
792 EXPECT_EQ(ret, SEND_EVENT_FAILED);
793 EXPECT_EQ(g_providerMockResult.errorCode_, SEND_EVENT_FAILED);
794
795
796 // 3 event not null and OH accessibilityProvider not null
797 auto ohAccessibilityProvider
798 = AceType::MakeRefPtr<MockOhAccessibilityProvider>();
799 accessibilityProvider.SetInnerAccessibilityProvider(ohAccessibilityProvider);
800 ret = accessibilityProvider.SendAccessibilityAsyncEvent(
801 &accessibilityEvent, MockEventCallBack);
802 EXPECT_EQ(ret, SEND_EVENT_SUCCESS);
803 }
804
805 /**
806 * @tc.name: accessibilityTest010
807 * @tc.desc: AccessibilityProviderRegisterCallbackWithInstance test
808 * @tc.type: FUNC
809 */
810 HWTEST_F(AccessibilityProviderTestNg, AccessibilityProviderTest010, TestSize.Level1)
811 {
812 ArkUI_AccessibilityProvider accessibilityProvider;
813 int32_t ret = 0;
814 ArkUI_AccessibilityProviderCallbacksWithInstance callBacks;
815 // callback null
816 ret = accessibilityProvider.AccessibilityProviderRegisterCallback(nullptr);
817 EXPECT_EQ(ret, ARKUI_ACCESSIBILITY_NATIVE_RESULT_BAD_PARAMETER);
818 EXPECT_EQ(accessibilityProvider.IsRegister(), false);
819 // findAccessibilityNodeInfosById null
820 ret = accessibilityProvider.AccessibilityProviderRegisterCallbackWithInstance(INSTANCE_ID, &callBacks);
821 EXPECT_EQ(ret, ARKUI_ACCESSIBILITY_NATIVE_RESULT_BAD_PARAMETER);
822 EXPECT_EQ(accessibilityProvider.IsRegister(), false);
823 // findAccessibilityNodeInfosByText null
824 callBacks.findAccessibilityNodeInfosById = MockFindAccessibilityNodeInfosByIdWithInstance;
825 ret = accessibilityProvider.AccessibilityProviderRegisterCallbackWithInstance(INSTANCE_ID, &callBacks);
826 EXPECT_EQ(ret, ARKUI_ACCESSIBILITY_NATIVE_RESULT_BAD_PARAMETER);
827 EXPECT_EQ(accessibilityProvider.IsRegister(), false);
828 // findFocusedAccessibilityNode null
829 callBacks.findAccessibilityNodeInfosByText =MockFindAccessibilityNodeInfosByTextWithInstanceId;
830 ret = accessibilityProvider.AccessibilityProviderRegisterCallbackWithInstance(INSTANCE_ID, &callBacks);
831 EXPECT_EQ(ret, ARKUI_ACCESSIBILITY_NATIVE_RESULT_BAD_PARAMETER);
832 EXPECT_EQ(accessibilityProvider.IsRegister(), false);
833 // findNextFocusAccessibilityNode null
834 callBacks.findFocusedAccessibilityNode = MockFindFocusedAccessibilityNodeWithInstance;
835 ret = accessibilityProvider.AccessibilityProviderRegisterCallbackWithInstance(INSTANCE_ID, &callBacks);
836 EXPECT_EQ(ret, ARKUI_ACCESSIBILITY_NATIVE_RESULT_BAD_PARAMETER);
837 EXPECT_EQ(accessibilityProvider.IsRegister(), false);
838
839 // executeAccessibilityAction null
840 callBacks.findNextFocusAccessibilityNode = MockFindNextFocusAccessibilityNodeWithInstance;
841 ret = accessibilityProvider.AccessibilityProviderRegisterCallbackWithInstance(INSTANCE_ID, &callBacks);
842 EXPECT_EQ(ret, ARKUI_ACCESSIBILITY_NATIVE_RESULT_BAD_PARAMETER);
843 EXPECT_EQ(accessibilityProvider.IsRegister(), false);
844 // clearFocusedFocusAccessibilityNode null
845 callBacks.executeAccessibilityAction = MockExecuteAccessibilityActionWithInstance;
846 ret = accessibilityProvider.AccessibilityProviderRegisterCallbackWithInstance(INSTANCE_ID, &callBacks);
847 EXPECT_EQ(ret, ARKUI_ACCESSIBILITY_NATIVE_RESULT_BAD_PARAMETER);
848 EXPECT_EQ(accessibilityProvider.IsRegister(), false);
849 // getAccessibilityNodeCursorPosition null
850 callBacks.clearFocusedFocusAccessibilityNode = MockClearFocusedFocusAccessibilityNodeWithInstance;
851 ret = accessibilityProvider.AccessibilityProviderRegisterCallbackWithInstance(INSTANCE_ID, &callBacks);
852 EXPECT_EQ(ret, ARKUI_ACCESSIBILITY_NATIVE_RESULT_BAD_PARAMETER);
853 EXPECT_EQ(accessibilityProvider.IsRegister(), false);
854 callBacks.getAccessibilityNodeCursorPosition = MockGetAccessibilityNodeCursorPositionWithInstance;
855 ret = accessibilityProvider.AccessibilityProviderRegisterCallbackWithInstance(INSTANCE_ID, &callBacks);
856 EXPECT_EQ(ret, ARKUI_ACCESSIBILITY_NATIVE_RESULT_SUCCESSFUL);
857 EXPECT_EQ(accessibilityProvider.IsRegister(), true);
858 EXPECT_EQ(g_providerMockResult.registerResult_, true);
859 }
860
861 /**
862 * @tc.name: accessibilityTest011
863 * @tc.desc: FindAccessibilityNodeInfosByIdWithInstance
864 * @tc.type: FUNC
865 */
866 HWTEST_F(AccessibilityProviderTestNg, AccessibilityProviderTest011, TestSize.Level1)
867 {
868 ArkUI_AccessibilityProvider accessibilityProvider;
869 int32_t ret;
870 ArkUI_AccessibilityProviderCallbacks callBacks;
871 ArkUI_AccessibilityProviderCallbacksWithInstance callBacksWithInstance;
872 accessibilityProvider.SetRegisterCallback(MockRegisterCallback);
873
874 auto now = std::chrono::system_clock::now();
875 int32_t testParameter =
876 std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch())
877 .count();
878 testParameter = testParameter % MAX_TEST_PARAMETER;
879 int64_t elementId = testParameter;
880 int32_t mode = testParameter + TEST_PARAMETER_OFFSET1;
881 int32_t requestId = testParameter + TEST_PARAMETER_OFFSET2;
882 std::vector<ArkUI_AccessibilityElementInfo> infos;
883
884 // register fail
885 ret = accessibilityProvider.FindAccessibilityNodeInfosById(
886 elementId, mode, requestId, infos);
887 EXPECT_EQ(ret, AccessibilityProviderOperatorErrorCode::NOT_REGISTERED);
888
889 // register success
890 BuildMockCallBack(callBacks);
891 BuildMockCallBackWithInstance(callBacksWithInstance);
892
893 ret = accessibilityProvider.AccessibilityProviderRegisterCallback(&callBacks);
894 EXPECT_EQ(ret, ARKUI_ACCESSIBILITY_NATIVE_RESULT_SUCCESSFUL);
895 ret = accessibilityProvider.AccessibilityProviderRegisterCallbackWithInstance(INSTANCE_ID, &callBacksWithInstance);
896 EXPECT_EQ(ret, ARKUI_ACCESSIBILITY_NATIVE_RESULT_SUCCESSFUL);
897
898 ret = accessibilityProvider.FindAccessibilityNodeInfosById(
899 elementId, mode, requestId, infos);
900 EXPECT_EQ(ret, ARKUI_ACCESSIBILITY_NATIVE_RESULT_SUCCESSFUL);
901 EXPECT_EQ(g_providerMockResult.elementId_, elementId);
902 EXPECT_EQ(g_providerMockResult.mode_, mode);
903 EXPECT_EQ(g_providerMockResult.requestId_, requestId);
904 EXPECT_EQ(g_providerMockResult.instanceId_, INSTANCE_ID);
905 }
906 } // namespace OHOS::Ace::NG
907