• 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 char VALUE[] = "value";
33 const char TYPE[] = "type";
34 const char DISABLED[] = "disabled";
35 const char GROUP[] = "accessibilitygroup";
36 const char ACCESS_TEXT[] = "accessibilitytext";
37 const char DESCRIPTION[] = "accessibilitydescription";
38 const char IMPORTANCE[] = "accessibilityimportance";
39 const char SHOW[] = "show";
40 const char ID[] = "id";
41 const char EVENT[] = "accessibility";
42 const char CLICK[] = "click";
43 const char LONG_PRESS[] = "longpress";
44 const char FOCUS[] = "focus";
45 const char BLUR[] = "blur";
46 const char FAKE[] = "fake";
47 const char INPUT_TYPE_CHECKBOX[] = "checkbox";
48 const char INPUT_TYPE_RADIO[] = "radio";
49 const char INPUT_TYPE_PASSWORD[] = "password";
50 } // namespace
51 
52 class AccessibilityNodeTestNg : public testing::Test {
53 public:
SetUpTestCase()54     static void SetUpTestCase()
55     {
56         MockPipelineContext::SetUp();
57         MockContainer::SetUp();
58     };
TearDownTestCase()59     static void TearDownTestCase() {};
60 };
61 
62 /**
63  * @tc.name: accessibilityNodeTest001
64  * @tc.type: FUNC
65  */
66 HWTEST_F(AccessibilityNodeTestNg, accessibilityNodeTest001, TestSize.Level1)
67 {
68     NodeId id = 0;
69     std::string nodeName = "accessibilityNodeTest";
70     AccessibilityNode accessibilityNode(id, nodeName);
71     EXPECT_FALSE(accessibilityNode.ActionClick());
__anon052614860202() 72     accessibilityNode.SetActionClickImpl([]() {});
73     EXPECT_TRUE(accessibilityNode.ActionClick());
74 
75     EXPECT_FALSE(accessibilityNode.ActionLongClick());
__anon052614860302() 76     accessibilityNode.SetActionLongClickImpl([]() {});
77     EXPECT_TRUE(accessibilityNode.ActionLongClick());
78 
79     EXPECT_FALSE(accessibilityNode.ActionSetText(nodeName));
__anon052614860402(const std::string& text) 80     accessibilityNode.SetActionSetTextImpl([](const std::string& text) {});
81     EXPECT_TRUE(accessibilityNode.ActionSetText(nodeName));
82 
83     EXPECT_FALSE(accessibilityNode.ActionScrollForward());
__anon052614860502() 84     accessibilityNode.SetActionScrollForward([]() { return true; });
85     EXPECT_TRUE(accessibilityNode.ActionScrollForward());
86 
87     EXPECT_FALSE(accessibilityNode.ActionScrollBackward());
__anon052614860602() 88     accessibilityNode.SetActionScrollBackward([]() { return true; });
89     EXPECT_TRUE(accessibilityNode.ActionScrollBackward());
90 
91     bool result = true;
92     EXPECT_FALSE(accessibilityNode.ActionAccessibilityFocus(result));
__anon052614860702(bool result) 93     accessibilityNode.SetActionAccessibilityFocusImpl([](bool result) {});
94     EXPECT_TRUE(accessibilityNode.ActionAccessibilityFocus(result));
95 
96     EXPECT_FALSE(accessibilityNode.ActionFocus());
__anon052614860802() 97     accessibilityNode.SetActionFocusImpl([]() {});
98     EXPECT_TRUE(accessibilityNode.ActionFocus());
99 
100     accessibilityNode.ActionUpdateIds();
__anon052614860902() 101     accessibilityNode.SetActionUpdateIdsImpl([]() {});
102     accessibilityNode.ActionUpdateIds();
103 }
104 
105 /**
106  * @tc.name: accessibilityNodeTest002
107  * @tc.type: FUNC
108  */
109 HWTEST_F(AccessibilityNodeTestNg, accessibilityNodeTest002, TestSize.Level1)
110 {
111     NodeId id = 0;
112     std::string nodeName = "accessibilityNodeTest";
113     AccessibilityNode accessibilityNode(id, nodeName);
114 
115     PositionInfo positionInfo;
116     positionInfo.height = TEST_NUMBER;
117     accessibilityNode.SetPositionInfo(positionInfo);
118     EXPECT_EQ(accessibilityNode.rect_.Height(), TEST_NUMBER);
119 
__anon052614860a02(const std::string& str) 120     accessibilityNode.focusChangeEventId_ = [](const std::string& str) {};
121     accessibilityNode.SetFocusedState(false);
122     accessibilityNode.SetFocusedState(true);
123 
124     EXPECT_EQ(accessibilityNode.GetSupportAction().size(), 0);
125     accessibilityNode.supportActions_ = static_cast<uint32_t>(AceAction::ACTION_SCROLL_FORWARD);
126     EXPECT_EQ(accessibilityNode.GetSupportAction().size(), 1);
127 }
128 
129 /**
130  * @tc.name: accessibilityNodeTest003
131  * @tc.type: FUNC
132  */
133 HWTEST_F(AccessibilityNodeTestNg, accessibilityNodeTest003, TestSize.Level1)
134 {
135     NodeId id = 0;
136     std::string nodeName = "text";
137     AccessibilityNode accessibilityNode(id, nodeName);
138 
139     std::vector<std::pair<std::string, std::string>> vec;
140     vec.emplace_back(std::make_pair(VALUE, "ACCESSIBILITY_VALUE"));
141     vec.emplace_back(std::make_pair(DISABLED, "ACCESSIBILITY_DISABLED"));
142     vec.emplace_back(std::make_pair(TYPE, "ACCESSIBILITY_TYPE"));
143     vec.emplace_back(std::make_pair(GROUP, "ACCESSIBILITY_GROUP"));
144     vec.emplace_back(std::make_pair(ACCESS_TEXT, "ACCESSIBILITY_TEXT"));
145     vec.emplace_back(std::make_pair(DESCRIPTION, "ACCESSIBILITY_DESCRIPTION"));
146     vec.emplace_back(std::make_pair(IMPORTANCE, "ACCESSIBILITY_IMPORTANCE"));
147     vec.emplace_back(std::make_pair(ID, "ID"));
148     vec.emplace_back(std::make_pair(SHOW, "ACCESSIBILITY_SHOW"));
149 
150     accessibilityNode.SetAttr(vec);
151     EXPECT_EQ(accessibilityNode.inputType_, "ACCESSIBILITY_TYPE");
152     EXPECT_TRUE(accessibilityNode.isEnabled_);
153     EXPECT_EQ(accessibilityNode.accessibilityLabel_, "ACCESSIBILITY_TEXT");
154     EXPECT_EQ(accessibilityNode.accessibilityHint_, "ACCESSIBILITY_DESCRIPTION");
155     EXPECT_EQ(accessibilityNode.importantForAccessibility_, "ACCESSIBILITY_IMPORTANCE");
156 
157     accessibilityNode.attrs_.emplace_back(std::make_pair(IMPORTANCE, "ACCESSIBILITY_IMPORTANCE"));
158     accessibilityNode.SetAttr(vec);
159     EXPECT_EQ(accessibilityNode.importantForAccessibility_, "ACCESSIBILITY_IMPORTANCE");
160 
161     accessibilityNode.SetTag("text");
162     accessibilityNode.SetAttr(vec);
163 }
164 
165 /**
166  * @tc.name: accessibilityNodeTest004
167  * @tc.type: FUNC
168  */
169 HWTEST_F(AccessibilityNodeTestNg, accessibilityNodeTest004, TestSize.Level1)
170 {
171     NodeId id = 0;
172     std::string nodeName = "text";
173     AccessibilityNode accessibilityNode(id, nodeName);
174 
175     std::vector<std::string> vec;
176     vec.emplace_back(EVENT);
177     vec.emplace_back(CLICK);
178     vec.emplace_back(LONG_PRESS);
179     vec.emplace_back(FOCUS);
180     vec.emplace_back(BLUR);
181     vec.emplace_back(FAKE);
182 
183     accessibilityNode.AddEvent(0, vec);
184     EXPECT_TRUE(accessibilityNode.isClickable_);
185     EXPECT_TRUE(accessibilityNode.isLongClickable_);
186 }
187 
188 /**
189  * @tc.name: accessibilityNodeTest005
190  * @tc.type: FUNC
191  */
192 HWTEST_F(AccessibilityNodeTestNg, accessibilityNodeTest005, TestSize.Level1)
193 {
194     /**
195      * @tc.steps: step1. create AccessibilityNode and vector.
196      */
197     NodeId id = 0;
198     std::string nodeName = "text";
199     AccessibilityNode accessibilityNode(id, nodeName);
200 
201     /**
202      * @tc.steps: step2. create offset.
203      */
204     Offset offset(1.0, 1.0);
205 
206     /**
207      * @tc.steps: step3. create child and add node twice.
208      * @tc.expected: only one can add success.
209      */
210     auto child = AceType::MakeRefPtr<AccessibilityNode>(1, "child");
211     accessibilityNode.AddNode(child, 0);
212     accessibilityNode.AddNode(child, 0);
213     EXPECT_EQ(accessibilityNode.children_.size(), 1);
214 
215     /**
216      * @tc.steps: step4. call AddOffsetForChildren.
217      * @tc.expected: accessibilityNode offset is meet expectations.
218      */
219     accessibilityNode.AddOffsetForChildren(offset);
220     EXPECT_EQ(accessibilityNode.GetLeft(), 1);
221 
222     /**
223      * @tc.steps: step5. call remove node.
224      * @tc.expected: child remove success.
225      */
226     accessibilityNode.RemoveNode(child);
227     EXPECT_EQ(accessibilityNode.children_.size(), 0);
228 }
229 
230 /**
231  * @tc.name: accessibilityNodeTest006
232  * @tc.type: FUNC
233  */
234 HWTEST_F(AccessibilityNodeTestNg, accessibilityNodeTest006, TestSize.Level1)
235 {
236     /**
237      * @tc.steps: step1. create AccessibilityNode and vector.
238      */
239     NodeId id = 0;
240     AccessibilityNode currentNode(id, "test");
241     std::vector<std::pair<std::string, std::string>> vec;
242 
243     /**
244      * @tc.steps: step2. config pare and call SetAttr.
245      * @tc.expected: currentNode params text_ is meet expectations.
246      */
247     vec.emplace_back(std::make_pair(VALUE, "value"));
248     currentNode.SetAttr(vec);
249     EXPECT_EQ(currentNode.text_, "value");
250 
251     /**
252      * @tc.steps: step3. create a parent node and setTag recall SetAttr.
253      * @tc.expected: currentNode params text_ is meet expectations.
254      */
255     auto parentNode = AceType::MakeRefPtr<AccessibilityNode>(1, "parent");
256     currentNode.SetParentNode(parentNode);
257     currentNode.SetTag("text");
258     currentNode.SetAttr(vec);
259     EXPECT_NE(parentNode->text_, "value");
260 
261     /**
262      * @tc.steps: step4. put a fake value in pair and set tag popup.
263      * @tc.expected: currentNode params text_ is meet expectations.
264      */
265     vec.emplace_back(std::make_pair(FAKE, "FAKE_VALUE"));
266     parentNode->SetTag("popup");
267     currentNode.SetAttr(vec);
268     EXPECT_EQ(parentNode->text_, "value");
269 
270     /**
271      * @tc.steps: step5. set tag input, put a wrong type in pair, initialization parameters.
272      * @tc.expected: currentNode params isCheckable_ is false.
273      */
274     currentNode.SetTag("input");
275     currentNode.isFocusable_ = false;
276     currentNode.isCheckable_ = false;
277     currentNode.isCheckable_ = false;
278     vec.emplace_back(std::make_pair(TYPE, FAKE));
279     currentNode.SetAttr(vec);
280     EXPECT_FALSE(currentNode.isCheckable_);
281 
282     /**
283      * @tc.steps: step6. remove fake pair and put type with INPUT_TYPE_CHECKBOX.
284      * @tc.expected: currentNode params isCheckable_ is true.
285      */
286     vec.pop_back();
287     vec.emplace_back(std::make_pair(TYPE, INPUT_TYPE_CHECKBOX));
288     currentNode.SetAttr(vec);
289     EXPECT_TRUE(currentNode.isCheckable_);
290 
291     /**
292      * @tc.steps: step7. remove fake pair and put type with INPUT_TYPE_RADIO.
293      * @tc.expected: currentNode params isCheckable_ is true.
294      */
295     currentNode.isCheckable_ = false;
296     vec.pop_back();
297     vec.emplace_back(std::make_pair(TYPE, INPUT_TYPE_RADIO));
298     currentNode.SetAttr(vec);
299     EXPECT_TRUE(currentNode.isCheckable_);
300 
301     /**
302      * @tc.steps: step8. remove fake pair and put type with INPUT_TYPE_PASSWORD.
303      * @tc.expected: currentNode params isPassword_ is true.
304      */
305     vec.pop_back();
306     vec.emplace_back(std::make_pair(TYPE, INPUT_TYPE_PASSWORD));
307     currentNode.SetAttr(vec);
308     EXPECT_TRUE(currentNode.isPassword_);
309 }
310 
311 /**
312  * @tc.name: accessibilityNodeTest007
313  * @tc.type: FUNC
314  */
315 HWTEST_F(AccessibilityNodeTestNg, accessibilityNodeTest007, TestSize.Level1)
316 {
317     /**
318      * @tc.steps: step1. create EventMarker with empty eventId and AccessibilityNode.
319      */
320     NodeId id = 0;
321     int32_t pageId = 1;
322     auto marker = EventMarker("", "event", pageId);
323     std::string nodeName = "text";
324     AccessibilityNode accessibilityNode(id, nodeName);
325 
326     /**
327      * @tc.steps: step2. call SetFocusChangeEventMarker function.
328      * @tc.expected: the param focusChangeEventId_ in accessibilityNode is null.
329      */
330     accessibilityNode.SetFocusChangeEventMarker(marker);
331     EXPECT_FALSE(accessibilityNode.focusChangeEventId_);
332 
333     /**
334      * @tc.steps: step3. set eventId not empty and config Container, then recall SetFocusChangeEventMarker.
335      * @tc.expected: the param focusChangeEventId_ in accessibilityNode is null.
336      */
337     marker.data_->eventId = std::to_string(id);
338     MockContainer::Current()->pipelineContext_ = MockPipelineContext::GetCurrent();
339     accessibilityNode.SetFocusChangeEventMarker(marker);
340     EXPECT_FALSE(accessibilityNode.focusChangeEventId_);
341 }
342 } // namespace OHOS::Ace::NG
343