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 int32_t MAX_TEST_PARAMETER = 20;
88 constexpr int32_t MAX_TEST_ELEMENT_COUNT = 10;
89 constexpr int32_t NOT_REGISTERED = -1;
90 constexpr int32_t COPY_FAILED = -2;
91 constexpr int32_t SEND_EVENT_FAILED = -1;
92 constexpr int32_t SEND_EVENT_SUCCESS = 0;
93 constexpr int32_t TEST_PARAMETER_OFFSET1 = 1;
94 constexpr int32_t TEST_PARAMETER_OFFSET2 = 2;
95 constexpr int32_t TEST_PARAMETER_OFFSET3 = 3;
96 
97 class ProviderMockResult {
98     public:
ProviderMockResult()99         ProviderMockResult()
100         {
101             for (int32_t i = 0; i < MAX_TEST_ELEMENT_COUNT; i++) {
102                 ArkUI_AccessibilityElementInfo tempElementInfo;
103                 tempElementInfo.SetElementId(i);
104                 tempElementInfo.SetContents(TEST_CONTENT_STR);
105                 elementInfosList_.push_back(tempElementInfo);
106             }
107 
108             focusElementInfo_.SetElementId(
109                 MAX_TEST_ELEMENT_COUNT + TEST_PARAMETER_OFFSET1);
110             nextFocusElementInfo_.SetElementId(
111                 MAX_TEST_ELEMENT_COUNT + TEST_PARAMETER_OFFSET2);
112 
113             originActionArguments_.emplace("action0", "1");
114             originActionArguments_.emplace("action1", "2");
115             cursorPosition_ = MAX_TEST_ELEMENT_COUNT + TEST_PARAMETER_OFFSET3;
116         }
117         ~ProviderMockResult() = default;
118 
Reset()119         void Reset()
120         {
121             elementId_ = 0;
122             mode_ = ARKUI_ACCESSIBILITY_NATIVE_SEARCH_MODE_PREFETCH_CURRENT;
123             requestId_ = 0;
124             focusType_ = ARKUI_ACCESSIBILITY_NATIVE_FOCUS_TYPE_INVALID;
125             direction_ = ARKUI_ACCESSIBILITY_NATIVE_DIRECTION_INVALID;
126             action_ = ARKUI_ACCESSIBILITY_NATIVE_ACTION_TYPE_INVALID;
127             receiveClear_ = false;
128             errorCode_ = 0;
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 };
150 
151 ProviderMockResult g_providerMockResult;
152 
MockFindAccessibilityNodeInfosById(int64_t elementId,ArkUI_AccessibilitySearchMode mode,int32_t requestId,ArkUI_AccessibilityElementInfoList * elementList)153 int32_t MockFindAccessibilityNodeInfosById(
154     int64_t elementId,
155     ArkUI_AccessibilitySearchMode mode,
156     int32_t requestId,
157     ArkUI_AccessibilityElementInfoList* elementList)
158 {
159     g_providerMockResult.elementId_ = elementId;
160     g_providerMockResult.mode_ = mode;
161     g_providerMockResult.requestId_ = requestId;
162 
163     ArkUI_AccessibilityElementInfo* tempElementInfo;
164     for (const auto &elementInfo: g_providerMockResult.elementInfosList_) {
165         tempElementInfo = elementList->AddAndGetElementInfo();
166         tempElementInfo->SetElementId(elementInfo.GetElementId());
167     }
168 
169     return ARKUI_ACCESSIBILITY_NATIVE_RESULT_SUCCESSFUL;
170 }
171 
MockFindAccessibilityNodeInfosByIdCopyFail(int64_t elementId,ArkUI_AccessibilitySearchMode mode,int32_t requestId,ArkUI_AccessibilityElementInfoList * elementList)172 int32_t MockFindAccessibilityNodeInfosByIdCopyFail(
173     int64_t elementId,
174     ArkUI_AccessibilitySearchMode mode,
175     int32_t requestId,
176     ArkUI_AccessibilityElementInfoList* elementList)
177 {
178     g_providerMockResult.elementId_ = elementId;
179     g_providerMockResult.mode_ = mode;
180     g_providerMockResult.requestId_ = requestId;
181     return ARKUI_ACCESSIBILITY_NATIVE_RESULT_SUCCESSFUL;
182 }
183 
MockFindAccessibilityNodeInfosByText(int64_t elementId,const char * text,int32_t requestId,ArkUI_AccessibilityElementInfoList * elementList)184 int32_t MockFindAccessibilityNodeInfosByText(
185     int64_t elementId,
186     const char* text,
187     int32_t requestId,
188     ArkUI_AccessibilityElementInfoList* elementList)
189 {
190     g_providerMockResult.elementId_ = elementId;
191     g_providerMockResult.requestId_ = requestId;
192 
193     ArkUI_AccessibilityElementInfo* tempElementInfo;
194     std::string textStr(text);
195     for (const auto &elementInfo: g_providerMockResult.elementInfosList_) {
196         if (elementInfo.GetContents() == textStr) {
197             tempElementInfo = elementList->AddAndGetElementInfo();
198             tempElementInfo->SetElementId(elementInfo.GetElementId());
199         }
200     }
201     return ARKUI_ACCESSIBILITY_NATIVE_RESULT_SUCCESSFUL;
202 }
203 
MockFindAccessibilityNodeInfosByTextCopyFail(int64_t elementId,const char * text,int32_t requestId,ArkUI_AccessibilityElementInfoList * elementList)204 int32_t MockFindAccessibilityNodeInfosByTextCopyFail(
205     int64_t elementId,
206     const char* text,
207     int32_t requestId,
208     ArkUI_AccessibilityElementInfoList* elementList)
209 {
210     g_providerMockResult.elementId_ = elementId;
211     g_providerMockResult.requestId_ = requestId;
212     return ARKUI_ACCESSIBILITY_NATIVE_RESULT_SUCCESSFUL;
213 }
214 
MockFindFocusedAccessibilityNode(int64_t elementId,ArkUI_AccessibilityFocusType focusType,int32_t requestId,ArkUI_AccessibilityElementInfo * elementInfo)215 int32_t MockFindFocusedAccessibilityNode(
216     int64_t elementId,
217     ArkUI_AccessibilityFocusType focusType,
218     int32_t requestId,
219     ArkUI_AccessibilityElementInfo* elementInfo)
220 {
221     g_providerMockResult.elementId_ = elementId;
222     g_providerMockResult.focusType_ = focusType;
223     g_providerMockResult.requestId_ = requestId;
224     elementInfo->SetElementId(
225         g_providerMockResult.focusElementInfo_.GetElementId());
226     return ARKUI_ACCESSIBILITY_NATIVE_RESULT_SUCCESSFUL;
227 }
228 
MockFindNextFocusAccessibilityNode(int64_t elementId,ArkUI_AccessibilityFocusMoveDirection direction,int32_t requestId,ArkUI_AccessibilityElementInfo * elementInfo)229 int32_t MockFindNextFocusAccessibilityNode(
230     int64_t elementId,
231     ArkUI_AccessibilityFocusMoveDirection direction,
232     int32_t requestId,
233     ArkUI_AccessibilityElementInfo* elementInfo)
234 {
235     g_providerMockResult.elementId_ = elementId;
236     g_providerMockResult.direction_ = direction;
237     g_providerMockResult.requestId_ = requestId;
238     elementInfo->SetElementId(
239         g_providerMockResult.nextFocusElementInfo_.GetElementId());
240     return ARKUI_ACCESSIBILITY_NATIVE_RESULT_SUCCESSFUL;
241 }
242 
MockExecuteAccessibilityAction(int64_t elementId,ArkUI_Accessibility_ActionType action,ArkUI_AccessibilityActionArguments * actionArguments,int32_t requestId)243 int32_t MockExecuteAccessibilityAction(
244     int64_t elementId,
245     ArkUI_Accessibility_ActionType action,
246     ArkUI_AccessibilityActionArguments *actionArguments,
247     int32_t requestId)
248 {
249     g_providerMockResult.action_ = action;
250     g_providerMockResult.requestId_ = requestId;
251 
252     g_providerMockResult.resultActionArguments_.clear();
253     for (auto &pair: g_providerMockResult.originActionArguments_) {
254         auto value = actionArguments->FindValueByKey(pair.first.c_str());
255         if (value) {
256             std::string textStr(value);
257             g_providerMockResult.resultActionArguments_.emplace(
258                 pair.first, textStr);
259         }
260     }
261 
262     return ARKUI_ACCESSIBILITY_NATIVE_RESULT_SUCCESSFUL;
263 }
264 
MockClearFocusedFocusAccessibilityNode()265 int32_t MockClearFocusedFocusAccessibilityNode()
266 {
267     g_providerMockResult.receiveClear_ = true;
268     return ARKUI_ACCESSIBILITY_NATIVE_RESULT_SUCCESSFUL;
269 }
270 
MockGetAccessibilityNodeCursorPosition(int64_t elementId,int32_t requestId,int32_t * index)271 int32_t MockGetAccessibilityNodeCursorPosition(
272     int64_t elementId,
273     int32_t requestId,
274     int32_t* index)
275 {
276     g_providerMockResult.elementId_ = elementId;
277     g_providerMockResult.requestId_ = requestId;
278     *index = g_providerMockResult.cursorPosition_;
279     return ARKUI_ACCESSIBILITY_NATIVE_RESULT_SUCCESSFUL;
280 }
281 
MockRegisterCallback(bool isRegistered)282 void MockRegisterCallback(bool isRegistered)
283 {
284     g_providerMockResult.registerResult_ = isRegistered;
285 }
286 
MockEventCallBack(int32_t errorCode)287 void MockEventCallBack(int32_t errorCode)
288 {
289     g_providerMockResult.errorCode_ = errorCode;
290 }
291 
BuildMockCallBack(ArkUI_AccessibilityProviderCallbacks & callBacks)292 void BuildMockCallBack(ArkUI_AccessibilityProviderCallbacks &callBacks)
293 {
294     // register success
295     callBacks.findAccessibilityNodeInfosById =
296         MockFindAccessibilityNodeInfosById;
297     callBacks.findAccessibilityNodeInfosByText =
298         MockFindAccessibilityNodeInfosByText;
299     callBacks.findFocusedAccessibilityNode =
300         MockFindFocusedAccessibilityNode;
301     callBacks.findNextFocusAccessibilityNode =
302         MockFindNextFocusAccessibilityNode;
303     callBacks.executeAccessibilityAction =
304         MockExecuteAccessibilityAction;
305     callBacks.clearFocusedFocusAccessibilityNode =
306         MockClearFocusedFocusAccessibilityNode;
307     callBacks.getAccessibilityNodeCursorPosition =
308         MockGetAccessibilityNodeCursorPosition;
309 }
310 } // namespace
311 
312 class AccessibilityProviderTestNg : public testing::Test {
313 public:
SetUpTestCase()314     static void SetUpTestCase() {};
TearDownTestCase()315     static void TearDownTestCase() {};
316 };
317 
318 
319 /**
320  * @tc.name: accessibilityTest001
321  * @tc.desc: AccessibilityProviderRegisterCallback abnormal
322  * @tc.type: FUNC
323  */
324 HWTEST_F(AccessibilityProviderTestNg, AccessibilityProviderTest001, TestSize.Level1)
325 {
326     g_providerMockResult.Reset();
327     ArkUI_AccessibilityProvider accessibilityProvider;
328     int32_t ret;
329     ArkUI_AccessibilityProviderCallbacks callBacks;
330     // callback null
331     ret = accessibilityProvider.AccessibilityProviderRegisterCallback(nullptr);
332     EXPECT_EQ(ret, ARKUI_ACCESSIBILITY_NATIVE_RESULT_BAD_PARAMETER);
333     EXPECT_EQ(accessibilityProvider.IsRegister(), false);
334     // findAccessibilityNodeInfosById null
335     ret = accessibilityProvider.AccessibilityProviderRegisterCallback(&callBacks);
336     EXPECT_EQ(ret, ARKUI_ACCESSIBILITY_NATIVE_RESULT_BAD_PARAMETER);
337     EXPECT_EQ(accessibilityProvider.IsRegister(), false);
338     // findAccessibilityNodeInfosByText null
339     callBacks.findAccessibilityNodeInfosById = MockFindAccessibilityNodeInfosById;
340     ret = accessibilityProvider.AccessibilityProviderRegisterCallback(&callBacks);
341     EXPECT_EQ(ret, ARKUI_ACCESSIBILITY_NATIVE_RESULT_BAD_PARAMETER);
342     EXPECT_EQ(accessibilityProvider.IsRegister(), false);
343     // findFocusedAccessibilityNode null
344     callBacks.findAccessibilityNodeInfosByText =
345         MockFindAccessibilityNodeInfosByText;
346     ret = accessibilityProvider.AccessibilityProviderRegisterCallback(&callBacks);
347     EXPECT_EQ(ret, ARKUI_ACCESSIBILITY_NATIVE_RESULT_BAD_PARAMETER);
348     EXPECT_EQ(accessibilityProvider.IsRegister(), false);
349     // findNextFocusAccessibilityNode null
350     callBacks.findFocusedAccessibilityNode = MockFindFocusedAccessibilityNode;
351     ret = accessibilityProvider.AccessibilityProviderRegisterCallback(&callBacks);
352     EXPECT_EQ(ret, ARKUI_ACCESSIBILITY_NATIVE_RESULT_BAD_PARAMETER);
353     EXPECT_EQ(accessibilityProvider.IsRegister(), false);
354 
355     // executeAccessibilityAction null
356     callBacks.findNextFocusAccessibilityNode = MockFindNextFocusAccessibilityNode;
357     ret = accessibilityProvider.AccessibilityProviderRegisterCallback(&callBacks);
358     EXPECT_EQ(ret, ARKUI_ACCESSIBILITY_NATIVE_RESULT_BAD_PARAMETER);
359     EXPECT_EQ(accessibilityProvider.IsRegister(), false);
360     // clearFocusedFocusAccessibilityNode null
361     callBacks.executeAccessibilityAction = MockExecuteAccessibilityAction;
362     ret = accessibilityProvider.AccessibilityProviderRegisterCallback(&callBacks);
363     EXPECT_EQ(ret, ARKUI_ACCESSIBILITY_NATIVE_RESULT_BAD_PARAMETER);
364     EXPECT_EQ(accessibilityProvider.IsRegister(), false);
365     // getAccessibilityNodeCursorPosition null
366     callBacks.clearFocusedFocusAccessibilityNode =
367         MockClearFocusedFocusAccessibilityNode;
368     ret = accessibilityProvider.AccessibilityProviderRegisterCallback(&callBacks);
369     EXPECT_EQ(ret, ARKUI_ACCESSIBILITY_NATIVE_RESULT_BAD_PARAMETER);
370     EXPECT_EQ(accessibilityProvider.IsRegister(), false);
371     callBacks.getAccessibilityNodeCursorPosition =
372         MockGetAccessibilityNodeCursorPosition;
373 }
374 
375 /**
376  * @tc.name: accessibilityTest002
377  * @tc.desc: AccessibilityProviderRegisterCallback abnormal
378  * @tc.type: FUNC
379  */
380 HWTEST_F(AccessibilityProviderTestNg, AccessibilityProviderTest002, TestSize.Level1)
381 {
382     g_providerMockResult.Reset();
383     ArkUI_AccessibilityProvider accessibilityProvider;
384     int32_t ret;
385     ArkUI_AccessibilityProviderCallbacks callBacks;
386     accessibilityProvider.SetRegisterCallback(MockRegisterCallback);
387     // register success
388     BuildMockCallBack(callBacks);
389     ret = accessibilityProvider.AccessibilityProviderRegisterCallback(&callBacks);
390     EXPECT_EQ(ret, ARKUI_ACCESSIBILITY_NATIVE_RESULT_SUCCESSFUL);
391     EXPECT_EQ(g_providerMockResult.registerResult_, true);
392     EXPECT_EQ(accessibilityProvider.IsRegister(), true);
393 
394     // then register fail, call registercallback false
395     callBacks.findAccessibilityNodeInfosById = nullptr;
396     ret = accessibilityProvider.AccessibilityProviderRegisterCallback(&callBacks);
397     EXPECT_EQ(ret, ARKUI_ACCESSIBILITY_NATIVE_RESULT_BAD_PARAMETER);
398     EXPECT_EQ(g_providerMockResult.registerResult_, false);
399 }
400 
401 /**
402  * @tc.name: accessibilityTest003
403  * @tc.desc: FindAccessibilityNodeInfosById
404  * @tc.type: FUNC
405  */
406 HWTEST_F(AccessibilityProviderTestNg, AccessibilityProviderTest003, TestSize.Level1)
407 {
408     g_providerMockResult.Reset();
409     ArkUI_AccessibilityProvider accessibilityProvider;
410     int32_t ret;
411     ArkUI_AccessibilityProviderCallbacks callBacks;
412     accessibilityProvider.SetRegisterCallback(MockRegisterCallback);
413 
414     auto now = std::chrono::system_clock::now();
415     int32_t testParameter =
416         std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch())
417         .count();
418     testParameter = testParameter % MAX_TEST_PARAMETER;
419     int64_t elementId = testParameter;
420     int32_t mode = testParameter + TEST_PARAMETER_OFFSET1;
421     int32_t requestId = testParameter + TEST_PARAMETER_OFFSET2;
422     std::vector<ArkUI_AccessibilityElementInfo> infos;
423 
424     // register fail
425     ret = accessibilityProvider.FindAccessibilityNodeInfosById(
426         elementId, mode, requestId, infos);
427     EXPECT_EQ(ret, NOT_REGISTERED);
428 
429     // register success
430     BuildMockCallBack(callBacks);
431     ret = accessibilityProvider.AccessibilityProviderRegisterCallback(&callBacks);
432     EXPECT_EQ(ret, ARKUI_ACCESSIBILITY_NATIVE_RESULT_SUCCESSFUL);
433 
434     ret = accessibilityProvider.FindAccessibilityNodeInfosById(
435         elementId, mode, requestId, infos);
436     EXPECT_EQ(ret, ARKUI_ACCESSIBILITY_NATIVE_RESULT_SUCCESSFUL);
437     EXPECT_EQ(g_providerMockResult.elementId_, elementId);
438     EXPECT_EQ(g_providerMockResult.mode_, mode);
439     EXPECT_EQ(g_providerMockResult.requestId_, requestId);
440     // id equals to prepared ids
441     for (int64_t i = 0; i < g_providerMockResult.elementInfosList_.size(); i++) {
442         EXPECT_EQ(g_providerMockResult.elementInfosList_[i].GetElementId(),
443             infos[i].GetElementId());
444     }
445 
446     // copy fail
447     ArkUI_AccessibilityProvider accessibilityProvider2;
448     accessibilityProvider2.SetRegisterCallback(MockRegisterCallback);
449     callBacks.findAccessibilityNodeInfosById =
450         MockFindAccessibilityNodeInfosByIdCopyFail;
451     ret = accessibilityProvider2.AccessibilityProviderRegisterCallback(&callBacks);
452     EXPECT_EQ(ret, ARKUI_ACCESSIBILITY_NATIVE_RESULT_SUCCESSFUL);
453     ret = accessibilityProvider2.FindAccessibilityNodeInfosById(
454         elementId, mode, requestId, infos);
455     EXPECT_EQ(ret, COPY_FAILED);
456 }
457 
458 /**
459  * @tc.name: accessibilityTest004
460  * @tc.desc: FindAccessibilityNodeInfosByText
461  * @tc.type: FUNC
462  */
463 HWTEST_F(AccessibilityProviderTestNg, AccessibilityProviderTest004, TestSize.Level1)
464 {
465     g_providerMockResult.Reset();
466     ArkUI_AccessibilityProvider accessibilityProvider;
467     int32_t ret;
468     ArkUI_AccessibilityProviderCallbacks callBacks;
469     accessibilityProvider.SetRegisterCallback(MockRegisterCallback);
470 
471     auto now = std::chrono::system_clock::now();
472     int32_t testParameter =
473         std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch())
474         .count();
475     testParameter = testParameter % MAX_TEST_PARAMETER;
476     int64_t elementId = testParameter;
477     int32_t requestId = testParameter + TEST_PARAMETER_OFFSET1;
478     std::vector<ArkUI_AccessibilityElementInfo> infos;
479     std::string text = TEST_CONTENT_STR;
480 
481     // register fail
482     ret = accessibilityProvider.FindAccessibilityNodeInfosByText(
483         elementId, text, requestId, infos);
484     EXPECT_EQ(ret, NOT_REGISTERED);
485 
486     // register success
487     BuildMockCallBack(callBacks);
488     ret = accessibilityProvider.AccessibilityProviderRegisterCallback(&callBacks);
489     EXPECT_EQ(ret, ARKUI_ACCESSIBILITY_NATIVE_RESULT_SUCCESSFUL);
490 
491     ret = accessibilityProvider.FindAccessibilityNodeInfosByText(
492         elementId, text, requestId, infos);
493     EXPECT_EQ(ret, ARKUI_ACCESSIBILITY_NATIVE_RESULT_SUCCESSFUL);
494     EXPECT_EQ(g_providerMockResult.elementId_, elementId);
495     EXPECT_EQ(g_providerMockResult.requestId_, requestId);
496     // all elementInfo's text matched
497     for (int64_t i = 0; i < g_providerMockResult.elementInfosList_.size(); i++) {
498         EXPECT_EQ(g_providerMockResult.elementInfosList_[i].GetElementId(),
499             infos[i].GetElementId());
500     }
501 
502     // copy fail
503     ArkUI_AccessibilityProvider accessibilityProvider2;
504     accessibilityProvider2.SetRegisterCallback(MockRegisterCallback);
505     callBacks.findAccessibilityNodeInfosByText =
506         MockFindAccessibilityNodeInfosByTextCopyFail;
507     ret = accessibilityProvider2.AccessibilityProviderRegisterCallback(&callBacks);
508     EXPECT_EQ(ret, ARKUI_ACCESSIBILITY_NATIVE_RESULT_SUCCESSFUL);
509     ret = accessibilityProvider2.FindAccessibilityNodeInfosByText(
510         elementId, text, requestId, infos);
511     EXPECT_EQ(ret, COPY_FAILED);
512 }
513 
514 /**
515  * @tc.name: accessibilityTest005
516  * @tc.desc: FindFocusedAccessibilityNode and FindNextFocusAccessibilityNode
517  * @tc.type: FUNC
518  */
519 HWTEST_F(AccessibilityProviderTestNg, AccessibilityProviderTest005, TestSize.Level1)
520 {
521     g_providerMockResult.Reset();
522     ArkUI_AccessibilityProvider accessibilityProvider;
523     int32_t ret;
524     ArkUI_AccessibilityProviderCallbacks callBacks;
525     accessibilityProvider.SetRegisterCallback(MockRegisterCallback);
526 
527     auto now = std::chrono::system_clock::now();
528     int32_t testParameter =
529         std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch())
530         .count();
531     testParameter = testParameter % MAX_TEST_PARAMETER;
532     int64_t elementId = testParameter;
533     int32_t focusType = testParameter + TEST_PARAMETER_OFFSET1;
534     int32_t requestId = testParameter + TEST_PARAMETER_OFFSET2;
535     int32_t direction = testParameter + TEST_PARAMETER_OFFSET3;
536     ArkUI_AccessibilityElementInfo elementInfo;
537 
538     // register fail
539     ret = accessibilityProvider.FindFocusedAccessibilityNode(
540         elementId, focusType, requestId, elementInfo);
541     EXPECT_EQ(ret, NOT_REGISTERED);
542     ret = accessibilityProvider.FindNextFocusAccessibilityNode(
543         elementId, direction, requestId, elementInfo);
544     EXPECT_EQ(ret, NOT_REGISTERED);
545 
546 
547     // register success
548     BuildMockCallBack(callBacks);
549     ret = accessibilityProvider.AccessibilityProviderRegisterCallback(&callBacks);
550     EXPECT_EQ(ret, ARKUI_ACCESSIBILITY_NATIVE_RESULT_SUCCESSFUL);
551 
552     ret = accessibilityProvider.FindFocusedAccessibilityNode(
553         elementId, focusType, requestId, elementInfo);
554     EXPECT_EQ(ret, ARKUI_ACCESSIBILITY_NATIVE_RESULT_SUCCESSFUL);
555     EXPECT_EQ(g_providerMockResult.elementId_, elementId);
556     EXPECT_EQ(g_providerMockResult.focusType_, focusType);
557     EXPECT_EQ(g_providerMockResult.requestId_, requestId);
558     EXPECT_EQ(g_providerMockResult.focusElementInfo_.GetElementId(),
559         elementInfo.GetElementId());
560 
561     ret = accessibilityProvider.FindNextFocusAccessibilityNode(
562         elementId, direction, requestId, elementInfo);
563     EXPECT_EQ(ret, ARKUI_ACCESSIBILITY_NATIVE_RESULT_SUCCESSFUL);
564     EXPECT_EQ(g_providerMockResult.elementId_, elementId);
565     EXPECT_EQ(g_providerMockResult.direction_, direction);
566     EXPECT_EQ(g_providerMockResult.requestId_, requestId);
567     EXPECT_EQ(g_providerMockResult.nextFocusElementInfo_.GetElementId(),
568         elementInfo.GetElementId());
569 }
570 
571 /**
572  * @tc.name: accessibilityTest006
573  * @tc.desc: ExecuteAccessibilityAction
574  * @tc.type: FUNC
575  */
576 HWTEST_F(AccessibilityProviderTestNg, AccessibilityProviderTest006, TestSize.Level1)
577 {
578     g_providerMockResult.Reset();
579     ArkUI_AccessibilityProvider accessibilityProvider;
580     int32_t ret;
581     ArkUI_AccessibilityProviderCallbacks callBacks;
582     accessibilityProvider.SetRegisterCallback(MockRegisterCallback);
583 
584     auto now = std::chrono::system_clock::now();
585     int32_t testParameter =
586         std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch())
587         .count();
588     testParameter = testParameter % MAX_TEST_PARAMETER;
589     int64_t elementId = testParameter;
590     int32_t action = testParameter + TEST_PARAMETER_OFFSET1;
591     int32_t requestId = testParameter + TEST_PARAMETER_OFFSET2;
592     std::map<std::string, std::string> actionArguments =
593         g_providerMockResult.originActionArguments_;
594     // register fail
595     ret = accessibilityProvider.ExecuteAccessibilityAction(
596         elementId, action, requestId, actionArguments);
597     EXPECT_EQ(ret, NOT_REGISTERED);
598 
599     // register success
600     BuildMockCallBack(callBacks);
601     ret = accessibilityProvider.AccessibilityProviderRegisterCallback(&callBacks);
602     EXPECT_EQ(ret, ARKUI_ACCESSIBILITY_NATIVE_RESULT_SUCCESSFUL);
603 
604     ret = accessibilityProvider.ExecuteAccessibilityAction(
605         elementId, action, requestId, actionArguments);
606     EXPECT_EQ(ret, ARKUI_ACCESSIBILITY_NATIVE_RESULT_SUCCESSFUL);
607     EXPECT_EQ(actionArguments, g_providerMockResult.resultActionArguments_);
608 }
609 
610 /**
611  * @tc.name: accessibilityTest007
612  * @tc.desc: ClearFocusedAccessibilityNode
613  * @tc.type: FUNC
614  */
615 HWTEST_F(AccessibilityProviderTestNg, AccessibilityProviderTest007, 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     // register fail
624     ret = accessibilityProvider.ClearFocusedAccessibilityNode();
625     EXPECT_EQ(ret, NOT_REGISTERED);
626 
627     // register success
628     BuildMockCallBack(callBacks);
629     ret = accessibilityProvider.AccessibilityProviderRegisterCallback(&callBacks);
630     EXPECT_EQ(ret, ARKUI_ACCESSIBILITY_NATIVE_RESULT_SUCCESSFUL);
631 
632     ret = accessibilityProvider.ClearFocusedAccessibilityNode();
633     EXPECT_EQ(ret, ARKUI_ACCESSIBILITY_NATIVE_RESULT_SUCCESSFUL);
634     EXPECT_EQ(g_providerMockResult.receiveClear_, true);
635 }
636 
637 /**
638  * @tc.name: accessibilityTest008
639  * @tc.desc: GetAccessibilityNodeCursorPosition
640  * @tc.type: FUNC
641  */
642 HWTEST_F(AccessibilityProviderTestNg, AccessibilityProviderTest008, TestSize.Level1)
643 {
644     g_providerMockResult.Reset();
645     ArkUI_AccessibilityProvider accessibilityProvider;
646     int32_t ret;
647     ArkUI_AccessibilityProviderCallbacks callBacks;
648     accessibilityProvider.SetRegisterCallback(MockRegisterCallback);
649 
650     auto now = std::chrono::system_clock::now();
651     int32_t testParameter =
652         std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch())
653         .count();
654     testParameter = testParameter % MAX_TEST_PARAMETER;
655     int64_t elementId = testParameter;
656     int32_t requestId = testParameter + TEST_PARAMETER_OFFSET1;
657     int32_t cursorPosition;
658     std::map<std::string, std::string> actionArguments =
659         g_providerMockResult.originActionArguments_;
660     // register fail
661     ret = accessibilityProvider.GetAccessibilityNodeCursorPosition(
662         elementId, requestId, cursorPosition);
663     EXPECT_EQ(ret, NOT_REGISTERED);
664 
665     // register success
666     BuildMockCallBack(callBacks);
667     ret = accessibilityProvider.AccessibilityProviderRegisterCallback(&callBacks);
668     EXPECT_EQ(ret, ARKUI_ACCESSIBILITY_NATIVE_RESULT_SUCCESSFUL);
669 
670     ret = accessibilityProvider.GetAccessibilityNodeCursorPosition(
671         elementId, requestId, cursorPosition);
672     EXPECT_EQ(ret, ARKUI_ACCESSIBILITY_NATIVE_RESULT_SUCCESSFUL);
673     EXPECT_EQ(cursorPosition, g_providerMockResult.cursorPosition_);
674 }
675 
676 /**
677  * @tc.name: accessibilityTest009
678  * @tc.desc: SendAccessibilityAsyncEvent
679  * @tc.type: FUNC
680  */
681 HWTEST_F(AccessibilityProviderTestNg, AccessibilityProviderTest009, TestSize.Level1)
682 {
683     g_providerMockResult.Reset();
684     ArkUI_AccessibilityProvider accessibilityProvider;
685     int32_t ret;
686 
687     // 1.1 event null and callback null
688     ret = accessibilityProvider.SendAccessibilityAsyncEvent(nullptr, nullptr);
689     EXPECT_EQ(ret, SEND_EVENT_FAILED);
690 
691     // 1.2 event null and callback not null
692     ret = accessibilityProvider.SendAccessibilityAsyncEvent(
693         nullptr, MockEventCallBack);
694     EXPECT_EQ(ret, SEND_EVENT_FAILED);
695     EXPECT_EQ(g_providerMockResult.errorCode_, SEND_EVENT_FAILED);
696 
697     // 2.1 event not null and OH accessibilityProvider null and callback null
698     ArkUI_AccessibilityEventInfo accessibilityEvent;
699     ret = accessibilityProvider.SendAccessibilityAsyncEvent(
700         &accessibilityEvent, nullptr);
701     EXPECT_EQ(ret, SEND_EVENT_FAILED);
702     // 2.2 event not null and  accessibilityProvider null and callback not null
703     ret = accessibilityProvider.SendAccessibilityAsyncEvent(
704         &accessibilityEvent, MockEventCallBack);
705     EXPECT_EQ(ret, SEND_EVENT_FAILED);
706     EXPECT_EQ(g_providerMockResult.errorCode_, SEND_EVENT_FAILED);
707 
708 
709     // 3 event not null and  OH accessibilityProvider not null
710     auto ohAccessibilityProvider
711         = AceType::MakeRefPtr<MockOhAccessibilityProvider>();
712     accessibilityProvider.SetInnerAccessibilityProvider(ohAccessibilityProvider);
713     ret = accessibilityProvider.SendAccessibilityAsyncEvent(
714         &accessibilityEvent, MockEventCallBack);
715     EXPECT_EQ(ret, SEND_EVENT_SUCCESS);
716 }
717 } // namespace OHOS::Ace::NG
718