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 #define private public
19 #define protected public
20
21 #include "test/mock/base/mock_task_executor.h"
22 #include "test/mock/core/common/mock_container.h"
23 #include "test/mock/core/pipeline/mock_pipeline_context.h"
24
25 #include "accessibility_system_ability_client.h"
26 #include "frameworks/core/accessibility/accessibility_manager.h"
27 #include "adapter/ohos/osal/js_third_provider_interaction_operation.h"
28
29 #include "frameworks/core/accessibility/accessibility_node.h"
30 #include "frameworks/core/accessibility/accessibility_utils.h"
31 #include "frameworks/core/accessibility/native_interface_accessibility_provider.h"
32 #include "frameworks/core/components_ng/pattern/ui_extension/ui_extension_manager.h"
33
34 using namespace testing;
35 using namespace testing::ext;
36
37 namespace OHOS::Ace {
38 int32_t g_mockErrorCode = -1;
39
40 std::string TEST_CONTENT_STR = "testForFindByText";
41 constexpr int32_t MAX_TEST_ELEMENT_COUNT = 10;
42 constexpr int32_t TEST_PARAMETER_OFFSET1 = 1;
43 constexpr int32_t TEST_PARAMETER_OFFSET2 = 2;
44 constexpr int32_t TEST_PARAMETER_OFFSET3 = 3;
45 constexpr int32_t SPECIAL_CURSOR_POSTION = 100;
46
47 class ProviderMockResult {
48 public:
ProviderMockResult()49 ProviderMockResult()
50 {
51 for (int32_t i = 0; i < MAX_TEST_ELEMENT_COUNT; i++) {
52 ArkUI_AccessibilityElementInfo tempElementInfo;
53 tempElementInfo.SetElementId(i);
54 tempElementInfo.SetContents(TEST_CONTENT_STR);
55 elementInfosList_.push_back(tempElementInfo);
56 }
57
58 focusElementInfo_.SetElementId(
59 MAX_TEST_ELEMENT_COUNT + TEST_PARAMETER_OFFSET1);
60 nextFocusElementInfo_.SetElementId(
61 MAX_TEST_ELEMENT_COUNT + TEST_PARAMETER_OFFSET2);
62
63 originActionArguments_.emplace("action0", "1");
64 originActionArguments_.emplace("action1", "2");
65 cursorPosition_ = MAX_TEST_ELEMENT_COUNT + TEST_PARAMETER_OFFSET3;
66 }
67 ~ProviderMockResult() = default;
68
Reset()69 void Reset()
70 {
71 elementId_ = 0;
72 mode_ = static_cast<int32_t>(ARKUI_ACCESSIBILITY_NATIVE_SEARCH_MODE_PREFETCH_CURRENT);
73 requestId_ = 0;
74 focusType_ = ARKUI_ACCESSIBILITY_NATIVE_FOCUS_TYPE_INVALID;
75 direction_ = ARKUI_ACCESSIBILITY_NATIVE_DIRECTION_INVALID;
76 action_ = ARKUI_ACCESSIBILITY_NATIVE_ACTION_TYPE_INVALID;
77 receiveClear_ = false;
78 errorCode_ = 0;
79 injectResult_ = 0;
80 injectActionResult_ = 0;
81 }
82
83 public:
84 int64_t elementId_;
85 int32_t mode_;
86 int32_t requestId_;
87 std::vector<ArkUI_AccessibilityElementInfo> elementInfosList_;
88 ArkUI_AccessibilityFocusType focusType_;
89 ArkUI_AccessibilityElementInfo focusElementInfo_;
90 ArkUI_AccessibilityElementInfo nextFocusElementInfo_;
91 ArkUI_AccessibilityFocusMoveDirection direction_;
92 ArkUI_Accessibility_ActionType action_;
93 std::map<std::string, std::string> originActionArguments_;
94 std::map<std::string, std::string> resultActionArguments_;
95 int32_t cursorPosition_;
96 bool receiveClear_;
97
98 bool registerResult_;
99
100 int32_t errorCode_;
101 int32_t injectResult_ = 0;
102 int32_t injectActionResult_ = 0;
103 ArkUI_AccessibilityElementInfo elementInfo_;
104 };
105
106 class MockOhAccessibilityProvider : public AccessibilityProvider {
107 DECLARE_ACE_TYPE(MockOhAccessibilityProvider, AccessibilityProvider);
108 public:
109 MockOhAccessibilityProvider() = default;
FindAccessibilityNodeInfosById(const int64_t elementId,const int32_t mode,const int32_t requestId,std::vector<ArkUI_AccessibilityElementInfo> & infos)110 int32_t FindAccessibilityNodeInfosById(
111 const int64_t elementId, const int32_t mode, const int32_t requestId,
112 std::vector<ArkUI_AccessibilityElementInfo>& infos) override
113 {
114 providerMockResult_.elementId_ = elementId;
115 providerMockResult_.mode_ = mode;
116 providerMockResult_.requestId_ = requestId;
117
118 infos = providerMockResult_.elementInfosList_;
119 return providerMockResult_.injectResult_;
120 }
FindAccessibilityNodeInfosByText(const int64_t elementId,std::string text,const int32_t requestId,std::vector<ArkUI_AccessibilityElementInfo> & infos)121 int32_t FindAccessibilityNodeInfosByText(
122 const int64_t elementId, std::string text, const int32_t requestId,
123 std::vector<ArkUI_AccessibilityElementInfo>& infos) override
124 {
125 providerMockResult_.elementId_ = elementId;
126 providerMockResult_.requestId_ = requestId;
127
128 std::string textStr(text);
129 for (const auto &elementInfo: providerMockResult_.elementInfosList_) {
130 if (elementInfo.GetContents() == textStr) {
131 infos.push_back(elementInfo);
132 }
133 }
134
135 return providerMockResult_.injectResult_;
136 }
FindFocusedAccessibilityNode(const int64_t elementId,int32_t focusType,const int32_t requestId,ArkUI_AccessibilityElementInfo & elementInfo)137 int32_t FindFocusedAccessibilityNode(
138 const int64_t elementId, int32_t focusType, const int32_t requestId,
139 ArkUI_AccessibilityElementInfo& elementInfo) override
140 {
141 elementInfo = providerMockResult_.focusElementInfo_;
142 return providerMockResult_.injectResult_;
143 }
FindNextFocusAccessibilityNode(const int64_t elementId,int32_t direction,const int32_t requestId,ArkUI_AccessibilityElementInfo & elementInfo)144 int32_t FindNextFocusAccessibilityNode(
145 const int64_t elementId, int32_t direction, const int32_t requestId,
146 ArkUI_AccessibilityElementInfo& elementInfo) override
147 {
148 elementInfo = providerMockResult_.nextFocusElementInfo_;
149 return providerMockResult_.injectResult_;
150 }
ExecuteAccessibilityAction(const int64_t elementId,int32_t action,const int32_t requestId,const std::map<std::string,std::string> & actionArguments)151 int32_t ExecuteAccessibilityAction(
152 const int64_t elementId, int32_t action, const int32_t requestId,
153 const std::map<std::string, std::string>& actionArguments) override
154 {
155 return providerMockResult_.injectActionResult_;
156 }
ClearFocusedAccessibilityNode()157 int32_t ClearFocusedAccessibilityNode() override
158 {
159 providerMockResult_.receiveClear_ = true;
160 return providerMockResult_.injectResult_;
161 }
GetAccessibilityNodeCursorPosition(const int64_t elementId,const int32_t requestId,int32_t & cursorPosition)162 int32_t GetAccessibilityNodeCursorPosition(
163 const int64_t elementId,
164 const int32_t requestId,
165 int32_t &cursorPosition) override
166 {
167 cursorPosition = SPECIAL_CURSOR_POSTION;
168 return providerMockResult_.injectResult_;
169 }
SendAccessibilityAsyncEvent(const ArkUI_AccessibilityEventInfo & accessibilityEvent,void (* callback)(int32_t errorCode))170 int32_t SendAccessibilityAsyncEvent(
171 const ArkUI_AccessibilityEventInfo& accessibilityEvent,
172 void (*callback)(int32_t errorCode)) override
173 {
174 return providerMockResult_.injectResult_;
175 }
SendThirdAccessibilityProvider(const std::weak_ptr<ThirdAccessibilityManager> & thirdAccessibilityManager)176 void SendThirdAccessibilityProvider(
177 const std::weak_ptr<ThirdAccessibilityManager>& thirdAccessibilityManager)
178 override {}
179
180 public:
SetInjectResult(int32_t injectResult)181 void SetInjectResult(int32_t injectResult)
182 {
183 providerMockResult_.injectResult_ = injectResult;
184 }
185
SetInjectActionResult(int32_t injectResult)186 void SetInjectActionResult(int32_t injectResult)
187 {
188 providerMockResult_.injectActionResult_ = injectResult;
189 }
190
191 ProviderMockResult providerMockResult_;
192 };
193
194 class MockAccessibilityElementOperatorCallback : public Accessibility::AccessibilityElementOperatorCallback {
195 public:
196 ~MockAccessibilityElementOperatorCallback() = default;
197
SetSearchElementInfoByAccessibilityIdResult(const std::list<Accessibility::AccessibilityElementInfo> & infos,const int32_t requestId)198 void SetSearchElementInfoByAccessibilityIdResult(const std::list<Accessibility::AccessibilityElementInfo> &infos,
199 const int32_t requestId) override
200 {
201 mockInfos_ = infos;
202 mockRequestId = requestId;
203 }
204
SetSearchElementInfoByTextResult(const std::list<Accessibility::AccessibilityElementInfo> & infos,const int32_t requestId)205 void SetSearchElementInfoByTextResult(const std::list<Accessibility::AccessibilityElementInfo> &infos,
206 const int32_t requestId) override
207 {
208 mockInfos_ = infos;
209 mockRequestId = requestId;
210 }
211
SetFindFocusedElementInfoResult(const Accessibility::AccessibilityElementInfo & info,const int32_t requestId)212 void SetFindFocusedElementInfoResult(
213 const Accessibility::AccessibilityElementInfo &info,
214 const int32_t requestId) override
215 {
216 mockInfo_ = info;
217 mockRequestId = requestId;
218 }
219
SetFocusMoveSearchResult(const Accessibility::AccessibilityElementInfo & info,const int32_t requestId)220 void SetFocusMoveSearchResult(const Accessibility::AccessibilityElementInfo &info, const int32_t requestId) override
221 {
222 mockInfo_ = info;
223 mockRequestId = requestId;
224 }
225
SetExecuteActionResult(const bool succeeded,const int32_t requestId)226 void SetExecuteActionResult(const bool succeeded, const int32_t requestId) override
227 {
228 mockSucceeded_ = succeeded;
229 mockRequestId = requestId;
230 }
231
SetCursorPositionResult(const int32_t cursorPosition,const int32_t requestId)232 void SetCursorPositionResult(const int32_t cursorPosition, const int32_t requestId) override
233 {
234 mockCursorPosition_ = cursorPosition;
235 mockRequestId = requestId;
236 }
237
238 std::list<Accessibility::AccessibilityElementInfo> mockInfos_;
239 Accessibility::AccessibilityElementInfo mockInfo_;
240 int32_t mockRequestId = 0;
241 bool mockSucceeded_ = false;
242 int32_t mockCursorPosition_ = 0;
243 };
244 } // namespace OHOS::Ace
245
246 namespace OHOS::Ace::NG {
247 namespace {
248 } // namespace
249
250 class JsThirdProviderInteractionOperationTest : public testing::Test {
251 public:
252 static void SetUpTestCase();
253 static void TearDownTestCase();
254 };
255
SetUpTestCase()256 void JsThirdProviderInteractionOperationTest::SetUpTestCase()
257 {
258 MockPipelineContext::SetUp();
259 MockContainer::SetUp();
260 MockContainer::Current()->taskExecutor_ = AceType::MakeRefPtr<MockTaskExecutor>();
261 MockContainer::Current()->pipelineContext_ = MockPipelineContext::GetCurrentContext();
262 MockContainer::Current()->pipelineContext_->taskExecutor_ = MockContainer::Current()->taskExecutor_;
263 }
264
TearDownTestCase()265 void JsThirdProviderInteractionOperationTest::TearDownTestCase()
266 {
267 MockPipelineContext::TearDown();
268 MockContainer::TearDown();
269 }
270
271 /**
272 * @tc.name: JsThirdProviderInteractionOperationTest001
273 * @tc.desc: ClearFocusFromProvider
274 * @tc.type: FUNC
275 */
276 HWTEST_F(JsThirdProviderInteractionOperationTest, JsThirdProviderInteractionOperationTest001, TestSize.Level1)
277 {
278 auto ohAccessibilityProvider
279 = AceType::MakeRefPtr<MockOhAccessibilityProvider>();
280
281 auto frameNode = FrameNode::CreateFrameNode("framenode", 1, AceType::MakeRefPtr<Pattern>(), true);
282 auto jsAccessibilityManager = AceType::MakeRefPtr<Framework::JsAccessibilityManager>();
283 auto jsInteractionOperation = AceType::MakeRefPtr<Framework::JsThirdProviderInteractionOperation>(
284 ohAccessibilityProvider, jsAccessibilityManager, frameNode);
285
286 auto ret =jsInteractionOperation->ClearFocusFromProvider();
287 jsInteractionOperation->ClearFocus();
288 EXPECT_EQ(ret, true);
289 EXPECT_EQ(ohAccessibilityProvider->providerMockResult_.receiveClear_, true);
290 }
291
292 /**
293 * @tc.name: JsThirdProviderInteractionOperationTest002
294 * @tc.desc: SearchElementInfoByAccessibilityId
295 * @tc.type: FUNC
296 */
297 HWTEST_F(JsThirdProviderInteractionOperationTest, JsThirdProviderInteractionOperationTest002, TestSize.Level1)
298 {
299 auto ohAccessibilityProvider
300 = AceType::MakeRefPtr<MockOhAccessibilityProvider>();
301 auto frameNode = FrameNode::CreateFrameNode("framenode", 1, AceType::MakeRefPtr<Pattern>(), true);
302 auto jsAccessibilityManager = AceType::MakeRefPtr<Framework::JsAccessibilityManager>();
303 auto context = NG::PipelineContext::GetCurrentContext();
304 jsAccessibilityManager->SetPipelineContext(context);
305 jsAccessibilityManager->Register(true);
306
307 auto jsInteractionOperation = AceType::MakeRefPtr<Framework::JsThirdProviderInteractionOperation>(
308 ohAccessibilityProvider, jsAccessibilityManager, frameNode);
309 jsInteractionOperation->SetBelongTreeId(0);
310
311 int64_t elementId = -1;
312 int32_t requestId = 2;
313 int32_t mode = 0;
314 MockAccessibilityElementOperatorCallback operatorCallback;
315
316 // 1 provider abnormal, callback should receive same request id and empty infos
317 ohAccessibilityProvider->SetInjectResult(-1);
318 jsInteractionOperation->SearchElementInfoByAccessibilityId(
319 elementId, requestId,
320 operatorCallback, mode);
321
322 EXPECT_EQ(operatorCallback.mockInfos_.size(), 0);
323 EXPECT_EQ(operatorCallback.mockRequestId, requestId);
324
325 // 2 provider normal,callback should receive same request id and same infos as provider
326 ohAccessibilityProvider->providerMockResult_.Reset();
327 jsInteractionOperation->SearchElementInfoByAccessibilityId(
328 elementId, requestId,
329 operatorCallback, mode);
330 EXPECT_EQ(operatorCallback.mockInfos_.size(),
331 ohAccessibilityProvider->providerMockResult_.elementInfosList_.size());
332 EXPECT_EQ(operatorCallback.mockRequestId, requestId);
333 }
334
335 /**
336 * @tc.name: JsThirdProviderInteractionOperationTest003
337 * @tc.desc: earchElementInfosByText
338 * @tc.type: FUNC
339 */
340 HWTEST_F(JsThirdProviderInteractionOperationTest, JsThirdProviderInteractionOperationTest003, TestSize.Level1)
341 {
342 auto ohAccessibilityProvider
343 = AceType::MakeRefPtr<MockOhAccessibilityProvider>();
344 auto frameNode = FrameNode::CreateFrameNode("framenode", 1, AceType::MakeRefPtr<Pattern>(), true);
345 auto jsAccessibilityManager = AceType::MakeRefPtr<Framework::JsAccessibilityManager>();
346 auto context = NG::PipelineContext::GetCurrentContext();
347 jsAccessibilityManager->SetPipelineContext(context);
348 jsAccessibilityManager->Register(true);
349
350 auto jsInteractionOperation = AceType::MakeRefPtr<Framework::JsThirdProviderInteractionOperation>(
351 ohAccessibilityProvider, jsAccessibilityManager, frameNode);
352 jsInteractionOperation->SetBelongTreeId(0);
353
354 int64_t elementId = -1;
355 int32_t requestId = 2;
356 std::string& text = TEST_CONTENT_STR;
357 MockAccessibilityElementOperatorCallback operatorCallback;
358
359 // 1 provider abnormal, callback should receive same request id and empty infos
360 ohAccessibilityProvider->SetInjectResult(-1);
361 jsInteractionOperation->SearchElementInfosByText(
362 elementId, text, requestId, operatorCallback);
363
364 EXPECT_EQ(operatorCallback.mockRequestId, requestId);
365
366 // 2 provider normal,callback should receive same request id and same infos as provider
367 ohAccessibilityProvider->providerMockResult_.Reset();
368 jsInteractionOperation->SearchElementInfosByText(
369 elementId, text, requestId, operatorCallback);
370 EXPECT_EQ(operatorCallback.mockInfos_.size(),
371 ohAccessibilityProvider->providerMockResult_.elementInfosList_.size());
372 EXPECT_EQ(operatorCallback.mockRequestId, requestId);
373 }
374
375 /**
376 * @tc.name: JsThirdProviderInteractionOperationTest004
377 * @tc.desc: FindFocusedElementInfo
378 * @tc.type: FUNC
379 */
380 HWTEST_F(JsThirdProviderInteractionOperationTest, JsThirdProviderInteractionOperationTest004, TestSize.Level1)
381 {
382 auto ohAccessibilityProvider
383 = AceType::MakeRefPtr<MockOhAccessibilityProvider>();
384 auto frameNode = FrameNode::CreateFrameNode("framenode", 1, AceType::MakeRefPtr<Pattern>(), true);
385 auto jsAccessibilityManager = AceType::MakeRefPtr<Framework::JsAccessibilityManager>();
386 auto context = NG::PipelineContext::GetCurrentContext();
387 jsAccessibilityManager->SetPipelineContext(context);
388 jsAccessibilityManager->Register(true);
389
390 auto jsInteractionOperation = AceType::MakeRefPtr<Framework::JsThirdProviderInteractionOperation>(
391 ohAccessibilityProvider, jsAccessibilityManager, frameNode);
392 jsInteractionOperation->SetBelongTreeId(0);
393
394 int64_t elementId = -1;
395 int32_t requestId = 2;
396 int32_t focusType = 3;
397 MockAccessibilityElementOperatorCallback operatorCallback;
398
399 // 1 provider abnormal, callback should receive same request id and empty info
400 ohAccessibilityProvider->SetInjectResult(-1);
401 jsInteractionOperation->FindFocusedElementInfo(
402 elementId, focusType, requestId, operatorCallback);
403
404 EXPECT_EQ(operatorCallback.mockInfo_.GetAccessibilityId(), -1);
405 EXPECT_EQ(operatorCallback.mockRequestId, requestId);
406
407 // 2 provider normal,callback should receive same request id and same info as provider
408 ohAccessibilityProvider->providerMockResult_.Reset();
409 jsInteractionOperation->FindFocusedElementInfo(
410 elementId, focusType, requestId, operatorCallback);
411 EXPECT_EQ(operatorCallback.mockInfo_.GetAccessibilityId(),
412 ohAccessibilityProvider->providerMockResult_.focusElementInfo_.GetElementId());
413 EXPECT_EQ(operatorCallback.mockRequestId, requestId);
414 }
415
416 /**
417 * @tc.name: JsThirdProviderInteractionOperationTest005
418 * @tc.desc: FocusMoveSearch
419 * @tc.type: FUNC
420 */
421 HWTEST_F(JsThirdProviderInteractionOperationTest, JsThirdProviderInteractionOperationTest005, TestSize.Level1)
422 {
423 auto ohAccessibilityProvider
424 = AceType::MakeRefPtr<MockOhAccessibilityProvider>();
425 auto frameNode = FrameNode::CreateFrameNode("framenode", 1, AceType::MakeRefPtr<Pattern>(), true);
426 auto jsAccessibilityManager = AceType::MakeRefPtr<Framework::JsAccessibilityManager>();
427 auto context = NG::PipelineContext::GetCurrentContext();
428 jsAccessibilityManager->SetPipelineContext(context);
429 jsAccessibilityManager->Register(true);
430
431 auto jsInteractionOperation = AceType::MakeRefPtr<Framework::JsThirdProviderInteractionOperation>(
432 ohAccessibilityProvider, jsAccessibilityManager, frameNode);
433 jsInteractionOperation->SetBelongTreeId(0);
434
435 int64_t elementId = -1;
436 int32_t requestId = 2;
437 int32_t direction = 3;
438 MockAccessibilityElementOperatorCallback operatorCallback;
439
440 // 1 provider abnormal, callback should receive same request id and empty info
441 ohAccessibilityProvider->SetInjectResult(-1);
442 jsInteractionOperation->FocusMoveSearch(
443 elementId, direction, requestId, operatorCallback);
444 EXPECT_EQ(operatorCallback.mockInfo_.GetAccessibilityId(), -1);
445 EXPECT_EQ(operatorCallback.mockRequestId, requestId);
446
447 // 2 provider normal,callback should receive same request id and same info as provider
448 ohAccessibilityProvider->providerMockResult_.Reset();
449 jsInteractionOperation->FocusMoveSearch(
450 elementId, direction, requestId, operatorCallback);
451 EXPECT_EQ(operatorCallback.mockInfo_.GetAccessibilityId(),
452 ohAccessibilityProvider->providerMockResult_.nextFocusElementInfo_.GetElementId());
453 EXPECT_EQ(operatorCallback.mockRequestId, requestId);
454 }
455
456 /**
457 * @tc.name: JsThirdProviderInteractionOperationTest006
458 * @tc.desc: ExecuteAction
459 * @tc.type: FUNC
460 */
461 HWTEST_F(JsThirdProviderInteractionOperationTest, JsThirdProviderInteractionOperationTest006, TestSize.Level1)
462 {
463 auto ohAccessibilityProvider
464 = AceType::MakeRefPtr<MockOhAccessibilityProvider>();
465 auto frameNode = FrameNode::CreateFrameNode("framenode", 1, AceType::MakeRefPtr<Pattern>(), true);
466 auto jsAccessibilityManager = AceType::MakeRefPtr<Framework::JsAccessibilityManager>();
467 auto context = NG::PipelineContext::GetCurrentContext();
468 jsAccessibilityManager->SetPipelineContext(context);
469 jsAccessibilityManager->Register(true);
470
471 auto jsInteractionOperation = AceType::MakeRefPtr<Framework::JsThirdProviderInteractionOperation>(
472 ohAccessibilityProvider, jsAccessibilityManager, frameNode);
473 jsInteractionOperation->SetBelongTreeId(0);
474 int64_t elementId = 0;
475 int32_t requestId = 2;
476 int32_t action = -1;
477 std::map<std::string, std::string> actionArguments =
478 ohAccessibilityProvider->providerMockResult_.originActionArguments_;
479
480 MockAccessibilityElementOperatorCallback operatorCallback;
481
482 // 1 FindAccessibilityNode abnormal, callback should receive same request id and false
483 ohAccessibilityProvider->SetInjectResult(-1);
484 operatorCallback.mockSucceeded_ = true;
485 jsInteractionOperation->ExecuteAction(
486 elementId, action, actionArguments, requestId, operatorCallback);
487 EXPECT_EQ(operatorCallback.mockSucceeded_, false);
488 EXPECT_EQ(operatorCallback.mockRequestId, requestId);
489
490 // 2 ExecuteAccessibilityAction abnormal, callback should receive same request id and false
491 ohAccessibilityProvider->providerMockResult_.Reset();
492 ohAccessibilityProvider->SetInjectActionResult(-1);
493 operatorCallback.mockSucceeded_ = true;
494 jsInteractionOperation->ExecuteAction(
495 elementId, action, actionArguments, requestId, operatorCallback);
496 EXPECT_EQ(operatorCallback.mockSucceeded_, false);
497 EXPECT_EQ(operatorCallback.mockRequestId, requestId);
498
499 // 3 ExecuteAccessibilityAction normal, callback should receive same request id and true
500 ohAccessibilityProvider->providerMockResult_.Reset();
501 jsInteractionOperation->ExecuteAction(
502 elementId, action, actionArguments, requestId, operatorCallback);
503 EXPECT_EQ(operatorCallback.mockSucceeded_, true);
504 EXPECT_EQ(operatorCallback.mockRequestId, requestId);
505 }
506
507 /**
508 * @tc.name: JsThirdProviderInteractionOperationTest007
509 * @tc.desc: GetCursorPosition
510 * @tc.type: FUNC
511 */
512 HWTEST_F(JsThirdProviderInteractionOperationTest, JsThirdProviderInteractionOperationTest007, TestSize.Level1)
513 {
514 auto ohAccessibilityProvider
515 = AceType::MakeRefPtr<MockOhAccessibilityProvider>();
516 auto frameNode = FrameNode::CreateFrameNode("framenode", 1, AceType::MakeRefPtr<Pattern>(), true);
517 auto jsAccessibilityManager = AceType::MakeRefPtr<Framework::JsAccessibilityManager>();
518 auto context = NG::PipelineContext::GetCurrentContext();
519 jsAccessibilityManager->SetPipelineContext(context);
520 jsAccessibilityManager->Register(true);
521
522 auto jsInteractionOperation = AceType::MakeRefPtr<Framework::JsThirdProviderInteractionOperation>(
523 ohAccessibilityProvider, jsAccessibilityManager, frameNode);
524 jsInteractionOperation->SetBelongTreeId(0);
525
526 int64_t elementId = -1;
527 int32_t requestId = 2;
528 MockAccessibilityElementOperatorCallback operatorCallback;
529
530 // 1 provider abnormal, callback should receive same request id and CursorPosition default
531 ohAccessibilityProvider->SetInjectResult(-1);
532 jsInteractionOperation->GetCursorPosition(
533 elementId, requestId, operatorCallback);
534 EXPECT_EQ(operatorCallback.mockCursorPosition_, -1);
535 EXPECT_EQ(operatorCallback.mockRequestId, requestId);
536
537 // 2 provider normal,callback should receive same request id and same CursorPosition as provider
538 ohAccessibilityProvider->providerMockResult_.Reset();
539 jsInteractionOperation->GetCursorPosition(
540 elementId, requestId, operatorCallback);
541 EXPECT_EQ(operatorCallback.mockCursorPosition_, SPECIAL_CURSOR_POSTION);
542 EXPECT_EQ(operatorCallback.mockRequestId, requestId);
543 }
544
545 /**
546 * @tc.name: JsThirdProviderInteractionOperationTest008
547 * @tc.desc: GetCursorPosition
548 * @tc.type: FUNC
549 */
550 HWTEST_F(JsThirdProviderInteractionOperationTest, JsThirdProviderInteractionOperationTest008, TestSize.Level1)
551 {
552 auto ohAccessibilityProvider
553 = AceType::MakeRefPtr<MockOhAccessibilityProvider>();
554 auto frameNode = FrameNode::CreateFrameNode("framenode", 1, AceType::MakeRefPtr<Pattern>(), true);
555 auto jsAccessibilityManager = AceType::MakeRefPtr<Framework::JsAccessibilityManager>();
556 auto context = NG::PipelineContext::GetCurrentContext();
557 jsAccessibilityManager->SetPipelineContext(context);
558 jsAccessibilityManager->Register(true);
559
560 auto jsInteractionOperation = AceType::MakeRefPtr<Framework::JsThirdProviderInteractionOperation>(
561 ohAccessibilityProvider, jsAccessibilityManager, frameNode);
562 jsInteractionOperation->SetBelongTreeId(0);
563
564 ArkUI_AccessibilityEventInfo event;
565
566 event.SetEventType(ARKUI_ACCESSIBILITY_NATIVE_EVENT_TYPE_ACCESSIBILITY_FOCUSED);
567 event.SetPageId(1);
568 int32_t requestFocusId = 0;
569 event.SetRequestFocusId(requestFocusId);
570 ArkUI_AccessibilityElementInfo elementInfo;
571 event.SetElementInfo(&elementInfo);
572 std::string textAnnouncedForAccessibility = "textAnnouncedForAccessibility";
573 event.SetTextAnnouncedForAccessibility(textAnnouncedForAccessibility);
574
575 g_mockErrorCode = -1;
576
__anona1ea35ec0202(int32_t errorCode) 577 auto callback = [](int32_t errorCode) { g_mockErrorCode = errorCode; };
578
579 // 1 send event and callback receive 0
580 jsInteractionOperation->SendAccessibilityAsyncEvent(
581 event, callback);
582
583 EXPECT_EQ(g_mockErrorCode, 0);
584 }
585
586 /**
587 * @tc.name: JsThirdProviderInteractionOperationTest009
588 * @tc.desc: element info transform by host node's info
589 * @tc.type: FUNC
590 */
591 HWTEST_F(JsThirdProviderInteractionOperationTest, JsThirdProviderInteractionOperationTest009, TestSize.Level1)
592 {
593 auto ohAccessibilityProvider
594 = AceType::MakeRefPtr<MockOhAccessibilityProvider>();
595 auto frameNode = FrameNode::CreateFrameNode("framenode", 1, AceType::MakeRefPtr<Pattern>(), true);
596 auto jsAccessibilityManager = AceType::MakeRefPtr<Framework::JsAccessibilityManager>();
597 auto context = NG::PipelineContext::GetCurrentContext();
598 jsAccessibilityManager->SetPipelineContext(context);
599 jsAccessibilityManager->Register(true);
600
601 auto jsInteractionOperation = AceType::MakeRefPtr<Framework::JsThirdProviderInteractionOperation>(
602 ohAccessibilityProvider, jsAccessibilityManager, frameNode);
603
604 int32_t treeId = 0;
605 jsInteractionOperation->SetBelongTreeId(treeId);
606 int32_t pageId = 4;
607 frameNode->SetHostPageId(pageId);
608 int32_t windowId = 5;
609 context->SetRealHostWindowId(windowId);
610 std::string bundleName = "com.example.myapplication";
611 AceApplicationInfo::GetInstance().SetPackageName(bundleName);
612
613 int64_t elementId = -1;
614 int32_t requestId = 2;
615 int32_t mode = 0;
616
617 MockAccessibilityElementOperatorCallback operatorCallback;
618
619 // 1 provider normal,callback should receive same request id and info's detail is transformed by host node's detail
620 ohAccessibilityProvider->providerMockResult_.Reset();
621 jsInteractionOperation->SearchElementInfoByAccessibilityId(
622 elementId, requestId,
623 operatorCallback, mode);
624 EXPECT_EQ(operatorCallback.mockRequestId, requestId);
625 EXPECT_EQ(operatorCallback.mockInfos_.size(),
626 ohAccessibilityProvider->providerMockResult_.elementInfosList_.size());
627
628 std::vector<Accessibility::AccessibilityElementInfo> mockInfosVector;
629 for (Accessibility::AccessibilityElementInfo &elementInfo : operatorCallback.mockInfos_) {
630 mockInfosVector.push_back(elementInfo);
631 }
632 for (int32_t i = 0; i < operatorCallback.mockInfos_.size(); i++) {
633 int64_t splitElementId = Accessibility::AccessibilityElementInfo::UNDEFINED_ACCESSIBILITY_ID;
634 int32_t splitTreeId = Accessibility::AccessibilityElementInfo::UNDEFINED_TREE_ID;
635
636 Accessibility::AccessibilitySystemAbilityClient::GetTreeIdAndElementIdBySplitElementId(
637 mockInfosVector[i].GetAccessibilityId(), splitElementId, splitTreeId);
638 EXPECT_EQ(splitTreeId, treeId);
639 EXPECT_EQ(splitElementId,
640 ohAccessibilityProvider->providerMockResult_.elementInfosList_[i].GetElementId());
641 EXPECT_EQ(mockInfosVector[i].GetBelongTreeId(), treeId);
642 EXPECT_EQ(mockInfosVector[i].GetPageId(), pageId);
643 EXPECT_EQ(mockInfosVector[i].GetWindowId(), windowId);
644 EXPECT_EQ(mockInfosVector[i].GetParentWindowId(), windowId);
645 EXPECT_EQ(mockInfosVector[i].GetBundleName(), bundleName);
646 }
647 }
648
649 /**
650 * @tc.name: JsThirdProviderInteractionOperationTest010
651 * @tc.desc: SendAccessibilityAsyncEventForThird
652 * @tc.type: FUNC
653 */
654 HWTEST_F(JsThirdProviderInteractionOperationTest, JsThirdProviderInteractionOperationTest010, TestSize.Level1)
655 {
656 auto ohAccessibilityProvider
657 = AceType::MakeRefPtr<MockOhAccessibilityProvider>();
658 auto frameNode = FrameNode::CreateFrameNode("framenode", 1, AceType::MakeRefPtr<Pattern>(), true);
659 auto jsAccessibilityManager = AceType::MakeRefPtr<Framework::JsAccessibilityManager>();
660 auto context = NG::PipelineContext::GetCurrentContext();
661 jsAccessibilityManager->SetPipelineContext(context);
662 jsAccessibilityManager->Register(true);
663
664 auto jsInteractionOperation = AceType::MakeRefPtr<Framework::JsThirdProviderInteractionOperation>(
665 ohAccessibilityProvider, jsAccessibilityManager, frameNode);
666 jsInteractionOperation->SetBelongTreeId(0);
667
668 int32_t ret = 0;
669
670 int64_t thirdElementId = 1;
671 Accessibility::EventType eventType = Accessibility::EventType::TYPE_VIEW_ACCESSIBILITY_FOCUSED_EVENT;
672
673 // 1 provider abnormal, return -1
674 ohAccessibilityProvider->SetInjectResult(-1);
675 ret = jsInteractionOperation->SendAccessibilityAsyncEventForThird(
676 thirdElementId, eventType);
677 EXPECT_EQ(ret, -1);
678 // 2 provider normal ; TBM check send client 's event is right
679 ohAccessibilityProvider->providerMockResult_.Reset();
680 ret = jsInteractionOperation->SendAccessibilityAsyncEventForThird(
681 thirdElementId, eventType);
682 EXPECT_EQ(ret, 0);
683 }
684
685 /**
686 * @tc.name: JsThirdProviderInteractionOperationTest011
687 * @tc.desc: HandleEventByFramework ARKUI_ACCESSIBILITY_NATIVE_EVENT_TYPE_FOCUS_NODE_UPDATE
688 * @tc.type: FUNC
689 */
690 HWTEST_F(JsThirdProviderInteractionOperationTest, JsThirdProviderInteractionOperationTest011, TestSize.Level1)
691 {
692 auto ohAccessibilityProvider
693 = AceType::MakeRefPtr<MockOhAccessibilityProvider>();
694 auto frameNode = FrameNode::CreateFrameNode("framenode", 1, AceType::MakeRefPtr<Pattern>(), true);
695 auto jsAccessibilityManager = AceType::MakeRefPtr<Framework::JsAccessibilityManager>();
696 auto context = NG::PipelineContext::GetCurrentContext();
697 jsAccessibilityManager->SetPipelineContext(context);
698 jsAccessibilityManager->Register(true);
699
700 auto jsInteractionOperation = AceType::MakeRefPtr<Framework::JsThirdProviderInteractionOperation>(
701 ohAccessibilityProvider, jsAccessibilityManager, frameNode);
702 jsInteractionOperation->SetBelongTreeId(0);
703
704 ArkUI_AccessibilityEventInfo event;
705
706 event.SetEventType(ARKUI_ACCESSIBILITY_NATIVE_EVENT_TYPE_FOCUS_NODE_UPDATE);
707 event.SetPageId(1);
708 int32_t requestFocusId = 0;
709 event.SetRequestFocusId(requestFocusId);
710 ArkUI_AccessibilityElementInfo elementInfo;
711 event.SetElementInfo(&elementInfo);
712 std::string textAnnouncedForAccessibility = "textAnnouncedForAccessibility";
713 event.SetTextAnnouncedForAccessibility(textAnnouncedForAccessibility);
714
715 g_mockErrorCode = -1;
716
__anona1ea35ec0302(int32_t errorCode) 717 auto callback = [](int32_t errorCode) { g_mockErrorCode = errorCode; };
718
719 // TBM check not send event to client
720 jsInteractionOperation->SendAccessibilityAsyncEvent(
721 event, callback);
722
723 EXPECT_EQ(g_mockErrorCode, 0);
724 }
725
726 } // namespace OHOS::Ace::NG
727