• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2023 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 <string>
17 
18 #include "gtest/gtest.h"
19 
20 #define private public
21 #define protected public
22 #include "core/components_ng/base/frame_node.h"
23 #include "core/components_ng/base/ui_node.h"
24 #include "core/components_ng/base/view_stack_processor.h"
25 #include "core/components_ng/event/long_press_event.h"
26 #include "core/components_ng/pattern/button/button_pattern.h"
27 #include "core/components_ng/pattern/linear_layout/column_model.h"
28 #include "core/components_ng/pattern/linear_layout/column_model_ng.h"
29 #include "core/components_ng/pattern/linear_layout/linear_layout_pattern.h"
30 #include "core/components_ng/pattern/pattern.h"
31 #include "core/components_ng/pattern/text/span_node.h"
32 #include "core/components_ng/property/accessibility_property.h"
33 #include "core/components_v2/inspector/inspector_constants.h"
34 #include "core/components_ng/base/view_abstract_model_ng.h"
35 
36 using namespace testing;
37 using namespace testing::ext;
38 
39 namespace OHOS::Ace::NG {
40 namespace {
41 const InspectorFilter filter;
42 const size_t ARRAY_SIZE = 1;
43 const OffsetF OFFSETF { 1.0, 1.0 };
44 } // namespace
45 
46 class MockPattern : public Pattern {
47 public:
48     MockPattern() = default;
49     ~MockPattern() override = default;
50 };
51 class AccessibilityPropertyTestNg : public testing::Test {
52 public:
SetUpTestCase()53     static void SetUpTestCase() {};
TearDownTestCase()54     static void TearDownTestCase() {};
55 };
56 
57 /**
58  * @tc.name: AccessibilityPropertyTest001
59  * @tc.desc: Set show value into supportActions_ and get SupportAction length.
60  * @tc.type: FUNC
61  */
62 HWTEST_F(AccessibilityPropertyTestNg, AccessibilityPropertyTest001, TestSize.Level1)
63 {
64     /**
65      * @tc.steps: step1. supportActions_ Use default values
66      * @tc.expected: Make the array length returned by the GetSupportAction function 0
67      */
68     AccessibilityProperty props;
69     auto actions = props.GetSupportAction();
70     EXPECT_EQ(actions.size(), 0);
71 
72     /**
73      * @tc.steps: step2. supportActions_ = AceAction::ACTION_SCROLL_FORWARD
74      * @tc.expected: Make the array length returned by the GetSupportAction function 1
75      */
76     props.supportActions_ = static_cast<uint32_t>(AceAction::ACTION_SCROLL_FORWARD);
77     actions = props.GetSupportAction();
78     EXPECT_EQ(actions.size(), ARRAY_SIZE);
79 
80     /**
81      * @tc.steps: step3. supportActions_ = AceAction::ACTION_PREVIOUS_AT_MOVEMENT_GRANULARITY
82      * @tc.expected: Make the array length returned by the GetSupportAction function 1
83      */
84     props.supportActions_ = static_cast<uint32_t>(AceAction::ACTION_PREVIOUS_AT_MOVEMENT_GRANULARITY);
85     actions = props.GetSupportAction();
86     EXPECT_EQ(actions.size(), 2);
87 
88     /**
89      * @tc.steps: step4. supportActions_ = AceAction::ACTION_SET_TEXT
90      * @tc.expected: Make the array length returned by the GetSupportAction function 1
91      */
92     props.supportActions_ = static_cast<uint32_t>(AceAction::ACTION_SET_TEXT);
93     actions = props.GetSupportAction();
94     EXPECT_EQ(actions.size(), ARRAY_SIZE);
95 
96     /**
97      * @tc.steps: step5. supportActions_ = AceAction::ACTION_COPY
98      * @tc.expected: Make the array length returned by the GetSupportAction function 1
99      */
100     props.supportActions_ = static_cast<uint32_t>(AceAction::ACTION_COPY);
101     actions = props.GetSupportAction();
102     EXPECT_EQ(actions.size(), 2);
103 
104     /**
105      * @tc.steps: step6. supportActions_ = AceAction::ACTION_PASTE
106      * @tc.expected: Make the array length returned by the GetSupportAction function 1
107      */
108     props.supportActions_ = static_cast<uint32_t>(AceAction::ACTION_PASTE);
109     actions = props.GetSupportAction();
110     EXPECT_EQ(actions.size(), 2);
111 
112     /**
113      * @tc.steps: step7. supportActions_ = AceAction::ACTION_CUT
114      * @tc.expected: Make the array length returned by the GetSupportAction function 1
115      */
116     props.supportActions_ = static_cast<uint32_t>(AceAction::ACTION_CUT);
117     actions = props.GetSupportAction();
118     EXPECT_EQ(actions.size(), 3);
119 
120     /**
121      * @tc.steps: step8. supportActions_ = AceAction::ACTION_SELECT
122      * @tc.expected: Make the array length returned by the GetSupportAction function 1
123      */
124     props.supportActions_ = static_cast<uint32_t>(AceAction::ACTION_SELECT);
125     actions = props.GetSupportAction();
126     EXPECT_EQ(actions.size(), 0);
127 
128     /**
129      * @tc.steps: step9. supportActions_ = AceAction::ACTION_SELECT
130      * @tc.expected: Make the array length returned by the GetSupportAction function 1
131      */
132     props.supportActions_ = static_cast<uint32_t>(AceAction::ACTION_SET_SELECTION);
133     actions = props.GetSupportAction();
134     EXPECT_EQ(actions.size(), 1);
135 
136     /**
137      * @tc.steps: step10. supportActions_ = AceAction::ACTION_CLEAR_SELECTION
138      * @tc.expected: Make the array length returned by the GetSupportAction function 1
139      */
140     props.supportActions_ = static_cast<uint32_t>(AceAction::ACTION_CLEAR_SELECTION);
141     actions = props.GetSupportAction();
142     EXPECT_EQ(actions.size(), 1);
143 }
144 
145 /**
146  * @tc.name: AccessibilityPropertyTest002
147  * @tc.desc: Set action and execute it.
148  * @tc.type: FUNC
149  */
150 HWTEST_F(AccessibilityPropertyTestNg, AccessibilityPropertyTest002, TestSize.Level1)
151 {
152     /**
153      * @tc.steps: step1. actions is empty
154      * @tc.expected: act every action return false
155      */
156     AccessibilityProperty props;
157     EXPECT_FALSE(props.ActActionClearSelection());
158     EXPECT_FALSE(props.ActActionCopy());
159     EXPECT_FALSE(props.ActActionCut());
160     EXPECT_FALSE(props.ActActionMoveText(1, true));
161     EXPECT_FALSE(props.ActActionPaste());
162     EXPECT_FALSE(props.ActActionScrollBackward());
163     EXPECT_FALSE(props.ActActionScrollForward());
164     EXPECT_FALSE(props.ActActionSelect());
165     EXPECT_FALSE(props.ActActionSetSelection(0, 1));
166     EXPECT_FALSE(props.ActActionSetText("abc"));
167 
168     /**
169      * @tc.steps: step2. Set action functions
170      * @tc.expected: act every action return true
171      */
__anon6b1023a30202() 172     props.SetActionClearSelection([]() {});
173     EXPECT_TRUE(props.ActActionClearSelection());
__anon6b1023a30302() 174     props.SetActionCopy([]() {});
175     EXPECT_TRUE(props.ActActionCopy());
__anon6b1023a30402() 176     props.SetActionCut([]() {});
177     EXPECT_TRUE(props.ActActionCut());
__anon6b1023a30502(int32_t moveUnit, bool forward) 178     props.SetActionMoveText([](int32_t moveUnit, bool forward) {});
179     EXPECT_TRUE(props.ActActionMoveText(1, true));
__anon6b1023a30602() 180     props.SetActionPaste([]() {});
181     EXPECT_TRUE(props.ActActionPaste());
__anon6b1023a30702() 182     props.SetActionScrollBackward([]() {});
183     EXPECT_TRUE(props.ActActionScrollBackward());
__anon6b1023a30802() 184     props.SetActionScrollForward([]() {});
185     EXPECT_TRUE(props.ActActionScrollForward());
__anon6b1023a30902() 186     props.SetActionSelect([]() {});
187     EXPECT_TRUE(props.ActActionSelect());
__anon6b1023a30a02(int32_t start, int32_t end, bool isforward) 188     props.SetActionSetSelection([](int32_t start, int32_t end, bool isforward) {});
189     EXPECT_TRUE(props.ActActionSetSelection(0, 1));
__anon6b1023a30b02(std::string text) 190     props.SetActionSetText([](std::string text) {});
191     EXPECT_TRUE(props.ActActionSetText("abc"));
192 }
193 
194 /**
195  * @tc.name: AccessibilityPropertyTest003
196  * @tc.desc: Set and get accessibility property.
197  * @tc.type: FUNC
198  */
199 HWTEST_F(AccessibilityPropertyTestNg, AccessibilityPropertyTest003, TestSize.Level1)
200 {
201     /**
202      * @tc.steps: step1. Set accessibility property value
203      * @tc.expected: Get default property value
204      */
205     AccessibilityProperty props;
206     props.SetText("test");
207     EXPECT_EQ(props.GetText(), "test");
208     auto json = std::make_unique<JsonValue>();
209     props.ToJsonValue(json, filter);
210     EXPECT_FALSE(json->GetBool("scrollable", false));
211     EXPECT_FALSE(props.IsCheckable());
212     EXPECT_FALSE(props.IsChecked());
213     EXPECT_FALSE(props.IsSelected());
214     EXPECT_FALSE(props.IsPassword());
215     EXPECT_FALSE(props.IsEditable());
216     EXPECT_FALSE(props.IsMultiLine());
217     EXPECT_FALSE(props.IsDeletable());
218 
219     EXPECT_FALSE(props.IsHint());
220     EXPECT_FALSE(props.IsScrollable());
221     EXPECT_EQ(props.GetCurrentIndex(), -1);
222     EXPECT_EQ(props.GetBeginIndex(), -1);
223     EXPECT_EQ(props.GetEndIndex(), -1);
224     EXPECT_FALSE(props.HasRange());
225     EXPECT_EQ(props.GetAccessibilityValue().min, 0.0);
226     EXPECT_EQ(props.GetAccessibilityValue().current, 0.0);
227     EXPECT_EQ(props.GetAccessibilityValue().max, 0.0);
228     EXPECT_EQ(props.GetHintText(), "");
229     EXPECT_EQ(props.GetTextLengthLimit(), -1);
230     EXPECT_EQ(props.GetCollectionInfo().columns, 0);
231     EXPECT_EQ(props.GetCollectionInfo().rows, 0);
232     EXPECT_EQ(props.GetCollectionInfo().selectMode, 0);
233     EXPECT_EQ(props.GetCollectionItemInfo().column, 0);
234     EXPECT_EQ(props.GetCollectionItemInfo().columnSpan, 0);
235     EXPECT_EQ(props.GetCollectionItemInfo().row, 0);
236     EXPECT_EQ(props.GetCollectionItemInfo().rowSpan, 0);
237     EXPECT_FALSE(props.GetCollectionItemInfo().heading);
238     EXPECT_EQ(props.GetErrorText(), "");
239     EXPECT_EQ(props.GetTextSelectionStart(), 0);
240     EXPECT_EQ(props.GetTextSelectionEnd(), 0);
241     EXPECT_EQ(props.GetTextInputType(), AceTextCategory::INPUT_TYPE_DEFAULT);
242     EXPECT_EQ(props.GetCollectionItemCounts(), 0);
243     EXPECT_TRUE(props.GetContentInvalid());
244     props.ResetSupportAction();
245     auto actions = props.GetSupportAction();
246     EXPECT_EQ(actions.size(), 0);
247 }
248 
249 /**
250  * @tc.name: AccessibilityPropertyTest004
251  * @tc.desc: Set show value into supportActions_ and get SupportAction length.
252  * @tc.type: FUNC
253  */
254 HWTEST_F(AccessibilityPropertyTestNg, AccessibilityPropertyTest004, TestSize.Level1)
255 {
256     /**
257      * @tc.steps: step1. supportActions_ Use default values
258      * @tc.expected: Make the array length returned by the GetSupportAction function 0
259      */
260     auto columnFrameNode1 = FrameNode::GetOrCreateFrameNode(
__anon6b1023a30c02() 261         V2::COLUMN_ETS_TAG, 0, []() { return AceType::MakeRefPtr<LinearLayoutPattern>(true); });
262     auto columnFrameNode2 = FrameNode::GetOrCreateFrameNode(
__anon6b1023a30d02() 263         V2::COLUMN_ETS_TAG, 1, []() { return AceType::MakeRefPtr<LinearLayoutPattern>(true); });
264     auto buttonNode1 =
__anon6b1023a30e02() 265         FrameNode::GetOrCreateFrameNode(V2::BUTTON_ETS_TAG, 2, []() { return AceType::MakeRefPtr<ButtonPattern>(); });
266     auto buttonNode2 =
__anon6b1023a30f02() 267         FrameNode::GetOrCreateFrameNode(V2::BUTTON_ETS_TAG, 3, []() { return AceType::MakeRefPtr<ButtonPattern>(); });
268     auto buttonNode3 =
__anon6b1023a31002() 269         FrameNode::GetOrCreateFrameNode(V2::BUTTON_ETS_TAG, 4, []() { return AceType::MakeRefPtr<ButtonPattern>(); });
270     auto buttonNode4 =
__anon6b1023a31102() 271         FrameNode::GetOrCreateFrameNode(V2::BUTTON_ETS_TAG, 5, []() { return AceType::MakeRefPtr<ButtonPattern>(); });
272     auto buttonAccessibilityProperty1 = buttonNode1->GetAccessibilityProperty<AccessibilityProperty>();
273     auto buttonAccessibilityProperty2 = buttonNode2->GetAccessibilityProperty<AccessibilityProperty>();
274     auto buttonAccessibilityProperty3 = buttonNode3->GetAccessibilityProperty<AccessibilityProperty>();
275     auto buttonAccessibilityProperty4 = buttonNode4->GetAccessibilityProperty<AccessibilityProperty>();
276     auto columnAccessibilityProperty2 = columnFrameNode2->GetAccessibilityProperty<AccessibilityProperty>();
277     buttonAccessibilityProperty1->SetText("Button1");
278     buttonAccessibilityProperty2->SetText("Button2");
279     buttonAccessibilityProperty3->SetText("Button3");
280     buttonAccessibilityProperty4->SetText("Button4");
281     columnAccessibilityProperty2->SetAccessibilityText("column2");
282     buttonAccessibilityProperty1->SetAccessibilityDescription("Button1");
283 
284     columnFrameNode1->frameChildren_.emplace(buttonNode1);
285     columnFrameNode1->frameChildren_.emplace(buttonNode2);
286     columnFrameNode1->frameChildren_.emplace(columnFrameNode2);
287     columnFrameNode2->frameChildren_.emplace(buttonNode3);
288     columnFrameNode2->frameChildren_.emplace(buttonNode4);
289 
290     auto columnAccessibilityProperty1 = columnFrameNode1->GetAccessibilityProperty<AccessibilityProperty>();
291     columnAccessibilityProperty1->SetAccessibilityGroup(true);
292     columnAccessibilityProperty1->SetAccessibilityLevel("yes");
293 
294     auto columnAccessibilityText1 = columnAccessibilityProperty1->GetGroupText();
295     /**
296      * @tc.expected: step1. expect target text combine
297      */
298     EXPECT_EQ(buttonAccessibilityProperty1->GetAccessibilityDescription(), "Button1");
299     EXPECT_EQ(columnAccessibilityText1, "Button1, Button2, Button3, Button4");
300 
301     columnAccessibilityProperty1->SetAccessibilityLevel("no-hide-descendants");
302     columnAccessibilityText1 = columnAccessibilityProperty1->GetGroupText();
303     EXPECT_EQ(columnAccessibilityText1, "");
304 }
305 
306 /**
307  * @tc.name: AccessibilityPropertyTest005
308  * @tc.desc: Set show value into supportActions_ and get SupportAction length.
309  * @tc.type: FUNC
310  */
311 HWTEST_F(AccessibilityPropertyTestNg, AccessibilityPropertyTest005, TestSize.Level1)
312 {
313     std::string tag = "root";
314 
315     auto spanNode = SpanNode::GetOrCreateSpanNode(1);
316     auto columnFrameNode1 = FrameNode::GetOrCreateFrameNode(
__anon6b1023a31202() 317         V2::COLUMN_ETS_TAG, 0, []() { return AceType::MakeRefPtr<LinearLayoutPattern>(true); });
318     auto buttonNode1 =
__anon6b1023a31302() 319         FrameNode::GetOrCreateFrameNode(V2::BUTTON_ETS_TAG, 2, []() { return AceType::MakeRefPtr<ButtonPattern>(); });
320     spanNode->AddChild(buttonNode1);
321     columnFrameNode1->AddChild(spanNode);
322 
323     std::list<RefPtr<FrameNode>> children;
324 
325     auto columnAccessibilityProperty1 = columnFrameNode1->GetAccessibilityProperty<AccessibilityProperty>();
326     columnAccessibilityProperty1->SetAccessibilityGroup(true);
327     columnAccessibilityProperty1->SetAccessibilityLevel("yes");
328     columnAccessibilityProperty1->SetAccessibilityText("column1");
329 
330     auto text = columnAccessibilityProperty1->GetAccessibilityText();
331     EXPECT_EQ(text, "column1");
332 }
333 
334 /**
335  * @tc.name: AccessibilityPropertyTest006
336  * @tc.desc: Set show value into supportActions_ and get SupportAction length.
337  * @tc.type: FUNC
338  */
339 HWTEST_F(AccessibilityPropertyTestNg, AccessibilityPropertyTest006, TestSize.Level1)
340 {
341     /**
342      * @tc.steps1: Create FrameNode and Add Children
343      */
344     std::string tag = "root";
345     auto spanNode = SpanNode::GetOrCreateSpanNode(1);
346     auto columnFrameNode1 = FrameNode::GetOrCreateFrameNode(
__anon6b1023a31402() 347         V2::COLUMN_ETS_TAG, 0, []() { return AceType::MakeRefPtr<LinearLayoutPattern>(true); });
348     auto buttonNode1 =
__anon6b1023a31502() 349         FrameNode::GetOrCreateFrameNode(V2::BUTTON_ETS_TAG, 2, []() { return AceType::MakeRefPtr<ButtonPattern>(); });
350     auto customFrameNode2 = CustomNode::CreateCustomNode(1, "Column");
351     spanNode->AddChild(buttonNode1);
352     spanNode->AddChild(customFrameNode2);
353     columnFrameNode1->AddChild(spanNode);
354     columnFrameNode1->AddChild(buttonNode1);
355     auto columnAccessibilityProperty1 = columnFrameNode1->GetAccessibilityProperty<AccessibilityProperty>();
356     columnAccessibilityProperty1->SetAccessibilityGroup(true);
357     columnAccessibilityProperty1->SetAccessibilityLevel("yes");
358     columnAccessibilityProperty1->SetAccessibilityText("column1");
359 
360     /**
361      * @tc.steps2: call GetAccessibilityText
362      * @tc.expected: 'column1'
363      */
364     auto text = columnAccessibilityProperty1->GetAccessibilityText();
365     EXPECT_EQ(text, "column1");
366 
367     /**
368      * @tc.steps3: reset accessibilityText_ and call GetAccessibilityText
369      * @tc.expected: ''
370      */
371     columnAccessibilityProperty1->accessibilityText_.reset();
372     text = columnAccessibilityProperty1->GetAccessibilityText();
373     EXPECT_EQ(text, "");
374 
375     /**
376      * @tc.steps4: add a new frameNode and SetAccessibilityText
377      * @tc.expected: 'test'
378      */
379     auto buttonNode2 =
__anon6b1023a31602() 380         FrameNode::GetOrCreateFrameNode(V2::BUTTON_ETS_TAG, 3, []() { return AceType::MakeRefPtr<ButtonPattern>(); });
381     buttonNode2->GetAccessibilityProperty<AccessibilityProperty>()->SetAccessibilityText("test");
382     text = buttonNode2->GetAccessibilityProperty<AccessibilityProperty>()->GetAccessibilityText();
383     EXPECT_EQ(text, "test");
384 }
385 
386 /**
387  * @tc.name: AccessibilityPropertyTest007
388  * @tc.desc: Set action and execute it.
389  * @tc.type: FUNC
390  */
391 HWTEST_F(AccessibilityPropertyTestNg, AccessibilityPropertyTest007, TestSize.Level1)
392 {
393     /**
394      * @tc.steps: step1. actions is empty
395      * @tc.expected: act every action return false
396      */
397     AccessibilityProperty props;
__anon6b1023a31702(int32_t start, int32_t end, bool isforward) 398     props.SetActionSetSelection([](int32_t start, int32_t end, bool isforward) {});
399     EXPECT_TRUE(props.ActActionSetSelection(0, 1));
__anon6b1023a31802(int32_t start) 400     props.SetActionSetIndex([](int32_t start) {});
401     EXPECT_TRUE(props.ActActionSetIndex(1));
__anon6b1023a31902() 402     props.SetActionGetIndex([]() {return 2;});
403     EXPECT_TRUE(props.ActActionGetIndex());
404 }
405 
406 /**
407  * @tc.name: AccessibilityPropertyTest008
408  * @tc.desc: GetScrollOffSet
409  * @tc.type: FUNC
410  */
411 HWTEST_F(AccessibilityPropertyTestNg, AccessibilityPropertyTest008, TestSize.Level1)
412 {
413     AccessibilityProperty accessibilityProperty;
414     auto result = accessibilityProperty.GetScrollOffSet();
415     EXPECT_EQ(result, -1.0f);
416 }
417 
418 /**
419  * @tc.name: AccessibilityPropertyTest009
420  * @tc.desc: HoverTest
421  * @tc.type: FUNC
422  */
423 HWTEST_F(AccessibilityPropertyTestNg, AccessibilityPropertyTest009, TestSize.Level1)
424 {
425     AccessibilityProperty accessibilityProperty;
426     auto root = FrameNode::GetOrCreateFrameNode(
__anon6b1023a31a02() 427         V2::BUTTON_ETS_TAG, 11, []() { return AceType::MakeRefPtr<ButtonPattern>(); });
428     NG::PointF hoverPoint(0, 0);
429     auto debugInfo = std::make_unique<AccessibilityProperty::HoverTestDebugTraceInfo>();
430     auto result = accessibilityProperty.HoverTest(hoverPoint, root, debugInfo);
431     EXPECT_EQ(result.size(), 0);
432 }
433 
434 /**
435  * @tc.name: AccessibilityPropertyTest010
436  * @tc.desc: CreateNodeSearchInfo
437  * @tc.type: FUNC
438  */
439 HWTEST_F(AccessibilityPropertyTestNg, AccessibilityPropertyTest010, TestSize.Level1)
440 {
441     AccessibilityProperty accessibilityProperty;
442     bool ancestorGroupFlag = false;
443     auto root = FrameNode::CreateFrameNode(
444         V2::BUTTON_ETS_TAG, 12, AceType::MakeRefPtr<Pattern>(), true);
445     NG::PointF hoverPoint(0, 0);
446     auto result = accessibilityProperty.CreateNodeSearchInfo(root, hoverPoint, ancestorGroupFlag);
447     EXPECT_TRUE(root->IsRootNode());
448 
449     auto subNode = FrameNode::GetOrCreateFrameNode(
__anon6b1023a31b02() 450         V2::BUTTON_ETS_TAG, 1, []() { return AceType::MakeRefPtr<ButtonPattern>(); });
451     root->AddChild(subNode);
452     EXPECT_FALSE(subNode->IsRootNode());
453     result = accessibilityProperty.CreateNodeSearchInfo(subNode, hoverPoint, ancestorGroupFlag);
454     EXPECT_TRUE(result->Contains("parent"));
455     EXPECT_TRUE(result->Contains("visible"));
456 
457     auto accessibilityPropertyRoot = root->GetAccessibilityProperty<NG::AccessibilityProperty>();
458     EXPECT_NE(accessibilityPropertyRoot, nullptr);
459     EXPECT_TRUE(result->Contains("accessibilityLevel"));
460 
461     root->SetHitTestMode(HitTestMode::HTMDEFAULT);
462     result = accessibilityProperty.CreateNodeSearchInfo(subNode, hoverPoint, ancestorGroupFlag);
463     EXPECT_TRUE(result->Contains("hitTestMode"));
464     std::string value = result->GetString("hitTestMode");
465     EXPECT_EQ(value, "Default");
466 
467     auto subNode1 = FrameNode::GetOrCreateFrameNode(
__anon6b1023a31c02() 468         V2::BUTTON_ETS_TAG, 2, []() { return AceType::MakeRefPtr<ButtonPattern>(); });
469     root->AddChild(subNode1);
470     subNode1->SetHitTestMode(HitTestMode::HTMBLOCK);
471     auto result1 = accessibilityProperty.CreateNodeSearchInfo(subNode1, hoverPoint, ancestorGroupFlag);
472     EXPECT_TRUE(result1->Contains("hitTestMode"));
473     std::string value1 = result1->GetString("hitTestMode");
474     EXPECT_EQ(value1, "Block");
475 
476     auto subNode2 = FrameNode::GetOrCreateFrameNode(
__anon6b1023a31d02() 477         V2::BUTTON_ETS_TAG, 3, []() { return AceType::MakeRefPtr<ButtonPattern>(); });
478     root->AddChild(subNode2);
479     subNode2->SetHitTestMode(HitTestMode::HTMTRANSPARENT);
480     auto result2 = accessibilityProperty.CreateNodeSearchInfo(subNode2, hoverPoint, ancestorGroupFlag);
481     EXPECT_TRUE(result2->Contains("hitTestMode"));
482     std::string value2 = result2->GetString("hitTestMode");
483     EXPECT_EQ(value2, "Transparent");
484 }
485 
486 /**
487  * @tc.name: AccessibilityPropertyTest011
488  * @tc.desc: HoverTestRecursive
489  * @tc.type: FUNC
490  */
491 HWTEST_F(AccessibilityPropertyTestNg, AccessibilityPropertyTest011, TestSize.Level1)
492 {
493     GTEST_LOG_(INFO) << "AccessibilityPropertyTest011 start";
494     AccessibilityProperty accessibilityProperty;
495     AccessibilityHoverTestPath path;
496     auto root = FrameNode::GetOrCreateFrameNode(
__anon6b1023a31e02() 497         V2::BUTTON_ETS_TAG, 1, []() { return AceType::MakeRefPtr<ButtonPattern>(); });
498     NG::PointF hoverPoint(0, 0);
499     auto debugInfo = std::make_unique<AccessibilityProperty::HoverTestDebugTraceInfo>();
500 
501     bool ancestorGroupFlag = false;
502 
503     root->SetActive(false);
504     auto result = accessibilityProperty.HoverTestRecursive(hoverPoint, root, path, debugInfo, ancestorGroupFlag);
505     EXPECT_EQ(result, false);
506     root->SetActive(true);
507 
508     root->SetInternal();
509     result = accessibilityProperty.HoverTestRecursive(hoverPoint, root, path, debugInfo, ancestorGroupFlag);
510     EXPECT_EQ(result, false);
511 
512     root->SetActive(true);
513     root->isInternal_ = false;
514 }
515 
516 /**
517  * @tc.name: AccessibilityPropertyTest012
518  * @tc.desc: GetSearchStrategy
519  * @tc.type: FUNC
520  */
521 HWTEST_F(AccessibilityPropertyTestNg, AccessibilityPropertyTest012, TestSize.Level1)
522 {
523     AccessibilityProperty accessibilityProperty;
524     bool ancestorGroupFlag = false;
525     auto frameNode = FrameNode::GetOrCreateFrameNode(
__anon6b1023a31f02() 526         V2::BUTTON_ETS_TAG, 14, []() { return AceType::MakeRefPtr<ButtonPattern>(); });
527     auto result = accessibilityProperty.GetSearchStrategy(frameNode, ancestorGroupFlag);
528     EXPECT_EQ(result, std::make_tuple(true, true, false));
529 
530     auto accessibilityPropertyNew = frameNode->GetAccessibilityProperty<NG::AccessibilityProperty>();
531     EXPECT_NE(accessibilityPropertyNew, nullptr);
532     auto levelBak = accessibilityPropertyNew->GetAccessibilityLevel();
533     accessibilityPropertyNew->SetAccessibilityLevel(AccessibilityProperty::Level::YES_STR);
534     result = accessibilityProperty.GetSearchStrategy(frameNode, ancestorGroupFlag);
535     EXPECT_EQ(result, std::make_tuple(true, true, false));
536 
537     bool hasGroupOrVirtualNodeBak = accessibilityPropertyNew->IsAccessibilityGroup();
538     accessibilityPropertyNew->SetAccessibilityGroup(true);
539     result = accessibilityProperty.GetSearchStrategy(frameNode, ancestorGroupFlag);
540     EXPECT_EQ(result, std::make_tuple(true, true, true));
541     accessibilityPropertyNew->SetAccessibilityGroup(hasGroupOrVirtualNodeBak);
542     accessibilityPropertyNew->SetAccessibilityLevel(levelBak);
543 
544     accessibilityPropertyNew->SetAccessibilityLevel(AccessibilityProperty::Level::NO_HIDE_DESCENDANTS);
545     result = accessibilityProperty.GetSearchStrategy(frameNode, ancestorGroupFlag);
546     EXPECT_EQ(result, std::make_tuple(false, false, false));
547     accessibilityPropertyNew->SetAccessibilityLevel(levelBak);
548 
549     hasGroupOrVirtualNodeBak = accessibilityPropertyNew->IsAccessibilityGroup();
550     result = accessibilityProperty.GetSearchStrategy(frameNode, ancestorGroupFlag);
551     EXPECT_EQ(result, std::make_tuple(true, true, false));
552 
553     accessibilityPropertyNew->SetAccessibilityGroup(true);
554     result = accessibilityProperty.GetSearchStrategy(frameNode, ancestorGroupFlag);
555     EXPECT_EQ(result, std::make_tuple(true, true, true));
556     accessibilityPropertyNew->SetAccessibilityGroup(hasGroupOrVirtualNodeBak);
557 
558     accessibilityPropertyNew->SetAccessibilityLevel(AccessibilityProperty::Level::NO_STR);
559     result = accessibilityProperty.GetSearchStrategy(frameNode, ancestorGroupFlag);
560     EXPECT_EQ(result, std::make_tuple(false, true, false));
561 
562     accessibilityPropertyNew->SetAccessibilityLevel(AccessibilityProperty::Level::AUTO);
563     accessibilityPropertyNew->SetAccessibilityGroup(true);
564     bool hasGroupOrVirtualNode = accessibilityPropertyNew->IsAccessibilityGroup() ||
565                 accessibilityPropertyNew->HasAccessibilityVirtualNode();
566     EXPECT_TRUE(hasGroupOrVirtualNode);
567     result = accessibilityProperty.GetSearchStrategy(frameNode, ancestorGroupFlag);
568     EXPECT_EQ(result, std::make_tuple(true, true, true));
569     accessibilityPropertyNew->SetAccessibilityGroup(hasGroupOrVirtualNodeBak);
570 }
571 
572 /**
573  * @tc.name: AccessibilityPropertyTest013
574  * @tc.desc: IsAccessibilityFocusableDebug
575  * @tc.type: FUNC
576  */
577 HWTEST_F(AccessibilityPropertyTestNg, AccessibilityPropertyTest013, TestSize.Level1)
578 {
579     AccessibilityProperty accessibilityProperty;
580     auto root = FrameNode::CreateFrameNode(
581         V2::BUTTON_ETS_TAG, 15, AceType::MakeRefPtr<Pattern>(), true);
582     std::unique_ptr<JsonValue> info = JsonUtil::Create();
583 
584     auto result = accessibilityProperty.IsAccessibilityFocusableDebug(root, info);
585     EXPECT_EQ(result, false);
586 
587     bool isRoot = root->IsRootNode();
588     EXPECT_EQ(isRoot, true);
589     auto buttonNode = FrameNode::GetOrCreateFrameNode(
__anon6b1023a32002() 590         V2::BUTTON_ETS_TAG, 6, []() { return AceType::MakeRefPtr<ButtonPattern>(); });
591     root->AddChild(buttonNode);
592     result = accessibilityProperty.IsAccessibilityFocusableDebug(buttonNode, info);
593     EXPECT_EQ(result, false);
594     EXPECT_TRUE(info->Contains("parent"));
595 
596     auto accessibilityPropertyBt = buttonNode->GetAccessibilityProperty<NG::AccessibilityProperty>();
597     EXPECT_NE(accessibilityPropertyBt, nullptr);
598     EXPECT_TRUE(info->Contains("hasAction"));
599 }
600 
601 
602 /**
603  * @tc.name: AccessibilityPropertyTest014
604  * @tc.desc: IsAccessibilityFocusable
605  * @tc.type: FUNC
606  */
607 HWTEST_F(AccessibilityPropertyTestNg, AccessibilityPropertyTest014, TestSize.Level1)
608 {
609     AccessibilityProperty accessibilityProperty1;
610     auto root = FrameNode::CreateFrameNode(
611         V2::BUTTON_ETS_TAG, 15, AceType::MakeRefPtr<Pattern>(), true);
612     auto result = accessibilityProperty1.IsAccessibilityFocusable(root);
613     EXPECT_EQ(result, false);
614 
615     auto frameNode = FrameNode::GetOrCreateFrameNode(
__anon6b1023a32102() 616         V2::BUTTON_ETS_TAG, 6, []() { return AceType::MakeRefPtr<ButtonPattern>(); });
617     auto accessibilityProperty = frameNode->GetAccessibilityProperty<NG::AccessibilityProperty>();
618     auto levelBak = accessibilityProperty->GetAccessibilityLevel();
619     EXPECT_NE(accessibilityProperty, nullptr);
620 
621     accessibilityProperty->SetAccessibilityLevel(AccessibilityProperty::Level::YES_STR);
622     result = accessibilityProperty->IsAccessibilityFocusable(frameNode);
623     EXPECT_EQ(result, true);
624 
625     accessibilityProperty->SetAccessibilityLevel(AccessibilityProperty::Level::NO_STR);
626     result = accessibilityProperty->IsAccessibilityFocusable(frameNode);
627     EXPECT_EQ(result, false);
628 
629     accessibilityProperty->SetAccessibilityLevel(AccessibilityProperty::Level::AUTO);
630     accessibilityProperty->SetAccessibilityGroup(true);
631     result = accessibilityProperty->IsAccessibilityFocusable(frameNode);
632     EXPECT_EQ(result, true);
633 
634 
635     auto eventHub = frameNode->GetOrCreateEventHub<EventHub>();
636     bool isEnableBak = eventHub->IsEnabled();
637     eventHub->SetEnabledInternal(false);
638     result = accessibilityProperty->IsAccessibilityFocusable(frameNode);
639     EXPECT_EQ(result, true);
640     eventHub->SetEnabledInternal(isEnableBak);
641 
642     auto gestureEventHubBak = eventHub->GetGestureEventHub();
643     auto gestureEventHubNew = eventHub->GetOrCreateGestureEventHub();
644     EXPECT_TRUE(gestureEventHubNew != nullptr);
645 
646 
647     result = accessibilityProperty->IsAccessibilityFocusable(frameNode);
648     EXPECT_EQ(result, true);
649     eventHub->SetGestureEventHub(gestureEventHubBak);
650 }
651 
652 /**
653  * @tc.name: AccessibilityPropertyTest015
654  * @tc.desc: HasAccessibilityTextOrDescription
655  * @tc.type: FUNC
656  */
657 HWTEST_F(AccessibilityPropertyTestNg, AccessibilityPropertyTest015, TestSize.Level1)
658 {
659     AccessibilityProperty accessibilityProperty;
660     auto result = accessibilityProperty.HasAccessibilityTextOrDescription();
661     EXPECT_EQ(result, false);
662 }
663 
664 /**
665  * @tc.name: AccessibilityPropertyTest016
666  * @tc.desc: HasAction
667  * @tc.type: FUNC
668  */
669 HWTEST_F(AccessibilityPropertyTestNg, AccessibilityPropertyTest016, TestSize.Level1)
670 {
671     AccessibilityProperty accessibilityProperty;
672     auto result = accessibilityProperty.HasAction();
673     EXPECT_EQ(result, false);
674 }
675 
676 /**
677  * @tc.name: AccessibilityPropertyTest017
678  * @tc.desc: SetAccessibilityActions, ResetAccessibilityActions, HasAccessibilityActions and GetAccessibilityActions
679  * @tc.type: FUNC
680  */
681 HWTEST_F(AccessibilityPropertyTestNg, AccessibilityPropertyTest017, TestSize.Level1)
682 {
683     AccessibilityProperty accessibilityProperty;
684     uint32_t accessibilityActions = 1;
685     accessibilityProperty.SetAccessibilityActions(accessibilityActions);
686     EXPECT_TRUE(accessibilityProperty.HasAccessibilityActions());
687     EXPECT_EQ(accessibilityProperty.GetAccessibilityActions(), accessibilityActions);
688     accessibilityProperty.ResetAccessibilityActions();
689     EXPECT_FALSE(accessibilityProperty.HasAccessibilityActions());
690     EXPECT_EQ(accessibilityProperty.GetAccessibilityActions(), 0);
691 }
692 
693 /**
694  * @tc.name: AccessibilityPropertyTest018
695  * @tc.desc: SetAccessibilityRole, ResetAccessibilityRole, HasAccessibilityRole and GetAccessibilityRole
696  * @tc.type: FUNC
697  */
698 HWTEST_F(AccessibilityPropertyTestNg, AccessibilityPropertyTest018, TestSize.Level1)
699 {
700     AccessibilityProperty accessibilityProperty;
701     const std::string role = "role";
702     accessibilityProperty.SetAccessibilityRole(role);
703     EXPECT_TRUE(accessibilityProperty.HasAccessibilityRole());
704     EXPECT_EQ(accessibilityProperty.GetAccessibilityRole(), role);
705     accessibilityProperty.ResetAccessibilityRole();
706     EXPECT_FALSE(accessibilityProperty.HasAccessibilityRole());
707     EXPECT_EQ(accessibilityProperty.GetAccessibilityRole(), "");
708 }
709 
710 /**
711  * @tc.name: AccessibilityPropertyTest019
712  * @tc.desc: SetActions
713  * @tc.type: FUNC
714  */
715 HWTEST_F(AccessibilityPropertyTestNg, AccessibilityPropertyTest019, TestSize.Level1)
716 {
717     AccessibilityProperty accessibilityProperty;
__anon6b1023a32202(uint32_t type)718     ActionsImpl actionsImpl = [](uint32_t type){};
719     accessibilityProperty.SetActions(actionsImpl);
720 }
721 
722 /**
723  * @tc.name: AccessibilityPropertyTest020
724  * @tc.desc: SetUserDisabled HasUserDisabled and IsUserDisabled
725  * @tc.type: FUNC
726  */
727 HWTEST_F(AccessibilityPropertyTestNg, AccessibilityPropertyTest020, TestSize.Level1)
728 {
729     AccessibilityProperty accessibilityProperty;
730     const bool isDisabled = true;
731     EXPECT_FALSE(accessibilityProperty.HasUserDisabled());
732     EXPECT_FALSE(accessibilityProperty.IsUserDisabled());
733     accessibilityProperty.SetUserDisabled(isDisabled);
734     EXPECT_TRUE(accessibilityProperty.HasUserDisabled());
735     EXPECT_TRUE(accessibilityProperty.IsUserDisabled());
736 }
737 
738 /**
739  * @tc.name: AccessibilityPropertyTest021
740  * @tc.desc: HasUserSelected SetUserSelected and IsUserSelected
741  * @tc.type: FUNC
742  */
743 HWTEST_F(AccessibilityPropertyTestNg, AccessibilityPropertyTest021, TestSize.Level1)
744 {
745     AccessibilityProperty accessibilityProperty;
746     const bool isSelected = true;
747     EXPECT_FALSE(accessibilityProperty.HasUserSelected());
748     EXPECT_FALSE(accessibilityProperty.IsUserSelected());
749     accessibilityProperty.SetUserSelected(isSelected);
750     EXPECT_TRUE(accessibilityProperty.HasUserSelected());
751     EXPECT_TRUE(accessibilityProperty.IsUserSelected());
752 }
753 
754 /**
755  * @tc.name: AccessibilityPropertyTest022
756  * @tc.desc: HasUserCheckedType GetUserCheckedType and SetUserCheckedType
757  * @tc.type: FUNC
758  */
759 HWTEST_F(AccessibilityPropertyTestNg, AccessibilityPropertyTest022, TestSize.Level1)
760 {
761     AccessibilityProperty accessibilityProperty;
762     const int32_t checkedType = 1;
763     EXPECT_FALSE(accessibilityProperty.HasUserCheckedType());
764     EXPECT_EQ(accessibilityProperty.GetUserCheckedType(), 0);
765     accessibilityProperty.SetUserCheckedType(checkedType);
766     EXPECT_TRUE(accessibilityProperty.HasUserCheckedType());
767     EXPECT_EQ(accessibilityProperty.GetUserCheckedType(), checkedType);
768 }
769 
770 /**
771  * @tc.name: AccessibilityPropertyTest023
772  * @tc.desc: GetUserMinValue SetUserMinValue and HasUserMinValue
773  * @tc.type: FUNC
774  */
775 HWTEST_F(AccessibilityPropertyTestNg, AccessibilityPropertyTest023, TestSize.Level1)
776 {
777     AccessibilityProperty accessibilityProperty;
778     const int32_t minValue = -2;
779     EXPECT_EQ(accessibilityProperty.GetUserMinValue(), -1);
780     EXPECT_FALSE(accessibilityProperty.HasUserMinValue());
781     accessibilityProperty.SetUserMinValue(minValue);
782     EXPECT_TRUE(accessibilityProperty.HasUserMinValue());
783     EXPECT_EQ(accessibilityProperty.GetUserMinValue(), minValue);
784 }
785 
786 /**
787  * @tc.name: AccessibilityPropertyTest024
788  * @tc.desc: GetUserMaxValue HasUserMaxValue and SetUserMaxValue
789  * @tc.type: FUNC
790  */
791 HWTEST_F(AccessibilityPropertyTestNg, AccessibilityPropertyTest024, TestSize.Level1)
792 {
793     AccessibilityProperty accessibilityProperty;
794     const int32_t maxValue = 2;
795     EXPECT_EQ(accessibilityProperty.GetUserMaxValue(), -1);
796     EXPECT_FALSE(accessibilityProperty.HasUserMaxValue());
797     accessibilityProperty.SetUserMaxValue(maxValue);
798     EXPECT_TRUE(accessibilityProperty.HasUserMaxValue());
799     EXPECT_EQ(accessibilityProperty.GetUserMaxValue(), maxValue);
800 }
801 
802 /**
803  * @tc.name: AccessibilityPropertyTest025
804  * @tc.desc: GetUserCurrentValue SetUserCurrentValue and HasUserCurrentValue
805  * @tc.type: FUNC
806  */
807 HWTEST_F(AccessibilityPropertyTestNg, AccessibilityPropertyTest025, TestSize.Level1)
808 {
809     AccessibilityProperty accessibilityProperty;
810     const int32_t currentValue = 2;
811     EXPECT_EQ(accessibilityProperty.GetUserCurrentValue(), -1);
812     EXPECT_FALSE(accessibilityProperty.HasUserCurrentValue());
813     accessibilityProperty.SetUserCurrentValue(currentValue);
814     EXPECT_TRUE(accessibilityProperty.HasUserCurrentValue());
815     EXPECT_EQ(accessibilityProperty.GetUserCurrentValue(), currentValue);
816 }
817 
818 /**
819  * @tc.name: AccessibilityPropertyTest026
820  * @tc.desc: SetUserTextValue, SetUserTextValue and GetUserTextValue
821  * @tc.type: FUNC
822  */
823 HWTEST_F(AccessibilityPropertyTestNg, AccessibilityPropertyTest026, TestSize.Level1)
824 {
825     AccessibilityProperty accessibilityProperty;
826     const std::string textValue = "textValue";
827     EXPECT_EQ(accessibilityProperty.GetUserTextValue(), "");
828     EXPECT_FALSE(accessibilityProperty.HasUserTextValue());
829     accessibilityProperty.SetUserTextValue(textValue);
830     EXPECT_TRUE(accessibilityProperty.HasUserTextValue());
831     EXPECT_EQ(accessibilityProperty.GetUserTextValue(), textValue);
832 }
833 
834 /**
835  * @tc.name: AccessibilityPropertyTest027
836  * @tc.desc: test GetGroupTextRecursive
837  * @tc.type: FUNC
838  */
839 HWTEST_F(AccessibilityPropertyTestNg, AccessibilityPropertyTest027, TestSize.Level1)
840 {
841     AccessibilityProperty accessibilityProperty;
842     const std::string textValue = "textValue";
843     accessibilityProperty.SetUserTextValue(textValue);
844     WeakPtr<FrameNode> hostBak = accessibilityProperty.host_;
845     accessibilityProperty.SetHost(nullptr);
846     std::string text = "";
847     accessibilityProperty.GetGroupTextRecursive(false, text, false);
848     EXPECT_EQ(text, "");
849 
850     accessibilityProperty.SetHost(hostBak);
851     accessibilityProperty.GetGroupTextRecursive(false, text, false);
852     EXPECT_EQ(text, "");
853 
854     std::string levelBak = accessibilityProperty.GetAccessibilityLevel();
855     accessibilityProperty.SetAccessibilityLevel(AccessibilityProperty::Level::YES_STR);
856     accessibilityProperty.GetGroupTextRecursive(false, text, false);
857     EXPECT_EQ(text, "");
858     size_t found = text.find(',');
859     EXPECT_FALSE(found != std::string::npos);
860     accessibilityProperty.SetAccessibilityLevel(levelBak);
861 
862     text = "";
863     levelBak = accessibilityProperty.GetAccessibilityLevel();
864     accessibilityProperty.SetAccessibilityLevel(AccessibilityProperty::Level::NO_HIDE_DESCENDANTS);
865     accessibilityProperty.GetGroupTextRecursive(false, text, false);
866     EXPECT_EQ(text, "");
867     accessibilityProperty.SetAccessibilityLevel(levelBak);
868 
869     text = "";
870     levelBak = accessibilityProperty.GetAccessibilityLevel();
871     accessibilityProperty.SetAccessibilityLevel(AccessibilityProperty::Level::NO_STR);
872     accessibilityProperty.GetGroupTextRecursive(false, text, false);
873     EXPECT_EQ(text, "");
874     accessibilityProperty.SetAccessibilityLevel(levelBak);
875 
876     text = "";
877     levelBak = accessibilityProperty.GetAccessibilityLevel();
878     bool isAccessibilityGroup = accessibilityProperty.IsAccessibilityGroup();
879     accessibilityProperty.SetAccessibilityLevel(AccessibilityProperty::Level::AUTO);
880     accessibilityProperty.SetAccessibilityGroup(true);
881     accessibilityProperty.GetGroupTextRecursive(true, text, false);
882     found = text.find(',');
883     EXPECT_FALSE(found != std::string::npos);
884     accessibilityProperty.SetAccessibilityLevel(levelBak);
885     accessibilityProperty.SetAccessibilityGroup(isAccessibilityGroup);
886 }
887 
888 /**
889  * @tc.name: AccessibilityPropertyTest028
890  * @tc.desc: test ActionsDefined
891  * @tc.type: FUNC
892  */
893 HWTEST_F(AccessibilityPropertyTestNg, AccessibilityPropertyTest028, TestSize.Level1)
894 {
895     AccessibilityProperty accessibilityProperty;
896     uint32_t actions = static_cast<uint32_t>(ArkUI_AccessibilityActionType::ARKUI_ACCESSIBILITY_ACTION_COPY);
897     accessibilityProperty.ResetAccessibilityActions();
898     bool isDefined = accessibilityProperty.ActionsDefined(actions);
899     EXPECT_FALSE(isDefined);
900 
901     accessibilityProperty.SetAccessibilityActions(actions);
902     isDefined = accessibilityProperty.ActionsDefined(actions);
903     ActionsImpl actionsImplBak = accessibilityProperty.actionsImpl_;
904     accessibilityProperty.SetActions(nullptr);
905     isDefined = accessibilityProperty.ActionsDefined(actions);
906     EXPECT_FALSE(isDefined);
907 
__anon6b1023a32302(uint32_t type)908     ActionsImpl actionsImpl = [](uint32_t type){};
909     accessibilityProperty.SetActions(actionsImpl);
910     isDefined = accessibilityProperty.ActionsDefined(actions);
911     EXPECT_TRUE(isDefined);
912 }
913 
914 /**
915  * @tc.name: AccessibilityPropertyTest029
916  * @tc.desc: test CreateNodeSearchInfo
917  * @tc.type: FUNC
918  */
919 HWTEST_F(AccessibilityPropertyTestNg, AccessibilityPropertyTest029, TestSize.Level1)
920 {
921     AccessibilityProperty accessibilityProperty;
922     bool ancestorGroupFlag = false;
923     auto root = FrameNode::CreateFrameNode(
924         V2::BUTTON_ETS_TAG, 12, AceType::MakeRefPtr<Pattern>(), true);
925     NG::PointF hoverPoint(0, 0);
926     auto result = accessibilityProperty.CreateNodeSearchInfo(root, hoverPoint, ancestorGroupFlag);
927     EXPECT_TRUE(root->IsRootNode());
928 
929     auto subNode = FrameNode::GetOrCreateFrameNode(
__anon6b1023a32402() 930         V2::BUTTON_ETS_TAG, 1, []() { return AceType::MakeRefPtr<ButtonPattern>(); });
931     root->AddChild(subNode);
932     EXPECT_FALSE(subNode->IsRootNode());
933     result = accessibilityProperty.CreateNodeSearchInfo(subNode, hoverPoint, ancestorGroupFlag);
934     EXPECT_TRUE(result->Contains("parent"));
935     EXPECT_TRUE(result->Contains("visible"));
936 
937     auto accessibilityPropertyRoot = root->GetAccessibilityProperty<NG::AccessibilityProperty>();
938     EXPECT_NE(accessibilityPropertyRoot, nullptr);
939     EXPECT_TRUE(result->Contains("accessibilityLevel"));
940 
941     auto subNode3 = FrameNode::GetOrCreateFrameNode(
__anon6b1023a32502() 942         V2::BUTTON_ETS_TAG, 4, []() { return AceType::MakeRefPtr<ButtonPattern>(); });
943     root->AddChild(subNode3);
944     subNode3->SetHitTestMode(HitTestMode::HTMNONE);
945     auto result3 = accessibilityProperty.CreateNodeSearchInfo(subNode3, hoverPoint, ancestorGroupFlag);
946     EXPECT_TRUE(result3->Contains("hitTestMode"));
947     std::string value3 = result3->GetString("hitTestMode");
948     EXPECT_EQ(value3, "None");
949 
950     auto subNode4 = FrameNode::GetOrCreateFrameNode(
__anon6b1023a32602() 951         V2::BUTTON_ETS_TAG, 5, []() { return AceType::MakeRefPtr<ButtonPattern>(); });
952     root->AddChild(subNode4);
953     subNode4->SetHitTestMode(HitTestMode::HTMTRANSPARENT_SELF);
954     auto result4 = accessibilityProperty.CreateNodeSearchInfo(subNode4, hoverPoint, ancestorGroupFlag);
955     EXPECT_TRUE(result4->Contains("hitTestMode"));
956     std::string value4 = result4->GetString("hitTestMode");
957     EXPECT_EQ(value4, "Unsupported");
958 }
959 
960 /**
961  * @tc.name: AccessibilityPropertyTest030
962  * @tc.desc: GetSearchStrategy
963  * @tc.type: FUNC
964  */
965 HWTEST_F(AccessibilityPropertyTestNg, AccessibilityPropertyTest030, TestSize.Level1)
966 {
967     AccessibilityProperty accessibilityProperty;
968     bool ancestorGroupFlag = false;
969     auto frameNode = FrameNode::GetOrCreateFrameNode(
__anon6b1023a32702() 970         V2::BUTTON_ETS_TAG, 14, []() { return AceType::MakeRefPtr<ButtonPattern>(); });
971 
972     auto accessibilityPropertyNew = frameNode->GetAccessibilityProperty<NG::AccessibilityProperty>();
973     EXPECT_NE(accessibilityPropertyNew, nullptr);
974     auto levelBak = accessibilityPropertyNew->GetAccessibilityLevel();
975     accessibilityPropertyNew->SetAccessibilityLevel(AccessibilityProperty::Level::YES_STR);
976     auto result = accessibilityProperty.GetSearchStrategy(frameNode, ancestorGroupFlag);
977     EXPECT_EQ(result, std::make_tuple(true, true, false));
978 
979     bool hasGroupOrVirtualNodeBak = accessibilityPropertyNew->IsAccessibilityGroup();
980     result = accessibilityProperty.GetSearchStrategy(frameNode, ancestorGroupFlag);
981     EXPECT_EQ(result, std::make_tuple(true, true, false));
982 
983     accessibilityPropertyNew->SetAccessibilityGroup(true);
984     result = accessibilityProperty.GetSearchStrategy(frameNode, ancestorGroupFlag);
985     EXPECT_EQ(result, std::make_tuple(true, true, true));
986     accessibilityPropertyNew->SetAccessibilityGroup(hasGroupOrVirtualNodeBak);
987 
988     accessibilityPropertyNew->SetAccessibilityText("test");
989     bool hasAccessibilityText = accessibilityPropertyNew->HasAccessibilityTextOrDescription();
990     EXPECT_TRUE(hasAccessibilityText);
991     result = accessibilityPropertyNew->GetSearchStrategy(frameNode, ancestorGroupFlag);
992     EXPECT_EQ(result, std::make_tuple(true, true, false));
993     accessibilityPropertyNew->SetAccessibilityLevel(levelBak);
994 
995     frameNode->accessibilityProperty_ = nullptr;
996     auto accessibilityProperty2 = frameNode->GetAccessibilityProperty<NG::AccessibilityProperty>();
997     EXPECT_EQ(accessibilityProperty2, nullptr);
998 
999     auto eventHub = frameNode->GetOrCreateEventHub<EventHub>();
1000     eventHub->SetEnabled(false);
1001     EXPECT_FALSE(eventHub->IsEnabled());
1002     result = accessibilityProperty.GetSearchStrategy(frameNode, ancestorGroupFlag);
1003     EXPECT_EQ(result, std::make_tuple(true, false, false));
1004 
1005     frameNode->SetHitTestMode(HitTestMode::HTMBLOCK);
1006     result = accessibilityProperty.GetSearchStrategy(frameNode, ancestorGroupFlag);
1007     EXPECT_EQ(result, std::make_tuple(true, false, false));
1008 
1009     frameNode->SetHitTestMode(HitTestMode::HTMTRANSPARENT);
1010     result = accessibilityProperty.GetSearchStrategy(frameNode, ancestorGroupFlag);
1011     EXPECT_EQ(result, std::make_tuple(true, false, false));
1012 
1013     frameNode->SetHitTestMode(HitTestMode::HTMNONE);
1014     result = accessibilityProperty.GetSearchStrategy(frameNode, ancestorGroupFlag);
1015     EXPECT_EQ(result, std::make_tuple(false, false, false));
1016 }
1017 
1018 /**
1019  * @tc.name: AccessibilityPropertyTest031
1020  * @tc.desc: GetSearchStrategy
1021  * @tc.type: FUNC
1022  */
1023 HWTEST_F(AccessibilityPropertyTestNg, AccessibilityPropertyTest031, TestSize.Level1)
1024 {
1025     bool ancestorGroupFlag = true;
1026     auto frameNode = FrameNode::GetOrCreateFrameNode(
__anon6b1023a32802() 1027         V2::BUTTON_ETS_TAG, 14, []() { return AceType::MakeRefPtr<ButtonPattern>(); });
1028     auto vNode = FrameNode::CreateFrameNode(V2::COLUMN_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(),
1029         AceType::MakeRefPtr<LinearLayoutPattern>(true));
1030     auto vChildNode = FrameNode::CreateFrameNode(V2::BUTTON_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(),
1031         AceType::MakeRefPtr<ButtonPattern>());
1032     vNode->AddChild(vChildNode);
1033     auto accessibilityProperty = frameNode->GetAccessibilityProperty<AccessibilityProperty>();
1034     accessibilityProperty->SetAccessibilityLevel("yes");
1035     accessibilityProperty->SetAccessibilityGroup(false);
1036     accessibilityProperty->SaveAccessibilityVirtualNode(vNode);
1037 
1038     auto result = accessibilityProperty->GetSearchStrategy(frameNode, ancestorGroupFlag);
1039     EXPECT_EQ(accessibilityProperty->HasAccessibilityVirtualNode(), true);
1040     EXPECT_EQ(result, std::make_tuple(true, true, true));
1041 }
1042 
1043 /**
1044  * @tc.name: AccessibilityPropertyTest032
1045  * @tc.desc: ProcessHoverTestRecursive
1046  * @tc.type: FUNC
1047  */
1048 HWTEST_F(AccessibilityPropertyTestNg, AccessibilityPropertyTest032, TestSize.Level1)
1049 {
1050     AccessibilityProperty accessibilityProperty;
1051     AccessibilityHoverTestPath path;
1052     auto root = FrameNode::GetOrCreateFrameNode(
__anon6b1023a32902() 1053         V2::BUTTON_ETS_TAG, 13, []() { return AceType::MakeRefPtr<ButtonPattern>(); });
1054     NG::PointF hoverPoint(0, 0);
1055     auto debugInfo = std::make_unique<AccessibilityProperty::HoverTestDebugTraceInfo>();
1056     AccessibilityProperty::RecursiveParam recursiveParam;
1057     recursiveParam.hitTarget = true;
1058     recursiveParam.ancestorGroupFlag = true;
1059     auto result = accessibilityProperty.ProcessHoverTestRecursive(hoverPoint, root, path, debugInfo, recursiveParam);
1060     EXPECT_EQ(result, true);
1061 }
1062 
1063 /**
1064  * @tc.name: AccessibilityPropertyTest033
1065  * @tc.desc: IsAccessibilityCompInResponseRegion
1066  * @tc.type: FUNC
1067  */
1068 HWTEST_F(AccessibilityPropertyTestNg, AccessibilityPropertyTest033, TestSize.Level1)
1069 {
1070     AccessibilityProperty accessibilityProperty;
1071     RectF rect1 = RectF(0.0f, 0.0f, 100.0f, 100.0f);
1072     RectF rect2 = RectF(-10.0f, -10.0f, 100.0f, 100.0f);
1073     RectF origRect1 = RectF(-10.0f, 0.0f, 100.0f, 100.0f);
1074     RectF origRect2 = RectF(0.0f, -10.0f, 100.0f, 100.0f);
1075     RectF origRect3 = RectF(0.0f, 0.0f, 200.0f, 100.0f);
1076     RectF origRect4 = RectF(0.0f, 0.0f, 100.0f, 200.0f);
1077     RectF origRect5 = RectF(0.0f, 0.0f, 50.0f, 50.0f);
1078     RectF origRect6 = RectF(0.0f, 0.0f, 50.0f, 50.0f);
1079     auto result = accessibilityProperty.IsAccessibilityCompInResponseRegion(rect1, origRect1);
1080     EXPECT_EQ(result, false);
1081 
1082     auto result1 = accessibilityProperty.IsAccessibilityCompInResponseRegion(rect1, origRect2);
1083     EXPECT_EQ(result1, false);
1084 
1085     auto result2 = accessibilityProperty.IsAccessibilityCompInResponseRegion(rect1, origRect3);
1086     EXPECT_EQ(result2, false);
1087 
1088     auto result3 = accessibilityProperty.IsAccessibilityCompInResponseRegion(rect1, origRect4);
1089     EXPECT_EQ(result3, false);
1090 
1091     auto result4 = accessibilityProperty.IsAccessibilityCompInResponseRegion(rect1, origRect5);
1092     EXPECT_EQ(result4, true);
1093 
1094     auto result5 = accessibilityProperty.IsAccessibilityCompInResponseRegion(rect2, origRect6);
1095     EXPECT_EQ(result5, true);
1096 }
1097 
1098 /**
1099  * @tc.name: AccessibilityPropertyTest034
1100  * @tc.desc: IsMatchAccessibilityResponseRegion
1101  * @tc.type: FUNC
1102  */
1103 HWTEST_F(AccessibilityPropertyTestNg, AccessibilityPropertyTest034, TestSize.Level1)
1104 {
1105     AccessibilityProperty accessibilityProperty;
1106     auto host = FrameNode::GetOrCreateFrameNode(
__anon6b1023a32a02() 1107         V2::BUTTON_ETS_TAG, 1, []() { return AceType::MakeRefPtr<ButtonPattern>(); });
1108     host->isActive_ = true;
1109     DimensionRect responseRect(Dimension(-1), Dimension(-1), DimensionOffset(OFFSETF));
1110     std::vector<DimensionRect> responseRegion;
1111     responseRegion.push_back(responseRect);
1112     auto gestureEventHub = host->GetOrCreateEventHub<EventHub>()->GetOrCreateGestureEventHub();
1113     gestureEventHub->SetResponseRegion(responseRegion);
1114     auto paintRect = host->renderContext_->GetPaintRectWithoutTransform();
1115     auto responseRegionList = host->GetResponseRegionList(paintRect, 2);
1116     EXPECT_FALSE(responseRegionList.size() != 1);
1117 
1118     auto rect = responseRegionList.back();
1119     EXPECT_FALSE(rect == paintRect);
1120 
1121     EXPECT_FALSE(!accessibilityProperty.IsAccessibilityCompInResponseRegion(rect, paintRect));
1122 
1123     WeakPtr<FrameNode> hostBak = host;
1124     accessibilityProperty.SetHost(hostBak);
1125     auto result = accessibilityProperty.IsMatchAccessibilityResponseRegion(false);
1126     EXPECT_EQ(result, true);
1127 }
1128 
1129 /**
1130  * @tc.name: AccessibilityPropertyTest035
1131  * @tc.desc: IsMatchAccessibilityResponseRegion
1132  * @tc.type: FUNC
1133  */
1134 HWTEST_F(AccessibilityPropertyTestNg, AccessibilityPropertyTest035, TestSize.Level1)
1135 {
1136     AccessibilityProperty accessibilityProperty;
1137     auto host = FrameNode::GetOrCreateFrameNode(
__anon6b1023a32b02() 1138         V2::BUTTON_ETS_TAG, 1, []() { return AceType::MakeRefPtr<ButtonPattern>(); });
1139     host->isActive_ = true;
1140     auto paintRect = host->GetTransformRectRelativeToWindow();
1141     DimensionRect responseRect(Dimension(-1), Dimension(-1), DimensionOffset(OFFSETF));
1142     std::vector<DimensionRect> responseRegion;
1143     responseRegion.push_back(responseRect);
1144     auto gestureEventHub = host->GetOrCreateEventHub<EventHub>()->GetOrCreateGestureEventHub();
1145     gestureEventHub->SetResponseRegion(responseRegion);
1146 
1147     auto responseRegionList = host->GetResponseRegionList(paintRect, 2);
1148     EXPECT_FALSE(responseRegionList.size() != 1);
1149 
1150     auto rect = responseRegionList.back();
1151     EXPECT_FALSE(rect == paintRect);
1152 
1153     EXPECT_FALSE(!accessibilityProperty.IsAccessibilityCompInResponseRegion(rect, paintRect));
1154 
1155     WeakPtr<FrameNode> hostBak = host;
1156     accessibilityProperty.SetHost(hostBak);
1157     auto result = accessibilityProperty.IsMatchAccessibilityResponseRegion(false);
1158     EXPECT_EQ(result, true);
1159 }
1160 
1161 /**
1162  * @tc.name: AccessibilityPropertyTest036
1163  * @tc.desc: GetAccessibilityResponseRegionRect
1164  * @tc.type: FUNC
1165  */
1166 HWTEST_F(AccessibilityPropertyTestNg, AccessibilityPropertyTest036, TestSize.Level1)
1167 {
1168     NG::RectT<int32_t> rectInt = RectT<int32_t>(0, 0, 0, 0);
1169     AccessibilityProperty accessibilityProperty;
1170     auto host = FrameNode::GetOrCreateFrameNode(
__anon6b1023a32c02() 1171         V2::BUTTON_ETS_TAG, 1, []() { return AceType::MakeRefPtr<ButtonPattern>(); });
1172     host->isActive_ = true;
1173     WeakPtr<FrameNode> hostBak = host;
1174     accessibilityProperty.SetHost(hostBak);
1175 
1176     auto result = accessibilityProperty.GetAccessibilityResponseRegionRect(false);
1177     EXPECT_EQ(result, rectInt);
1178 
1179     auto result1 = accessibilityProperty.GetAccessibilityResponseRegionRect(true);
1180     EXPECT_EQ(result1, rectInt);
1181 }
1182 
1183 /**
1184  * @tc.name: AccessibilityPropertyTest037
1185  * @tc.desc: AccessibilityRole
1186  * @tc.type: FUNC
1187  */
1188 HWTEST_F(AccessibilityPropertyTestNg, AccessibilityPropertyTest037, TestSize.Level1)
1189 {
1190     auto frameNode = ViewStackProcessor::GetInstance()->GetMainFrameNode();
1191     CHECK_NULL_VOID(frameNode);
1192     AccessibilityProperty accessibilityProperty;
1193     ViewAbstractModelNG viewAbstractModelNG;
1194     const std::string role = "";
1195     viewAbstractModelNG.SetAccessibilityRole(role, true);
1196     EXPECT_EQ(accessibilityProperty.GetAccessibilityCustomRole(), "");
1197     accessibilityProperty.SetAccessibilityCustomRole(role);
1198     EXPECT_EQ(accessibilityProperty.GetAccessibilityCustomRole(), role);
1199     accessibilityProperty.ResetAccessibilityCustomRole();
1200     EXPECT_EQ(accessibilityProperty.GetAccessibilityCustomRole(), "");
1201 
1202     const std::string customrole = "IMAGE";
1203     viewAbstractModelNG.SetAccessibilityRole(customrole, false);
1204     EXPECT_EQ(accessibilityProperty.GetAccessibilityCustomRole(), customrole);
1205 }
1206 
1207 /**
1208  * @tc.name: AccessibilityPropertyTest038
1209  * @tc.desc: OnAccessibilityFocus
1210  * @tc.type: FUNC
1211  */
1212 HWTEST_F(AccessibilityPropertyTestNg, AccessibilityPropertyTest038, TestSize.Level1)
1213 {
1214     AccessibilityProperty accessibilityProperty;
1215     ViewAbstractModelNG viewAbstractModelNG;
1216     viewAbstractModelNG.ResetOnAccessibilityFocus();
1217     EXPECT_EQ(accessibilityProperty.onUserAccessibilityFocusCallbackImpl_, nullptr);
1218 }
1219 
1220 /**
1221  * @tc.name: AccessibilityPropertyTest039
1222  * @tc.desc: SetAccessibilityNextFocusInspectorKey and GetAccessibilityNextFocusInspectorKey
1223  * @tc.type: FUNC
1224  */
1225 HWTEST_F(AccessibilityPropertyTestNg, AccessibilityPropertyTest039, TestSize.Level1)
1226 {
1227     AccessibilityProperty accessibilityProperty;
1228     const std::string nextFocusId = "nextId";
1229     accessibilityProperty.SetAccessibilityNextFocusInspectorKey(nextFocusId);
1230     EXPECT_EQ(accessibilityProperty.GetAccessibilityNextFocusInspectorKey(), nextFocusId);
1231 }
1232 
1233 /**
1234  * @tc.name: AccessibilityPropertyTest040
1235  * @tc.desc: SetAccessibilitySamePage, HasAccessibilitySamePage and GetAccessibilitySamePage
1236  * @tc.type: FUNC
1237  */
1238 HWTEST_F(AccessibilityPropertyTestNg, AccessibilityPropertyTest040, TestSize.Level1)
1239 {
1240     AccessibilityProperty accessibilityProperty;
1241     const std::string pageMode = "FULL_SILENT";
1242     accessibilityProperty.SetAccessibilitySamePage(pageMode);
1243     EXPECT_TRUE(accessibilityProperty.HasAccessibilitySamePage());
1244     EXPECT_EQ(accessibilityProperty.GetAccessibilitySamePage(), pageMode);
1245 }
1246 
1247 /**
1248  * @tc.name: AccessibilityPropertyTest041
1249  * @tc.desc: SetAccessibilitySamePage, HasAccessibilitySamePage and IsAccessibilityTextPreferred
1250  * @tc.type: FUNC
1251  */
1252 HWTEST_F(AccessibilityPropertyTestNg, AccessibilityPropertyTest041, TestSize.Level1)
1253 {
1254     AccessibilityProperty accessibilityProperty;
1255     const std::string pageMode = "FULL_SILENT";
1256     accessibilityProperty.SetAccessibilitySamePage(pageMode);
1257     EXPECT_TRUE(accessibilityProperty.HasAccessibilitySamePage());
1258     accessibilityProperty.SetAccessibilityTextPreferred(true);
1259     EXPECT_TRUE(accessibilityProperty.IsAccessibilityTextPreferred());
1260     accessibilityProperty.SetAccessibilityTextPreferred(false);
1261     EXPECT_FALSE(accessibilityProperty.IsAccessibilityTextPreferred());
1262 }
1263 
1264 /**
1265  * @tc.name: AccessibilityPropertyTest042
1266  * @tc.desc: IsMatchAccessibilityResponseRegion
1267  * @tc.type: FUNC
1268  */
1269 HWTEST_F(AccessibilityPropertyTestNg, AccessibilityPropertyTest042, TestSize.Level1)
1270 {
1271     AccessibilityProperty accessibilityProperty;
1272     auto host = FrameNode::GetOrCreateFrameNode(
__anon6b1023a32d02() 1273         V2::BUTTON_ETS_TAG, 1, []() { return AceType::MakeRefPtr<ButtonPattern>(); });
1274     host->isActive_ = true;
1275     auto paintRect = host->GetTransformRectRelativeToWindow();
1276     auto responseRegionList = host->GetResponseRegionList(paintRect, 2);
1277     EXPECT_FALSE(responseRegionList.size() != 1);
1278 
1279     auto rect = responseRegionList.back();
1280     EXPECT_TRUE(rect == paintRect);
1281 
1282     WeakPtr<FrameNode> hostBak = host;
1283     accessibilityProperty.SetHost(hostBak);
1284     auto result = accessibilityProperty.IsMatchAccessibilityResponseRegion(false);
1285     EXPECT_EQ(result, true);
1286 
1287     accessibilityProperty.focusDrawLevel_ = FocusDrawLevel::TOP;
1288     result = accessibilityProperty.IsMatchAccessibilityResponseRegion(false);
1289     EXPECT_EQ(result, false);
1290 }
1291 } // namespace OHOS::Ace::NG
1292