• 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());
__anon547d9e260202() 72     accessibilityNode.SetActionClickImpl([]() {});
73     EXPECT_TRUE(accessibilityNode.ActionClick());
74 
75     EXPECT_FALSE(accessibilityNode.ActionLongClick());
__anon547d9e260302() 76     accessibilityNode.SetActionLongClickImpl([]() {});
77     EXPECT_TRUE(accessibilityNode.ActionLongClick());
78 
79     EXPECT_FALSE(accessibilityNode.ActionSetText(nodeName));
__anon547d9e260402(const std::string& text) 80     accessibilityNode.SetActionSetTextImpl([](const std::string& text) {});
81     EXPECT_TRUE(accessibilityNode.ActionSetText(nodeName));
82 
83     EXPECT_FALSE(accessibilityNode.ActionScrollForward());
__anon547d9e260502() 84     accessibilityNode.SetActionScrollForward([]() { return true; });
85     EXPECT_TRUE(accessibilityNode.ActionScrollForward());
86 
87     EXPECT_FALSE(accessibilityNode.ActionScrollBackward());
__anon547d9e260602() 88     accessibilityNode.SetActionScrollBackward([]() { return true; });
89     EXPECT_TRUE(accessibilityNode.ActionScrollBackward());
90 
91     bool result = true;
92     EXPECT_FALSE(accessibilityNode.ActionAccessibilityFocus(result));
__anon547d9e260702(bool result) 93     accessibilityNode.SetActionAccessibilityFocusImpl([](bool result) {});
94     EXPECT_TRUE(accessibilityNode.ActionAccessibilityFocus(result));
95 
96     EXPECT_FALSE(accessibilityNode.ActionFocus());
__anon547d9e260802() 97     accessibilityNode.SetActionFocusImpl([]() {});
98     EXPECT_TRUE(accessibilityNode.ActionFocus());
99 
100     accessibilityNode.ActionUpdateIds();
__anon547d9e260902() 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 
__anon547d9e260a02(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.SetStyle(vec);
151     accessibilityNode.SetAttr(vec);
152     EXPECT_EQ(accessibilityNode.inputType_, "ACCESSIBILITY_TYPE");
153     EXPECT_TRUE(accessibilityNode.isEnabled_);
154     EXPECT_EQ(accessibilityNode.accessibilityLabel_, "ACCESSIBILITY_TEXT");
155     EXPECT_EQ(accessibilityNode.accessibilityHint_, "ACCESSIBILITY_DESCRIPTION");
156     EXPECT_EQ(accessibilityNode.importantForAccessibility_, "ACCESSIBILITY_IMPORTANCE");
157 
158     accessibilityNode.attrs_.emplace_back(std::make_pair(IMPORTANCE, "ACCESSIBILITY_IMPORTANCE"));
159     accessibilityNode.SetAttr(vec);
160     EXPECT_EQ(accessibilityNode.importantForAccessibility_, "ACCESSIBILITY_IMPORTANCE");
161 
162     accessibilityNode.SetTag("text");
163     accessibilityNode.SetAttr(vec);
164 }
165 
166 /**
167  * @tc.name: accessibilityNodeTest004
168  * @tc.type: FUNC
169  */
170 HWTEST_F(AccessibilityNodeTestNg, accessibilityNodeTest004, TestSize.Level1)
171 {
172     NodeId id = 0;
173     std::string nodeName = "text";
174     AccessibilityNode accessibilityNode(id, nodeName);
175 
176     std::vector<std::string> vec;
177     vec.emplace_back(EVENT);
178     vec.emplace_back(CLICK);
179     vec.emplace_back(LONG_PRESS);
180     vec.emplace_back(FOCUS);
181     vec.emplace_back(BLUR);
182     vec.emplace_back(FAKE);
183 
184     accessibilityNode.AddEvent(0, vec);
185     EXPECT_TRUE(accessibilityNode.isClickable_);
186     EXPECT_TRUE(accessibilityNode.isLongClickable_);
187 }
188 
189 /**
190  * @tc.name: accessibilityNodeTest005
191  * @tc.type: FUNC
192  */
193 HWTEST_F(AccessibilityNodeTestNg, accessibilityNodeTest005, TestSize.Level1)
194 {
195     /**
196      * @tc.steps: step1. create AccessibilityNode and vector.
197      */
198     NodeId id = 0;
199     std::string nodeName = "text";
200     AccessibilityNode accessibilityNode(id, nodeName);
201 
202     /**
203      * @tc.steps: step2. create offset.
204      */
205     Offset offset(1.0, 1.0);
206 
207     /**
208      * @tc.steps: step3. create child and add node twice.
209      * @tc.expected: only one can add success.
210      */
211     auto child = AceType::MakeRefPtr<AccessibilityNode>(1, "child");
212     accessibilityNode.AddNode(child, 0);
213     accessibilityNode.AddNode(child, 0);
214     EXPECT_EQ(accessibilityNode.children_.size(), 1);
215 
216     /**
217      * @tc.steps: step4. call AddOffsetForChildren.
218      * @tc.expected: accessibilityNode offset is meet expectations.
219      */
220     accessibilityNode.AddOffsetForChildren(offset);
221     EXPECT_EQ(accessibilityNode.GetLeft(), 1);
222 
223     /**
224      * @tc.steps: step5. call remove node.
225      * @tc.expected: child remove success.
226      */
227     accessibilityNode.RemoveNode(child);
228     EXPECT_EQ(accessibilityNode.children_.size(), 0);
229 }
230 
231 /**
232  * @tc.name: accessibilityNodeTest006
233  * @tc.type: FUNC
234  */
235 HWTEST_F(AccessibilityNodeTestNg, accessibilityNodeTest006, TestSize.Level1)
236 {
237     /**
238      * @tc.steps: step1. create AccessibilityNode and vector.
239      */
240     NodeId id = 0;
241     AccessibilityNode currentNode(id, "test");
242     std::vector<std::pair<std::string, std::string>> vec;
243 
244     /**
245      * @tc.steps: step2. config pare and call SetAttr.
246      * @tc.expected: currentNode params text_ is meet expectations.
247      */
248     vec.emplace_back(std::make_pair(VALUE, "value"));
249     currentNode.SetAttr(vec);
250     EXPECT_EQ(currentNode.text_, "value");
251 
252     /**
253      * @tc.steps: step3. create a parent node and setTag recall SetAttr.
254      * @tc.expected: currentNode params text_ is meet expectations.
255      */
256     auto parentNode = AceType::MakeRefPtr<AccessibilityNode>(1, "parent");
257     currentNode.SetParentNode(parentNode);
258     currentNode.SetTag("text");
259     currentNode.SetAttr(vec);
260     EXPECT_NE(parentNode->text_, "value");
261 
262     /**
263      * @tc.steps: step4. put a fake value in pair and set tag popup.
264      * @tc.expected: currentNode params text_ is meet expectations.
265      */
266     vec.emplace_back(std::make_pair(FAKE, "FAKE_VALUE"));
267     parentNode->SetTag("popup");
268     currentNode.SetAttr(vec);
269     EXPECT_EQ(parentNode->text_, "value");
270 
271     /**
272      * @tc.steps: step5. set tag input, put a wrong type in pair, initialization parameters.
273      * @tc.expected: currentNode params isCheckable_ is false.
274      */
275     currentNode.SetTag("input");
276     currentNode.isFocusable_ = false;
277     currentNode.isCheckable_ = false;
278     currentNode.isCheckable_ = false;
279     vec.emplace_back(std::make_pair(TYPE, FAKE));
280     currentNode.SetAttr(vec);
281     EXPECT_FALSE(currentNode.isCheckable_);
282 
283     /**
284      * @tc.steps: step6. remove fake pair and put type with INPUT_TYPE_CHECKBOX.
285      * @tc.expected: currentNode params isCheckable_ is true.
286      */
287     vec.pop_back();
288     vec.emplace_back(std::make_pair(TYPE, INPUT_TYPE_CHECKBOX));
289     currentNode.SetAttr(vec);
290     EXPECT_TRUE(currentNode.isCheckable_);
291 
292     /**
293      * @tc.steps: step7. remove fake pair and put type with INPUT_TYPE_RADIO.
294      * @tc.expected: currentNode params isCheckable_ is true.
295      */
296     currentNode.isCheckable_ = false;
297     vec.pop_back();
298     vec.emplace_back(std::make_pair(TYPE, INPUT_TYPE_RADIO));
299     currentNode.SetAttr(vec);
300     EXPECT_TRUE(currentNode.isCheckable_);
301 
302     /**
303      * @tc.steps: step8. remove fake pair and put type with INPUT_TYPE_PASSWORD.
304      * @tc.expected: currentNode params isPassword_ is true.
305      */
306     vec.pop_back();
307     vec.emplace_back(std::make_pair(TYPE, INPUT_TYPE_PASSWORD));
308     currentNode.SetAttr(vec);
309     EXPECT_TRUE(currentNode.isPassword_);
310 }
311 
312 /**
313  * @tc.name: accessibilityNodeTest007
314  * @tc.type: FUNC
315  */
316 HWTEST_F(AccessibilityNodeTestNg, accessibilityNodeTest007, TestSize.Level1)
317 {
318     /**
319      * @tc.steps: step1. create EventMarker with empty eventId and AccessibilityNode.
320      */
321     NodeId id = 0;
322     int32_t pageId = 1;
323     auto marker = EventMarker("", "event", pageId);
324     std::string nodeName = "text";
325     AccessibilityNode accessibilityNode(id, nodeName);
326     accessibilityNode.Mount(0);
327     /**
328      * @tc.steps: step2. call SetFocusChangeEventMarker function.
329      * @tc.expected: the param focusChangeEventId_ in accessibilityNode is null.
330      */
331     accessibilityNode.SetFocusChangeEventMarker(marker);
332     EXPECT_FALSE(accessibilityNode.focusChangeEventId_);
333 
334     /**
335      * @tc.steps: step3. set eventId not empty and config Container, then recall SetFocusChangeEventMarker.
336      * @tc.expected: the param focusChangeEventId_ in accessibilityNode is null.
337      */
338     marker.data_->eventId = std::to_string(id);
339     MockContainer::Current()->pipelineContext_ = MockPipelineContext::GetCurrent();
340     accessibilityNode.SetFocusChangeEventMarker(marker);
341     EXPECT_FALSE(accessibilityNode.focusChangeEventId_);
342 }
343 } // namespace OHOS::Ace::NG
344