1 /*
2 * Copyright (C) 2022-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 #include "A11y_ability_ut_helper.h"
18 #include "A11y_ui_test_ability_impl.h"
19 #include "mock_accessible_ability_listener.h"
20
21 using namespace testing;
22 using namespace testing::ext;
23
24 namespace OHOS {
25 namespace A11y {
26 namespace {
27 const std::string TEST = "test";
28 constexpr int32_t FOCUS_TYPE = 1;
29 constexpr int32_t WINDOW_ID = 1;
30 constexpr uint64_t DISPLAY_ID = 1;
31 constexpr int32_t CACHE_MODE = 2;
32 } // namespace
33
34 class A11yUITestAbilityImplTest : public ::testing::Test {
35 public:
A11yUITestAbilityImplTest()36 A11yUITestAbilityImplTest()
37 {}
~A11yUITestAbilityImplTest()38 ~A11yUITestAbilityImplTest()
39 {}
40
41 std::shared_ptr<A11yUITestAbilityImpl> instance_ = nullptr;
SetUpTestCase()42 static void SetUpTestCase()
43 {
44 GTEST_LOG_(INFO) << "A11yUITestAbilityImplTest Start";
45 }
TearDownTestCase()46 static void TearDownTestCase()
47 {
48 GTEST_LOG_(INFO) << "A11yUITestAbilityImplTest End";
49 }
SetUp()50 void SetUp()
51 {
52 GTEST_LOG_(INFO) << "A11yUITestAbilityImplTest SetUp()";
53 instance_ = std::make_shared<A11yUITestAbilityImpl>();
54 }
TearDown()55 void TearDown()
56 {
57 GTEST_LOG_(INFO) << "A11yUITestAbilityImplTest TearDown()";
58 instance_ = nullptr;
59 }
60 };
61
62 /**
63 * @tc.number: GetInstance_001
64 * @tc.name: GetInstance
65 * @tc.desc: Test function GetInstance
66 */
HWTEST_F(A11yUITestAbilityImplTest, GetInstance_001, TestSize.Level1)67 HWTEST_F(A11yUITestAbilityImplTest, GetInstance_001, TestSize.Level1)
68 {
69 GTEST_LOG_(INFO) << "GetInstance_001 start";
70 EXPECT_TRUE(A11yUITestAbility::GetInstance());
71 GTEST_LOG_(INFO) << "GetInstance_001 end";
72 }
73
74 /**
75 * @tc.number: RegisterAbilityListener_001
76 * @tc.name: RegisterAbilityListener
77 * @tc.desc: Test function RegisterAbilityListener(listener is null)
78 */
HWTEST_F(A11yUITestAbilityImplTest, RegisterAbilityListener_001, TestSize.Level1)79 HWTEST_F(A11yUITestAbilityImplTest, RegisterAbilityListener_001, TestSize.Level1)
80 {
81 GTEST_LOG_(INFO) << "RegisterAbilityListener_001 start";
82
83 if (!instance_) {
84 GTEST_LOG_(INFO) << "Cann't get A11yUITestAbilityImpl instance_";
85 return;
86 }
87 std::shared_ptr<AccessibleAbilityListener> listener = nullptr;
88 EXPECT_EQ(instance_->RegisterAbilityListener(listener), RET_ERR_INVALID_PARAM);
89
90 GTEST_LOG_(INFO) << "RegisterAbilityListener_001 end";
91 }
92
93 /**
94 * @tc.number: RegisterAbilityListener_002
95 * @tc.name: RegisterAbilityListener
96 * @tc.desc: Test function RegisterAbilityListener(AccessibleAbilityClient is null)
97 */
HWTEST_F(A11yUITestAbilityImplTest, RegisterAbilityListener_002, TestSize.Level1)98 HWTEST_F(A11yUITestAbilityImplTest, RegisterAbilityListener_002, TestSize.Level1)
99 {
100 GTEST_LOG_(INFO) << "RegisterAbilityListener_002 start";
101
102 if (!instance_) {
103 GTEST_LOG_(INFO) << "Cann't get A11yUITestAbilityImpl instance_";
104 return;
105 }
106 A11yAbilityUtHelper::GetInstance().SetAbilityClientNullFlag(true);
107 std::shared_ptr<AccessibleAbilityListener> listener = std::make_shared<MockAccessibleAbilityListener>();
108 EXPECT_EQ(instance_->RegisterAbilityListener(listener), RET_ERR_NULLPTR);
109 A11yAbilityUtHelper::GetInstance().SetAbilityClientNullFlag(false);
110
111 GTEST_LOG_(INFO) << "RegisterAbilityListener_002 end";
112 }
113
114 /**
115 * @tc.number: RegisterAbilityListener_003
116 * @tc.name: RegisterAbilityListener
117 * @tc.desc: Test function RegisterAbilityListener(AccessibleAbilityClient is not null)
118 */
HWTEST_F(A11yUITestAbilityImplTest, RegisterAbilityListener_003, TestSize.Level1)119 HWTEST_F(A11yUITestAbilityImplTest, RegisterAbilityListener_003, TestSize.Level1)
120 {
121 GTEST_LOG_(INFO) << "RegisterAbilityListener_003 start";
122
123 if (!instance_) {
124 GTEST_LOG_(INFO) << "Cann't get A11yUITestAbilityImpl instance_";
125 return;
126 }
127 std::shared_ptr<AccessibleAbilityListener> listener = std::make_shared<MockAccessibleAbilityListener>();
128 EXPECT_EQ(instance_->RegisterAbilityListener(listener), RET_OK);
129
130 GTEST_LOG_(INFO) << "RegisterAbilityListener_003 end";
131 }
132
133 /**
134 * @tc.number: Connect_001
135 * @tc.name: Connect
136 * @tc.desc: Test function Connect
137 */
HWTEST_F(A11yUITestAbilityImplTest, Connect_001, TestSize.Level1)138 HWTEST_F(A11yUITestAbilityImplTest, Connect_001, TestSize.Level1)
139 {
140 GTEST_LOG_(INFO) << "Connect_001 start";
141
142 if (!instance_) {
143 GTEST_LOG_(INFO) << "Cann't get A11yUITestAbilityImpl instance_";
144 return;
145 }
146 EXPECT_EQ(RET_OK, instance_->Connect());
147
148 GTEST_LOG_(INFO) << "Connect_001 end";
149 }
150
151 /**
152 * @tc.number: Disconnect_001
153 * @tc.name: Disconnect
154 * @tc.desc: Test function Disconnect
155 */
HWTEST_F(A11yUITestAbilityImplTest, Disconnect_001, TestSize.Level1)156 HWTEST_F(A11yUITestAbilityImplTest, Disconnect_001, TestSize.Level1)
157 {
158 GTEST_LOG_(INFO) << "Disconnect_001 start";
159
160 if (!instance_) {
161 GTEST_LOG_(INFO) << "Cann't get A11yUITestAbilityImpl instance_";
162 return;
163 }
164 EXPECT_EQ(instance_->Disconnect(), RET_OK);
165
166 GTEST_LOG_(INFO) << "Disconnect_001 end";
167 }
168
169 /**
170 * @tc.number: GetFocus_001
171 * @tc.name: GetFocus
172 * @tc.desc: Test function GetFocus(AccessibleAbilityClient is null)
173 */
HWTEST_F(A11yUITestAbilityImplTest, GetFocus_001, TestSize.Level1)174 HWTEST_F(A11yUITestAbilityImplTest, GetFocus_001, TestSize.Level1)
175 {
176 GTEST_LOG_(INFO) << "GetFocus_001 start";
177
178 if (!instance_) {
179 GTEST_LOG_(INFO) << "Cann't get A11yUITestAbilityImpl instance_";
180 return;
181 }
182 A11yAbilityUtHelper::GetInstance().SetAbilityClientNullFlag(true);
183 A11yElementInfo elementInfo {};
184 EXPECT_EQ(instance_->GetFocus(FOCUS_TYPE, elementInfo), RET_ERR_NULLPTR);
185 A11yAbilityUtHelper::GetInstance().SetAbilityClientNullFlag(false);
186
187 GTEST_LOG_(INFO) << "GetFocus_001 end";
188 }
189
190 /**
191 * @tc.number: GetFocus_002
192 * @tc.name: GetFocus
193 * @tc.desc: Test function GetFocus(AccessibleAbilityClient is not null)
194 */
HWTEST_F(A11yUITestAbilityImplTest, GetFocus_002, TestSize.Level1)195 HWTEST_F(A11yUITestAbilityImplTest, GetFocus_002, TestSize.Level1)
196 {
197 GTEST_LOG_(INFO) << "GetFocus_002 start";
198
199 if (!instance_) {
200 GTEST_LOG_(INFO) << "Cann't get A11yUITestAbilityImpl instance_";
201 return;
202 }
203 A11yElementInfo elementInfo {};
204 EXPECT_EQ(instance_->GetFocus(FOCUS_TYPE, elementInfo), RET_OK);
205
206 GTEST_LOG_(INFO) << "GetFocus_002 end";
207 }
208
209 /**
210 * @tc.number: GetFocusByElementInfo_001
211 * @tc.name: GetFocusByElementInfo
212 * @tc.desc: Test function GetFocusByElementInfo(AccessibleAbilityClient is null)
213 */
HWTEST_F(A11yUITestAbilityImplTest, GetFocusByElementInfo_001, TestSize.Level1)214 HWTEST_F(A11yUITestAbilityImplTest, GetFocusByElementInfo_001, TestSize.Level1)
215 {
216 GTEST_LOG_(INFO) << "GetFocusByElementInfo_001 start";
217
218 if (!instance_) {
219 GTEST_LOG_(INFO) << "Cann't get A11yUITestAbilityImpl instance_";
220 return;
221 }
222 A11yAbilityUtHelper::GetInstance().SetAbilityClientNullFlag(true);
223 A11yElementInfo sourceInfo {};
224 A11yElementInfo elementInfo {};
225 EXPECT_EQ(instance_->GetFocusByElementInfo(sourceInfo, FOCUS_TYPE, elementInfo), RET_ERR_NULLPTR);
226 A11yAbilityUtHelper::GetInstance().SetAbilityClientNullFlag(false);
227
228 GTEST_LOG_(INFO) << "GetFocusByElementInfo_001 end";
229 }
230
231 /**
232 * @tc.number: GetFocusByElementInfo_002
233 * @tc.name: GetFocusByElementInfo
234 * @tc.desc: Test function GetFocusByElementInfo(AccessibleAbilityClient is not null)
235 */
HWTEST_F(A11yUITestAbilityImplTest, GetFocusByElementInfo_002, TestSize.Level1)236 HWTEST_F(A11yUITestAbilityImplTest, GetFocusByElementInfo_002, TestSize.Level1)
237 {
238 GTEST_LOG_(INFO) << "GetFocusByElementInfo_002 start";
239
240 if (!instance_) {
241 GTEST_LOG_(INFO) << "Cann't get A11yUITestAbilityImpl instance_";
242 return;
243 }
244 A11yElementInfo sourceInfo {};
245 A11yElementInfo elementInfo {};
246 EXPECT_EQ(instance_->GetFocusByElementInfo(sourceInfo, FOCUS_TYPE, elementInfo), RET_OK);
247
248 GTEST_LOG_(INFO) << "GetFocusByElementInfo_002 end";
249 }
250
251 /**
252 * @tc.number: InjectGesture_001
253 * @tc.name: InjectGesture
254 * @tc.desc: Test function InjectGesture(AccessibleAbilityClient is null)
255 */
HWTEST_F(A11yUITestAbilityImplTest, InjectGesture_001, TestSize.Level1)256 HWTEST_F(A11yUITestAbilityImplTest, InjectGesture_001, TestSize.Level1)
257 {
258 GTEST_LOG_(INFO) << "InjectGesture_001 start";
259
260 if (!instance_) {
261 GTEST_LOG_(INFO) << "Cann't get A11yUITestAbilityImpl instance_";
262 return;
263 }
264 A11yAbilityUtHelper::GetInstance().SetAbilityClientNullFlag(true);
265 std::shared_ptr<A11yGestureInjectPath> gesturePath = std::make_shared<A11yGestureInjectPath>();
266 EXPECT_EQ(instance_->InjectGesture(gesturePath), RET_ERR_NULLPTR);
267 A11yAbilityUtHelper::GetInstance().SetAbilityClientNullFlag(false);
268
269 GTEST_LOG_(INFO) << "InjectGesture_001 end";
270 }
271
272 /**
273 * @tc.number: InjectGesture_002
274 * @tc.name: InjectGesture
275 * @tc.desc: Test function InjectGesture(AccessibleAbilityClient is not null)
276 */
HWTEST_F(A11yUITestAbilityImplTest, InjectGesture_002, TestSize.Level1)277 HWTEST_F(A11yUITestAbilityImplTest, InjectGesture_002, TestSize.Level1)
278 {
279 GTEST_LOG_(INFO) << "InjectGesture_002 start";
280
281 if (!instance_) {
282 GTEST_LOG_(INFO) << "Cann't get A11yUITestAbilityImpl instance_";
283 return;
284 }
285 std::shared_ptr<A11yGestureInjectPath> gesturePath = std::make_shared<A11yGestureInjectPath>();
286 EXPECT_EQ(instance_->InjectGesture(gesturePath), RET_OK);
287
288 GTEST_LOG_(INFO) << "InjectGesture_002 end";
289 }
290
291 /**
292 * @tc.number: GetRoot_001
293 * @tc.name: GetRoot
294 * @tc.desc: Test function GetRoot(AccessibleAbilityClient is null)
295 */
HWTEST_F(A11yUITestAbilityImplTest, GetRoot_001, TestSize.Level1)296 HWTEST_F(A11yUITestAbilityImplTest, GetRoot_001, TestSize.Level1)
297 {
298 GTEST_LOG_(INFO) << "GetRoot_001 start";
299
300 if (!instance_) {
301 GTEST_LOG_(INFO) << "Cann't get A11yUITestAbilityImpl instance_";
302 return;
303 }
304 A11yAbilityUtHelper::GetInstance().SetAbilityClientNullFlag(true);
305 A11yElementInfo elementInfo {};
306 EXPECT_EQ(instance_->GetRoot(elementInfo), RET_ERR_NULLPTR);
307 A11yAbilityUtHelper::GetInstance().SetAbilityClientNullFlag(false);
308
309 GTEST_LOG_(INFO) << "GetRoot_001 end";
310 }
311
312 /**
313 * @tc.number: GetRoot_002
314 * @tc.name: GetRoot
315 * @tc.desc: Test function GetRoot(AccessibleAbilityClient is not null)
316 */
HWTEST_F(A11yUITestAbilityImplTest, GetRoot_002, TestSize.Level1)317 HWTEST_F(A11yUITestAbilityImplTest, GetRoot_002, TestSize.Level1)
318 {
319 GTEST_LOG_(INFO) << "GetRoot_002 start";
320
321 if (!instance_) {
322 GTEST_LOG_(INFO) << "Cann't get A11yUITestAbilityImpl instance_";
323 return;
324 }
325 A11yElementInfo elementInfo {};
326 EXPECT_EQ(instance_->GetRoot(elementInfo), RET_OK);
327
328 GTEST_LOG_(INFO) << "GetRoot_002 end";
329 }
330
331 /**
332 * @tc.number: GetRootByWindow_001
333 * @tc.name: GetRootByWindow
334 * @tc.desc: Test function GetRootByWindow(AccessibleAbilityClient is null)
335 */
HWTEST_F(A11yUITestAbilityImplTest, GetRootByWindow_001, TestSize.Level1)336 HWTEST_F(A11yUITestAbilityImplTest, GetRootByWindow_001, TestSize.Level1)
337 {
338 GTEST_LOG_(INFO) << "GetRootByWindow_001 start";
339
340 if (!instance_) {
341 GTEST_LOG_(INFO) << "Cann't get A11yUITestAbilityImpl instance_";
342 return;
343 }
344 A11yAbilityUtHelper::GetInstance().SetAbilityClientNullFlag(true);
345 A11yWindowInfo windowInfo {};
346 A11yElementInfo elementInfo {};
347 EXPECT_EQ(instance_->GetRootByWindow(windowInfo, elementInfo), RET_ERR_NULLPTR);
348 A11yAbilityUtHelper::GetInstance().SetAbilityClientNullFlag(false);
349
350 GTEST_LOG_(INFO) << "GetRootByWindow_001 end";
351 }
352
353 /**
354 * @tc.number: GetRootByWindow_002
355 * @tc.name: GetRootByWindow
356 * @tc.desc: Test function GetRootByWindow(AccessibleAbilityClient is not null)
357 */
HWTEST_F(A11yUITestAbilityImplTest, GetRootByWindow_002, TestSize.Level1)358 HWTEST_F(A11yUITestAbilityImplTest, GetRootByWindow_002, TestSize.Level1)
359 {
360 GTEST_LOG_(INFO) << "GetRootByWindow_002 start";
361
362 if (!instance_) {
363 GTEST_LOG_(INFO) << "Cann't get A11yUITestAbilityImpl instance_";
364 return;
365 }
366 A11yWindowInfo windowInfo {};
367 A11yElementInfo elementInfo {};
368 EXPECT_EQ(instance_->GetRootByWindow(windowInfo, elementInfo), RET_OK);
369
370 GTEST_LOG_(INFO) << "GetRootByWindow_002 end";
371 }
372
373 /**
374 * @tc.number: GetWindow_001
375 * @tc.name: GetWindow
376 * @tc.desc: Test function GetWindow(AccessibleAbilityClient is null)
377 */
HWTEST_F(A11yUITestAbilityImplTest, GetWindow_001, TestSize.Level1)378 HWTEST_F(A11yUITestAbilityImplTest, GetWindow_001, TestSize.Level1)
379 {
380 GTEST_LOG_(INFO) << "GetWindow_001 start";
381
382 if (!instance_) {
383 GTEST_LOG_(INFO) << "Cann't get A11yUITestAbilityImpl instance_";
384 return;
385 }
386 A11yAbilityUtHelper::GetInstance().SetAbilityClientNullFlag(true);
387 A11yWindowInfo winInfo {};
388 EXPECT_EQ(instance_->GetWindow(WINDOW_ID, winInfo), RET_ERR_NULLPTR);
389 A11yAbilityUtHelper::GetInstance().SetAbilityClientNullFlag(false);
390 GTEST_LOG_(INFO) << "GetWindow_001 end";
391 }
392
393 /**
394 * @tc.number: GetWindow_002
395 * @tc.name: GetWindow
396 * @tc.desc: Test function GetWindow(AccessibleAbilityClient is not null)
397 */
HWTEST_F(A11yUITestAbilityImplTest, GetWindow_002, TestSize.Level1)398 HWTEST_F(A11yUITestAbilityImplTest, GetWindow_002, TestSize.Level1)
399 {
400 GTEST_LOG_(INFO) << "GetWindow_002 start";
401
402 if (!instance_) {
403 GTEST_LOG_(INFO) << "Cann't get A11yUITestAbilityImpl instance_";
404 return;
405 }
406 A11yWindowInfo winInfo {};
407 EXPECT_EQ(instance_->GetWindow(WINDOW_ID, winInfo), RET_OK);
408 GTEST_LOG_(INFO) << "GetWindow_002 end";
409 }
410
411 /**
412 * @tc.number: GetWindows_001
413 * @tc.name: GetWindows
414 * @tc.desc: Test function GetWindows(AccessibleAbilityClient is null)
415 */
HWTEST_F(A11yUITestAbilityImplTest, GetWindows_001, TestSize.Level1)416 HWTEST_F(A11yUITestAbilityImplTest, GetWindows_001, TestSize.Level1)
417 {
418 GTEST_LOG_(INFO) << "GetWindows_001 start";
419
420 if (!instance_) {
421 GTEST_LOG_(INFO) << "Cann't get A11yUITestAbilityImpl instance_";
422 return;
423 }
424 A11yAbilityUtHelper::GetInstance().SetAbilityClientNullFlag(true);
425 std::vector<A11yWindowInfo> res {};
426 EXPECT_EQ(instance_->GetWindows(res), RET_ERR_NULLPTR);
427 A11yAbilityUtHelper::GetInstance().SetAbilityClientNullFlag(false);
428 GTEST_LOG_(INFO) << "GetWindows_001 end";
429 }
430
431 /**
432 * @tc.number: GetWindows_002
433 * @tc.name: GetWindows
434 * @tc.desc: Test function GetWindows(AccessibleAbilityClient is not null)
435 */
HWTEST_F(A11yUITestAbilityImplTest, GetWindows_002, TestSize.Level1)436 HWTEST_F(A11yUITestAbilityImplTest, GetWindows_002, TestSize.Level1)
437 {
438 GTEST_LOG_(INFO) << "GetWindows_002 start";
439
440 if (!instance_) {
441 GTEST_LOG_(INFO) << "Cann't get A11yUITestAbilityImpl instance_";
442 return;
443 }
444 std::vector<A11yWindowInfo> res {};
445 EXPECT_EQ(instance_->GetWindows(res), RET_OK);
446 GTEST_LOG_(INFO) << "GetWindows_002 end";
447 }
448
449 /**
450 * @tc.number: GetWindows_003
451 * @tc.name: GetWindows
452 * @tc.desc: Test function GetWindows(AccessibleAbilityClient is null)
453 */
HWTEST_F(A11yUITestAbilityImplTest, GetWindows_003, TestSize.Level1)454 HWTEST_F(A11yUITestAbilityImplTest, GetWindows_003, TestSize.Level1)
455 {
456 GTEST_LOG_(INFO) << "GetWindows_003 start";
457
458 if (!instance_) {
459 GTEST_LOG_(INFO) << "Cann't get A11yUITestAbilityImpl instance_";
460 return;
461 }
462 A11yAbilityUtHelper::GetInstance().SetAbilityClientNullFlag(true);
463 std::vector<A11yWindowInfo> res {};
464 EXPECT_EQ(instance_->GetWindows(DISPLAY_ID, res), RET_ERR_NULLPTR);
465 A11yAbilityUtHelper::GetInstance().SetAbilityClientNullFlag(false);
466 GTEST_LOG_(INFO) << "GetWindows_003 end";
467 }
468
469 /**
470 * @tc.number: GetWindows_004
471 * @tc.name: GetWindows
472 * @tc.desc: Test function GetWindows(AccessibleAbilityClient is not null)
473 */
HWTEST_F(A11yUITestAbilityImplTest, GetWindows_004, TestSize.Level1)474 HWTEST_F(A11yUITestAbilityImplTest, GetWindows_004, TestSize.Level1)
475 {
476 GTEST_LOG_(INFO) << "GetWindows_004 start";
477
478 if (!instance_) {
479 GTEST_LOG_(INFO) << "Cann't get A11yUITestAbilityImpl instance_";
480 return;
481 }
482 std::vector<A11yWindowInfo> res {};
483 EXPECT_EQ(instance_->GetWindows(DISPLAY_ID, res), RET_OK);
484 GTEST_LOG_(INFO) << "GetWindows_004 end";
485 }
486
487 /**
488 * @tc.number: GetNext_001
489 * @tc.name: GetNext
490 * @tc.desc: Test function GetNext(AccessibleAbilityClient is null)
491 */
HWTEST_F(A11yUITestAbilityImplTest, GetNext_001, TestSize.Level1)492 HWTEST_F(A11yUITestAbilityImplTest, GetNext_001, TestSize.Level1)
493 {
494 GTEST_LOG_(INFO) << "GetNext_001 start";
495
496 if (!instance_) {
497 GTEST_LOG_(INFO) << "Cann't get A11yUITestAbilityImpl instance_";
498 return;
499 }
500 A11yAbilityUtHelper::GetInstance().SetAbilityClientNullFlag(true);
501 A11yElementInfo nextElementInfo {};
502 A11yElementInfo elementInfo {};
503 FocusMoveDirection direction = DIRECTION_INVALID;
504 EXPECT_EQ(instance_->GetNext(elementInfo, direction, elementInfo), RET_ERR_NULLPTR);
505 A11yAbilityUtHelper::GetInstance().SetAbilityClientNullFlag(false);
506
507 GTEST_LOG_(INFO) << "GetNext_001 end";
508 }
509
510 /**
511 * @tc.number: GetNext_002
512 * @tc.name: GetNext
513 * @tc.desc: Test function GetNext(AccessibleAbilityClient is not null)
514 */
HWTEST_F(A11yUITestAbilityImplTest, GetNext_002, TestSize.Level1)515 HWTEST_F(A11yUITestAbilityImplTest, GetNext_002, TestSize.Level1)
516 {
517 GTEST_LOG_(INFO) << "GetNext_002 start";
518
519 if (!instance_) {
520 GTEST_LOG_(INFO) << "Cann't get A11yUITestAbilityImpl instance_";
521 return;
522 }
523 A11yElementInfo nextElementInfo {};
524 A11yElementInfo elementInfo {};
525 FocusMoveDirection direction = DIRECTION_INVALID;
526 EXPECT_EQ(instance_->GetNext(elementInfo, direction, elementInfo), RET_OK);
527
528 GTEST_LOG_(INFO) << "GetNext_002 end";
529 }
530
531 /**
532 * @tc.number: GetChildElementInfo_001
533 * @tc.name: GetChildElementInfo
534 * @tc.desc: Test function GetChildElementInfo(AccessibleAbilityClient is null)
535 */
HWTEST_F(A11yUITestAbilityImplTest, GetChildElementInfo_001, TestSize.Level1)536 HWTEST_F(A11yUITestAbilityImplTest, GetChildElementInfo_001, TestSize.Level1)
537 {
538 GTEST_LOG_(INFO) << "GetChildElementInfo_001 start";
539
540 if (!instance_) {
541 GTEST_LOG_(INFO) << "Cann't get A11yUITestAbilityImpl instance_";
542 return;
543 }
544 A11yAbilityUtHelper::GetInstance().SetAbilityClientNullFlag(true);
545 A11yElementInfo parent {};
546 A11yElementInfo child {};
547 int32_t index = 1;
548 EXPECT_EQ(instance_->GetChildElementInfo(index, parent, child), RET_ERR_NULLPTR);
549 A11yAbilityUtHelper::GetInstance().SetAbilityClientNullFlag(false);
550
551 GTEST_LOG_(INFO) << "GetChildElementInfo_001 end";
552 }
553
554 /**
555 * @tc.number: GetChildElementInfo_002
556 * @tc.name: GetChildElementInfo
557 * @tc.desc: Test function GetChildElementInfo(AccessibleAbilityClient is not null)
558 */
HWTEST_F(A11yUITestAbilityImplTest, GetChildElementInfo_002, TestSize.Level1)559 HWTEST_F(A11yUITestAbilityImplTest, GetChildElementInfo_002, TestSize.Level1)
560 {
561 GTEST_LOG_(INFO) << "GetChildElementInfo_002 start";
562
563 if (!instance_) {
564 GTEST_LOG_(INFO) << "Cann't get A11yUITestAbilityImpl instance_";
565 return;
566 }
567 A11yElementInfo parent {};
568 A11yElementInfo child {};
569 int32_t index = 1;
570 EXPECT_EQ(instance_->GetChildElementInfo(index, parent, child), RET_OK);
571
572 GTEST_LOG_(INFO) << "GetChildElementInfo_002 end";
573 }
574
575 /**
576 * @tc.number: GetByContent_001
577 * @tc.name: GetByContent
578 * @tc.desc: Test function GetByContent(AccessibleAbilityClient is null)
579 */
HWTEST_F(A11yUITestAbilityImplTest, GetByContent_001, TestSize.Level1)580 HWTEST_F(A11yUITestAbilityImplTest, GetByContent_001, TestSize.Level1)
581 {
582 GTEST_LOG_(INFO) << "GetByContent_001 start";
583
584 if (!instance_) {
585 GTEST_LOG_(INFO) << "Cann't get A11yUITestAbilityImpl instance_";
586 return;
587 }
588 A11yAbilityUtHelper::GetInstance().SetAbilityClientNullFlag(true);
589 A11yElementInfo parent {};
590 std::vector<A11yElementInfo> elementInfos {};
591 EXPECT_EQ(instance_->GetByContent(parent, TEST, elementInfos), RET_ERR_NULLPTR);
592 A11yAbilityUtHelper::GetInstance().SetAbilityClientNullFlag(false);
593
594 GTEST_LOG_(INFO) << "GetByContent_001 end";
595 }
596
597 /**
598 * @tc.number: GetByContent_002
599 * @tc.name: GetByContent
600 * @tc.desc: Test function GetByContent(AccessibleAbilityClient is not null)
601 */
HWTEST_F(A11yUITestAbilityImplTest, GetByContent_002, TestSize.Level1)602 HWTEST_F(A11yUITestAbilityImplTest, GetByContent_002, TestSize.Level1)
603 {
604 GTEST_LOG_(INFO) << "GetByContent_002 start";
605
606 if (!instance_) {
607 GTEST_LOG_(INFO) << "Cann't get A11yUITestAbilityImpl instance_";
608 return;
609 }
610 A11yElementInfo parent {};
611 std::vector<A11yElementInfo> elementInfos {};
612 EXPECT_EQ(instance_->GetByContent(parent, TEST, elementInfos), RET_OK);
613
614 GTEST_LOG_(INFO) << "GetByContent_002 end";
615 }
616
617 /**
618 * @tc.number: GetSource_001
619 * @tc.name: GetSource
620 * @tc.desc: Test function GetSource(AccessibleAbilityClient is null)
621 */
HWTEST_F(A11yUITestAbilityImplTest, GetSource_001, TestSize.Level1)622 HWTEST_F(A11yUITestAbilityImplTest, GetSource_001, TestSize.Level1)
623 {
624 GTEST_LOG_(INFO) << "GetSource_001 start";
625
626 if (!instance_) {
627 GTEST_LOG_(INFO) << "Cann't get A11yUITestAbilityImpl instance_";
628 return;
629 }
630 A11yAbilityUtHelper::GetInstance().SetAbilityClientNullFlag(true);
631 A11yEventInfo eventInfo {};
632 A11yElementInfo elementInfo {};
633 EXPECT_EQ(instance_->GetSource(eventInfo, elementInfo), RET_ERR_NULLPTR);
634 A11yAbilityUtHelper::GetInstance().SetAbilityClientNullFlag(false);
635
636 GTEST_LOG_(INFO) << "GetSource_001 end";
637 }
638
639 /**
640 * @tc.number: GetSource_002
641 * @tc.name: GetSource
642 * @tc.desc: Test function GetSource(AccessibleAbilityClient is not null)
643 */
HWTEST_F(A11yUITestAbilityImplTest, GetSource_002, TestSize.Level1)644 HWTEST_F(A11yUITestAbilityImplTest, GetSource_002, TestSize.Level1)
645 {
646 GTEST_LOG_(INFO) << "GetSource_002 start";
647
648 if (!instance_) {
649 GTEST_LOG_(INFO) << "Cann't get A11yUITestAbilityImpl instance_";
650 return;
651 }
652 A11yEventInfo eventInfo {};
653 A11yElementInfo elementInfo {};
654 EXPECT_EQ(instance_->GetSource(eventInfo, elementInfo), RET_OK);
655
656 GTEST_LOG_(INFO) << "GetSource_002 end";
657 }
658
659 /**
660 * @tc.number: GetParentElementInfo_001
661 * @tc.name: GetParentElementInfo
662 * @tc.desc: Test function GetParentElementInfo(AccessibleAbilityClient is null)
663 */
HWTEST_F(A11yUITestAbilityImplTest, GetParentElementInfo_001, TestSize.Level1)664 HWTEST_F(A11yUITestAbilityImplTest, GetParentElementInfo_001, TestSize.Level1)
665 {
666 GTEST_LOG_(INFO) << "GetParentElementInfo_001 start";
667
668 if (!instance_) {
669 GTEST_LOG_(INFO) << "Cann't get A11yUITestAbilityImpl instance_";
670 return;
671 }
672 A11yAbilityUtHelper::GetInstance().SetAbilityClientNullFlag(true);
673 A11yElementInfo child {};
674 A11yElementInfo parent {};
675 EXPECT_EQ(instance_->GetParentElementInfo(child, parent), RET_ERR_NULLPTR);
676 A11yAbilityUtHelper::GetInstance().SetAbilityClientNullFlag(false);
677
678 GTEST_LOG_(INFO) << "GetParentElementInfo_001 end";
679 }
680
681 /**
682 * @tc.number: GetParentElementInfo_002
683 * @tc.name: GetParentElementInfo
684 * @tc.desc: Test function GetParentElementInfo(AccessibleAbilityClient is not null)
685 */
HWTEST_F(A11yUITestAbilityImplTest, GetParentElementInfo_002, TestSize.Level1)686 HWTEST_F(A11yUITestAbilityImplTest, GetParentElementInfo_002, TestSize.Level1)
687 {
688 GTEST_LOG_(INFO) << "GetParentElementInfo_002 start";
689
690 if (!instance_) {
691 GTEST_LOG_(INFO) << "Cann't get A11yUITestAbilityImpl instance_";
692 return;
693 }
694 A11yElementInfo child {};
695 A11yElementInfo parent {};
696 EXPECT_EQ(instance_->GetParentElementInfo(child, parent), RET_OK);
697
698 GTEST_LOG_(INFO) << "GetParentElementInfo_002 end";
699 }
700
701 /**
702 * @tc.number: ExecuteAction_001
703 * @tc.name: ExecuteAction
704 * @tc.desc: Test function ExecuteAction(AccessibleAbilityClient is null)
705 */
HWTEST_F(A11yUITestAbilityImplTest, ExecuteAction_001, TestSize.Level1)706 HWTEST_F(A11yUITestAbilityImplTest, ExecuteAction_001, TestSize.Level1)
707 {
708 GTEST_LOG_(INFO) << "ExecuteAction_001 start";
709
710 if (!instance_) {
711 GTEST_LOG_(INFO) << "Cann't get A11yUITestAbilityImpl instance_";
712 return;
713 }
714 A11yAbilityUtHelper::GetInstance().SetAbilityClientNullFlag(true);
715 A11yElementInfo elementInfo {};
716 ActionType action = A11y_ACTION_INVALID;
717 std::map<std::string, std::string> actionArguments {};
718 EXPECT_EQ(instance_->ExecuteAction(elementInfo, action, actionArguments), RET_ERR_NULLPTR);
719 A11yAbilityUtHelper::GetInstance().SetAbilityClientNullFlag(false);
720
721 GTEST_LOG_(INFO) << "ExecuteAction_001 end";
722 }
723
724 /**
725 * @tc.number: ExecuteAction_002
726 * @tc.name: ExecuteAction
727 * @tc.desc: Test function ExecuteAction(AccessibleAbilityClient is not null)
728 */
HWTEST_F(A11yUITestAbilityImplTest, ExecuteAction_002, TestSize.Level1)729 HWTEST_F(A11yUITestAbilityImplTest, ExecuteAction_002, TestSize.Level1)
730 {
731 GTEST_LOG_(INFO) << "ExecuteAction_002 start";
732
733 if (!instance_) {
734 GTEST_LOG_(INFO) << "Cann't get A11yUITestAbilityImpl instance_";
735 return;
736 }
737 A11yElementInfo elementInfo {};
738 ActionType action = A11y_ACTION_INVALID;
739 std::map<std::string, std::string> actionArguments {};
740 EXPECT_EQ(instance_->ExecuteAction(elementInfo, action, actionArguments), RET_OK);
741
742 GTEST_LOG_(INFO) << "ExecuteAction_002 end";
743 }
744
745 /**
746 * @tc.number: SetTargetBundleName_001
747 * @tc.name: SetTargetBundleName
748 * @tc.desc: Test function SetTargetBundleName(AccessibleAbilityClient is null)
749 */
HWTEST_F(A11yUITestAbilityImplTest, SetTargetBundleName_001, TestSize.Level1)750 HWTEST_F(A11yUITestAbilityImplTest, SetTargetBundleName_001, TestSize.Level1)
751 {
752 GTEST_LOG_(INFO) << "SetTargetBundleName_001 start";
753
754 if (!instance_) {
755 GTEST_LOG_(INFO) << "Cann't get A11yUITestAbilityImpl instance_";
756 return;
757 }
758 A11yAbilityUtHelper::GetInstance().SetAbilityClientNullFlag(true);
759 std::vector<std::string> targetBundleNames;
760 EXPECT_EQ(instance_->SetTargetBundleName(targetBundleNames), RET_ERR_NULLPTR);
761 A11yAbilityUtHelper::GetInstance().SetAbilityClientNullFlag(false);
762
763 GTEST_LOG_(INFO) << "SetTargetBundleName_001 end";
764 }
765
766 /**
767 * @tc.number: SetTargetBundleName_002
768 * @tc.name: SetTargetBundleName
769 * @tc.desc: Test function SetTargetBundleName(AccessibleAbilityClient is not null)
770 */
HWTEST_F(A11yUITestAbilityImplTest, SetTargetBundleName_002, TestSize.Level1)771 HWTEST_F(A11yUITestAbilityImplTest, SetTargetBundleName_002, TestSize.Level1)
772 {
773 GTEST_LOG_(INFO) << "SetTargetBundleName_002 start";
774
775 if (!instance_) {
776 GTEST_LOG_(INFO) << "Cann't get A11yUITestAbilityImpl instance_";
777 return;
778 }
779 std::vector<std::string> targetBundleNames;
780 EXPECT_EQ(instance_->SetTargetBundleName(targetBundleNames), RET_OK);
781
782 GTEST_LOG_(INFO) << "SetTargetBundleName_002 end";
783 }
784
785 /**
786 * @tc.number: GetChildren_001
787 * @tc.name: GetChildren
788 * @tc.desc: Test function GetChildren
789 */
HWTEST_F(A11yUITestAbilityImplTest, GetChildren_001, TestSize.Level1)790 HWTEST_F(A11yUITestAbilityImplTest, GetChildren_001, TestSize.Level1)
791 {
792 GTEST_LOG_(INFO) << "GetChildren_001 start";
793
794 if (!instance_) {
795 GTEST_LOG_(INFO) << "Cann't get A11yUITestAbilityImpl instance_";
796 return;
797 }
798 A11yElementInfo parent;
799 std::vector<A11yElementInfo> children;
800 EXPECT_EQ(instance_->GetChildren(parent, children), RET_OK);
801
802 GTEST_LOG_(INFO) << "GetChildren_001 end";
803 }
804
805 /**
806 * @tc.number: SetCacheMode_001
807 * @tc.name: SetCacheMode
808 * @tc.desc: Test function SetCacheMode
809 */
HWTEST_F(A11yUITestAbilityImplTest, SetCacheMode_001, TestSize.Level1)810 HWTEST_F(A11yUITestAbilityImplTest, SetCacheMode_001, TestSize.Level1)
811 {
812 GTEST_LOG_(INFO) << "SetCacheMode_001 start";
813
814 if (!instance_) {
815 GTEST_LOG_(INFO) << "Cann't get A11yUITestAbilityImpl instance_";
816 return;
817 }
818 instance_->SetCacheMode(CACHE_MODE);
819 EXPECT_EQ(CACHE_MODE, A11yAbilityUtHelper::GetInstance().GetCacheMode());
820
821 GTEST_LOG_(INFO) << "SetCacheMode_001 end";
822 }
823
824 /**
825 * @tc.number: GetRootBatch_001
826 * @tc.name: GetRootBatch
827 * @tc.desc: Test function GetRootBatch(AccessibleAbilityClient is null)
828 */
HWTEST_F(A11yUITestAbilityImplTest, GetRootBatch_001, TestSize.Level1)829 HWTEST_F(A11yUITestAbilityImplTest, GetRootBatch_001, TestSize.Level1)
830 {
831 GTEST_LOG_(INFO) << "GetRootBatch_001 start";
832
833 if (!instance_) {
834 GTEST_LOG_(INFO) << "Cann't get A11yUITestAbilityImpl instance_";
835 return;
836 }
837 A11yAbilityUtHelper::GetInstance().SetAbilityClientNullFlag(true);
838 std::vector<A11yElementInfo> elementInfos;
839 EXPECT_EQ(instance_->GetRootBatch(elementInfos), RET_ERR_NULLPTR);
840 A11yAbilityUtHelper::GetInstance().SetAbilityClientNullFlag(false);
841
842 GTEST_LOG_(INFO) << "GetRootBatch_001 end";
843 }
844
845 /**
846 * @tc.number: GetRootBatch_002
847 * @tc.name: GetRootBatch
848 * @tc.desc: Test function GetRootBatch(AccessibleAbilityClient is not null)
849 */
HWTEST_F(A11yUITestAbilityImplTest, GetRootBatch_002, TestSize.Level1)850 HWTEST_F(A11yUITestAbilityImplTest, GetRootBatch_002, TestSize.Level1)
851 {
852 GTEST_LOG_(INFO) << "GetRootBatch_002 start";
853
854 if (!instance_) {
855 GTEST_LOG_(INFO) << "Cann't get A11yUITestAbilityImpl instance_";
856 return;
857 }
858 std::vector<A11yElementInfo> elementInfos;
859 EXPECT_EQ(instance_->GetRootBatch(elementInfos), RET_OK);
860
861 GTEST_LOG_(INFO) << "GetRootBatch_002 end";
862 }
863
864 /**
865 * @tc.number: GetRootByWindowBatch_001
866 * @tc.name: GetRootByWindowbatch
867 * @tc.desc: Test function GetRootByWindow(AccessibleAbilityClient is null)
868 */
HWTEST_F(A11yUITestAbilityImplTest, GetRootByWindowBatch_001, TestSize.Level1)869 HWTEST_F(A11yUITestAbilityImplTest, GetRootByWindowBatch_001, TestSize.Level1)
870 {
871 GTEST_LOG_(INFO) << "GetRootByWindowBatch_001 start";
872
873 if (!instance_) {
874 GTEST_LOG_(INFO) << "Cann't get A11yUITestAbilityImpl instance_";
875 return;
876 }
877 A11yAbilityUtHelper::GetInstance().SetAbilityClientNullFlag(true);
878 A11yWindowInfo windowInfo {};
879 std::vector<A11yElementInfo> elementInfos;
880 EXPECT_EQ(instance_->GetRootByWindowBatch(windowInfo, elementInfos, true), RET_ERR_NULLPTR);
881 A11yAbilityUtHelper::GetInstance().SetAbilityClientNullFlag(false);
882
883 GTEST_LOG_(INFO) << "GetRootByWindowBatch_001 end";
884 }
885
886 /**
887 * @tc.number: GetRootByWindowBatch_002
888 * @tc.name: GetRootByWindowBatch
889 * @tc.desc: Test function GetRootByWindowBatch(AccessibleAbilityClient is not null)
890 */
HWTEST_F(A11yUITestAbilityImplTest, GetRootByWindowBatch_002, TestSize.Level1)891 HWTEST_F(A11yUITestAbilityImplTest, GetRootByWindowBatch_002, TestSize.Level1)
892 {
893 GTEST_LOG_(INFO) << "GetRootByWindowBatch_002 start";
894
895 if (!instance_) {
896 GTEST_LOG_(INFO) << "Cann't get A11yUITestAbilityImpl instance_";
897 return;
898 }
899 A11yWindowInfo windowInfo {};
900 std::vector<A11yElementInfo> elementInfos;
901 EXPECT_EQ(instance_->GetRootByWindowBatch(windowInfo, elementInfos, true), RET_OK);
902
903 GTEST_LOG_(INFO) << "GetRootByWindowBatch_002 end";
904 }
905 } // namespace A11y
906 } // namespace OHOS