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 "gmock/gmock.h"
17 #include "gtest/gtest.h"
18
19 #define private public
20 #define protected public
21 #include "accessibility_system_ability_client.h"
22 #include "test/mock/base/mock_task_executor.h"
23 #include "test/mock/core/common/mock_container.h"
24 #include "test/mock/core/pipeline/mock_pipeline_context.h"
25
26 #include "base/log/dump_log.h"
27 #include "adapter/ohos/osal/js_accessibility_manager.h"
28 #include "frameworks/core/accessibility/accessibility_node.h"
29 #include "adapter/ohos/entrance/ace_container.h"
30
31 using namespace OHOS::Accessibility;
32 using namespace testing;
33 using namespace testing::ext;
34
35 namespace OHOS::Ace {
36 } // namespace OHOS::Ace
37
38 namespace OHOS::Ace::NG {
39 namespace {
40 } // namespace
41
42 class MockAccessibilityChildTreeCallback : public AccessibilityChildTreeCallback {
43 public:
MockAccessibilityChildTreeCallback(int64_t accessibilityId)44 explicit MockAccessibilityChildTreeCallback(int64_t accessibilityId)
45 : AccessibilityChildTreeCallback(accessibilityId)
46 {}
47
48 ~MockAccessibilityChildTreeCallback() override = default;
49
OnRegister(uint32_t windowId,int32_t treeId)50 bool OnRegister(uint32_t windowId, int32_t treeId) override
51 {
52 return true;
53 }
54
OnDeregister()55 bool OnDeregister() override
56 {
57 return true;
58 }
59
OnSetChildTree(int32_t childWindowId,int32_t childTreeId)60 bool OnSetChildTree(int32_t childWindowId, int32_t childTreeId) override
61 {
62 return true;
63 }
64
OnDumpChildInfo(const std::vector<std::string> & params,std::vector<std::string> & info)65 bool OnDumpChildInfo(const std::vector<std::string>& params, std::vector<std::string>& info) override
66 {
67 return true;
68 }
69
OnClearRegisterFlag()70 void OnClearRegisterFlag() override
71 {
72 isReg_ = false;
73 }
74
75 private:
76 bool isReg_ = false;
77 };
78
79 class MockAccessibilitySAObserverCallback : public AccessibilitySAObserverCallback {
80 public:
MockAccessibilitySAObserverCallback(int64_t accessibilityId)81 explicit MockAccessibilitySAObserverCallback(int64_t accessibilityId)
82 : AccessibilitySAObserverCallback(accessibilityId)
83 {}
84
85 ~MockAccessibilitySAObserverCallback() override = default;
86
OnState(bool state)87 bool OnState(bool state) override
88 {
89 return true;
90 }
91 };
92
93 class JsAccessibilityManagerTest : public testing::Test {
94 public:
95 static void SetUpTestCase();
96 static void TearDownTestCase();
97 };
98
SetUpTestCase()99 void JsAccessibilityManagerTest::SetUpTestCase()
100 {
101 MockPipelineContext::SetUp();
102 MockContainer::SetUp();
103 MockContainer::Current()->taskExecutor_ = AceType::MakeRefPtr<MockTaskExecutor>();
104 MockContainer::Current()->pipelineContext_ = MockPipelineContext::GetCurrentContext();
105 MockContainer::Current()->pipelineContext_->taskExecutor_ = MockContainer::Current()->taskExecutor_;
106
107 std::unique_ptr<std::ostream> ostream = std::make_unique<std::ostringstream>();
108 ASSERT_NE(ostream, nullptr);
109 DumpLog::GetInstance().SetDumpFile(std::move(ostream));
110 }
111
TearDownTestCase()112 void JsAccessibilityManagerTest::TearDownTestCase()
113 {
114 MockPipelineContext::TearDown();
115 MockContainer::TearDown();
116 }
117
118 class MockJsAccessibilityManager : public Framework::JsAccessibilityManager {
119 public:
120 MOCK_METHOD3(SendEventToAccessibilityWithNode,
121 void(const AccessibilityEvent& accessibilityEvent,
122 const RefPtr<AceType>& node, const RefPtr<PipelineBase>& context));
123 };
124
125 /**
126 * @tc.name: JsAccessibilityManager001
127 * @tc.desc: UpdateAccessibilityElementInfo
128 * @tc.type: FUNC
129 */
130 HWTEST_F(JsAccessibilityManagerTest, JsAccessibilityManager001, TestSize.Level1)
131 {
132 /**
133 * @tc.steps: step1. construct JsAccessibilityManager
134 */
135 auto frameNode = FrameNode::CreateFrameNode("framenode", 1, AceType::MakeRefPtr<Pattern>(), true);
136 auto jsAccessibilityManager = AceType::MakeRefPtr<Framework::JsAccessibilityManager>();
137 Accessibility::AccessibilityElementInfo nodeInfo;
138 auto accessibilityProperty = frameNode->GetAccessibilityProperty<NG::AccessibilityProperty>();
139 accessibilityProperty->SetAccessibilityRole("test");
140 accessibilityProperty->SetUserRangeCurrentValue(5);
141 accessibilityProperty->SetUserRangeMinValue(1);
142 accessibilityProperty->SetUserRangeMaxValue(10);
143 accessibilityProperty->SetAccessibilityLevel("yes");
144 jsAccessibilityManager->UpdateAccessibilityElementInfo(frameNode, nodeInfo);
145
146 /**
147 * @tc.steps: step2. init accessibilityProperty and set level yes.
148 * @tc.expected: UpdateAccessibilityElementInfo nodeInfo level is yes.
149 */
150 EXPECT_EQ(nodeInfo.GetAccessibilityLevel(), "yes");
151 }
152
153 /**
154 * @tc.name: JsAccessibilityManager002
155 * @tc.desc: UpdateElementInfoTreeId
156 * @tc.type: FUNC
157 */
158 HWTEST_F(JsAccessibilityManagerTest, JsAccessibilityManager002, TestSize.Level1)
159 {
160 /**
161 * @tc.steps: step1. construct JsAccessibilityManager
162 */
163 auto frameNode = FrameNode::CreateFrameNode("framenode", 1, AceType::MakeRefPtr<Pattern>(), true);
164 auto jsAccessibilityManager = AceType::MakeRefPtr<Framework::JsAccessibilityManager>();
165 Accessibility::AccessibilityElementInfo info;
166 info.SetPageId(1);
167 info.SetParent(0);
168 info.SetBelongTreeId(10);
169 info.SetAccessibilityId(11);
170 jsAccessibilityManager->UpdateElementInfoTreeId(info);
171
172 /**
173 * @tc.steps: step2. init AccessibilityElementInfo and SetBelongTreeId 10, pageid 1, parent 0.
174 * @tc.expected: UpdateElementInfoTreeId nodeInfo pageid is not equal 1.
175 */
176 EXPECT_NE(info.GetPageId(), 1);
177
178 info.SetBelongTreeId(0);
179 info.SetPageId(1);
180 jsAccessibilityManager->UpdateElementInfoTreeId(info);
181
182 /**
183 * @tc.steps: step3. AccessibilityElementInfo and SetBelongTreeId 0
184 * @tc.expected: UpdateElementInfoTreeId nodeInfo pageid is 1.
185 */
186 EXPECT_EQ(info.GetPageId(), 1);
187 }
188
189 /**
190 * @tc.name: JsAccessibilityManager003
191 * @tc.desc: UpdateAccessibilityVisible
192 * @tc.type: FUNC
193 */
194 HWTEST_F(JsAccessibilityManagerTest, JsAccessibilityManager003, TestSize.Level1)
195 {
196 /**
197 * @tc.steps: step1. construct JsAccessibilityManager
198 */
199 auto frameNode = FrameNode::CreateFrameNode("framenode", 1, AceType::MakeRefPtr<Pattern>(), false);
200 auto jsAccessibilityManager = AceType::MakeRefPtr<Framework::JsAccessibilityManager>();
201
202 /**
203 * @tc.steps: step2. test UpdateAccessibilityVisible
204 */
205 Accessibility::AccessibilityElementInfo nodeInfo;
206 // without parent node return visiable false
207 jsAccessibilityManager->UpdateAccessibilityVisible(frameNode, nodeInfo);
208 EXPECT_EQ(nodeInfo.GetAccessibilityVisible(), false);
209
210 nodeInfo.SetParent(0);
211 jsAccessibilityManager->UpdateAccessibilityVisible(frameNode, nodeInfo);
212 EXPECT_EQ(nodeInfo.GetAccessibilityVisible(), false);
213 }
214
215 /**
216 * @tc.name: JsAccessibilityManager004
217 * @tc.desc: GenerateCommonProperty
218 * @tc.type: FUNC
219 */
220 HWTEST_F(JsAccessibilityManagerTest, JsAccessibilityManager004, TestSize.Level1)
221 {
222 /**
223 * @tc.steps: step1. construct JsAccessibilityManager
224 */
225 auto rootNode = FrameNode::CreateFrameNode(V2::WINDOW_SCENE_ETS_TAG,
226 ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<Pattern>(), true);
227 auto frameNode = FrameNode::CreateFrameNode("framenode", ElementRegister::GetInstance()->MakeUniqueId(),
228 AceType::MakeRefPtr<Pattern>(), false);
229 rootNode->AddChild(frameNode);
230 auto jsAccessibilityManager = AceType::MakeRefPtr<Framework::JsAccessibilityManager>();
231 auto context = NG::PipelineContext::GetCurrentContext();
232 jsAccessibilityManager->SetPipelineContext(context);
233 jsAccessibilityManager->Register(true);
234 jsAccessibilityManager->SetWindowId(1);
235
236 /**
237 * @tc.steps: step2. test GenerateCommonProperty
238 */
239 auto mainContext = context;
240 Framework::CommonProperty commonProperty;
241 jsAccessibilityManager->GenerateCommonProperty(context, commonProperty, mainContext, frameNode);
242 EXPECT_EQ(commonProperty.innerWindowId, -1);
243
244 jsAccessibilityManager->DumpTreeNodeCommonInfoNg(frameNode, commonProperty);
245 jsAccessibilityManager->DumpTreeNodeSimplifyInfoNG(frameNode, 1, commonProperty, 1);
246 jsAccessibilityManager->DumpTreeNG(frameNode, 1, frameNode->GetId(), true);
247 jsAccessibilityManager->DumpTree(1, 1, true);
248
249 jsAccessibilityManager->UpdateViewScale();
250 EXPECT_EQ(jsAccessibilityManager->scaleX_, 1.0f);
251 }
252
253 /**
254 * @tc.name: JsAccessibilityManager005
255 * @tc.desc: dump func
256 * @tc.type: FUNC
257 */
258 HWTEST_F(JsAccessibilityManagerTest, JsAccessibilityManager005, TestSize.Level1)
259 {
260 /**
261 * @tc.steps: step1. construct JsAccessibilityManager
262 */
263 auto frameNode = FrameNode::CreateFrameNode("framenode", ElementRegister::GetInstance()->MakeUniqueId(),
264 AceType::MakeRefPtr<Pattern>(), false);
265 auto jsAccessibilityManager = AceType::MakeRefPtr<Framework::JsAccessibilityManager>();
266 Accessibility::AccessibilityElementInfo nodeInfo;
267 nodeInfo.SetAccessibilityId(1);
268 jsAccessibilityManager->DumpAccessibilityPropertyNG(nodeInfo);
269 jsAccessibilityManager->DumpCommonPropertyNG(nodeInfo, 1);
270
271 /**
272 * @tc.steps: step2. test DumpTreeNG
273 */
274 bool useWindowId = false;
275 uint32_t windowId = 1;
276 int64_t rootId = -1;
277 bool isDumpSimplify = false;
278 jsAccessibilityManager->DumpTreeNG(useWindowId, windowId, rootId, isDumpSimplify);
279
280 rootId = 1;
281 jsAccessibilityManager->SetWindowId(0);
282 jsAccessibilityManager->DumpTreeNG(useWindowId, windowId, rootId, isDumpSimplify);
283
284 jsAccessibilityManager->SetWindowId(1);
285 jsAccessibilityManager->DumpTreeNG(useWindowId, windowId, rootId, isDumpSimplify);
286
287 /**
288 * @tc.steps: step3. test DumpHoverTestNG/DumpTreeNodeSafeAreaInfoNg
289 */
290 bool verbose = false;
291 jsAccessibilityManager->DumpHoverTestNG(windowId, rootId, 100, 100, verbose);
292 jsAccessibilityManager->DumpTreeNodeSafeAreaInfoNg(frameNode);
293 EXPECT_EQ(nodeInfo.GetAccessibilityId(), 1);
294 }
295
296 /**
297 * @tc.name: JsAccessibilityManager006
298 * @tc.desc: UpdateVirtualNodeFocus
299 * @tc.type: FUNC
300 */
301 HWTEST_F(JsAccessibilityManagerTest, JsAccessibilityManager006, TestSize.Level1)
302 {
303 /**
304 * @tc.steps: step1. construct JsAccessibilityManager
305 */
306 auto frameNode = FrameNode::CreateFrameNode("framenode", ElementRegister::GetInstance()->MakeUniqueId(),
307 AceType::MakeRefPtr<Pattern>(), false);
308 auto jsAccessibilityManager = AceType::MakeRefPtr<Framework::JsAccessibilityManager>();
309
310 /**
311 * @tc.steps: step2. test UpdateVirtualNodeFocus
312 */
313 Accessibility::AccessibilityElementInfo nodeInfo;
314 RefPtr<GeometryNode> geometryNode = AceType::MakeRefPtr<GeometryNode>();
315 ASSERT_NE(geometryNode, nullptr);
316 frameNode->SetGeometryNode(geometryNode);
317 jsAccessibilityManager->SaveLast(0, frameNode);
318 jsAccessibilityManager->UpdateVirtualNodeFocus();
319 auto accessibilityProperty = frameNode->GetAccessibilityProperty<NG::AccessibilityProperty>();
320 ASSERT_NE(accessibilityProperty, nullptr);
321 EXPECT_EQ(accessibilityProperty->GetAccessibilityFocusState(), false);
322 }
323
324 /**
325 * @tc.name: JsAccessibilityManager007
326 * @tc.desc: stateObserver
327 * @tc.type: FUNC
328 */
329 HWTEST_F(JsAccessibilityManagerTest, JsAccessibilityManager007, TestSize.Level1)
330 {
331 /**
332 * @tc.steps: step1. construct JsAccessibilityManager
333 */
334 auto jsAccessibilityManager = AceType::MakeRefPtr<Framework::JsAccessibilityManager>();
335
336 /**
337 * @tc.steps: step2. test SubscribeToastObserver
338 */
339 auto ret = jsAccessibilityManager->SubscribeToastObserver();
340 EXPECT_EQ(ret, true);
341
342 /**
343 * @tc.steps: step3. test UnsubscribeToastObserver
344 */
345 ret = jsAccessibilityManager->UnsubscribeToastObserver();
346 EXPECT_EQ(ret, true);
347
348 /**
349 * @tc.steps: step4. test SubscribeStateObserver
350 */
351 ret = jsAccessibilityManager->SubscribeStateObserver(16);
352 EXPECT_EQ(ret, false);
353
354 /**
355 * @tc.steps: step5. test UnsubscribeStateObserver
356 */
357 ret = jsAccessibilityManager->UnsubscribeStateObserver(16);
358 EXPECT_EQ(ret, false);
359 }
360
361 /**
362 * @tc.name: JsAccessibilityManager008
363 * @tc.desc: SendAccessibilitySyncEvent, TransferAccessibilityAsyncEvent
364 * @tc.type: FUNC
365 */
366 HWTEST_F(JsAccessibilityManagerTest, JsAccessibilityManager008, TestSize.Level1)
367 {
368 /**
369 * @tc.steps: step1. construct JsAccessibilityManager
370 */
371 auto jsAccessibilityManager = AceType::MakeRefPtr<Framework::JsAccessibilityManager>();
372 auto context = NG::PipelineContext::GetCurrentContext();
373 jsAccessibilityManager->SetPipelineContext(context);
374 jsAccessibilityManager->Register(true);
375 auto client = Accessibility::AccessibilitySystemAbilityClient::GetInstance();
376
377 /**
378 * @tc.steps: step2. test SendAccessibilitySyncEvent with register true
379 */
380 AccessibilityEvent accessibilityEvent;
381 Accessibility::AccessibilityEventInfo eventInfo;
382 auto ret = jsAccessibilityManager->SendAccessibilitySyncEvent(accessibilityEvent, eventInfo);
383 if (client) {
384 bool isEnabled = false;
385 client->IsEnabled(isEnabled);
386 EXPECT_EQ(ret, isEnabled);
387 } else {
388 EXPECT_EQ(ret, false);
389 }
390
391 /**
392 * @tc.steps: step3. test TransferAccessibilityAsyncEvent with register true
393 */
394 int64_t uiExtensionOffset = 1000;
395 ret = jsAccessibilityManager->TransferAccessibilityAsyncEvent(eventInfo, uiExtensionOffset);
396 if (client) {
397 bool isEnabled = false;
398 client->IsEnabled(isEnabled);
399 EXPECT_EQ(ret, isEnabled);
400 } else {
401 EXPECT_EQ(ret, false);
402 }
403
404 /**
405 * @tc.steps: step4. test SendAccessibilitySyncEvent with register false
406 */
407 jsAccessibilityManager->Register(false);
408 ret = jsAccessibilityManager->SendAccessibilitySyncEvent(accessibilityEvent, eventInfo);
409 EXPECT_EQ(ret, false);
410 /**
411 * @tc.steps: step5. test TransferAccessibilityAsyncEvent with register false
412 */
413 ret = jsAccessibilityManager->TransferAccessibilityAsyncEvent(eventInfo, uiExtensionOffset);
414 EXPECT_EQ(ret, false);
415 }
416
417 /**
418 * @tc.name: JsAccessibilityManager009
419 * @tc.desc: GetDelayTimeBeforeSendEvent
420 * @tc.type: FUNC
421 */
422 HWTEST_F(JsAccessibilityManagerTest, JsAccessibilityManager009, TestSize.Level1)
423 {
424 /**
425 * @tc.steps: step1. construct JsAccessibilityManager
426 */
427 auto frameNode = FrameNode::CreateFrameNode("framenode", ElementRegister::GetInstance()->MakeUniqueId(),
428 AceType::MakeRefPtr<Pattern>(), false);
429 auto accessibilityProperty = frameNode->GetAccessibilityProperty<NG::AccessibilityProperty>();
430 accessibilityProperty->SetAccessibilityLevel("yes");
431 auto jsAccessibilityManager = AceType::MakeRefPtr<Framework::JsAccessibilityManager>();
432 auto context = NG::PipelineContext::GetCurrentContext();
433 jsAccessibilityManager->SetPipelineContext(context);
434 jsAccessibilityManager->Register(true);
435
436 /**
437 * @tc.steps: step2. test GetPipelineByWindowId
438 */
439 AccessibilityEvent event;
440 int64_t ret;
441 ret = jsAccessibilityManager->GetDelayTimeBeforeSendEvent(event, frameNode);
442 EXPECT_EQ(ret, 0);
443 // test GetDelayTimeBeforeSendEvent with node selected, event type click, return 0
444 event.type = AccessibilityEventType::CLICK;
445 accessibilityProperty->SetUserSelected(true);
446 ret = jsAccessibilityManager->GetDelayTimeBeforeSendEvent(event, frameNode);
447 EXPECT_EQ(ret, 20);
448 // test GetDelayTimeBeforeSendEvent with node not selected, return 0
449 accessibilityProperty->SetUserSelected(false);
450 ret = jsAccessibilityManager->GetDelayTimeBeforeSendEvent(event, frameNode);
451 EXPECT_EQ(ret, 20);
452
453 ret = jsAccessibilityManager->GetDelayTimeBeforeSendEvent(event, nullptr);
454 EXPECT_EQ(ret, 0);
455 }
456
457 /**
458 * @tc.name: JsAccessibilityManager010
459 * @tc.desc: GetPipelineByWindowId
460 * @tc.type: FUNC
461 */
462 HWTEST_F(JsAccessibilityManagerTest, JsAccessibilityManager010, TestSize.Level1)
463 {
464 /**
465 * @tc.steps: step1. construct JsAccessibilityManager
466 */
467 auto jsAccessibilityManager = AceType::MakeRefPtr<Framework::JsAccessibilityManager>();
468 auto context = NG::PipelineContext::GetCurrentContext();
469 jsAccessibilityManager->SetPipelineContext(context);
470 jsAccessibilityManager->Register(true);
471 jsAccessibilityManager->SetWindowId(1);
472
473 /**
474 * @tc.steps: step2. test GetPipelineByWindowId
475 */
476 auto pattern = jsAccessibilityManager->GetPipelineByWindowId(1);
477 EXPECT_NE(pattern, nullptr);
478
479 pattern = jsAccessibilityManager->GetPipelineByWindowId(2);
480 EXPECT_EQ(pattern, nullptr);
481 }
482
483 /**
484 * @tc.name: JsAccessibilityManager011
485 * @tc.desc: CheckDumpInfoParams,OnDumpInfoNG,CheckDumpHandleEventParams,DumpProperty
486 * @tc.type: FUNC
487 */
488 HWTEST_F(JsAccessibilityManagerTest, JsAccessibilityManager011, TestSize.Level1)
489 {
490 /**
491 * @tc.steps: step1. construct JsAccessibilityManager
492 */
493 std::vector<std::string> params = {};
494 auto jsAccessibilityManager = AceType::MakeRefPtr<Framework::JsAccessibilityManager>();
495
496 /**
497 * @tc.steps: step2. test CheckDumpInfoParams
498 */
499 auto ret = jsAccessibilityManager->CheckDumpInfoParams(params);
500 EXPECT_EQ(ret, false);
501
502 params = { "-inspector", "-accessibility", "-simplify"};
503 ret = jsAccessibilityManager->CheckDumpInfoParams(params);
504 EXPECT_EQ(ret, true);
505
506 params = { "-inspector", "-accessibility"};
507 ret = jsAccessibilityManager->CheckDumpInfoParams(params);
508 EXPECT_EQ(ret, true);
509
510 /**
511 * @tc.steps: step3. test OnDumpInfoNG
512 */
513 params = { "-inspector", "-accessibility", "-simplify", "-w", "1"};
514 jsAccessibilityManager->OnDumpInfoNG(params, 1, false);
515
516 /**
517 * @tc.steps: step4. test CheckDumpHandleEventParams
518 */
519 ret = jsAccessibilityManager->CheckDumpHandleEventParams(params);
520 EXPECT_EQ(ret, true);
521
522 /**
523 * @tc.steps: step5. test DumpProperty
524 */
525 jsAccessibilityManager->DumpProperty(params);
526 }
527
528 /**
529 * @tc.name: JsAccessibilityManager012
530 * @tc.desc: Test UIExtensionManager ConvertActionTypeToBoolen
531 * @tc.type: FUNC
532 */
533 HWTEST_F(JsAccessibilityManagerTest, JsAccessibilityManager012, TestSize.Level1)
534 {
535 /**
536 * @tc.steps: step1. construct JsAccessibilityManager
537 */
538 auto jsAccessibilityManager = AceType::MakeRefPtr<Framework::JsAccessibilityManager>();
539 auto frameNode = FrameNode::CreateFrameNode("framenode", 1, AceType::MakeRefPtr<Pattern>(), true);
540 auto context = NG::PipelineContext::GetCurrentContext();
541 int64_t elementId = 0;
542
543 /**
544 * @tc.steps: step2. test ConvertActionTypeToBoolen
545 */
546 auto ret = jsAccessibilityManager->ConvertActionTypeToBoolen(ActionType::ACCESSIBILITY_ACTION_FOCUS,
547 frameNode, elementId, context);
548 EXPECT_EQ(ret, false);
549
550 ret = jsAccessibilityManager->ConvertActionTypeToBoolen(ActionType::ACCESSIBILITY_ACTION_CLEAR_FOCUS,
551 frameNode, elementId, context);
552 EXPECT_EQ(ret, false);
553
554 ret = jsAccessibilityManager->ConvertActionTypeToBoolen(ActionType::ACCESSIBILITY_ACTION_CLICK,
555 frameNode, elementId, context);
556 EXPECT_EQ(ret, false);
557
558 ret = jsAccessibilityManager->ConvertActionTypeToBoolen(ActionType::ACCESSIBILITY_ACTION_LONG_CLICK,
559 frameNode, elementId, context);
560 EXPECT_EQ(ret, false);
561
562 ret = jsAccessibilityManager->ConvertActionTypeToBoolen(ActionType::ACCESSIBILITY_ACTION_ACCESSIBILITY_FOCUS,
563 frameNode, elementId, context);
564 EXPECT_EQ(ret, true);
565
566 ret = jsAccessibilityManager->ConvertActionTypeToBoolen(ActionType::ACCESSIBILITY_ACTION_CLEAR_ACCESSIBILITY_FOCUS,
567 frameNode, elementId, context);
568 EXPECT_EQ(ret, false);
569 }
570
571 /**
572 * @tc.name: JsAccessibilityManager013
573 * @tc.desc: Test UIExtensionManager SendEventToAccessibilityWithNode/SendEventToAccessibilityWithNodeInner
574 * @tc.type: FUNC
575 */
576 HWTEST_F(JsAccessibilityManagerTest, JsAccessibilityManager013, TestSize.Level1)
577 {
578 /**
579 * @tc.steps: step1. construct JsAccessibilityManager
580 */
581 auto rootNode = FrameNode::CreateFrameNode(V2::WINDOW_SCENE_ETS_TAG,
582 ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<Pattern>(), true);
583 auto frameNode = FrameNode::CreateFrameNode("framenode", ElementRegister::GetInstance()->MakeUniqueId(),
584 AceType::MakeRefPtr<Pattern>(), false);
585 rootNode->AddChild(frameNode);
586 auto accessibilityProperty = frameNode->GetAccessibilityProperty<NG::AccessibilityProperty>();
587 accessibilityProperty->SetAccessibilityLevel("yes");
588 auto jsAccessibilityManager = AceType::MakeRefPtr<Framework::JsAccessibilityManager>();
589
590 /**
591 * @tc.steps: step2. test SendEventToAccessibilityWithNode
592 */
593 AccessibilityEvent accessibilityEvent;
594 auto context = NG::PipelineContext::GetCurrentContext();
595 EXPECT_EQ(jsAccessibilityManager->context_.Upgrade(), nullptr);
596 jsAccessibilityManager->SetPipelineContext(context);
597 EXPECT_NE(jsAccessibilityManager->context_.Upgrade(), nullptr);
598 jsAccessibilityManager->SendEventToAccessibilityWithNode(accessibilityEvent, frameNode, context);
599
600 /**
601 * @tc.steps: step2. test SendEventToAccessibilityWithNodeInner
602 */
603 jsAccessibilityManager->SendEventToAccessibilityWithNodeInner(accessibilityEvent, frameNode, context);
604 }
605
606 /**
607 * @tc.name: JsAccessibilityManager014
608 * @tc.desc: Test UIExtensionManager RegisterSubWindowInteractionOperation/CanAccessibilityFocused
609 * @tc.type: FUNC
610 */
611 HWTEST_F(JsAccessibilityManagerTest, JsAccessibilityManager014, TestSize.Level1)
612 {
613 /**
614 * @tc.steps: step1. construct JsAccessibilityManager
615 */
616 auto rootNode = FrameNode::CreateFrameNode(V2::WINDOW_SCENE_ETS_TAG,
617 ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<Pattern>(), true);
618 auto frameNode = FrameNode::CreateFrameNode("framenode", ElementRegister::GetInstance()->MakeUniqueId(),
619 AceType::MakeRefPtr<Pattern>(), false);
620 rootNode->AddChild(frameNode);
621 auto accessibilityProperty = frameNode->GetAccessibilityProperty<NG::AccessibilityProperty>();
622 accessibilityProperty->SetAccessibilityLevel("yes");
623 auto jsAccessibilityManager = AceType::MakeRefPtr<Framework::JsAccessibilityManager>();
624
625 /**
626 * @tc.steps: step2. test RegisterSubWindowInteractionOperation
627 */
628 jsAccessibilityManager->RegisterSubWindowInteractionOperation(0);
629
630 /**
631 * @tc.steps: step3. test CanAccessibilityFocused
632 */
633 auto node = jsAccessibilityManager->GetAccessibilityNodeFromPage(0);
634 EXPECT_FALSE(jsAccessibilityManager->CanAccessibilityFocused(node));
635 }
636
637 /**
638 * @tc.name: JsAccessibilityManager015
639 * @tc.desc: Test UIExtensionManager NeedRegisterChildTree
640 * @tc.type: FUNC
641 */
642 HWTEST_F(JsAccessibilityManagerTest, JsAccessibilityManager015, TestSize.Level1)
643 {
644 /**
645 * @tc.steps: step1. construct JsAccessibilityManager
646 */
647 auto jsAccessibilityManager = AceType::MakeRefPtr<Framework::JsAccessibilityManager>();
648
649 /**
650 * @tc.steps: step2. test NeedRegisterChildTree
651 */
652 uint32_t parentWindowId = 0;
653 int32_t parentTreeId = 0;
654 int64_t parentElementId = 0;
655 jsAccessibilityManager->parentWindowId_ = parentWindowId;
656 jsAccessibilityManager->parentTreeId_ = parentTreeId;
657 jsAccessibilityManager->parentElementId_ = parentElementId;
658 EXPECT_TRUE(jsAccessibilityManager->NeedRegisterChildTree(parentWindowId, parentTreeId, parentElementId));
659
660 jsAccessibilityManager->Register(true);
661 EXPECT_FALSE(jsAccessibilityManager->NeedRegisterChildTree(parentWindowId, parentTreeId, parentElementId));
662
663 jsAccessibilityManager->parentWindowId_ = 1;
664 EXPECT_TRUE(jsAccessibilityManager->NeedRegisterChildTree(parentWindowId, parentTreeId, parentElementId));
665 jsAccessibilityManager->parentTreeId_ = 1;
666 EXPECT_TRUE(jsAccessibilityManager->NeedRegisterChildTree(parentWindowId, parentTreeId, parentElementId));
667 jsAccessibilityManager->parentElementId_ = 1;
668 EXPECT_TRUE(jsAccessibilityManager->NeedRegisterChildTree(parentWindowId, parentTreeId, parentElementId));
669 }
670
671 /**
672 * @tc.name: JsAccessibilityManager016
673 * @tc.desc: Test UIExtensionManager OnDumpChildInfoForThird/CheckIsChildElement
674 * @tc.type: FUNC
675 */
676 HWTEST_F(JsAccessibilityManagerTest, JsAccessibilityManager016, TestSize.Level1)
677 {
678 /**
679 * @tc.steps: step1. construct JsAccessibilityManager
680 */
681 auto jsAccessibilityManager = AceType::MakeRefPtr<Framework::JsAccessibilityManager>();
682 std::vector<std::string> params = {};
683 std::vector<std::string> info = {};
684
685 /**
686 * @tc.steps: step2. test CheckIsChildElement
687 */
688 int64_t elementId = 0;
689 int64_t rootId = 0;
690 EXPECT_FALSE(
691 jsAccessibilityManager->CheckIsChildElement(elementId, params, info, Framework::DumpMode::TREE, rootId));
692 EXPECT_FALSE(
693 jsAccessibilityManager->CheckIsChildElement(elementId, params, info, Framework::DumpMode::NODE, rootId));
694 }
695
696 /**
697 * @tc.name: JsAccessibilityManager017
698 * @tc.desc: Test UIExtensionManager RegisterInteractionOperation
699 * @tc.type: FUNC
700 */
701 HWTEST_F(JsAccessibilityManagerTest, JsAccessibilityManager017, TestSize.Level1)
702 {
703 /**
704 * @tc.steps: step1. construct JsAccessibilityManager
705 */
706 auto rootNode = FrameNode::CreateFrameNode(V2::WINDOW_SCENE_ETS_TAG,
707 ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<Pattern>(), true);
708 auto frameNode = FrameNode::CreateFrameNode("framenode", ElementRegister::GetInstance()->MakeUniqueId(),
709 AceType::MakeRefPtr<Pattern>(), false);
710 rootNode->AddChild(frameNode);
711 auto accessibilityProperty = frameNode->GetAccessibilityProperty<NG::AccessibilityProperty>();
712 accessibilityProperty->SetAccessibilityLevel("yes");
713 auto jsAccessibilityManager = AceType::MakeRefPtr<Framework::JsAccessibilityManager>();
714 std::vector<std::string> params = {};
715 std::vector<std::string> info = {};
716
717 /**
718 * @tc.steps: step2. test RegisterInteractionOperation
719 */
720 auto ret = jsAccessibilityManager->RegisterInteractionOperation(0);
721 EXPECT_EQ(ret, false);
722 }
723
724 /**
725 * @tc.name: JsAccessibilityManager018
726 * @tc.desc: Test UIExtensionManager RegisterAccessibilityChildTreeCallback/DeregisterAccessibilityChildTreeCallback
727 * @tc.type: FUNC
728 */
729 HWTEST_F(JsAccessibilityManagerTest, JsAccessibilityManager018, TestSize.Level1)
730 {
731 /**
732 * @tc.steps: step1. construct JsAccessibilityManager
733 */
734 auto jsAccessibilityManager = AceType::MakeRefPtr<Framework::JsAccessibilityManager>();
735 EXPECT_EQ(0, jsAccessibilityManager->childTreeCallbackMap_.size());
736
737 /**
738 * @tc.steps: step2. test RegisterAccessibilityChildTreeCallback
739 */
740 int64_t elementId0 = 0;
741 auto callback0 = std::make_shared<MockAccessibilityChildTreeCallback>(0);
742 jsAccessibilityManager->RegisterAccessibilityChildTreeCallback(elementId0, callback0);
743 EXPECT_EQ(1, jsAccessibilityManager->childTreeCallbackMap_.size());
744 EXPECT_EQ(callback0, jsAccessibilityManager->childTreeCallbackMap_[elementId0]);
745 int64_t elementId1 = 1;
746 auto callback1 = std::make_shared<MockAccessibilityChildTreeCallback>(1);
747 jsAccessibilityManager->RegisterAccessibilityChildTreeCallback(elementId1, callback1);
748 EXPECT_EQ(2, jsAccessibilityManager->childTreeCallbackMap_.size());
749 EXPECT_EQ(callback1, jsAccessibilityManager->childTreeCallbackMap_[elementId1]);
750
751 /**
752 * @tc.steps: step3. test DeregisterAccessibilityChildTreeCallback
753 */
754 jsAccessibilityManager->DeregisterAccessibilityChildTreeCallback(elementId1);
755 EXPECT_EQ(1, jsAccessibilityManager->childTreeCallbackMap_.size());
756 EXPECT_EQ(callback0, jsAccessibilityManager->childTreeCallbackMap_[elementId0]);
757 jsAccessibilityManager->DeregisterAccessibilityChildTreeCallback(elementId0);
758 EXPECT_EQ(0, jsAccessibilityManager->childTreeCallbackMap_.size());
759 }
760
761 /**
762 * @tc.name: JsAccessibilityManager019
763 * @tc.desc: Test UIExtensionManager RegisterAccessibilitySAObserverCallback/DeregisterAccessibilitySAObserverCallback
764 * @tc.type: FUNC
765 */
766 HWTEST_F(JsAccessibilityManagerTest, JsAccessibilityManager019, TestSize.Level1)
767 {
768 /**
769 * @tc.steps: step1. construct JsAccessibilityManager
770 */
771 auto jsAccessibilityManager = AceType::MakeRefPtr<Framework::JsAccessibilityManager>();
772 EXPECT_EQ(0, jsAccessibilityManager->componentSACallbackMap_.size());
773
774 /**
775 * @tc.steps: step2. test RegisterAccessibilitySAObserverCallback
776 */
777 int64_t elementId0 = 0;
778 auto callback0 = std::make_shared<MockAccessibilitySAObserverCallback>(0);
779 jsAccessibilityManager->RegisterAccessibilitySAObserverCallback(elementId0, callback0);
780 EXPECT_EQ(1, jsAccessibilityManager->componentSACallbackMap_.size());
781 EXPECT_EQ(callback0, jsAccessibilityManager->componentSACallbackMap_[elementId0]);
782 int64_t elementId1 = 1;
783 auto callback1 = std::make_shared<MockAccessibilitySAObserverCallback>(1);
784 jsAccessibilityManager->RegisterAccessibilitySAObserverCallback(elementId1, callback1);
785 EXPECT_EQ(2, jsAccessibilityManager->componentSACallbackMap_.size());
786 EXPECT_EQ(callback1, jsAccessibilityManager->componentSACallbackMap_[elementId1]);
787
788 /**
789 * @tc.steps: step3. test DeregisterAccessibilitySAObserverCallback
790 */
791 jsAccessibilityManager->DeregisterAccessibilitySAObserverCallback(elementId1);
792 EXPECT_EQ(1, jsAccessibilityManager->componentSACallbackMap_.size());
793 EXPECT_EQ(callback0, jsAccessibilityManager->componentSACallbackMap_[elementId0]);
794 jsAccessibilityManager->DeregisterAccessibilitySAObserverCallback(elementId0);
795 EXPECT_EQ(0, jsAccessibilityManager->componentSACallbackMap_.size());
796 }
797 /**
798 * @tc.name: UpdateWindowInfo001
799 * @tc.desc: UpdateWindowInfo
800 * @tc.type: FUNC
801 */
802 HWTEST_F(JsAccessibilityManagerTest, UpdateWindowInfo001, TestSize.Level1)
803 {
804 /**
805 * @tc.steps: step1. construct jsAccessibilityManager
806 */
807 auto jsAccessibilityManager = AceType::MakeRefPtr<Framework::JsAccessibilityManager>();
808 ASSERT_NE(jsAccessibilityManager, nullptr);
809 auto pipelineContext = MockContainer::Current()->GetPipelineContext();
810 ASSERT_NE(pipelineContext, nullptr);
811 jsAccessibilityManager->context_ = pipelineContext;
812
813 /**
814 * @tc.steps: step2. construct windowInfo
815 */
816 AccessibilityWindowInfo windowInfo;
817 windowInfo.left = 10;
818 windowInfo.top = 10;
819 windowInfo.scaleX = 1.0f;
820 windowInfo.scaleY = 1.0f;
821
822 /**
823 * @tc.steps: step3. call and test UpdateWindowInfo method
824 */
825 jsAccessibilityManager->UpdateWindowInfo(windowInfo, pipelineContext);
826 EXPECT_EQ(windowInfo.left, 10);
827 EXPECT_EQ(windowInfo.top, 10);
828 EXPECT_EQ(windowInfo.scaleX, 1.0f);
829 EXPECT_EQ(windowInfo.scaleY, 1.0f);
830
831 auto container = Platform::AceContainer::GetContainer(pipelineContext->GetInstanceId());
832 ASSERT_NE(container, nullptr);
833 container->SetSingleHandTransform(Platform::SingleHandTransform(100.0f, 200.0f, 0.7f, 0.6f));
834
835 jsAccessibilityManager->UpdateWindowInfo(windowInfo, pipelineContext);
836 EXPECT_EQ(windowInfo.left, 107.0f);
837 EXPECT_EQ(windowInfo.top, 206.0f);
838 EXPECT_EQ(windowInfo.scaleX, 0.7f);
839 EXPECT_EQ(windowInfo.scaleY, 0.6f);
840 }
841
842 /**
843 * @tc.name: GenerateWindowInfo001
844 * @tc.desc: GenerateWindowInfo
845 * @tc.type: FUNC
846 */
847 HWTEST_F(JsAccessibilityManagerTest, GenerateWindowInfo001, TestSize.Level1)
848 {
849 /**
850 * @tc.steps: step1. construct jsAccessibilityManager
851 */
852 auto jsAccessibilityManager = AceType::MakeRefPtr<Framework::JsAccessibilityManager>();
853 ASSERT_NE(jsAccessibilityManager, nullptr);
854
855 /**
856 * @tc.steps: step3. call and test GenerateWindowInfo method
857 */
858 auto windowInfo = jsAccessibilityManager->GenerateWindowInfo(nullptr, nullptr);
859 EXPECT_EQ(windowInfo.left, 0);
860 EXPECT_EQ(windowInfo.top, 0);
861 EXPECT_EQ(windowInfo.scaleX, 1.0f);
862 EXPECT_EQ(windowInfo.scaleY, 1.0f);
863
864 auto frameNode = FrameNode::CreateFrameNode("framenode", ElementRegister::GetInstance()->MakeUniqueId(),
865 AceType::MakeRefPtr<Pattern>(), false);
866 windowInfo = jsAccessibilityManager->GenerateWindowInfo(frameNode, nullptr);
867
868 auto pipelineContext = MockContainer::Current()->GetPipelineContext();
869 ASSERT_NE(pipelineContext, nullptr);
870 jsAccessibilityManager->context_ = pipelineContext;
871 auto container = Platform::AceContainer::GetContainer(pipelineContext->GetInstanceId());
872 ASSERT_NE(container, nullptr);
873 auto singleHandTransform = container->GetSingleHandTransform();
874 container->SetSingleHandTransform(Platform::SingleHandTransform(0.0f, 0.0f, 1.0f, 1.0f));
875
876 auto context = NG::PipelineContext::GetCurrentContext();
877 ASSERT_NE(context, nullptr);
878 jsAccessibilityManager->getParentRectHandler_ = nullptr;
879 jsAccessibilityManager->getParentRectHandlerNew_ = nullptr;
880 windowInfo = jsAccessibilityManager->GenerateWindowInfo(nullptr, context);
881
882 EXPECT_EQ(windowInfo.left, 0);
883 EXPECT_EQ(windowInfo.top, 0);
884 EXPECT_EQ(windowInfo.scaleX, 1.0f);
885 EXPECT_EQ(windowInfo.scaleY, 1.0f);
886
887 /**
888 * @tc.steps: step4. mock SingleHandTransform, and then test GenerateWindowInfo method again
889 */
890 container->SetSingleHandTransform(Platform::SingleHandTransform(100.0f, 200.0f, 0.7f, 0.7f));
891
892 jsAccessibilityManager->UpdateWindowInfo(windowInfo, pipelineContext);
893 EXPECT_EQ(windowInfo.left, 100.0f);
894 EXPECT_EQ(windowInfo.top, 200.0f);
895 EXPECT_EQ(windowInfo.scaleX, 0.7f);
896 EXPECT_EQ(windowInfo.scaleY, 0.7f);
897 }
898
899 /**
900 * @tc.name: SingleHandTransformTest001
901 * @tc.desc: SetSingleHandTransform & GetSingleHandTransform
902 * @tc.type: FUNC
903 */
904 HWTEST_F(JsAccessibilityManagerTest, SingleHandTransformTest001, TestSize.Level1)
905 {
906 /**
907 * @tc.steps: step1. construct AceContainer
908 */
909 auto pipelineContext = MockContainer::Current()->GetPipelineContext();
910 ASSERT_NE(pipelineContext, nullptr);
911 auto container = Platform::AceContainer::GetContainer(pipelineContext->GetInstanceId());
912 ASSERT_NE(container, nullptr);
913
914 /**
915 * @tc.steps: step2. test SetSingleHandTransform & GetSingleHandTransform
916 */
917 container->SetSingleHandTransform(Platform::SingleHandTransform(100.0f, 200.0f, 0.7f, 0.6f));
918 auto singleHandTransform = container->GetSingleHandTransform();
919 EXPECT_EQ(singleHandTransform.x_, 100.0f);
920 EXPECT_EQ(singleHandTransform.y_, 200.0f);
921 EXPECT_EQ(singleHandTransform.scaleX_, 0.7f);
922 EXPECT_EQ(singleHandTransform.scaleY_, 0.6f);
923 }
924
925 /**
926 * @tc.name: JsAccessibilityManager020
927 * @tc.desc: dump event test DumpProcessEventParameters
928 * @tc.type: FUNC
929 */
930 HWTEST_F(JsAccessibilityManagerTest, JsAccessibilityManager020, TestSize.Level1)
931 {
932 auto frameNode = FrameNode::CreateFrameNode("framenode", 1, AceType::MakeRefPtr<Pattern>(), true);
933 auto jsAccessibilityManager = AceType::MakeRefPtr<Framework::JsAccessibilityManager>();
934 auto context = NG::PipelineContext::GetCurrentContext();
935 jsAccessibilityManager->SetPipelineContext(context);
936 jsAccessibilityManager->Register(true);
937 bool ret;
938 AccessibilityEvent accessibilityEvent;
939 accessibilityEvent.nodeId = 1;
940 accessibilityEvent.windowChangeTypes = WindowUpdateType::WINDOW_UPDATE_ACTIVE;
941 accessibilityEvent.type = AccessibilityEventType::PAGE_CHANGE;
942 // 1. parameter stackNodeId
943 std::vector<std::string> params;
944 params.push_back("-inspector");
945 params.push_back("1");
946
947 params.push_back("--stackNodeId");
948
949 ret = jsAccessibilityManager->DumpProcessEventParameters(accessibilityEvent, params);
950 EXPECT_EQ(ret, false);
951
952 int64_t testStackId = 2;
953 params.push_back(std::to_string(testStackId));
954 ret = jsAccessibilityManager->DumpProcessEventParameters(accessibilityEvent, params);
955 EXPECT_EQ(ret, true);
956 EXPECT_EQ(accessibilityEvent.stackNodeId, testStackId);
957
958 // 2. parameter beforeText
959 params.push_back("--beforeText");
960 ret = jsAccessibilityManager->DumpProcessEventParameters(accessibilityEvent, params);
961 EXPECT_EQ(ret, false);
962
963 std::string beforeText = "teststr1";
964 params.push_back(beforeText);
965 ret = jsAccessibilityManager->DumpProcessEventParameters(accessibilityEvent, params);
966 EXPECT_EQ(ret, true);
967 EXPECT_EQ(accessibilityEvent.beforeText, beforeText);
968 }
969
970 /**
971 * @tc.name: JsAccessibilityManager020
972 * @tc.desc: dump event test DumpProcessEventParameters
973 * @tc.type: FUNC
974 */
975 HWTEST_F(JsAccessibilityManagerTest, JsAccessibilityManager0201, TestSize.Level1)
976 {
977 auto frameNode = FrameNode::CreateFrameNode("framenode", 1, AceType::MakeRefPtr<Pattern>(), true);
978 auto jsAccessibilityManager = AceType::MakeRefPtr<Framework::JsAccessibilityManager>();
979 auto context = NG::PipelineContext::GetCurrentContext();
980 jsAccessibilityManager->SetPipelineContext(context);
981 jsAccessibilityManager->Register(true);
982 bool ret;
983 AccessibilityEvent accessibilityEvent;
984 accessibilityEvent.nodeId = 1;
985 accessibilityEvent.windowChangeTypes = WindowUpdateType::WINDOW_UPDATE_ACTIVE;
986 accessibilityEvent.type = AccessibilityEventType::PAGE_CHANGE;
987 std::vector<std::string> params;
988 params.push_back("-inspector");
989 params.push_back("1");
990
991 // 3. parameter latestContent
992 params.push_back("--latestContent");
993 ret = jsAccessibilityManager->DumpProcessEventParameters(accessibilityEvent, params);
994 EXPECT_EQ(ret, false);
995
996 std::string latestContent = "teststr2";
997 params.push_back(latestContent);
998 ret = jsAccessibilityManager->DumpProcessEventParameters(accessibilityEvent, params);
999 EXPECT_EQ(ret, true);
1000 EXPECT_EQ(accessibilityEvent.latestContent, latestContent);
1001
1002 // 4. parameter latestContent
1003 params.push_back("--textAnnounced");
1004 ret = jsAccessibilityManager->DumpProcessEventParameters(accessibilityEvent, params);
1005 EXPECT_EQ(ret, false);
1006
1007 std::string textAnnounced = "teststr3";
1008 params.push_back(textAnnounced);
1009 ret = jsAccessibilityManager->DumpProcessEventParameters(accessibilityEvent, params);
1010 EXPECT_EQ(ret, true);
1011 EXPECT_EQ(accessibilityEvent.textAnnouncedForAccessibility, textAnnounced);
1012 }
1013
1014 /**
1015 * @tc.name: JsAccessibilityManager021
1016 * @tc.desc: dump event test DumpProcessEventParameters
1017 * @tc.type: FUNC
1018 */
1019 HWTEST_F(JsAccessibilityManagerTest, JsAccessibilityManager021, TestSize.Level1)
1020 {
1021 auto frameNode = FrameNode::CreateFrameNode("framenode", 1, AceType::MakeRefPtr<Pattern>(), true);
1022 auto context = NG::PipelineContext::GetCurrentContext();
1023
1024 MockJsAccessibilityManager mockJsManger;
1025 mockJsManger.SetPipelineContext(context);
1026 mockJsManger.Register(true);
1027
1028 int64_t nodeId = 1;
1029 int32_t eventId = 2;
1030 // 1. check parameter fail
1031 std::vector<std::string> params;
1032 params.push_back("-inspector");
1033 params.push_back("1");
1034 params.push_back("--stackNodeId");
1035 EXPECT_CALL(mockJsManger, SendEventToAccessibilityWithNode(_, _, _))
1036 .Times(0);
1037
1038 mockJsManger.DumpSendEventTest(nodeId, eventId, params);
1039
1040 // 2. check parameter success
1041 int64_t testStackId = 2;
1042 params.push_back(std::to_string(testStackId));
1043
1044 EXPECT_CALL(mockJsManger, SendEventToAccessibilityWithNode(_, _, _))
1045 .Times(1);
1046
1047 mockJsManger.DumpSendEventTest(nodeId, eventId, params);
1048 }
1049
1050 /**
1051 * @tc.name: JsAccessibilityManager022
1052 * @tc.desc: dump event test OnDumpInfoNG
1053 * @tc.type: FUNC
1054 */
1055 HWTEST_F(JsAccessibilityManagerTest, JsAccessibilityManager022, TestSize.Level1)
1056 {
1057 auto frameNode = FrameNode::CreateFrameNode("framenode", 1, AceType::MakeRefPtr<Pattern>(), true);
1058 auto context = NG::PipelineContext::GetCurrentContext();
1059 MockJsAccessibilityManager mockJsManger;
1060 mockJsManger.SetPipelineContext(context);
1061 mockJsManger.Register(true);
1062
1063 std::vector<std::string> params;
1064
1065 // 1. dump event
1066 params.push_back("-inspector");
1067 params.push_back("--event-test");
1068 params.push_back("1");
1069 params.push_back("2");
1070
1071 EXPECT_CALL(mockJsManger, SendEventToAccessibilityWithNode(_, _, _))
1072 .Times(1);
1073 mockJsManger.OnDumpInfoNG(params, 1, false);
1074 }
1075
1076 /**
1077 * @tc.name: JsAccessibilityManager023
1078 * @tc.desc: UpdateAccessibilityElementInfo ScrollTriggerable
1079 * @tc.type: FUNC
1080 */
1081 HWTEST_F(JsAccessibilityManagerTest, JsAccessibilityManager023, TestSize.Level1)
1082 {
1083 /**
1084 * @tc.steps: step1. construct JsAccessibilityManager
1085 * @tc.desc: Create a FrameNode object and initialize the JsAccessibilityManager object.
1086 */
1087 auto frameNode = FrameNode::CreateFrameNode("framenode", 1, AceType::MakeRefPtr<Pattern>(), true);
1088 CHECK_NULL_VOID(frameNode);
1089 auto jsAccessibilityManager = AceType::MakeRefPtr<Framework::JsAccessibilityManager>();
1090 Accessibility::AccessibilityElementInfo nodeInfo;
1091
1092 // Update information in nodeInfo and verify that its default scrollable is true
1093 jsAccessibilityManager->UpdateAccessibilityElementInfo(frameNode, nodeInfo);
1094 CHECK_NULL_VOID(jsAccessibilityManager);
1095 EXPECT_EQ(nodeInfo.GetAccessibilityScrollable(), true);
1096
1097 /**
1098 * @tc.steps: step2. Initialize accessibilityProperty and set ScrollTriggerable to false.
1099 * @tc.expected: The updated nodeInfo's ScrollTriggerable property should be false.
1100 */
1101 auto accessibilityProperty = frameNode->GetAccessibilityProperty<NG::AccessibilityProperty>();
1102 CHECK_NULL_VOID(accessibilityProperty);
1103 accessibilityProperty->SetUserScrollTriggerable(false);
1104 jsAccessibilityManager->UpdateAccessibilityElementInfo(frameNode, nodeInfo);
1105 EXPECT_EQ(nodeInfo.GetAccessibilityScrollable(), false);
1106
1107 /**
1108 * @tc.steps: step3. Reset the ScrollTriggerable property of accessibilityProperty.
1109 * @tc.expected: The updated nodeInfo's ScrollTriggerable property should be true.
1110 */
1111 accessibilityProperty->ResetUserScrollTriggerable();
1112 jsAccessibilityManager->UpdateAccessibilityElementInfo(frameNode, nodeInfo);
1113 EXPECT_EQ(nodeInfo.GetAccessibilityScrollable(), true);
1114 }
1115
1116 class MockRenderContextTest : public RenderContext {
1117 public:
GetPaintRectWithoutTransform()1118 RectF GetPaintRectWithoutTransform() override
1119 {
1120 return *retf;
1121 }
1122 std::shared_ptr<RectF> retf;
1123 };
1124
1125 /**
1126 * @tc.name: FrameNodeAccessibilityVisible02
1127 * @tc.desc: Test the function accessibilityVisible
1128 * @tc.type: FUNC
1129 */
1130 HWTEST_F(JsAccessibilityManagerTest, FrameNodeAccessibilityVisible02, TestSize.Level1)
1131 {
1132 /**
1133 * @tc.steps: step1. create parent frameNode and set up its rect.
1134 */
1135 auto frameNode = FrameNode::CreateFrameNode("framenode", 1, AceType::MakeRefPtr<Pattern>(), true);
1136 CHECK_NULL_VOID(frameNode);
1137 EXPECT_NE(frameNode->pattern_, nullptr);
1138 frameNode->isActive_ = true;
1139 auto pipeline = frameNode->GetContext();
1140
1141 auto parentRender = AceType::MakeRefPtr<MockRenderContextTest>();
1142 CHECK_NULL_VOID(parentRender);
1143 auto parentRec = std::make_shared<RectF>(10.0, 10.0, 10.0, 5.0);
1144 parentRender->retf = parentRec;
1145 frameNode->renderContext_ = parentRender;
1146
1147 /**
1148 * @tc.steps: step2. create child frameNode and set up its rect.
1149 */
1150 auto childNode = FrameNode::CreateFrameNode(
1151 "child", ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<Pattern>());
1152 childNode->isActive_ = true;
1153 auto childRender = AceType::MakeRefPtr<MockRenderContextTest>();
1154 CHECK_NULL_VOID(childRender);
1155 auto childRec = std::make_shared<RectF>(10.0, 10.0, 10.0, 10.0);
1156 childRender->retf = childRec;
1157 childNode->renderContext_ = childRender;
1158
1159 /**
1160 * @tc.steps: step3. add parent and child node to the pipeline context.
1161 */
1162 auto context = NG::PipelineContext::GetCurrentContext();
1163 context->GetRootElement()->AddChild(frameNode);
1164 frameNode->AddChild(childNode);
1165
1166 /**
1167 * @tc.steps: step4. verify the child node's accessibilityVisible is true.
1168 */
1169 auto jsAccessibilityManager = AceType::MakeRefPtr<Framework::JsAccessibilityManager>();
1170 CHECK_NULL_VOID(jsAccessibilityManager);
1171 jsAccessibilityManager->SetPipelineContext(context);
1172 jsAccessibilityManager->Register(true);
1173 RefPtr<NG::PipelineContext> ngPipeline;
1174 ngPipeline = AceType::DynamicCast<NG::PipelineContext>(pipeline);
1175 std::list<AccessibilityElementInfo> extensionElementInfos;
1176 jsAccessibilityManager->SearchElementInfoByAccessibilityIdNG(
1177 childNode->GetAccessibilityId(), 1, extensionElementInfos, ngPipeline, 1);
1178 for (auto& extensionElementInfo : extensionElementInfos) {
1179 if (childNode->GetAccessibilityId() == extensionElementInfo.GetAccessibilityId()) {
1180 EXPECT_TRUE(extensionElementInfo.GetAccessibilityVisible());
1181 }
1182 }
1183 }
1184
1185 /**
1186 * @tc.name: JsAccessibilityManager024
1187 * @tc.desc: RegisterGetParentRectHandler
1188 * @tc.type: FUNC
1189 */
1190 HWTEST_F(JsAccessibilityManagerTest, JsAccessibilityManager024, TestSize.Level1)
1191 {
1192 /**
1193 * @tc.steps: step1. construct JsAccessibilityManager
1194 */
1195 auto jsAccessibilityManager = AceType::MakeRefPtr<Framework::JsAccessibilityManager>();
1196 ASSERT_NE(jsAccessibilityManager, nullptr);
1197 /**
1198 * @tc.steps: step2. test RegisterGetParentRectHandler
1199 */
1200 jsAccessibilityManager->uecRectInfo_.isChanged = false;
1201 jsAccessibilityManager->RegisterGetParentRectHandler();
1202 EXPECT_NE(jsAccessibilityManager->getParentRectHandlerNew_, nullptr);
1203 }
1204
1205 /**
1206 * @tc.name: JsAccessibilityManager025
1207 * @tc.desc: GetTransformRectInfoRelativeToWindow
1208 * @tc.type: FUNC
1209 */
1210 HWTEST_F(JsAccessibilityManagerTest, JsAccessibilityManager025, TestSize.Level1)
1211 {
1212 /**
1213 * @tc.steps: step1. construct JsAccessibilityManager
1214 */
1215 auto jsAccessibilityManager = AceType::MakeRefPtr<Framework::JsAccessibilityManager>();
1216 auto context = NG::PipelineContext::GetCurrentContext();
1217 jsAccessibilityManager->SetPipelineContext(context);
1218 ASSERT_NE(jsAccessibilityManager, nullptr);
1219 auto frameNode = FrameNode::CreateFrameNode(
1220 "frameNode", ElementRegister::GetInstance()->MakeUniqueId(), AceType::MakeRefPtr<Pattern>());
1221 ASSERT_NE(frameNode, nullptr);
1222 /**
1223 * @tc.steps: step2. test GetTransformRectInfoRelativeToWindow
1224 */
1225 auto rectInfo = jsAccessibilityManager->GetTransformRectInfoRelativeToWindow(frameNode, context);
1226 EXPECT_EQ(rectInfo.left, 100);
1227 EXPECT_EQ(rectInfo.top, 200);
1228 }
1229 } // namespace OHOS::Ace::NG