• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2025 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 #include "frameworks/base/utils/multi_thread.h"
36 #include "test/mock/base/mock_task_executor.h"
37 #include "test/mock/core/common/mock_container.h"
38 #include "test/mock/core/common/mock_theme_manager.h"
39 #include "test/mock/core/pipeline/mock_pipeline_context.h"
40 #include "test/mock/core/render/mock_render_context.h"
41 
42 using namespace testing;
43 using namespace testing::ext;
44 
45 namespace OHOS::Ace::NG {
46 namespace {
47 const std::string TEST_TEXT = "test text";
48 } // namespace
49 
50 class MockPattern : public Pattern {
51 public:
52     MockPattern() = default;
53     ~MockPattern() override = default;
54 };
55 class AccessibilityPropertyTestThreeNg : public testing::Test {
56 public:
SetUpTestSuite()57     static void SetUpTestSuite()
58     {
59         NG::MockPipelineContext::SetUp();
60         MockContainer::SetUp();
61         MockContainer::Current()->pipelineContext_ = NG::MockPipelineContext::GetCurrent();
62         MockContainer::Current()->taskExecutor_ = AceType::MakeRefPtr<MockTaskExecutor>();
63         MockContainer::Current()->pipelineContext_->taskExecutor_ = MockContainer::Current()->taskExecutor_;
64         auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
65         PipelineBase::GetCurrentContext()->SetThemeManager(themeManager);
66     }
TearDownTestSuite()67     static void TearDownTestSuite()
68     {
69         NG::MockPipelineContext::TearDown();
70         MockContainer::TearDown();
71     }
72 };
73 
74 /**
75  * @tc.name: AccessibilityPropertyTest001
76  * @tc.desc: Test the method IsTagInSubTreeComponent.
77  * @tc.type: FUNC
78  */
79 HWTEST_F(AccessibilityPropertyTestThreeNg, AccessibilityPropertyTestThree001, TestSize.Level1)
80 {
81     std::string tag = V2::XCOMPONENT_ETS_TAG;
82     AccessibilityProperty accessibilityProperty;
83 
84     bool ret = accessibilityProperty.IsTagInSubTreeComponent(tag);
85     EXPECT_TRUE(ret);
86 }
87 
88 /**
89  * @tc.name: AccessibilityPropertyTest002
90  * @tc.desc: Test the method IsTagInSubTreeComponent.
91  * @tc.type: FUNC
92  */
93 HWTEST_F(AccessibilityPropertyTestThreeNg, AccessibilityPropertyTestThree002, TestSize.Level1)
94 {
95     std::string tag = V2::CHECKBOX_ETS_TAG;
96     AccessibilityProperty accessibilityProperty;
97 
98     bool ret = accessibilityProperty.IsAccessibilityFocusableTag(tag);
99     EXPECT_TRUE(ret);
100 
101     tag = "test";
102     ret = accessibilityProperty.IsAccessibilityFocusableTag(tag);
103     EXPECT_FALSE(ret);
104 }
105 
106 /**
107  * @tc.name: AccessibilityPropertyTest003
108  * @tc.desc: Test the method IsAccessibilityFocusableTag.
109  * @tc.type: FUNC
110  */
111 HWTEST_F(AccessibilityPropertyTestThreeNg, AccessibilityPropertyTestThree003, TestSize.Level1)
112 {
113     std::string tag = V2::CHECKBOX_ETS_TAG;
114     AccessibilityProperty accessibilityProperty;
115 
116     bool ret = accessibilityProperty.IsAccessibilityFocusableTag(tag);
117     EXPECT_TRUE(ret);
118 
119     tag = "test";
120     ret = accessibilityProperty.IsAccessibilityFocusableTag(tag);
121     EXPECT_FALSE(ret);
122 }
123 
124 /**
125  * @tc.name: AccessibilityPropertyTest004
126  * @tc.desc: Test the method SetAccessibilityNextFocusInspectorKey && SetAccessibilityTextWithEvent
127  *           && SetAccessibilityDescriptionWithEvent.
128  * @tc.type: FUNC
129  */
130 HWTEST_F(AccessibilityPropertyTestThreeNg, AccessibilityPropertyTestThree004, TestSize.Level1)
131 {
132     std::string accessibilityNextFocusInspectorKey = "test";
133     AccessibilityProperty accessibilityProperty;
134 
135     accessibilityProperty.SetAccessibilityNextFocusInspectorKey(accessibilityNextFocusInspectorKey);
136     EXPECT_EQ(accessibilityNextFocusInspectorKey, accessibilityProperty.accessibilityNextFocusInspectorKey_);
137 
138     accessibilityNextFocusInspectorKey = "";
139     accessibilityProperty.SetAccessibilityNextFocusInspectorKey(accessibilityNextFocusInspectorKey);
140     EXPECT_EQ(accessibilityNextFocusInspectorKey,
141         accessibilityProperty.accessibilityNextFocusInspectorKey_.value_or(""));
142 
143     std::string text = "test";
144     accessibilityProperty.SetAccessibilityTextWithEvent(text);
145     EXPECT_EQ(text, accessibilityProperty.accessibilityText_);
146 
147     text = "";
148     accessibilityProperty.SetAccessibilityTextWithEvent(text);
149     EXPECT_EQ(text, accessibilityProperty.accessibilityText_.value_or(""));
150 
151     std::string accessibilityDescription = "";
152     accessibilityProperty.SetAccessibilityDescriptionWithEvent(accessibilityDescription);
153     EXPECT_EQ(accessibilityDescription, accessibilityProperty.accessibilityDescription_.value_or(""));
154 }
155 
156 /**
157  * @tc.name: AccessibilityPropertyTest005
158  * @tc.desc: Test the method ActActionClick.
159  * @tc.type: FUNC
160  */
161 HWTEST_F(AccessibilityPropertyTestThreeNg, AccessibilityPropertyTestThree005, TestSize.Level1)
162 {
163     AccessibilityProperty accessibilityProperty;
164 
165     uint32_t action = 1;
166     accessibilityProperty.accessibilityActions_ = 1;
__anon1c13763a0202(uint32_t type)167     accessibilityProperty.actionsImpl_ = [](uint32_t type){};
168     bool actionsDefined = accessibilityProperty.ActionsDefined(action);
169     EXPECT_TRUE(actionsDefined);
170     actionsDefined = accessibilityProperty.ActionsDefined(static_cast<uint32_t>(ARKUI_ACCESSIBILITY_ACTION_CLICK));
171     EXPECT_TRUE(actionsDefined);
172     auto result = accessibilityProperty.ActActionClick();
173     EXPECT_TRUE(result);
174 
175     action = 0;
176     accessibilityProperty.accessibilityActions_ = 0;
177     accessibilityProperty.actionClickImpl_ = nullptr;
178     result = accessibilityProperty.ActActionClick();
179     EXPECT_FALSE(result);
180 }
181 
182 /**
183  * @tc.name: AccessibilityPropertyTest006
184  * @tc.desc: Test the method ActActionLongClick.
185  * @tc.type: FUNC
186  */
187 HWTEST_F(AccessibilityPropertyTestThreeNg, AccessibilityPropertyTestThree006, TestSize.Level1)
188 {
189     AccessibilityProperty accessibilityProperty;
190 
191     uint32_t action = 2;
192     accessibilityProperty.accessibilityActions_ = 2;
__anon1c13763a0302(uint32_t type)193     accessibilityProperty.actionsImpl_ = [](uint32_t type){};
194     bool actionsDefined = accessibilityProperty.ActionsDefined(action);
195     EXPECT_TRUE(actionsDefined);
196     actionsDefined = accessibilityProperty.ActionsDefined(static_cast<uint32_t>(ARKUI_ACCESSIBILITY_ACTION_LONG_CLICK));
197     EXPECT_TRUE(actionsDefined);
198     auto result = accessibilityProperty.ActActionLongClick();
199     EXPECT_TRUE(result);
200 
201     action = 0;
202     accessibilityProperty.accessibilityActions_ = 0;
203     accessibilityProperty.actionClickImpl_ = nullptr;
204     result = accessibilityProperty.ActActionLongClick();
205     EXPECT_FALSE(result);
206 }
207 
208 /**
209  * @tc.name: AccessibilityPropertyTest007
210  * @tc.desc: Test the method ActActionPaste.
211  * @tc.type: FUNC
212  */
213 HWTEST_F(AccessibilityPropertyTestThreeNg, AccessibilityPropertyTestThree007, TestSize.Level1)
214 {
215     AccessibilityProperty accessibilityProperty;
216 
217     uint32_t action = 16;
218     accessibilityProperty.accessibilityActions_ = 16;
__anon1c13763a0402(uint32_t type)219     accessibilityProperty.actionsImpl_ = [](uint32_t type){};
220     bool actionsDefined = accessibilityProperty.ActionsDefined(action);
221     EXPECT_TRUE(actionsDefined);
222     actionsDefined = accessibilityProperty.ActionsDefined(static_cast<uint32_t>(ARKUI_ACCESSIBILITY_ACTION_PASTE));
223     EXPECT_TRUE(actionsDefined);
224     auto result = accessibilityProperty.ActActionPaste();
225     EXPECT_TRUE(result);
226 }
227 
228 /**
229  * @tc.name: AccessibilityPropertyTest008
230  * @tc.desc: Test the method ActActionCut.
231  * @tc.type: FUNC
232  */
233 HWTEST_F(AccessibilityPropertyTestThreeNg, AccessibilityPropertyTestThree008, TestSize.Level1)
234 {
235     AccessibilityProperty accessibilityProperty;
236 
237     uint32_t action = 4;
238     accessibilityProperty.accessibilityActions_ = 4;
__anon1c13763a0502(uint32_t type)239     accessibilityProperty.actionsImpl_ = [](uint32_t type){};
240     bool actionsDefined = accessibilityProperty.ActionsDefined(action);
241     EXPECT_TRUE(actionsDefined);
242     actionsDefined = accessibilityProperty.ActionsDefined(static_cast<uint32_t>(ARKUI_ACCESSIBILITY_ACTION_CUT));
243     EXPECT_TRUE(actionsDefined);
244     auto result = accessibilityProperty.ActActionCut();
245     EXPECT_TRUE(result);
246 }
247 
248 /**
249  * @tc.name: AccessibilityPropertyTest009
250  * @tc.desc: Test the method ActActionCopy.
251  * @tc.type: FUNC
252  */
253 HWTEST_F(AccessibilityPropertyTestThreeNg, AccessibilityPropertyTestThree009, TestSize.Level1)
254 {
255     AccessibilityProperty accessibilityProperty;
256 
257     uint32_t action = 8;
258     accessibilityProperty.accessibilityActions_ = 8;
__anon1c13763a0602(uint32_t type)259     accessibilityProperty.actionsImpl_ = [](uint32_t type){};
260     bool actionsDefined = accessibilityProperty.ActionsDefined(action);
261     EXPECT_TRUE(actionsDefined);
262     actionsDefined = accessibilityProperty.ActionsDefined(static_cast<uint32_t>(ARKUI_ACCESSIBILITY_ACTION_COPY));
263     EXPECT_TRUE(actionsDefined);
264     auto result = accessibilityProperty.ActActionCopy();
265     EXPECT_TRUE(result);
266 }
267 
268 /**
269  * @tc.name: AccessibilityPropertyTest010
270  * @tc.desc: Test the method UpdateHoverTestRect.
271  * @tc.type: FUNC
272  */
273 HWTEST_F(AccessibilityPropertyTestThreeNg, AccessibilityPropertyTestThree010, TestSize.Level1)
274 {
275     AccessibilityProperty accessibilityProperty;
276     RectF origRect;
277     auto node = FrameNode::GetOrCreateFrameNode(
__anon1c13763a0702() 278         V2::BUTTON_ETS_TAG, 1, []() { return AceType::MakeRefPtr<ButtonPattern>(); });
279     auto ret = accessibilityProperty.UpdateHoverTestRect(node);
280     EXPECT_EQ(origRect, ret);
281 }
282 
283 /**
284  * @tc.name: AccessibilityPropertyTest011
285  * @tc.desc: Test the method HoverTestRecursive.
286  * @tc.type: FUNC
287  */
288 HWTEST_F(AccessibilityPropertyTestThreeNg, AccessibilityPropertyTestThree011, TestSize.Level1)
289 {
290     AccessibilityProperty accessibilityProperty;
291     PointF parentPoint(1, 1);
292     auto node = FrameNode::GetOrCreateFrameNode(
__anon1c13763a0802() 293         V2::BUTTON_ETS_TAG, 1, []() { return AceType::MakeRefPtr<ButtonPattern>(); });
294     AccessibilityHoverTestPath path;
295     std::unique_ptr<AccessibilityProperty::HoverTestDebugTraceInfo> debugInfo = nullptr;
296     bool ancestorGroupFlag;
297 
298     node->SetAccessibilityNodeVirtual();
299     EXPECT_TRUE(node->IsAccessibilityVirtualNode());
300     debugInfo = std::make_unique<AccessibilityProperty::HoverTestDebugTraceInfo>();
301 
302     bool ret = accessibilityProperty.HoverTestRecursive(parentPoint, node, path, debugInfo, ancestorGroupFlag);
303     EXPECT_FALSE(ret);
304 
305     node->isActive_ = true;
306     ret = accessibilityProperty.HoverTestRecursive(parentPoint, node, path, debugInfo, ancestorGroupFlag);
307     EXPECT_FALSE(ret);
308 }
309 
310 /**
311  * @tc.name: AccessibilityPropertyTestThree012
312  * @tc.desc: NotifyComponentChangeEvent
313  * @tc.type: FUNC
314  */
315 HWTEST_F(AccessibilityPropertyTestThreeNg, AccessibilityPropertyTestThree012, TestSize.Level1)
316 {
317     AccessibilityProperty accessibilityProperty;
318     AccessibilityEventType eventType = AccessibilityEventType::CLICK;
319     AceApplicationInfo::GetInstance().SetAccessibilityEnabled(false);
320     accessibilityProperty.NotifyComponentChangeEvent(eventType);
321 
322     AceApplicationInfo::GetInstance().SetAccessibilityEnabled(true);
323     auto node = FrameNode::GetOrCreateFrameNode(
__anon1c13763a0902() 324         V2::COLUMN_ETS_TAG, 0, []() { return AceType::MakeRefPtr<LinearLayoutPattern>(true); });
325     accessibilityProperty.host_ = AceType::WeakClaim(AceType::RawPtr(node));
326 
327     accessibilityProperty.NotifyComponentChangeEvent(eventType);
328     auto frameNode = accessibilityProperty.host_.Upgrade();
329     EXPECT_NE(frameNode, nullptr);
330     auto context = NG::MockPipelineContext::GetCurrent();
331     frameNode->context_ = AceType::RawPtr(context);
332     auto pipeline = frameNode->GetContext();
333     EXPECT_NE(pipeline, nullptr);
334 }
335 
336 /**
337  * @tc.name: AccessibilityPropertyTestThree013
338  * @tc.desc: HoverTestRecursive
339  * @tc.type: FUNC
340  */
341 HWTEST_F(AccessibilityPropertyTestThreeNg, AccessibilityPropertyTestThree013, TestSize.Level1)
342 {
343     AccessibilityProperty accessibilityProperty;
344     NG::PointF parentPoint(1, 1);
345     auto node = FrameNode::GetOrCreateFrameNode(
__anon1c13763a0a02() 346         V2::BUTTON_ETS_TAG, 13, []() { return AceType::MakeRefPtr<ButtonPattern>(); });
347     AccessibilityHoverTestPath path;
348     auto debugInfo = std::make_unique<AccessibilityProperty::HoverTestDebugTraceInfo>();
349     bool ancestorGroupFlag = false;
350 
351     node->isAccessibilityVirtualNode_ = true;
352     bool result = accessibilityProperty.HoverTestRecursive(parentPoint, node, path, debugInfo, ancestorGroupFlag);
353     EXPECT_FALSE(result);
354 
355     node->layoutProperty_->UpdateVisibility(VisibleType::INVISIBLE);
356     EXPECT_FALSE(node->IsVisible());
357     auto renderContext = node->GetRenderContext();
358     EXPECT_NE(renderContext, nullptr);
359     result = accessibilityProperty.HoverTestRecursive(parentPoint, node, path, debugInfo, ancestorGroupFlag);
360     EXPECT_FALSE(result);
361 }
362 
363 /**
364  * @tc.name: AccessibilityPropertyTestThree014
365  * @tc.desc: HoverTestRecursive
366  * @tc.type: FUNC
367  */
368 HWTEST_F(AccessibilityPropertyTestThreeNg, AccessibilityPropertyTestThree014, TestSize.Level1)
369 {
370     AccessibilityProperty accessibilityProperty;
371     NG::PointF parentPoint(150, 160);
372     auto node = FrameNode::GetOrCreateFrameNode(
__anon1c13763a0b02() 373         V2::BUTTON_ETS_TAG, 13, []() { return AceType::MakeRefPtr<ButtonPattern>(); });
374     AccessibilityHoverTestPath path;
375     auto debugInfo = std::make_unique<AccessibilityProperty::HoverTestDebugTraceInfo>();
376     bool ancestorGroupFlag = false;
377     node->isAccessibilityVirtualNode_ = true;
378 
379     auto eventHub = node->GetOrCreateEventHub<EventHub>();
380     eventHub->enabled_ = false;
381 
382     auto mockRenderContext = AceType::MakeRefPtr<MockRenderContext>();
383     node->renderContext_ = mockRenderContext;
384     RectF rect1(100, 100, 100, 100);
385     mockRenderContext->SetPaintRectWithTransform(rect1);
386 
387     PointF selfPoint = parentPoint;
388     mockRenderContext->GetPointWithRevert(selfPoint);
389 
390     auto property = node->GetAccessibilityProperty<NG::AccessibilityProperty>();
391     property->accessibilityLevel_ = AccessibilityProperty::Level::YES_STR;
392     property->accessibilityHoverPriority_ = true;
393 
394     auto result = accessibilityProperty.HoverTestRecursive(parentPoint, node, path, debugInfo, ancestorGroupFlag);
395     EXPECT_TRUE(result);
396 }
397 
398 /**
399  * @tc.name: AccessibilityPropertyTestThree015
400  * @tc.desc: ProcessHoverTestRecursive
401  * @tc.type: FUNC
402  */
403 HWTEST_F(AccessibilityPropertyTestThreeNg, AccessibilityPropertyTestThree015, TestSize.Level1)
404 {
405     AccessibilityProperty accessibilityProperty;
406     AccessibilityHoverTestPath path;
407     auto node = FrameNode::GetOrCreateFrameNode(
__anon1c13763a0c02() 408         V2::BUTTON_ETS_TAG, 13, []() { return AceType::MakeRefPtr<ButtonPattern>(); });
409     NG::PointF hoverPoint(1, 1);
410     auto debugInfo = std::make_unique<AccessibilityProperty::HoverTestDebugTraceInfo>();
411     AccessibilityProperty::RecursiveParam recursiveParam;
412     recursiveParam.hitTarget = true;
413     recursiveParam.ancestorGroupFlag = true;
414 
415     auto property = node->GetAccessibilityProperty<NG::AccessibilityProperty>();
416     property->accessibilityVirtualNode_ = node;
417     auto virtualNode = property->GetAccessibilityVirtualNode();
418     EXPECT_NE(virtualNode, nullptr);
419     auto frameNode = AceType::DynamicCast<FrameNode>(virtualNode);
420     EXPECT_NE(frameNode, nullptr);
421 
422     bool ret = AccessibilityProperty::HoverTestRecursive(hoverPoint, frameNode, path, debugInfo,
423             recursiveParam.ancestorGroupFlag);
424     EXPECT_FALSE(ret);
425 
426     auto result = accessibilityProperty.ProcessHoverTestRecursive(hoverPoint, node, path, debugInfo, recursiveParam);
427     EXPECT_EQ(result, true);
428 }
429 
430 /**
431  * @tc.name: AccessibilityPropertyTestThree016
432  * @tc.desc: SpecificSupportActionCallback
433  * @tc.type: FUNC
434  */
435 HWTEST_F(AccessibilityPropertyTestThreeNg, AccessibilityPropertyTestThree016, TestSize.Level1)
436 {
437     AccessibilityProperty accessibilityProperty;
438 
__anon1c13763a0d02() 439     accessibilityProperty.SetSpecificSupportActionCallback([&]() {
440         accessibilityProperty.AddSupportAction(AceAction::ACTION_SCROLL_BACKWARD);
441     });
442     auto supportAceActions = accessibilityProperty.GetSupportAction();
443     auto ret = std::any_of(supportAceActions.begin(),
444         supportAceActions.end(),
__anon1c13763a0e02(const AceAction& action) 445         [](const AceAction& action) { return action == AceAction::ACTION_SCROLL_BACKWARD; });
446     EXPECT_EQ(ret, false);
447 
448     accessibilityProperty.ResetSupportAction();
449 
450     supportAceActions = accessibilityProperty.GetSupportAction();
451     ret = std::any_of(supportAceActions.begin(),
452         supportAceActions.end(),
__anon1c13763a0f02(const AceAction& action) 453         [](const AceAction& action) { return action == AceAction::ACTION_SCROLL_BACKWARD; });
454     EXPECT_EQ(ret, true);
455 }
456 
457 /**
458  * @tc.name: AccessibilityPropertyTest017
459  * @tc.desc: Test the method SetAccessibilityGroup.
460  * @tc.type: FUNC
461  */
462 HWTEST_F(AccessibilityPropertyTestThreeNg, AccessibilityPropertyTestThree017, TestSize.Level1)
463 {
464     AccessibilityProperty accessibilityProperty;
465     EXPECT_FALSE(accessibilityProperty.accessibilityGroup_);
466     WeakPtr<FrameNode> hostBak = accessibilityProperty.host_;
467     bool accessibilityGroup = true;
468     accessibilityProperty.SetAccessibilityGroup(accessibilityGroup);
469     EXPECT_TRUE(accessibilityProperty.accessibilityGroup_);
470 }
471 
472 /**
473  * @tc.name: AccessibilityPropertyTest018
474  * @tc.desc: Test the method SetAccessibilityTextWithEvent.
475  * @tc.type: FUNC
476  */
477 HWTEST_F(AccessibilityPropertyTestThreeNg, AccessibilityPropertyTestThree018, TestSize.Level1)
478 {
479     AccessibilityProperty accessibilityProperty;
480     EXPECT_FALSE(accessibilityProperty.accessibilityText_.has_value());
481     WeakPtr<FrameNode> hostBak = accessibilityProperty.host_;
482     accessibilityProperty.SetAccessibilityTextWithEvent(TEST_TEXT);
483     EXPECT_EQ(accessibilityProperty.accessibilityText_.value_or(""), TEST_TEXT);
484 }
485 
486 /**
487  * @tc.name: AccessibilityPropertyTest019
488  * @tc.desc: Test the method SetAccessibilityDescriptionWithEvent.
489  * @tc.type: FUNC
490  */
491 HWTEST_F(AccessibilityPropertyTestThreeNg, AccessibilityPropertyTestThree019, TestSize.Level1)
492 {
493     AccessibilityProperty accessibilityProperty;
494     EXPECT_FALSE(accessibilityProperty.accessibilityDescription_.has_value());
495     WeakPtr<FrameNode> hostBak = accessibilityProperty.host_;
496     accessibilityProperty.SetAccessibilityDescriptionWithEvent(TEST_TEXT);
497     EXPECT_EQ(accessibilityProperty.accessibilityDescription_.value_or(""), TEST_TEXT);
498 }
499 
500 /**
501  * @tc.name: AccessibilityPropertyTest020
502  * @tc.desc: Test the method SetAccessibilityLevel.
503  * @tc.type: FUNC
504  */
505 HWTEST_F(AccessibilityPropertyTestThreeNg, AccessibilityPropertyTestThree020, TestSize.Level1)
506 {
507     AccessibilityProperty accessibilityProperty;
508     EXPECT_FALSE(accessibilityProperty.accessibilityLevel_.has_value());
509     WeakPtr<FrameNode> hostBak = accessibilityProperty.host_;
510     std::string accessibilityLevel = "auto";
511     accessibilityProperty.SetAccessibilityLevel(accessibilityLevel);
512     EXPECT_EQ(accessibilityProperty.accessibilityLevel_.value_or(""), accessibilityLevel);
513 }
514 } // namespace OHOS::Ace::NG
515