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 int64_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 constexpr int32_t WINDOW_ID = 10;
39 } // namespace
40
41 class AccessibilityElementOperatorImplUnitTest : public ::testing::Test {
42 public:
43 sptr<AccessibilityElementOperatorImpl> mockStub_ = nullptr;
AccessibilityElementOperatorImplUnitTest()44 AccessibilityElementOperatorImplUnitTest()
45 {}
~AccessibilityElementOperatorImplUnitTest()46 ~AccessibilityElementOperatorImplUnitTest()
47 {}
48 int32_t windowID_ = 1;
49 std::shared_ptr<MockAccessibilityElementOperator> operation_ = nullptr;
50 std::shared_ptr<AccessibilitySystemAbilityClientImpl> asac_ = nullptr;
SetUpTestCase()51 static void SetUpTestCase()
52 {
53 GTEST_LOG_(INFO) << "AccessibilityElementOperatorImplUnitTest Start";
54 }
TearDownTestCase()55 static void TearDownTestCase()
56 {
57 GTEST_LOG_(INFO) << "AccessibilityElementOperatorImplUnitTest End";
58 }
SetUp()59 void SetUp()
60 {
61 GTEST_LOG_(INFO) << "AccessibilityElementOperatorImplUnitTest SetUp() Start";
62 operation_ = std::make_shared<MockAccessibilityElementOperator>();
63 asac_ = std::make_shared<AccessibilitySystemAbilityClientImpl>();
64 mockStub_ = new AccessibilityElementOperatorImpl(windowID_, operation_, *asac_);
65 GTEST_LOG_(INFO) << "AccessibilityElementOperatorImplUnitTest SetUp() End";
66 };
TearDown()67 void TearDown()
68 {
69 GTEST_LOG_(INFO) << "AccessibilityElementOperatorImplUnitTest TearDown()";
70 mockStub_ = nullptr;
71 }
72
73 int32_t CompositeId(int32_t requestId);
74 };
75
CompositeId(int32_t requestId)76 int32_t AccessibilityElementOperatorImplUnitTest::CompositeId(int32_t requestId)
77 {
78 uint32_t compositionRequestId = static_cast<uint32_t>(requestId) |
79 (static_cast<uint32_t>(windowID_) << REQUEST_ID_MASK_BIT);
80 return static_cast<int32_t>(compositionRequestId);
81 }
82
83 /**
84 * @tc.number: SearchElementInfoByAccessibilityId_001
85 * @tc.name: SearchElementInfoByAccessibilityId
86 * @tc.desc: Test function SearchElementInfoByAccessibilityId
87 */
88 HWTEST_F(AccessibilityElementOperatorImplUnitTest, SearchElementInfoByAccessibilityId_001, TestSize.Level1)
89 {
90 GTEST_LOG_(INFO) << "SearchElementInfoByAccessibilityId_001 start";
91 if (!mockStub_) {
92 GTEST_LOG_(INFO) << "Cann't get AccessibilityElementOperatorImpl mockStub_";
93 return;
94 }
95 sptr<MockAccessibilityElementOperatorCallbackImpl> elementOperator =
96 new(std::nothrow) MockAccessibilityElementOperatorCallbackImpl();
97 EXPECT_CALL(*operation_, SearchElementInfoByAccessibilityId(_, _, _, _)).Times(1);
98 mockStub_->SearchElementInfoByAccessibilityId(ELEMENT_ID, REQUEST_ID, elementOperator, MODE);
99 GTEST_LOG_(INFO) << "SearchElementInfoByAccessibilityId_001 end";
100 }
101
102 /**
103 * @tc.number: SearchDefaultFocusedByWindowId_001
104 * @tc.name: SearchDefaultFocusedByWindowId
105 * @tc.desc: Test function SearchDefaultFocusedByWindowId
106 */
107 HWTEST_F(AccessibilityElementOperatorImplUnitTest, SearchDefaultFocusedByWindowId_001, TestSize.Level1)
108 {
109 GTEST_LOG_(INFO) << "SearchDefaultFocusedByWindowId_001 start";
110 if (!mockStub_) {
111 GTEST_LOG_(INFO) << "Cann't get AccessibilityElementOperatorImpl mockStub_";
112 return;
113 }
114 bool isFilter = false;
115 sptr<MockAccessibilityElementOperatorCallbackImpl> elementOperator =
116 new(std::nothrow) MockAccessibilityElementOperatorCallbackImpl();
117 EXPECT_CALL(*operation_, SearchDefaultFocusByWindowId(_, _, _, _)).Times(1);
118 mockStub_->SearchDefaultFocusedByWindowId(WINDOW_ID, REQUEST_ID, elementOperator, MODE, isFilter);
119 GTEST_LOG_(INFO) << "SearchDefaultFocusedByWindowId_001 end";
120 }
121
122 /**
123 * @tc.number: SearchElementInfosByText_001
124 * @tc.name: SearchElementInfosByText
125 * @tc.desc: Test function SearchElementInfosByText
126 */
127 HWTEST_F(AccessibilityElementOperatorImplUnitTest, SearchElementInfosByText_001, TestSize.Level1)
128 {
129 GTEST_LOG_(INFO) << "SearchElementInfosByText_001 start";
130 if (!mockStub_) {
131 GTEST_LOG_(INFO) << "Cann't get AccessibilityElementOperatorImpl mockStub_";
132 return;
133 }
134
135 EXPECT_CALL(*operation_, SearchElementInfosByText(_, _, _, _)).Times(1);
136 mockStub_->SearchElementInfosByText(ELEMENT_ID, TEST, REQUEST_ID, nullptr);
137 GTEST_LOG_(INFO) << "SearchElementInfosByText_001 end";
138 }
139
140 /**
141 * @tc.number: FindFocusedElementInfo_001
142 * @tc.name: FindFocusedElementInfo
143 * @tc.desc: Test function FindFocusedElementInfo
144 */
145 HWTEST_F(AccessibilityElementOperatorImplUnitTest, FindFocusedElementInfo_001, TestSize.Level1)
146 {
147 GTEST_LOG_(INFO) << "FindFocusedElementInfo_001 start";
148 if (!mockStub_) {
149 GTEST_LOG_(INFO) << "Cann't get AccessibilityElementOperatorImpl mockStub_";
150 return;
151 }
152
153 EXPECT_CALL(*operation_, FindFocusedElementInfo(_, _, _, _)).Times(1);
154 mockStub_->FindFocusedElementInfo(ELEMENT_ID, FOCUS_TYPE, REQUEST_ID, nullptr);
155 GTEST_LOG_(INFO) << "FindFocusedElementInfo_001 end";
156 }
157
158 /**
159 * @tc.number: FocusMoveSearch_001
160 * @tc.name: FocusMoveSearch
161 * @tc.desc: Test function FocusMoveSearch
162 */
163 HWTEST_F(AccessibilityElementOperatorImplUnitTest, FocusMoveSearch_001, TestSize.Level1)
164 {
165 GTEST_LOG_(INFO) << "FocusMoveSearch_001 start";
166 if (!mockStub_) {
167 GTEST_LOG_(INFO) << "Cann't get AccessibilityElementOperatorImpl mockStub_";
168 return;
169 }
170
171 EXPECT_CALL(*operation_, FocusMoveSearch(_, _, _, _)).Times(1);
172 mockStub_->FocusMoveSearch(ELEMENT_ID, DIRECTION, REQUEST_ID, nullptr);
173 GTEST_LOG_(INFO) << "FocusMoveSearch_001 end";
174 }
175
176 /**
177 * @tc.number: ExecuteAction_001
178 * @tc.name: ExecuteAction
179 * @tc.desc: Test function ExecuteAction
180 */
181 HWTEST_F(AccessibilityElementOperatorImplUnitTest, ExecuteAction_001, TestSize.Level1)
182 {
183 GTEST_LOG_(INFO) << "ExecuteAction_001 start";
184 if (!mockStub_) {
185 GTEST_LOG_(INFO) << "Cann't get AccessibilityElementOperatorImpl mockStub_";
186 return;
187 }
188
189 EXPECT_CALL(*operation_, ExecuteAction(_, _, _, _, _)).Times(1);
190 std::map<std::string, std::string> actionArguments;
191 mockStub_->ExecuteAction(ELEMENT_ID, ACTION, actionArguments, REQUEST_ID, nullptr);
192 GTEST_LOG_(INFO) << "ExecuteAction_001 end";
193 }
194
195 /**
196 * @tc.number: ClearFocus_001
197 * @tc.name: ClearFocus
198 * @tc.desc: Test function ClearFocus
199 */
200 HWTEST_F(AccessibilityElementOperatorImplUnitTest, ClearFocus_001, TestSize.Level1)
201 {
202 GTEST_LOG_(INFO) << "ClearFocus_001 start";
203 if (!mockStub_) {
204 GTEST_LOG_(INFO) << "Cann't get AccessibilityElementOperatorImpl mockStub_";
205 return;
206 }
207
208 EXPECT_CALL(*operation_, ClearFocus()).Times(1);
209 mockStub_->ClearFocus();
210 GTEST_LOG_(INFO) << "ClearFocus_001 end";
211 }
212
213 /**
214 * @tc.number: OutsideTouch_001
215 * @tc.name: OutsideTouch
216 * @tc.desc: Test function OutsideTouch
217 */
218 HWTEST_F(AccessibilityElementOperatorImplUnitTest, OutsideTouch_001, TestSize.Level1)
219 {
220 GTEST_LOG_(INFO) << "OutsideTouch_001 start";
221 if (!mockStub_) {
222 GTEST_LOG_(INFO) << "Cann't get AccessibilityElementOperatorImpl mockStub_";
223 return;
224 }
225
226 EXPECT_CALL(*operation_, OutsideTouch()).Times(1);
227 mockStub_->OutsideTouch();
228 GTEST_LOG_(INFO) << "OutsideTouch_001 end";
229 }
230
231 /**
232 * @tc.number: GetWindowId
233 * @tc.name: GetWindowId
234 * @tc.desc: Test function GetWindowId
235 */
236 HWTEST_F(AccessibilityElementOperatorImplUnitTest, GetWindowId, TestSize.Level1)
237 {
238 GTEST_LOG_(INFO) << "GetWindowId start";
239 if (!mockStub_) {
240 GTEST_LOG_(INFO) << "Cann't get AccessibilityElementOperatorImpl mockStub_";
241 return;
242 }
243 EXPECT_EQ(1, mockStub_->GetWindowId());
244 GTEST_LOG_(INFO) << "GetWindowId end";
245 }
246
247 /**
248 * @tc.number: SetSearchElementInfoByAccessibilityIdResult_001
249 * @tc.name: SetSearchElementInfoByAccessibilityIdResult
250 * @tc.desc: Test function SetSearchElementInfoByAccessibilityIdResult
251 */
252 HWTEST_F(AccessibilityElementOperatorImplUnitTest, SetSearchElementInfoByAccessibilityIdResult_001, TestSize.Level1)
253 {
254 GTEST_LOG_(INFO) << "SetSearchElementInfoByAccessibilityIdResult_001 start";
255 if (!mockStub_) {
256 GTEST_LOG_(INFO) << "Cann't get AccessibilityElementOperatorImpl mockStub_";
257 return;
258 }
259
260 sptr<MockAccessibilityElementOperatorCallbackImpl> elementOperator =
261 new(std::nothrow) MockAccessibilityElementOperatorCallbackImpl();
262 EXPECT_CALL(*elementOperator, SetSearchElementInfoByAccessibilityIdResult(_, _)).Times(0);
263 std::list<AccessibilityElementInfo> infos;
264 AccessibilityElementInfo info {};
265 infos.push_back(info);
266 mockStub_->SetSearchElementInfoByAccessibilityIdResult(infos, REQUEST_ID);
267 GTEST_LOG_(INFO) << "SetSearchElementInfoByAccessibilityIdResult_001 end";
268 }
269
270 /**
271 * @tc.number: SetSearchElementInfoByAccessibilityIdResult_002
272 * @tc.name: SetSearchElementInfoByAccessibilityIdResult
273 * @tc.desc: Test function SetSearchElementInfoByAccessibilityIdResult
274 */
275 HWTEST_F(AccessibilityElementOperatorImplUnitTest, SetSearchElementInfoByAccessibilityIdResult_002, TestSize.Level1)
276 {
277 GTEST_LOG_(INFO) << "SetSearchElementInfoByAccessibilityIdResult_002 start";
278 if (!mockStub_) {
279 GTEST_LOG_(INFO) << "Cann't get AccessibilityElementOperatorImpl mockStub_";
280 return;
281 }
282
283 sptr<MockAccessibilityElementOperatorCallbackImpl> elementOperator =
284 new(std::nothrow) MockAccessibilityElementOperatorCallbackImpl();
285 mockStub_->SearchElementInfoByAccessibilityId(ELEMENT_ID, REQUEST_ID_2, elementOperator, MODE, false);
286 std::list<AccessibilityElementInfo> infos;
287 AccessibilityElementInfo info {};
288 infos.push_back(info);
289 mockStub_->SetSearchElementInfoByAccessibilityIdResult(infos, CompositeId(REQUEST_ID_2));
290 GTEST_LOG_(INFO) << "SetSearchElementInfoByAccessibilityIdResult_002 end";
291 }
292
293 /**
294 * @tc.number: SetSearchDefaultFocusByWindowIdResult_001
295 * @tc.name: SetSearchDefaultFocusByWindowIdResult
296 * @tc.desc: Test function SetSearchDefaultFocusByWindowIdResult
297 */
298 HWTEST_F(AccessibilityElementOperatorImplUnitTest, SetSearchDefaultFocusByWindowIdResult_001, TestSize.Level1)
299 {
300 GTEST_LOG_(INFO) << "SetSearchDefaultFocusByWindowIdResult_001 start";
301 if (!mockStub_) {
302 GTEST_LOG_(INFO) << "Cann't get AccessibilityElementOperatorImpl mockStub_";
303 return;
304 }
305
306 sptr<MockAccessibilityElementOperatorCallbackImpl> elementOperator =
307 new(std::nothrow) MockAccessibilityElementOperatorCallbackImpl();
308 EXPECT_CALL(*elementOperator, SetSearchDefaultFocusByWindowIdResult(_, _)).Times(0);
309 std::list<AccessibilityElementInfo> infos;
310 AccessibilityElementInfo info {};
311 infos.push_back(info);
312 mockStub_->SetSearchDefaultFocusByWindowIdResult(infos, REQUEST_ID);
313 GTEST_LOG_(INFO) << "SetSearchDefaultFocusByWindowIdResult_001 end";
314 }
315
316 /**
317 * @tc.number: SetSearchDefaultFocusByWindowIdResult_002
318 * @tc.name: SetSearchDefaultFocusByWindowIdResult
319 * @tc.desc: Test function SetSearchElementInfoByAccessibilityIdResult
320 */
321 HWTEST_F(AccessibilityElementOperatorImplUnitTest, SetSearchDefaultFocusByWindowIdResult_002, TestSize.Level1)
322 {
323 GTEST_LOG_(INFO) << "SetSearchDefaultFocusByWindowIdResult_002 start";
324 if (!mockStub_) {
325 GTEST_LOG_(INFO) << "Cann't get AccessibilityElementOperatorImpl mockStub_";
326 return;
327 }
328
329 sptr<MockAccessibilityElementOperatorCallbackImpl> elementOperator =
330 new(std::nothrow) MockAccessibilityElementOperatorCallbackImpl();
331 EXPECT_CALL(*elementOperator, SetSearchDefaultFocusByWindowIdResult(_, _)).Times(0);
332 std::list<AccessibilityElementInfo> infos;
333 AccessibilityElementInfo info {};
334 infos.push_back(info);
335 mockStub_->SetSearchDefaultFocusByWindowIdResult(infos, REQUEST_ID);
336 GTEST_LOG_(INFO) << "SetSearchDefaultFocusByWindowIdResult_002 end";
337 }
338
339 /**
340 * @tc.number: SetSearchElementInfoByTextResult_001
341 * @tc.name: SetSearchElementInfoByTextResult
342 * @tc.desc: Test function SetSearchElementInfoByTextResult
343 */
344 HWTEST_F(AccessibilityElementOperatorImplUnitTest, SetSearchElementInfoByTextResult_001, TestSize.Level1)
345 {
346 GTEST_LOG_(INFO) << "SetSearchElementInfoByTextResult_001 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, SetSearchElementInfoByTextResult(_, _)).Times(0);
355 std::list<AccessibilityElementInfo> infos;
356 AccessibilityElementInfo info {};
357 infos.push_back(info);
358 mockStub_->SetSearchElementInfoByTextResult(infos, REQUEST_ID);
359 GTEST_LOG_(INFO) << "SetSearchElementInfoByTextResult_001 end";
360 }
361
362 /**
363 * @tc.number: SetSearchElementInfoByTextResult_002
364 * @tc.name: SetSearchElementInfoByTextResult
365 * @tc.desc: Test function SetSearchElementInfoByTextResult
366 */
367 HWTEST_F(AccessibilityElementOperatorImplUnitTest, SetSearchElementInfoByTextResult_002, TestSize.Level1)
368 {
369 GTEST_LOG_(INFO) << "SetSearchElementInfoByTextResult_002 start";
370 if (!mockStub_) {
371 GTEST_LOG_(INFO) << "Cann't get AccessibilityElementOperatorImpl mockStub_";
372 return;
373 }
374 sptr<MockAccessibilityElementOperatorCallbackImpl> elementOperator =
375 new(std::nothrow) MockAccessibilityElementOperatorCallbackImpl();
376 EXPECT_CALL(*elementOperator, SetSearchElementInfoByTextResult(_, _)).Times(0);
377 std::list<AccessibilityElementInfo> infos;
378 AccessibilityElementInfo info {};
379 infos.push_back(info);
380 mockStub_->SetSearchElementInfoByTextResult(infos, REQUEST_ID);
381 GTEST_LOG_(INFO) << "SetSearchElementInfoByTextResult_002 end";
382 }
383
384 /**
385 * @tc.number: SetFindFocusedElementInfoResult_001
386 * @tc.name: SetFindFocusedElementInfoResult
387 * @tc.desc: Test function SetFindFocusedElementInfoResult
388 */
389 HWTEST_F(AccessibilityElementOperatorImplUnitTest, SetFindFocusedElementInfoResult_001, TestSize.Level1)
390 {
391 GTEST_LOG_(INFO) << "SetFindFocusedElementInfoResult_001 start";
392 if (!mockStub_) {
393 GTEST_LOG_(INFO) << "Cann't get AccessibilityElementOperatorImpl mockStub_";
394 return;
395 }
396
397 sptr<MockAccessibilityElementOperatorCallbackImpl> elementOperator =
398 new(std::nothrow) MockAccessibilityElementOperatorCallbackImpl();
399 EXPECT_CALL(*elementOperator, SetFindFocusedElementInfoResult(_, _)).Times(0);
400 AccessibilityElementInfo info {};
401 mockStub_->SetFindFocusedElementInfoResult(info, REQUEST_ID);
402 GTEST_LOG_(INFO) << "SetFindFocusedElementInfoResult_001 end";
403 }
404
405 /**
406 * @tc.number: SetFindFocusedElementInfoResult_002
407 * @tc.name: SetFindFocusedElementInfoResult
408 * @tc.desc: Test function SetFindFocusedElementInfoResult
409 */
410 HWTEST_F(AccessibilityElementOperatorImplUnitTest, SetFindFocusedElementInfoResult_002, TestSize.Level1)
411 {
412 GTEST_LOG_(INFO) << "SetFindFocusedElementInfoResult_002 start";
413 if (!mockStub_) {
414 GTEST_LOG_(INFO) << "Cann't get AccessibilityElementOperatorImpl mockStub_";
415 return;
416 }
417
418 sptr<MockAccessibilityElementOperatorCallbackImpl> elementOperator =
419 new(std::nothrow) MockAccessibilityElementOperatorCallbackImpl();
420 EXPECT_CALL(*elementOperator, SetFindFocusedElementInfoResult(_, _)).Times(0);
421 mockStub_->FindFocusedElementInfo(ELEMENT_ID, FOCUS_TYPE, REQUEST_ID_2, elementOperator);
422 AccessibilityElementInfo info {};
423 mockStub_->SetFindFocusedElementInfoResult(info, REQUEST_ID_2);
424 GTEST_LOG_(INFO) << "SetFindFocusedElementInfoResult_002 end";
425 }
426
427 /**
428 * @tc.number: SetFocusMoveSearchResult_001
429 * @tc.name: SetFocusMoveSearchResult
430 * @tc.desc: Test function SetFocusMoveSearchResult
431 */
432 HWTEST_F(AccessibilityElementOperatorImplUnitTest, SetFocusMoveSearchResult_001, TestSize.Level1)
433 {
434 GTEST_LOG_(INFO) << "SetFocusMoveSearchResult_001 start";
435 if (!mockStub_) {
436 GTEST_LOG_(INFO) << "Cann't get AccessibilityElementOperatorImpl mockStub_";
437 return;
438 }
439
440 sptr<MockAccessibilityElementOperatorCallbackImpl> elementOperator =
441 new(std::nothrow) MockAccessibilityElementOperatorCallbackImpl();
442 EXPECT_CALL(*elementOperator, SetFocusMoveSearchResult(_, _)).Times(0);
443 AccessibilityElementInfo info {};
444 mockStub_->SetFocusMoveSearchResult(info, REQUEST_ID);
445 GTEST_LOG_(INFO) << "SetFocusMoveSearchResult_001 end";
446 }
447
448 /**
449 * @tc.number: SetFocusMoveSearchResult_002
450 * @tc.name: SetFocusMoveSearchResult
451 * @tc.desc: Test function SetFocusMoveSearchResult
452 */
453 HWTEST_F(AccessibilityElementOperatorImplUnitTest, SetFocusMoveSearchResult_002, TestSize.Level1)
454 {
455 GTEST_LOG_(INFO) << "SetFocusMoveSearchResult_002 start";
456 if (!mockStub_) {
457 GTEST_LOG_(INFO) << "Cann't get AccessibilityElementOperatorImpl mockStub_";
458 return;
459 }
460
461 sptr<MockAccessibilityElementOperatorCallbackImpl> elementOperator =
462 new(std::nothrow) MockAccessibilityElementOperatorCallbackImpl();
463 EXPECT_CALL(*elementOperator, SetFocusMoveSearchResult(_, _)).Times(1);
464 mockStub_->FocusMoveSearch(ELEMENT_ID, DIRECTION, REQUEST_ID_2, elementOperator);
465 AccessibilityElementInfo info {};
466 mockStub_->SetFocusMoveSearchResult(info, REQUEST_ID_2);
467 GTEST_LOG_(INFO) << "SetFocusMoveSearchResult_002 end";
468 }
469
470 /**
471 * @tc.number: SetExecuteActionResult_001
472 * @tc.name: SetExecuteActionResult
473 * @tc.desc: Test function SetExecuteActionResult
474 */
475 HWTEST_F(AccessibilityElementOperatorImplUnitTest, SetExecuteActionResult_001, TestSize.Level1)
476 {
477 GTEST_LOG_(INFO) << "SetExecuteActionResult_001 start";
478 if (!mockStub_) {
479 GTEST_LOG_(INFO) << "Cann't get AccessibilityElementOperatorImpl mockStub_";
480 return;
481 }
482 mockStub_->SetExecuteActionResult(true, REQUEST_ID);
483 EXPECT_NE(mockStub_.GetRefPtr(), nullptr);
484 GTEST_LOG_(INFO) << "SetExecuteActionResult_001 end";
485 }
486
487 /**
488 * @tc.number: SetExecuteActionResult_002
489 * @tc.name: SetExecuteActionResult
490 * @tc.desc: Test function SetExecuteActionResult
491 */
492 HWTEST_F(AccessibilityElementOperatorImplUnitTest, SetExecuteActionResult_002, TestSize.Level1)
493 {
494 GTEST_LOG_(INFO) << "SetExecuteActionResult_002 start";
495 if (!mockStub_) {
496 GTEST_LOG_(INFO) << "Cann't get AccessibilityElementOperatorImpl mockStub_";
497 return;
498 }
499 sptr<MockAccessibilityElementOperatorCallbackImpl> elementOperator =
500 new(std::nothrow) MockAccessibilityElementOperatorCallbackImpl();
501 std::map<std::string, std::string> actionArguments;
502 mockStub_->ExecuteAction(ELEMENT_ID, ACTION, actionArguments, REQUEST_ID_2, elementOperator);
503 mockStub_->SetExecuteActionResult(true, CompositeId(REQUEST_ID_2));
504 EXPECT_NE(mockStub_.GetRefPtr(), nullptr);
505 GTEST_LOG_(INFO) << "SetExecuteActionResult_002 end";
506 }
507
508 /**
509 * @tc.number: GetCursorPosition_001
510 * @tc.name: GetCursorPosition
511 * @tc.desc: Test function GetCursorPosition
512 */
513 HWTEST_F(AccessibilityElementOperatorImplUnitTest, GetCursorPosition_001, TestSize.Level1)
514 {
515 GTEST_LOG_(INFO) << "GetCursorPosition_001 start";
516 if (!mockStub_) {
517 GTEST_LOG_(INFO) << "Cann't get AccessibilityElementOperatorImpl mockStub_";
518 return;
519 }
520
521 EXPECT_CALL(*operation_, GetCursorPosition(_, _, _)).Times(1);
522 mockStub_->GetCursorPosition(ELEMENT_ID, REQUEST_ID, nullptr);
523 GTEST_LOG_(INFO) << "GetCursorPosition_001 end";
524 }
525
526 /**
527 * @tc.number: SetChildTreeIdAndWinId_001
528 * @tc.name: SetChildTreeIdAndWinId
529 * @tc.desc: Test function SetChildTreeIdAndWinId
530 */
531 HWTEST_F(AccessibilityElementOperatorImplUnitTest, SetChildTreeIdAndWinId_001, TestSize.Level1)
532 {
533 GTEST_LOG_(INFO) << "SetChildTreeIdAndWinId_001 start";
534 if (!mockStub_) {
535 GTEST_LOG_(INFO) << "Cann't get AccessibilityElementOperatorImpl mockStub_";
536 return;
537 }
538 int64_t nodeId = 1;
539 int32_t childTreeId = 1;
540 int32_t childWindowId = 1;
541 EXPECT_CALL(*operation_, SetChildTreeIdAndWinId(_, _, _)).Times(1);
542 mockStub_->SetChildTreeIdAndWinId(nodeId, childTreeId, childWindowId);
543 GTEST_LOG_(INFO) << "SetChildTreeIdAndWinId_001 end";
544 }
545
546 /**
547 * @tc.number: SetBelongTreeId_001
548 * @tc.name: SetBelongTreeId
549 * @tc.desc: Test function SetBelongTreeId
550 */
551 HWTEST_F(AccessibilityElementOperatorImplUnitTest, SetBelongTreeId_001, TestSize.Level1)
552 {
553 GTEST_LOG_(INFO) << "SetBelongTreeId_001 start";
554 if (!mockStub_) {
555 GTEST_LOG_(INFO) << "Cann't get AccessibilityElementOperatorImpl mockStub_";
556 return;
557 }
558 int64_t treeId = 1;
559 EXPECT_CALL(*operation_, SetBelongTreeId(_)).Times(1);
560 mockStub_->SetBelongTreeId(treeId);
561 GTEST_LOG_(INFO) << "SetBelongTreeId_001 end";
562 }
563
564 /**
565 * @tc.number: SetParentWindowId_001
566 * @tc.name: SetParentWindowId
567 * @tc.desc: Test function SetParentWindowId
568 */
569 HWTEST_F(AccessibilityElementOperatorImplUnitTest, SetParentWindowId_001, TestSize.Level1)
570 {
571 GTEST_LOG_(INFO) << "SetParentWindowId_001 start";
572 if (!mockStub_) {
573 GTEST_LOG_(INFO) << "Cann't get AccessibilityElementOperatorImpl mockStub_";
574 return;
575 }
576 int64_t parentWindowId = 1;
577 EXPECT_CALL(*operation_, SetParentWindowId(_)).Times(1);
578 mockStub_->SetParentWindowId(parentWindowId);
579 GTEST_LOG_(INFO) << "SetParentWindowId_001 end";
580 }
581
582 /**
583 * @tc.number: SetFiltering_001
584 * @tc.name: SetFiltering
585 * @tc.desc: Test function SetFiltering
586 */
587 HWTEST_F(AccessibilityElementOperatorImplUnitTest, SetFiltering_001, TestSize.Level1)
588 {
589 GTEST_LOG_(INFO) << "SetFiltering_001 start";
590 if (!mockStub_) {
591 GTEST_LOG_(INFO) << "Cann't get AccessibilityElementOperatorImpl mockStub_";
592 return;
593 }
594 std::vector<AccessibilityElementInfo> filterInfos;
595 mockStub_->SetFiltering(filterInfos);
596 GTEST_LOG_(INFO) << "SetFiltering_001 end";
597 }
598
599 /**
600 * @tc.number: SetCursorPositionResult_001
601 * @tc.name: SetCursorPositionResult
602 * @tc.desc: Test function SetCursorPositionResult
603 */
604 HWTEST_F(AccessibilityElementOperatorImplUnitTest, SetCursorPositionResult_001, TestSize.Level1)
605 {
606 GTEST_LOG_(INFO) << "SetCursorPositionResult_001 start";
607 if (!mockStub_) {
608 GTEST_LOG_(INFO) << "Cann't get AccessibilityElementOperatorImpl mockStub_";
609 return;
610 }
611 int32_t cursorPosition = 1;
612 mockStub_->SetCursorPositionResult(cursorPosition, REQUEST_ID);
613 EXPECT_NE(mockStub_.GetRefPtr(), nullptr);
614 GTEST_LOG_(INFO) << "SetCursorPositionResult_001 end";
615 }
616
617 /**
618 * @tc.number: SetCursorPositionResult_002
619 * @tc.name: SetCursorPositionResult
620 * @tc.desc: Test function SetCursorPositionResult
621 */
622 HWTEST_F(AccessibilityElementOperatorImplUnitTest, SetCursorPositionResult_002, TestSize.Level1)
623 {
624 GTEST_LOG_(INFO) << "SetCursorPositionResult_002 start";
625 if (!mockStub_) {
626 GTEST_LOG_(INFO) << "Cann't get AccessibilityElementOperatorImpl mockStub_";
627 return;
628 }
629 sptr<MockAccessibilityElementOperatorCallbackImpl> elementOperator =
630 new(std::nothrow) MockAccessibilityElementOperatorCallbackImpl();
631 int32_t cursorPosition = 1;
632 mockStub_->GetCursorPosition(ELEMENT_ID, REQUEST_ID, elementOperator);
633 mockStub_->SetCursorPositionResult(cursorPosition, CompositeId(REQUEST_ID_2));
634 EXPECT_NE(mockStub_.GetRefPtr(), nullptr);
635 GTEST_LOG_(INFO) << "SetCursorPositionResult_002 end";
636 }
637 } // namespace Accessibility
638 } // namespace OHOS