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 <memory>
18 #include "accessibility_element_operator_callback_impl.h"
19 #include "accessibility_system_ability_client_impl.h"
20 #include "mock_accessibility_element_operator.h"
21
22 using namespace testing;
23 using namespace testing::ext;
24
25 namespace OHOS {
26 namespace Accessibility {
27 namespace {
28 const std::string TEST = "test";
29 constexpr int32_t ELEMENT_ID = 1;
30 constexpr int32_t REQUEST_ID = 1;
31 constexpr int32_t REQUEST_ID_2 = 2;
32 constexpr int32_t MODE = 0;
33 constexpr int32_t FOCUS_TYPE = 1;
34 constexpr int32_t DIRECTION = 1;
35 constexpr int32_t ACTION = 1;
36 constexpr int32_t REQUEST_ID_MASK_BIT = 16;
37 } // namespace
38
39 class AccessibilityElementOperatorImplUnitTest : public ::testing::Test {
40 public:
41 sptr<AccessibilityElementOperatorImpl> mockStub_ = nullptr;
AccessibilityElementOperatorImplUnitTest()42 AccessibilityElementOperatorImplUnitTest()
43 {}
~AccessibilityElementOperatorImplUnitTest()44 ~AccessibilityElementOperatorImplUnitTest()
45 {}
46 int32_t windowID_ = 1;
47 std::shared_ptr<MockAccessibilityElementOperator> operation_ = nullptr;
48 std::shared_ptr<AccessibilitySystemAbilityClientImpl> asac_ = nullptr;
SetUpTestCase()49 static void SetUpTestCase()
50 {
51 GTEST_LOG_(INFO) << "AccessibilityElementOperatorImplUnitTest Start";
52 }
TearDownTestCase()53 static void TearDownTestCase()
54 {
55 GTEST_LOG_(INFO) << "AccessibilityElementOperatorImplUnitTest End";
56 }
SetUp()57 void SetUp()
58 {
59 GTEST_LOG_(INFO) << "AccessibilityElementOperatorImplUnitTest SetUp() Start";
60 operation_ = std::make_shared<MockAccessibilityElementOperator>();
61 asac_ = std::make_shared<AccessibilitySystemAbilityClientImpl>();
62 mockStub_ = new AccessibilityElementOperatorImpl(windowID_, operation_, *asac_);
63 GTEST_LOG_(INFO) << "AccessibilityElementOperatorImplUnitTest SetUp() End";
64 };
TearDown()65 void TearDown()
66 {
67 GTEST_LOG_(INFO) << "AccessibilityElementOperatorImplUnitTest TearDown()";
68 mockStub_ = nullptr;
69 }
70
71 int32_t CompositeId(int32_t requestId);
72 };
73
CompositeId(int32_t requestId)74 int32_t AccessibilityElementOperatorImplUnitTest::CompositeId(int32_t requestId)
75 {
76 uint32_t compositionRequestId = static_cast<uint32_t>(requestId) |
77 (static_cast<uint32_t>(windowID_) << REQUEST_ID_MASK_BIT);
78 return static_cast<int32_t>(compositionRequestId);
79 }
80
81 /**
82 * @tc.number: SearchElementInfoByAccessibilityId_001
83 * @tc.name: SearchElementInfoByAccessibilityId
84 * @tc.desc: Test function SearchElementInfoByAccessibilityId
85 */
86 HWTEST_F(AccessibilityElementOperatorImplUnitTest, SearchElementInfoByAccessibilityId_001, TestSize.Level1)
87 {
88 GTEST_LOG_(INFO) << "SearchElementInfoByAccessibilityId_001 start";
89 if (!mockStub_) {
90 GTEST_LOG_(INFO) << "Cann't get AccessibilityElementOperatorImpl mockStub_";
91 return;
92 }
93 mockStub_->SearchElementInfoByAccessibilityId(ELEMENT_ID, REQUEST_ID, nullptr, MODE);
94 GTEST_LOG_(INFO) << "SearchElementInfoByAccessibilityId_001 end";
95 }
96
97 /**
98 * @tc.number: SearchElementInfosByText_001
99 * @tc.name: SearchElementInfosByText
100 * @tc.desc: Test function SearchElementInfosByText
101 */
102 HWTEST_F(AccessibilityElementOperatorImplUnitTest, SearchElementInfosByText_001, TestSize.Level1)
103 {
104 GTEST_LOG_(INFO) << "SearchElementInfosByText_001 start";
105 if (!mockStub_) {
106 GTEST_LOG_(INFO) << "Cann't get AccessibilityElementOperatorImpl mockStub_";
107 return;
108 }
109 mockStub_->SearchElementInfosByText(ELEMENT_ID, TEST, REQUEST_ID, nullptr);
110 GTEST_LOG_(INFO) << "SearchElementInfosByText_001 end";
111 }
112
113 /**
114 * @tc.number: FindFocusedElementInfo_001
115 * @tc.name: FindFocusedElementInfo
116 * @tc.desc: Test function FindFocusedElementInfo
117 */
118 HWTEST_F(AccessibilityElementOperatorImplUnitTest, FindFocusedElementInfo_001, TestSize.Level1)
119 {
120 GTEST_LOG_(INFO) << "FindFocusedElementInfo_001 start";
121 if (!mockStub_) {
122 GTEST_LOG_(INFO) << "Cann't get AccessibilityElementOperatorImpl mockStub_";
123 return;
124 }
125 mockStub_->FindFocusedElementInfo(ELEMENT_ID, FOCUS_TYPE, REQUEST_ID, nullptr);
126 GTEST_LOG_(INFO) << "FindFocusedElementInfo_001 end";
127 }
128
129 /**
130 * @tc.number: FocusMoveSearch_001
131 * @tc.name: FocusMoveSearch
132 * @tc.desc: Test function FocusMoveSearch
133 */
134 HWTEST_F(AccessibilityElementOperatorImplUnitTest, FocusMoveSearch_001, TestSize.Level1)
135 {
136 GTEST_LOG_(INFO) << "FocusMoveSearch_001 start";
137 if (!mockStub_) {
138 GTEST_LOG_(INFO) << "Cann't get AccessibilityElementOperatorImpl mockStub_";
139 return;
140 }
141 mockStub_->FocusMoveSearch(ELEMENT_ID, DIRECTION, REQUEST_ID, nullptr);
142 GTEST_LOG_(INFO) << "FocusMoveSearch_001 end";
143 }
144
145 /**
146 * @tc.number: ExecuteAction_001
147 * @tc.name: ExecuteAction
148 * @tc.desc: Test function ExecuteAction
149 */
150 HWTEST_F(AccessibilityElementOperatorImplUnitTest, ExecuteAction_001, TestSize.Level1)
151 {
152 GTEST_LOG_(INFO) << "ExecuteAction_001 start";
153 if (!mockStub_) {
154 GTEST_LOG_(INFO) << "Cann't get AccessibilityElementOperatorImpl mockStub_";
155 return;
156 }
157 std::map<std::string, std::string> actionArguments;
158 mockStub_->ExecuteAction(ELEMENT_ID, ACTION, actionArguments, REQUEST_ID, nullptr);
159 GTEST_LOG_(INFO) << "ExecuteAction_001 end";
160 }
161
162 /**
163 * @tc.number: ClearFocus_001
164 * @tc.name: ClearFocus
165 * @tc.desc: Test function ClearFocus
166 */
167 HWTEST_F(AccessibilityElementOperatorImplUnitTest, ClearFocus_001, TestSize.Level1)
168 {
169 GTEST_LOG_(INFO) << "ClearFocus_001 start";
170 if (!mockStub_) {
171 GTEST_LOG_(INFO) << "Cann't get AccessibilityElementOperatorImpl mockStub_";
172 return;
173 }
174 mockStub_->ClearFocus();
175 GTEST_LOG_(INFO) << "ClearFocus_001 end";
176 }
177
178 /**
179 * @tc.number: OutsideTouch_001
180 * @tc.name: OutsideTouch
181 * @tc.desc: Test function OutsideTouch
182 */
183 HWTEST_F(AccessibilityElementOperatorImplUnitTest, OutsideTouch_001, TestSize.Level1)
184 {
185 GTEST_LOG_(INFO) << "OutsideTouch_001 start";
186 if (!mockStub_) {
187 GTEST_LOG_(INFO) << "Cann't get AccessibilityElementOperatorImpl mockStub_";
188 return;
189 }
190 mockStub_->OutsideTouch();
191 GTEST_LOG_(INFO) << "OutsideTouch_001 end";
192 }
193
194 /**
195 * @tc.number: GetWindowId
196 * @tc.name: GetWindowId
197 * @tc.desc: Test function GetWindowId
198 */
199 HWTEST_F(AccessibilityElementOperatorImplUnitTest, GetWindowId, TestSize.Level1)
200 {
201 GTEST_LOG_(INFO) << "GetWindowId start";
202 if (!mockStub_) {
203 GTEST_LOG_(INFO) << "Cann't get AccessibilityElementOperatorImpl mockStub_";
204 return;
205 }
206 EXPECT_EQ(1, mockStub_->GetWindowId());
207 GTEST_LOG_(INFO) << "GetWindowId end";
208 }
209
210 /**
211 * @tc.number: SetSearchElementInfoByAccessibilityIdResult_001
212 * @tc.name: SetSearchElementInfoByAccessibilityIdResult
213 * @tc.desc: Test function SetSearchElementInfoByAccessibilityIdResult
214 */
215 HWTEST_F(AccessibilityElementOperatorImplUnitTest, SetSearchElementInfoByAccessibilityIdResult_001, TestSize.Level1)
216 {
217 GTEST_LOG_(INFO) << "SetSearchElementInfoByAccessibilityIdResult_001 start";
218 if (!mockStub_) {
219 GTEST_LOG_(INFO) << "Cann't get AccessibilityElementOperatorImpl mockStub_";
220 return;
221 }
222 std::list<AccessibilityElementInfo> infos;
223 AccessibilityElementInfo info {};
224 infos.push_back(info);
225 mockStub_->SetSearchElementInfoByAccessibilityIdResult(infos, REQUEST_ID);
226 GTEST_LOG_(INFO) << "SetSearchElementInfoByAccessibilityIdResult_001 end";
227 }
228
229 /**
230 * @tc.number: SetSearchElementInfoByAccessibilityIdResult_002
231 * @tc.name: SetSearchElementInfoByAccessibilityIdResult
232 * @tc.desc: Test function SetSearchElementInfoByAccessibilityIdResult
233 */
234 HWTEST_F(AccessibilityElementOperatorImplUnitTest, SetSearchElementInfoByAccessibilityIdResult_002, TestSize.Level1)
235 {
236 GTEST_LOG_(INFO) << "SetSearchElementInfoByAccessibilityIdResult_002 start";
237 if (!mockStub_) {
238 GTEST_LOG_(INFO) << "Cann't get AccessibilityElementOperatorImpl mockStub_";
239 return;
240 }
241
242 sptr<AccessibilityElementOperatorCallbackImpl> elementOperator =
243 new(std::nothrow) AccessibilityElementOperatorCallbackImpl();
244 mockStub_->SearchElementInfoByAccessibilityId(ELEMENT_ID, REQUEST_ID_2, elementOperator, MODE);
245 std::list<AccessibilityElementInfo> infos;
246 AccessibilityElementInfo info {};
247 infos.push_back(info);
248 mockStub_->SetSearchElementInfoByAccessibilityIdResult(infos, CompositeId(REQUEST_ID_2));
249 GTEST_LOG_(INFO) << "SetSearchElementInfoByAccessibilityIdResult_002 end";
250 }
251
252 /**
253 * @tc.number: SetSearchElementInfoByTextResult_001
254 * @tc.name: SetSearchElementInfoByTextResult
255 * @tc.desc: Test function SetSearchElementInfoByTextResult
256 */
257 HWTEST_F(AccessibilityElementOperatorImplUnitTest, SetSearchElementInfoByTextResult_001, TestSize.Level1)
258 {
259 GTEST_LOG_(INFO) << "SetSearchElementInfoByTextResult_001 start";
260 if (!mockStub_) {
261 GTEST_LOG_(INFO) << "Cann't get AccessibilityElementOperatorImpl mockStub_";
262 return;
263 }
264 std::list<AccessibilityElementInfo> infos;
265 AccessibilityElementInfo info {};
266 infos.push_back(info);
267 mockStub_->SetSearchElementInfoByTextResult(infos, REQUEST_ID);
268 GTEST_LOG_(INFO) << "SetSearchElementInfoByTextResult_001 end";
269 }
270
271 /**
272 * @tc.number: SetSearchElementInfoByTextResult_002
273 * @tc.name: SetSearchElementInfoByTextResult
274 * @tc.desc: Test function SetSearchElementInfoByTextResult
275 */
276 HWTEST_F(AccessibilityElementOperatorImplUnitTest, SetSearchElementInfoByTextResult_002, TestSize.Level1)
277 {
278 GTEST_LOG_(INFO) << "SetSearchElementInfoByTextResult_002 start";
279 if (!mockStub_) {
280 GTEST_LOG_(INFO) << "Cann't get AccessibilityElementOperatorImpl mockStub_";
281 return;
282 }
283 sptr<AccessibilityElementOperatorCallbackImpl> elementOperator =
284 new(std::nothrow) AccessibilityElementOperatorCallbackImpl();
285 mockStub_->SearchElementInfosByText(ELEMENT_ID, TEST, REQUEST_ID_2, elementOperator);
286 std::list<AccessibilityElementInfo> infos;
287 AccessibilityElementInfo info {};
288 infos.push_back(info);
289 mockStub_->SetSearchElementInfoByTextResult(infos, CompositeId(REQUEST_ID_2));
290 GTEST_LOG_(INFO) << "SetSearchElementInfoByTextResult_002 end";
291 }
292
293 /**
294 * @tc.number: SetFindFocusedElementInfoResult_001
295 * @tc.name: SetFindFocusedElementInfoResult
296 * @tc.desc: Test function SetFindFocusedElementInfoResult
297 */
298 HWTEST_F(AccessibilityElementOperatorImplUnitTest, SetFindFocusedElementInfoResult_001, TestSize.Level1)
299 {
300 GTEST_LOG_(INFO) << "SetFindFocusedElementInfoResult_001 start";
301 if (!mockStub_) {
302 GTEST_LOG_(INFO) << "Cann't get AccessibilityElementOperatorImpl mockStub_";
303 return;
304 }
305 AccessibilityElementInfo info {};
306 mockStub_->SetFindFocusedElementInfoResult(info, REQUEST_ID);
307 GTEST_LOG_(INFO) << "SetFindFocusedElementInfoResult_001 end";
308 }
309
310 /**
311 * @tc.number: SetFindFocusedElementInfoResult_002
312 * @tc.name: SetFindFocusedElementInfoResult
313 * @tc.desc: Test function SetFindFocusedElementInfoResult
314 */
315 HWTEST_F(AccessibilityElementOperatorImplUnitTest, SetFindFocusedElementInfoResult_002, TestSize.Level1)
316 {
317 GTEST_LOG_(INFO) << "SetFindFocusedElementInfoResult_002 start";
318 if (!mockStub_) {
319 GTEST_LOG_(INFO) << "Cann't get AccessibilityElementOperatorImpl mockStub_";
320 return;
321 }
322 sptr<AccessibilityElementOperatorCallbackImpl> elementOperator =
323 new(std::nothrow) AccessibilityElementOperatorCallbackImpl();
324 mockStub_->FindFocusedElementInfo(ELEMENT_ID, FOCUS_TYPE, REQUEST_ID_2, elementOperator);
325 AccessibilityElementInfo info {};
326 mockStub_->SetFindFocusedElementInfoResult(info, CompositeId(REQUEST_ID_2));
327 GTEST_LOG_(INFO) << "SetFindFocusedElementInfoResult_002 end";
328 }
329
330 /**
331 * @tc.number: SetFocusMoveSearchResult_001
332 * @tc.name: SetFocusMoveSearchResult
333 * @tc.desc: Test function SetFocusMoveSearchResult
334 */
335 HWTEST_F(AccessibilityElementOperatorImplUnitTest, SetFocusMoveSearchResult_001, TestSize.Level1)
336 {
337 GTEST_LOG_(INFO) << "SetFocusMoveSearchResult_001 start";
338 if (!mockStub_) {
339 GTEST_LOG_(INFO) << "Cann't get AccessibilityElementOperatorImpl mockStub_";
340 return;
341 }
342 AccessibilityElementInfo info {};
343 mockStub_->SetFocusMoveSearchResult(info, REQUEST_ID);
344 GTEST_LOG_(INFO) << "SetFocusMoveSearchResult_001 end";
345 }
346
347 /**
348 * @tc.number: SetFocusMoveSearchResult_002
349 * @tc.name: SetFocusMoveSearchResult
350 * @tc.desc: Test function SetFocusMoveSearchResult
351 */
352 HWTEST_F(AccessibilityElementOperatorImplUnitTest, SetFocusMoveSearchResult_002, TestSize.Level1)
353 {
354 GTEST_LOG_(INFO) << "SetFocusMoveSearchResult_002 start";
355 if (!mockStub_) {
356 GTEST_LOG_(INFO) << "Cann't get AccessibilityElementOperatorImpl mockStub_";
357 return;
358 }
359 sptr<AccessibilityElementOperatorCallbackImpl> elementOperator =
360 new(std::nothrow) AccessibilityElementOperatorCallbackImpl();
361 mockStub_->FocusMoveSearch(ELEMENT_ID, DIRECTION, REQUEST_ID_2, elementOperator);
362 AccessibilityElementInfo info {};
363 mockStub_->SetFocusMoveSearchResult(info, CompositeId(REQUEST_ID_2));
364 GTEST_LOG_(INFO) << "SetFocusMoveSearchResult_002 end";
365 }
366
367 /**
368 * @tc.number: SetExecuteActionResult_001
369 * @tc.name: SetExecuteActionResult
370 * @tc.desc: Test function SetExecuteActionResult
371 */
372 HWTEST_F(AccessibilityElementOperatorImplUnitTest, SetExecuteActionResult_001, TestSize.Level1)
373 {
374 GTEST_LOG_(INFO) << "SetExecuteActionResult_001 start";
375 if (!mockStub_) {
376 GTEST_LOG_(INFO) << "Cann't get AccessibilityElementOperatorImpl mockStub_";
377 return;
378 }
379 mockStub_->SetExecuteActionResult(true, REQUEST_ID);
380 GTEST_LOG_(INFO) << "SetExecuteActionResult_001 end";
381 }
382
383 /**
384 * @tc.number: SetExecuteActionResult_002
385 * @tc.name: SetExecuteActionResult
386 * @tc.desc: Test function SetExecuteActionResult
387 */
388 HWTEST_F(AccessibilityElementOperatorImplUnitTest, SetExecuteActionResult_002, TestSize.Level1)
389 {
390 GTEST_LOG_(INFO) << "SetExecuteActionResult_002 start";
391 if (!mockStub_) {
392 GTEST_LOG_(INFO) << "Cann't get AccessibilityElementOperatorImpl mockStub_";
393 return;
394 }
395 sptr<AccessibilityElementOperatorCallbackImpl> elementOperator =
396 new(std::nothrow) AccessibilityElementOperatorCallbackImpl();
397 std::map<std::string, std::string> actionArguments;
398 mockStub_->ExecuteAction(ELEMENT_ID, ACTION, actionArguments, REQUEST_ID_2, elementOperator);
399 mockStub_->SetExecuteActionResult(true, CompositeId(REQUEST_ID_2));
400 GTEST_LOG_(INFO) << "SetExecuteActionResult_002 end";
401 }
402 } // namespace Accessibility
403 } // namespace OHOS