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