1 /*
2 * Copyright (C) 2022 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 #include <optional>
18 #include <memory>
19 #include "accessibility_element_info.h"
20 #include "accessibility_extension_context.h"
21 #include "accessibility_extension.h"
22 #include "mock_gesture_simulation.h"
23
24 using namespace testing;
25 using namespace testing::ext;
26 using namespace std;
27
28 namespace OHOS {
29 namespace Accessibility {
30 class AccessibilityExtensionContextUnitTest : public ::testing::Test {
31 public:
AccessibilityExtensionContextUnitTest()32 AccessibilityExtensionContextUnitTest() {}
~AccessibilityExtensionContextUnitTest()33 ~AccessibilityExtensionContextUnitTest() {}
34
35 static void SetUpTestCase();
36 static void TearDownTestCase();
37 void SetUp() override;
38 void TearDown() override;
39
40 std::shared_ptr<AccessibilityExtensionContext> context_ = nullptr;
41 };
42
SetUpTestCase()43 void AccessibilityExtensionContextUnitTest::SetUpTestCase()
44 {
45 GTEST_LOG_(INFO) << "###################### AccessibilityExtensionContextUnitTest Start ######################";
46 }
47
TearDownTestCase()48 void AccessibilityExtensionContextUnitTest::TearDownTestCase()
49 {
50 GTEST_LOG_(INFO) << "###################### AccessibilityExtensionContextUnitTest End ######################";
51 }
52
SetUp()53 void AccessibilityExtensionContextUnitTest::SetUp()
54 {
55 context_ = std::make_shared<AccessibilityExtensionContext>();
56 }
57
TearDown()58 void AccessibilityExtensionContextUnitTest::TearDown()
59 {
60 context_ = nullptr;
61 }
62
63 /**
64 * @tc.number: AccessibilityExtensionContext_Unittest_GetFocusElementInfo_001
65 * @tc.name: GetFocusElementInfo
66 * @tc.desc: Test function GetFocusElementInfo
67 */
68 HWTEST_F(AccessibilityExtensionContextUnitTest,
69 AccessibilityExtensionContext_Unittest_GetFocusElementInfo_001, TestSize.Level1)
70 {
71 GTEST_LOG_(INFO) << "AccessibilityExtensionContext_Unittest_GetFocusElementInfo_001 start";
72
73 std::optional<AccessibilityElementInfo> elementInfo;
74 bool result = context_->GetFocusElementInfo(FOCUS_TYPE_INPUT, elementInfo);
75 EXPECT_TRUE(elementInfo.has_value());
76 EXPECT_TRUE(result);
77
78 GTEST_LOG_(INFO) << "AccessibilityExtensionContext_Unittest_GetFocusElementInfo_001 end";
79 }
80
81 /**
82 * @tc.number: AccessibilityExtensionContext_Unittest_GetFocusElementInfo_002
83 * @tc.name: GetFocusElementInfo
84 * @tc.desc: Test function GetFocusElementInfo
85 * Get focus elementInfo when focusType is not allowed.
86 */
87 HWTEST_F(AccessibilityExtensionContextUnitTest,
88 AccessibilityExtensionContext_Unittest_GetFocusElementInfo_002, TestSize.Level1)
89 {
90 GTEST_LOG_(INFO) << "AccessibilityExtensionContext_Unittest_GetFocusElementInfo_002 start";
91
92 std::optional<AccessibilityElementInfo> elementInfo;
93 bool result = context_->GetFocusElementInfo(FOCUS_TYPE_INVALID, elementInfo);
94 EXPECT_FALSE(elementInfo.has_value());
95 EXPECT_FALSE(result);
96
97 GTEST_LOG_(INFO) << "AccessibilityExtensionContext_Unittest_GetFocusElementInfo_002 end";
98 }
99
100 /**
101 * @tc.number: AccessibilityExtensionContext_Unittest_GestureSimulate_001
102 * @tc.name: GestureSimulate
103 * @tc.desc: Test function GestureSimulate
104 * Send a gesture without any path.
105 */
106 HWTEST_F(AccessibilityExtensionContextUnitTest,
107 AccessibilityExtensionContext_Unittest_GestureSimulate_001, TestSize.Level1)
108 {
109 GTEST_LOG_(INFO) << "AccessibilityExtensionContext_Unittest_GestureSimulate_001 start";
110
111 std::vector<GesturePathDefine> gesturePathDefineList {};
112 std::shared_ptr<GestureResultListener> listener = nullptr;
113 EXPECT_FALSE(context_->GestureSimulate(0, gesturePathDefineList, listener));
114
115 GTEST_LOG_(INFO) << "AccessibilityExtensionContext_Unittest_GestureSimulate_001 end";
116 }
117
118 /**
119 * @tc.number: AccessibilityExtensionContext_Unittest_GestureSimulate_002
120 * @tc.name: GestureSimulate
121 * @tc.desc: Test function GestureSimulate
122 * Send a gesture whose total duration time is not allowed.
123 */
124 HWTEST_F(AccessibilityExtensionContextUnitTest,
125 AccessibilityExtensionContext_Unittest_GestureSimulate_002, TestSize.Level1)
126 {
127 GTEST_LOG_(INFO) << "AccessibilityExtensionContext_Unittest_GestureSimulate_002 start";
128
129 std::vector<GesturePathDefine> gesturePathDefineList {};
130 GesturePathDefine gesturePath;
131 gesturePath.SetDurationTime(gesturePath.GetMaxStrokeDuration() + 1);
132 gesturePathDefineList.push_back(gesturePath);
133 std::shared_ptr<GestureResultListener> listener = nullptr;
134
135 EXPECT_FALSE(context_->GestureSimulate(0, gesturePathDefineList, listener));
136
137 GTEST_LOG_(INFO) << "AccessibilityExtensionContext_Unittest_GestureSimulate_002 end";
138 }
139
140 /**
141 * @tc.number: AccessibilityExtensionContext_Unittest_GestureSimulate_003
142 * @tc.name: GestureSimulate
143 * @tc.desc: Test function GestureSimulate
144 * Send a gesture with one path.
145 */
146 HWTEST_F(AccessibilityExtensionContextUnitTest,
147 AccessibilityExtensionContext_Unittest_GestureSimulate_003, TestSize.Level1)
148 {
149 GTEST_LOG_(INFO) << "AccessibilityExtensionContext_Unittest_GestureSimulate_003 start";
150
151 std::vector<GesturePathDefine> gesturePathDefineList {};
152 GesturePathDefine gesturePath;
153 gesturePathDefineList.push_back(gesturePath);
154 std::shared_ptr<GestureResultListener> listener = make_shared<MockGestureResultListener>();
155
156 EXPECT_TRUE(context_->GestureSimulate(0, gesturePathDefineList, listener));
157
158 GTEST_LOG_(INFO) << "AccessibilityExtensionContext_Unittest_GestureSimulate_003 end";
159 }
160
161 /**
162 * @tc.number: AccessibilityExtensionContext_Unittest_GetDisplayResizeController_001
163 * @tc.name: GetDisplayResizeController
164 * @tc.desc: Test function GetDisplayResizeController
165 * Get a default displayResize controller.
166 */
167 HWTEST_F(AccessibilityExtensionContextUnitTest,
168 AccessibilityExtensionContext_Unittest_GetDisplayResizeController_001, TestSize.Level1)
169 {
170 GTEST_LOG_(INFO) << "AccessibilityExtensionContext_Unittest_GetDisplayResizeController_001 start";
171
172 EXPECT_TRUE(context_->GetDisplayResizeController() != nullptr);
173
174 GTEST_LOG_(INFO) << "AccessibilityExtensionContext_Unittest_GetDisplayResizeController_001 end";
175 }
176
177 /**
178 * @tc.number: AccessibilityExtensionContext_Unittest_GetDisplayResizeController_002
179 * @tc.name: GetDisplayResizeController
180 * @tc.desc: Test function GetDisplayResizeController
181 * Get an informal displayResize controller.
182 */
183 HWTEST_F(AccessibilityExtensionContextUnitTest,
184 AccessibilityExtensionContext_Unittest_GetDisplayResizeController_002, TestSize.Level1)
185 {
186 GTEST_LOG_(INFO) << "AccessibilityExtensionContext_Unittest_GetDisplayResizeController_002 start";
187
188 uint32_t displayId = 0x2;
189 context_->GetDisplayResizeController(displayId);
190 EXPECT_TRUE(context_->GetDisplayResizeController(displayId) != nullptr);
191
192 GTEST_LOG_(INFO) << "AccessibilityExtensionContext_Unittest_GetDisplayResizeController_002 end";
193 }
194
195 /**
196 * @tc.number: AccessibilityExtensionContext_Unittest_GetRootElementInfo_001
197 * @tc.name: GetRootElementInfo
198 * @tc.desc: Test function GetRootElementInfo
199 */
200 HWTEST_F(AccessibilityExtensionContextUnitTest,
201 AccessibilityExtensionContext_Unittest_GetRootElementInfo_001, TestSize.Level1)
202 {
203 GTEST_LOG_(INFO) << "AccessibilityExtensionContext_Unittest_GetRootElementInfo_001 start";
204
205 std::optional<AccessibilityElementInfo> elementInfo;
206 context_->GetRootElementInfo(elementInfo);
207 EXPECT_TRUE(elementInfo.has_value());
208
209 GTEST_LOG_(INFO) << "AccessibilityExtensionContext_Unittest_GetRootElementInfo_001 end";
210 }
211
212 /**
213 * @tc.number: AccessibilityExtensionContext_Unittest_GetWindows_001
214 * @tc.name: GetWindows
215 * @tc.desc: Test function GetWindows
216 */
217 HWTEST_F(AccessibilityExtensionContextUnitTest, AccessibilityExtensionContext_Unittest_GetWindows_001, TestSize.Level1)
218 {
219 GTEST_LOG_(INFO) << "AccessibilityExtensionContext_Unittest_GetWindows_001 start";
220
221 EXPECT_EQ(int(context_->GetWindows().size()), 0);
222
223 GTEST_LOG_(INFO) << "AccessibilityExtensionContext_Unittest_GetWindows_001 end";
224 }
225
226 /**
227 * @tc.number: AccessibilityExtensionContext_Unittest_PerformCommonAction_001
228 * @tc.name: ExecuteCommonAction
229 * @tc.desc: Test function ExecuteCommonAction
230 */
231 HWTEST_F(AccessibilityExtensionContextUnitTest,
232 AccessibilityExtensionContext_Unittest_PerformCommonAction_001, TestSize.Level1)
233 {
234 GTEST_LOG_(INFO) << "AccessibilityExtensionContext_Unittest_PerformCommonAction_001 start";
235
236 EXPECT_TRUE(context_->ExecuteCommonAction(GLOBAL_ACTION_BACK));
237
238 GTEST_LOG_(INFO) << "AccessibilityExtensionContext_Unittest_PerformCommonAction_001 end";
239 }
240
241 /**
242 * @tc.number: AccessibilityExtensionContext_Unittest_PerformCommonAction_002
243 * @tc.name: ExecuteCommonAction
244 * @tc.desc: Test function ExecuteCommonAction
245 * Perform common action which is not allowed.
246 */
247 HWTEST_F(AccessibilityExtensionContextUnitTest,
248 AccessibilityExtensionContext_Unittest_PerformCommonAction_002, TestSize.Level1)
249 {
250 GTEST_LOG_(INFO) << "AccessibilityExtensionContext_Unittest_PerformCommonAction_002 start";
251
252 EXPECT_FALSE(context_->ExecuteCommonAction(0xFFFFFFFF));
253
254 GTEST_LOG_(INFO) << "AccessibilityExtensionContext_Unittest_PerformCommonAction_002 end";
255 }
256
257 /**
258 * @tc.number: AccessibilityExtensionContext_Unittest_DispatchOnSimulationGestureResult_001
259 * @tc.name: DispatchOnSimulationGestureResult
260 * @tc.desc: Test function DispatchOnSimulationGestureResult
261 * Dispatch simulation gesture's result without listener.
262 */
263 HWTEST_F(AccessibilityExtensionContextUnitTest,
264 AccessibilityExtensionContext_Unittest_DispatchOnSimulationGestureResult_001, TestSize.Level1)
265 {
266 GTEST_LOG_(INFO) << "AccessibilityExtensionContext_Unittest_DispatchOnSimulationGestureResult_001 start";
267
268 context_->DispatchOnSimulationGestureResult(0, 0);
269
270 GTEST_LOG_(INFO) << "AccessibilityExtensionContext_Unittest_DispatchOnSimulationGestureResult_001 end";
271 }
272
273 /**
274 * @tc.number: AccessibilityExtensionContext_Unittest_DispatchOnSimulationGestureResult_002
275 * @tc.name: DispatchOnSimulationGestureResult
276 * @tc.desc: Test function DispatchOnSimulationGestureResult
277 * Dispatch simulation gesture's result with listener and the result is completed.
278 */
279 HWTEST_F(AccessibilityExtensionContextUnitTest,
280 AccessibilityExtensionContext_Unittest_DispatchOnSimulationGestureResult_002, TestSize.Level1)
281 {
282 GTEST_LOG_(INFO) << "AccessibilityExtensionContext_Unittest_DispatchOnSimulationGestureResult_002 start";
283
284 std::vector<GesturePathDefine> gesturePathDefineList {};
285 GesturePathDefine gesturePath;
286 gesturePathDefineList.push_back(gesturePath);
287 std::shared_ptr<GestureResultListener> listener = std::make_shared<MockGestureResultListener>();
288 uint32_t sequence = 0;
289
290 context_->GestureSimulate(sequence, gesturePathDefineList, listener);
291 context_->DispatchOnSimulationGestureResult(sequence, 1);
292
293 GTEST_LOG_(INFO) << "AccessibilityExtensionContext_Unittest_DispatchOnSimulationGestureResult_002 end";
294 }
295
296 /**
297 * @tc.number: AccessibilityExtensionContext_Unittest_SetChannelId_001
298 * @tc.name: SetChannelId
299 * @tc.desc: Test function SetChannelId
300 */
301 HWTEST_F(AccessibilityExtensionContextUnitTest,
302 AccessibilityExtensionContext_Unittest_SetChannelId_001, TestSize.Level1)
303 {
304 GTEST_LOG_(INFO) << "AccessibilityExtensionContext_Unittest_SetChannelId_001 start";
305
306 context_->SetChannelId(0);
307
308 GTEST_LOG_(INFO) << "AccessibilityExtensionContext_Unittest_SetChannelId_001 end";
309 }
310 } // namespace Accessibility
311 } // namespace OHOS