• 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 "gtest/gtest.h"
17 
18 #define private public
19 #define protected public
20 #include "frameworks/core/accessibility/accessibility_manager.h"
21 #include "frameworks/core/accessibility/accessibility_node.h"
22 #include "frameworks/core/accessibility/accessibility_utils.h"
23 #include "core/common/container.h"
24 #include "test/mock/core/common/mock_container.h"
25 #include "test/mock/core/pipeline/mock_pipeline_context.h"
26 using namespace testing;
27 using namespace testing::ext;
28 
29 namespace OHOS::Ace::NG {
30 namespace {
31 const double TEST_NUMBER = 10.0;
32 const double TEST_NUMBER_SECOND = 11.0;
33 const char VALUE[] = "value";
34 const char TYPE[] = "type";
35 const char DISABLED[] = "disabled";
36 const char GROUP[] = "accessibilitygroup";
37 const char ACCESS_TEXT[] = "accessibilitytext";
38 const char DESCRIPTION[] = "accessibilitydescription";
39 const char IMPORTANCE[] = "accessibilityimportance";
40 const char SHOW[] = "show";
41 const char ID[] = "id";
42 const char EVENT[] = "accessibility";
43 const char CLICK[] = "click";
44 const char LONG_PRESS[] = "longpress";
45 const char FOCUS[] = "focus";
46 const char BLUR[] = "blur";
47 const char FAKE[] = "fake";
48 const char INPUT_TYPE_CHECKBOX[] = "checkbox";
49 const char INPUT_TYPE_RADIO[] = "radio";
50 const char INPUT_TYPE_PASSWORD[] = "password";
51 } // namespace
52 
53 class AccessibilityNodeTestNg : public testing::Test {
54 public:
SetUpTestCase()55     static void SetUpTestCase()
56     {
57         MockPipelineContext::SetUp();
58         MockContainer::SetUp();
59     };
TearDownTestCase()60     static void TearDownTestCase() {};
61 };
62 
63 /**
64  * @tc.name: accessibilityNodeTest001
65  * @tc.type: FUNC
66  */
67 HWTEST_F(AccessibilityNodeTestNg, accessibilityNodeTest001, TestSize.Level1)
68 {
69     NodeId id = 0;
70     std::string nodeName = "accessibilityNodeTest";
71     AccessibilityNode accessibilityNode(id, nodeName);
72     EXPECT_FALSE(accessibilityNode.ActionClick());
__anoned395de50202() 73     accessibilityNode.SetActionClickImpl([]() {});
74     EXPECT_TRUE(accessibilityNode.ActionClick());
75 
76     EXPECT_FALSE(accessibilityNode.ActionLongClick());
__anoned395de50302() 77     accessibilityNode.SetActionLongClickImpl([]() {});
78     EXPECT_TRUE(accessibilityNode.ActionLongClick());
79 
80     EXPECT_FALSE(accessibilityNode.ActionSetText(nodeName));
__anoned395de50402(const std::string& text) 81     accessibilityNode.SetActionSetTextImpl([](const std::string& text) {});
82     EXPECT_TRUE(accessibilityNode.ActionSetText(nodeName));
83 
84     EXPECT_FALSE(accessibilityNode.ActionScrollForward());
__anoned395de50502() 85     accessibilityNode.SetActionScrollForward([]() { return true; });
86     EXPECT_TRUE(accessibilityNode.ActionScrollForward());
87 
88     EXPECT_FALSE(accessibilityNode.ActionScrollBackward());
__anoned395de50602() 89     accessibilityNode.SetActionScrollBackward([]() { return true; });
90     EXPECT_TRUE(accessibilityNode.ActionScrollBackward());
91 
92     bool result = true;
93     EXPECT_FALSE(accessibilityNode.ActionAccessibilityFocus(result));
__anoned395de50702(bool result) 94     accessibilityNode.SetActionAccessibilityFocusImpl([](bool result) {});
95     EXPECT_TRUE(accessibilityNode.ActionAccessibilityFocus(result));
96 
97     EXPECT_FALSE(accessibilityNode.ActionFocus());
__anoned395de50802() 98     accessibilityNode.SetActionFocusImpl([]() {});
99     EXPECT_TRUE(accessibilityNode.ActionFocus());
100 
101     accessibilityNode.ActionUpdateIds();
__anoned395de50902() 102     accessibilityNode.SetActionUpdateIdsImpl([]() {});
103     accessibilityNode.ActionUpdateIds();
104 }
105 
106 /**
107  * @tc.name: accessibilityNodeTest002
108  * @tc.type: FUNC
109  */
110 HWTEST_F(AccessibilityNodeTestNg, accessibilityNodeTest002, TestSize.Level1)
111 {
112     NodeId id = 0;
113     std::string nodeName = "accessibilityNodeTest";
114     AccessibilityNode accessibilityNode(id, nodeName);
115 
116     PositionInfo positionInfo;
117     positionInfo.height = TEST_NUMBER;
118     positionInfo.width = TEST_NUMBER;
119     accessibilityNode.SetPositionInfo(positionInfo);
120     EXPECT_EQ(accessibilityNode.GetHeight(), TEST_NUMBER);
121     EXPECT_EQ(accessibilityNode.GetWidth(), TEST_NUMBER);
122     accessibilityNode.SetHeight(TEST_NUMBER_SECOND);
123     accessibilityNode.SetWidth(TEST_NUMBER_SECOND);
124     EXPECT_EQ(accessibilityNode.GetHeight(), TEST_NUMBER_SECOND);
125     EXPECT_EQ(accessibilityNode.GetWidth(), TEST_NUMBER_SECOND);
__anoned395de50a02(const std::string& str) 126     accessibilityNode.focusChangeEventId_ = [](const std::string& str) {};
127     accessibilityNode.SetFocusedState(false);
128     accessibilityNode.SetFocusedState(true);
129 
130     EXPECT_EQ(accessibilityNode.GetSupportAction().size(), 0);
131     accessibilityNode.supportActions_ = static_cast<uint32_t>(AceAction::ACTION_SCROLL_FORWARD);
132     EXPECT_EQ(accessibilityNode.GetSupportAction().size(), 1);
133 
134     Rect testRect(10.0, 10.0, 5.0, 5.0);
135     accessibilityNode.SetRect(testRect);
136     EXPECT_EQ(accessibilityNode.GetWidth(), 5.0);
137     accessibilityNode.GetRect();
138 }
139 
140 /**
141  * @tc.name: accessibilityNodeTest003
142  * @tc.type: FUNC
143  */
144 HWTEST_F(AccessibilityNodeTestNg, accessibilityNodeTest003, TestSize.Level1)
145 {
146     NodeId id = 0;
147     std::string nodeName = "text";
148     AccessibilityNode accessibilityNode(id, nodeName);
149 
150     std::vector<std::pair<std::string, std::string>> vec;
151     vec.emplace_back(std::make_pair(VALUE, "ACCESSIBILITY_VALUE"));
152     vec.emplace_back(std::make_pair(DISABLED, "ACCESSIBILITY_DISABLED"));
153     vec.emplace_back(std::make_pair(TYPE, "ACCESSIBILITY_TYPE"));
154     vec.emplace_back(std::make_pair(GROUP, "ACCESSIBILITY_GROUP"));
155     vec.emplace_back(std::make_pair(ACCESS_TEXT, "ACCESSIBILITY_TEXT"));
156     vec.emplace_back(std::make_pair(DESCRIPTION, "ACCESSIBILITY_DESCRIPTION"));
157     vec.emplace_back(std::make_pair(IMPORTANCE, "ACCESSIBILITY_IMPORTANCE"));
158     vec.emplace_back(std::make_pair(ID, "ID"));
159     vec.emplace_back(std::make_pair(SHOW, "ACCESSIBILITY_SHOW"));
160 
161     accessibilityNode.SetStyle(vec);
162     accessibilityNode.SetAttr(vec);
163     EXPECT_EQ(accessibilityNode.inputType_, "ACCESSIBILITY_TYPE");
164     EXPECT_TRUE(accessibilityNode.isEnabled_);
165     EXPECT_EQ(accessibilityNode.accessibilityLabel_, "ACCESSIBILITY_TEXT");
166     EXPECT_EQ(accessibilityNode.accessibilityHint_, "ACCESSIBILITY_DESCRIPTION");
167     EXPECT_EQ(accessibilityNode.importantForAccessibility_, "ACCESSIBILITY_IMPORTANCE");
168 
169     accessibilityNode.attrs_.emplace_back(std::make_pair(IMPORTANCE, "ACCESSIBILITY_IMPORTANCE"));
170     accessibilityNode.SetAttr(vec);
171     EXPECT_EQ(accessibilityNode.importantForAccessibility_, "ACCESSIBILITY_IMPORTANCE");
172 
173     accessibilityNode.SetTag("text");
174     accessibilityNode.SetAttr(vec);
175 }
176 
177 /**
178  * @tc.name: accessibilityNodeTest004
179  * @tc.type: FUNC
180  */
181 HWTEST_F(AccessibilityNodeTestNg, accessibilityNodeTest004, TestSize.Level1)
182 {
183     NodeId id = 0;
184     std::string nodeName = "text";
185     AccessibilityNode accessibilityNode(id, nodeName);
186 
187     std::vector<std::string> vec;
188     vec.emplace_back(EVENT);
189     vec.emplace_back(CLICK);
190     vec.emplace_back(LONG_PRESS);
191     vec.emplace_back(FOCUS);
192     vec.emplace_back(BLUR);
193     vec.emplace_back(FAKE);
194 
195     accessibilityNode.AddEvent(0, vec);
196     EXPECT_TRUE(accessibilityNode.isClickable_);
197     EXPECT_TRUE(accessibilityNode.isLongClickable_);
198 
199     accessibilityNode.GetAccessibilityEventMarker();
200     accessibilityNode.GetClickEventMarker();
201     accessibilityNode.GetLongPressEventMarker();
202     accessibilityNode.GetFocusEventMarker();
203     accessibilityNode.GetBlurEventMarker();
204 }
205 
206 /**
207  * @tc.name: accessibilityNodeTest005
208  * @tc.type: FUNC
209  */
210 HWTEST_F(AccessibilityNodeTestNg, accessibilityNodeTest005, TestSize.Level1)
211 {
212     /**
213      * @tc.steps: step1. create AccessibilityNode and vector.
214      */
215     NodeId id = 0;
216     std::string nodeName = "text";
217     AccessibilityNode accessibilityNode(id, nodeName);
218 
219     /**
220      * @tc.steps: step2. create offset.
221      */
222     Offset offset(1.0, 1.0);
223 
224     /**
225      * @tc.steps: step3. create child and add node twice.
226      * @tc.expected: only one can add success.
227      */
228     auto child = AceType::MakeRefPtr<AccessibilityNode>(1, "child");
229     accessibilityNode.AddNode(child, 0);
230     accessibilityNode.AddNode(child, 0);
231     EXPECT_EQ(accessibilityNode.children_.size(), 1);
232 
233     /**
234      * @tc.steps: step4. call AddOffsetForChildren.
235      * @tc.expected: accessibilityNode offset is meet expectations.
236      */
237     accessibilityNode.AddOffsetForChildren(offset);
238     EXPECT_EQ(accessibilityNode.GetLeft(), 1);
239 
240     /**
241      * @tc.steps: step5. call remove node.
242      * @tc.expected: child remove success.
243      */
244     accessibilityNode.RemoveNode(child);
245     EXPECT_EQ(accessibilityNode.children_.size(), 0);
246 
247     /**
248      * @tc.steps: step6. ResetChildList.
249      * @tc.expected: .
250      */
251     NodeId idSecond = 11;
252     std::string nodeNameSecond = "textSecond";
253     AccessibilityNode accessibilityNodeSecond(idSecond, nodeNameSecond);
254     accessibilityNodeSecond.AddNode(child, 0);
255     accessibilityNodeSecond.AddNode(child, 1);
256     accessibilityNode.ResetChildList(accessibilityNodeSecond.children_);
257     EXPECT_EQ(accessibilityNode.children_.size(), 1);
258 }
259 
260 /**
261  * @tc.name: accessibilityNodeTest006
262  * @tc.type: FUNC
263  */
264 HWTEST_F(AccessibilityNodeTestNg, accessibilityNodeTest006, TestSize.Level1)
265 {
266     /**
267      * @tc.steps: step1. create AccessibilityNode and vector.
268      */
269     NodeId id = 0;
270     AccessibilityNode currentNode(id, "test");
271     std::vector<std::pair<std::string, std::string>> vec;
272 
273     /**
274      * @tc.steps: step2. config pare and call SetAttr.
275      * @tc.expected: currentNode params text_ is meet expectations.
276      */
277     vec.emplace_back(std::make_pair(VALUE, "value"));
278     currentNode.SetAttr(vec);
279     EXPECT_EQ(currentNode.text_, "value");
280 
281     /**
282      * @tc.steps: step3. create a parent node and setTag recall SetAttr.
283      * @tc.expected: currentNode params text_ is meet expectations.
284      */
285     auto parentNode = AceType::MakeRefPtr<AccessibilityNode>(1, "parent");
286     currentNode.SetParentNode(parentNode);
287     currentNode.SetTag("text");
288     currentNode.SetAttr(vec);
289     EXPECT_NE(parentNode->text_, "value");
290 
291     /**
292      * @tc.steps: step4. put a fake value in pair and set tag popup.
293      * @tc.expected: currentNode params text_ is meet expectations.
294      */
295     vec.emplace_back(std::make_pair(FAKE, "FAKE_VALUE"));
296     parentNode->SetTag("popup");
297     currentNode.SetAttr(vec);
298     EXPECT_EQ(parentNode->text_, "value");
299 
300     /**
301      * @tc.steps: step5. set tag input, put a wrong type in pair, initialization parameters.
302      * @tc.expected: currentNode params isCheckable_ is false.
303      */
304     currentNode.SetTag("input");
305     currentNode.isFocusable_ = false;
306     currentNode.isCheckable_ = false;
307     currentNode.isCheckable_ = false;
308     vec.emplace_back(std::make_pair(TYPE, FAKE));
309     currentNode.SetAttr(vec);
310     EXPECT_FALSE(currentNode.isCheckable_);
311 
312     /**
313      * @tc.steps: step6. remove fake pair and put type with INPUT_TYPE_CHECKBOX.
314      * @tc.expected: currentNode params isCheckable_ is true.
315      */
316     vec.pop_back();
317     vec.emplace_back(std::make_pair(TYPE, INPUT_TYPE_CHECKBOX));
318     currentNode.SetAttr(vec);
319     EXPECT_TRUE(currentNode.isCheckable_);
320 
321     /**
322      * @tc.steps: step7. remove fake pair and put type with INPUT_TYPE_RADIO.
323      * @tc.expected: currentNode params isCheckable_ is true.
324      */
325     currentNode.isCheckable_ = false;
326     vec.pop_back();
327     vec.emplace_back(std::make_pair(TYPE, INPUT_TYPE_RADIO));
328     currentNode.SetAttr(vec);
329     EXPECT_TRUE(currentNode.isCheckable_);
330 
331     /**
332      * @tc.steps: step8. remove fake pair and put type with INPUT_TYPE_PASSWORD.
333      * @tc.expected: currentNode params isPassword_ is true.
334      */
335     vec.pop_back();
336     vec.emplace_back(std::make_pair(TYPE, INPUT_TYPE_PASSWORD));
337     currentNode.SetAttr(vec);
338     EXPECT_TRUE(currentNode.GetIsPassword());
339     int windowId = 233;
340     currentNode.SetWindowId(windowId);
341     EXPECT_EQ(currentNode.GetWindowId(), windowId);
342     currentNode.SetIsRootNode(false);
343     EXPECT_FALSE(currentNode.IsRootNode());
344     int pageId = 233;
345     currentNode.SetPageId(pageId);
346     EXPECT_EQ(currentNode.GetPageId(), pageId);
347     currentNode.SetHintText("233");
348     EXPECT_EQ(currentNode.GetHintText(), "233");
349     currentNode.SetAccessibilityLabel("yes");
350     EXPECT_EQ(currentNode.GetAccessibilityLabel(), "yes");
351     currentNode.SetCheckableState(true);
352     EXPECT_TRUE(currentNode.GetCheckableState());
353     currentNode.SetCheckedState(true);
354     EXPECT_TRUE(currentNode.GetCheckedState());
355     currentNode.SetEnabledState(false);
356     EXPECT_FALSE(currentNode.GetEnabledState());
357     currentNode.SetEditable(true);
358     EXPECT_TRUE(currentNode.GetEditable());
359     currentNode.SetFocusableState(true);
360     EXPECT_TRUE(currentNode.GetFocusableState());
361     currentNode.SetAccessibilityFocusedState(true);
362     EXPECT_TRUE(currentNode.GetAccessibilityFocusedState());
363     currentNode.SetSelectedState(true);
364     EXPECT_TRUE(currentNode.GetSelectedState());
365     currentNode.SetClickableState(true);
366     EXPECT_TRUE(currentNode.GetClickableState());
367     currentNode.SetScrollableState(true);
368     EXPECT_TRUE(currentNode.GetScrollableState());
369     currentNode.SetLongClickableState(true);
370     EXPECT_TRUE(currentNode.GetLongClickableState());
371     currentNode.SetIsMultiLine(true);
372     EXPECT_TRUE(currentNode.GetIsMultiLine());
373     currentNode.SetIsPassword(false);
374     EXPECT_FALSE(currentNode.GetIsPassword());
375     currentNode.SetAccessibilityHint("233");
376     EXPECT_EQ(currentNode.GetAccessibilityHint(), "233");
377     currentNode.SetVisible(true);
378     EXPECT_TRUE(currentNode.GetVisible());
379 }
380 
381 /**
382  * @tc.name: accessibilityNodeTest007
383  * @tc.type: FUNC
384  */
385 HWTEST_F(AccessibilityNodeTestNg, accessibilityNodeTest007, TestSize.Level1)
386 {
387     /**
388      * @tc.steps: step1. create EventMarker with empty eventId and AccessibilityNode.
389      */
390     NodeId id = 0;
391     int32_t pageId = 1;
392     auto marker = EventMarker("", "event", pageId);
393     std::string nodeName = "text";
394     AccessibilityNode accessibilityNode(id, nodeName);
395     accessibilityNode.Mount(0);
396     /**
397      * @tc.steps: step2. call SetFocusChangeEventMarker function.
398      * @tc.expected: the param focusChangeEventId_ in accessibilityNode is null.
399      */
400     accessibilityNode.SetFocusChangeEventMarker(marker);
401     EXPECT_FALSE(accessibilityNode.focusChangeEventId_);
402 
403     /**
404      * @tc.steps: step3. set eventId not empty and config Container, then recall SetFocusChangeEventMarker.
405      * @tc.expected: the param focusChangeEventId_ in accessibilityNode is null.
406      */
407     marker.data_->eventId = std::to_string(id);
408     MockContainer::Current()->pipelineContext_ = MockPipelineContext::GetCurrent();
409     accessibilityNode.SetFocusChangeEventMarker(marker);
410     EXPECT_FALSE(accessibilityNode.focusChangeEventId_);
411 }
412 } // namespace OHOS::Ace::NG
413