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 "accessibility_ability_ut_helper.h" 18 #include "accessibility_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 Accessibility { 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 AccessibilityUITestAbilityImplTest : public ::testing::Test { 35 public: AccessibilityUITestAbilityImplTest()36 AccessibilityUITestAbilityImplTest() 37 {} ~AccessibilityUITestAbilityImplTest()38 ~AccessibilityUITestAbilityImplTest() 39 {} 40 41 std::shared_ptr<AccessibilityUITestAbilityImpl> instance_ = nullptr; SetUpTestCase()42 static void SetUpTestCase() 43 { 44 GTEST_LOG_(INFO) << "AccessibilityUITestAbilityImplTest Start"; 45 } TearDownTestCase()46 static void TearDownTestCase() 47 { 48 GTEST_LOG_(INFO) << "AccessibilityUITestAbilityImplTest End"; 49 } SetUp()50 void SetUp() 51 { 52 GTEST_LOG_(INFO) << "AccessibilityUITestAbilityImplTest SetUp()"; 53 instance_ = std::make_shared<AccessibilityUITestAbilityImpl>(); 54 } TearDown()55 void TearDown() 56 { 57 GTEST_LOG_(INFO) << "AccessibilityUITestAbilityImplTest TearDown()"; 58 instance_ = nullptr; 59 } 60 }; 61 62 /** 63 * @tc.number: GetInstance_001 64 * @tc.name: GetInstance 65 * @tc.desc: Test function GetInstance 66 */ 67 HWTEST_F(AccessibilityUITestAbilityImplTest, GetInstance_001, TestSize.Level1) 68 { 69 GTEST_LOG_(INFO) << "GetInstance_001 start"; 70 EXPECT_TRUE(AccessibilityUITestAbility::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 */ 79 HWTEST_F(AccessibilityUITestAbilityImplTest, RegisterAbilityListener_001, TestSize.Level1) 80 { 81 GTEST_LOG_(INFO) << "RegisterAbilityListener_001 start"; 82 83 if (!instance_) { 84 GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl 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 */ 98 HWTEST_F(AccessibilityUITestAbilityImplTest, RegisterAbilityListener_002, TestSize.Level1) 99 { 100 GTEST_LOG_(INFO) << "RegisterAbilityListener_002 start"; 101 102 if (!instance_) { 103 GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_"; 104 return; 105 } 106 AccessibilityAbilityUtHelper::GetInstance().SetAbilityClientNullFlag(true); 107 std::shared_ptr<AccessibleAbilityListener> listener = std::make_shared<MockAccessibleAbilityListener>(); 108 EXPECT_EQ(instance_->RegisterAbilityListener(listener), RET_ERR_NULLPTR); 109 AccessibilityAbilityUtHelper::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 */ 119 HWTEST_F(AccessibilityUITestAbilityImplTest, RegisterAbilityListener_003, TestSize.Level1) 120 { 121 GTEST_LOG_(INFO) << "RegisterAbilityListener_003 start"; 122 123 if (!instance_) { 124 GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl 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 */ 138 HWTEST_F(AccessibilityUITestAbilityImplTest, Connect_001, TestSize.Level1) 139 { 140 GTEST_LOG_(INFO) << "Connect_001 start"; 141 142 if (!instance_) { 143 GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl 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 */ 156 HWTEST_F(AccessibilityUITestAbilityImplTest, Disconnect_001, TestSize.Level1) 157 { 158 GTEST_LOG_(INFO) << "Disconnect_001 start"; 159 160 if (!instance_) { 161 GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl 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 */ 174 HWTEST_F(AccessibilityUITestAbilityImplTest, GetFocus_001, TestSize.Level1) 175 { 176 GTEST_LOG_(INFO) << "GetFocus_001 start"; 177 178 if (!instance_) { 179 GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_"; 180 return; 181 } 182 AccessibilityAbilityUtHelper::GetInstance().SetAbilityClientNullFlag(true); 183 AccessibilityElementInfo elementInfo {}; 184 EXPECT_EQ(instance_->GetFocus(FOCUS_TYPE, elementInfo), RET_ERR_NULLPTR); 185 AccessibilityAbilityUtHelper::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 */ 195 HWTEST_F(AccessibilityUITestAbilityImplTest, GetFocus_002, TestSize.Level1) 196 { 197 GTEST_LOG_(INFO) << "GetFocus_002 start"; 198 199 if (!instance_) { 200 GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_"; 201 return; 202 } 203 AccessibilityElementInfo 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 */ 214 HWTEST_F(AccessibilityUITestAbilityImplTest, GetFocusByElementInfo_001, TestSize.Level1) 215 { 216 GTEST_LOG_(INFO) << "GetFocusByElementInfo_001 start"; 217 218 if (!instance_) { 219 GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_"; 220 return; 221 } 222 AccessibilityAbilityUtHelper::GetInstance().SetAbilityClientNullFlag(true); 223 AccessibilityElementInfo sourceInfo {}; 224 AccessibilityElementInfo elementInfo {}; 225 EXPECT_EQ(instance_->GetFocusByElementInfo(sourceInfo, FOCUS_TYPE, elementInfo), RET_ERR_NULLPTR); 226 AccessibilityAbilityUtHelper::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 */ 236 HWTEST_F(AccessibilityUITestAbilityImplTest, GetFocusByElementInfo_002, TestSize.Level1) 237 { 238 GTEST_LOG_(INFO) << "GetFocusByElementInfo_002 start"; 239 240 if (!instance_) { 241 GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_"; 242 return; 243 } 244 AccessibilityElementInfo sourceInfo {}; 245 AccessibilityElementInfo 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 */ 256 HWTEST_F(AccessibilityUITestAbilityImplTest, InjectGesture_001, TestSize.Level1) 257 { 258 GTEST_LOG_(INFO) << "InjectGesture_001 start"; 259 260 if (!instance_) { 261 GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_"; 262 return; 263 } 264 AccessibilityAbilityUtHelper::GetInstance().SetAbilityClientNullFlag(true); 265 std::shared_ptr<AccessibilityGestureInjectPath> gesturePath = std::make_shared<AccessibilityGestureInjectPath>(); 266 EXPECT_EQ(instance_->InjectGesture(gesturePath), RET_ERR_NULLPTR); 267 AccessibilityAbilityUtHelper::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 */ 277 HWTEST_F(AccessibilityUITestAbilityImplTest, InjectGesture_002, TestSize.Level1) 278 { 279 GTEST_LOG_(INFO) << "InjectGesture_002 start"; 280 281 if (!instance_) { 282 GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_"; 283 return; 284 } 285 std::shared_ptr<AccessibilityGestureInjectPath> gesturePath = std::make_shared<AccessibilityGestureInjectPath>(); 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 */ 296 HWTEST_F(AccessibilityUITestAbilityImplTest, GetRoot_001, TestSize.Level1) 297 { 298 GTEST_LOG_(INFO) << "GetRoot_001 start"; 299 300 if (!instance_) { 301 GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_"; 302 return; 303 } 304 AccessibilityAbilityUtHelper::GetInstance().SetAbilityClientNullFlag(true); 305 AccessibilityElementInfo elementInfo {}; 306 EXPECT_EQ(instance_->GetRoot(elementInfo), RET_ERR_NULLPTR); 307 AccessibilityAbilityUtHelper::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 */ 317 HWTEST_F(AccessibilityUITestAbilityImplTest, GetRoot_002, TestSize.Level1) 318 { 319 GTEST_LOG_(INFO) << "GetRoot_002 start"; 320 321 if (!instance_) { 322 GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_"; 323 return; 324 } 325 AccessibilityElementInfo 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 */ 336 HWTEST_F(AccessibilityUITestAbilityImplTest, GetRootByWindow_001, TestSize.Level1) 337 { 338 GTEST_LOG_(INFO) << "GetRootByWindow_001 start"; 339 340 if (!instance_) { 341 GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_"; 342 return; 343 } 344 AccessibilityAbilityUtHelper::GetInstance().SetAbilityClientNullFlag(true); 345 AccessibilityWindowInfo windowInfo {}; 346 AccessibilityElementInfo elementInfo {}; 347 EXPECT_EQ(instance_->GetRootByWindow(windowInfo, elementInfo), RET_ERR_NULLPTR); 348 AccessibilityAbilityUtHelper::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 */ 358 HWTEST_F(AccessibilityUITestAbilityImplTest, GetRootByWindow_002, TestSize.Level1) 359 { 360 GTEST_LOG_(INFO) << "GetRootByWindow_002 start"; 361 362 if (!instance_) { 363 GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_"; 364 return; 365 } 366 AccessibilityWindowInfo windowInfo {}; 367 AccessibilityElementInfo 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 */ 378 HWTEST_F(AccessibilityUITestAbilityImplTest, GetWindow_001, TestSize.Level1) 379 { 380 GTEST_LOG_(INFO) << "GetWindow_001 start"; 381 382 if (!instance_) { 383 GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_"; 384 return; 385 } 386 AccessibilityAbilityUtHelper::GetInstance().SetAbilityClientNullFlag(true); 387 AccessibilityWindowInfo winInfo {}; 388 EXPECT_EQ(instance_->GetWindow(WINDOW_ID, winInfo), RET_ERR_NULLPTR); 389 AccessibilityAbilityUtHelper::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 */ 398 HWTEST_F(AccessibilityUITestAbilityImplTest, GetWindow_002, TestSize.Level1) 399 { 400 GTEST_LOG_(INFO) << "GetWindow_002 start"; 401 402 if (!instance_) { 403 GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_"; 404 return; 405 } 406 AccessibilityWindowInfo 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 */ 416 HWTEST_F(AccessibilityUITestAbilityImplTest, GetWindows_001, TestSize.Level1) 417 { 418 GTEST_LOG_(INFO) << "GetWindows_001 start"; 419 420 if (!instance_) { 421 GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_"; 422 return; 423 } 424 AccessibilityAbilityUtHelper::GetInstance().SetAbilityClientNullFlag(true); 425 std::vector<AccessibilityWindowInfo> res {}; 426 EXPECT_EQ(instance_->GetWindows(res), RET_ERR_NULLPTR); 427 AccessibilityAbilityUtHelper::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 */ 436 HWTEST_F(AccessibilityUITestAbilityImplTest, GetWindows_002, TestSize.Level1) 437 { 438 GTEST_LOG_(INFO) << "GetWindows_002 start"; 439 440 if (!instance_) { 441 GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_"; 442 return; 443 } 444 std::vector<AccessibilityWindowInfo> 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 */ 454 HWTEST_F(AccessibilityUITestAbilityImplTest, GetWindows_003, TestSize.Level1) 455 { 456 GTEST_LOG_(INFO) << "GetWindows_003 start"; 457 458 if (!instance_) { 459 GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_"; 460 return; 461 } 462 AccessibilityAbilityUtHelper::GetInstance().SetAbilityClientNullFlag(true); 463 std::vector<AccessibilityWindowInfo> res {}; 464 EXPECT_EQ(instance_->GetWindows(DISPLAY_ID, res), RET_ERR_NULLPTR); 465 AccessibilityAbilityUtHelper::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 */ 474 HWTEST_F(AccessibilityUITestAbilityImplTest, GetWindows_004, TestSize.Level1) 475 { 476 GTEST_LOG_(INFO) << "GetWindows_004 start"; 477 478 if (!instance_) { 479 GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_"; 480 return; 481 } 482 std::vector<AccessibilityWindowInfo> 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 */ 492 HWTEST_F(AccessibilityUITestAbilityImplTest, GetNext_001, TestSize.Level1) 493 { 494 GTEST_LOG_(INFO) << "GetNext_001 start"; 495 496 if (!instance_) { 497 GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_"; 498 return; 499 } 500 AccessibilityAbilityUtHelper::GetInstance().SetAbilityClientNullFlag(true); 501 AccessibilityElementInfo nextElementInfo {}; 502 AccessibilityElementInfo elementInfo {}; 503 FocusMoveDirection direction = DIRECTION_INVALID; 504 EXPECT_EQ(instance_->GetNext(elementInfo, direction, elementInfo), RET_ERR_NULLPTR); 505 AccessibilityAbilityUtHelper::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 */ 515 HWTEST_F(AccessibilityUITestAbilityImplTest, GetNext_002, TestSize.Level1) 516 { 517 GTEST_LOG_(INFO) << "GetNext_002 start"; 518 519 if (!instance_) { 520 GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_"; 521 return; 522 } 523 AccessibilityElementInfo nextElementInfo {}; 524 AccessibilityElementInfo 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 */ 536 HWTEST_F(AccessibilityUITestAbilityImplTest, GetChildElementInfo_001, TestSize.Level1) 537 { 538 GTEST_LOG_(INFO) << "GetChildElementInfo_001 start"; 539 540 if (!instance_) { 541 GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_"; 542 return; 543 } 544 AccessibilityAbilityUtHelper::GetInstance().SetAbilityClientNullFlag(true); 545 AccessibilityElementInfo parent {}; 546 AccessibilityElementInfo child {}; 547 int32_t index = 1; 548 EXPECT_EQ(instance_->GetChildElementInfo(index, parent, child), RET_ERR_NULLPTR); 549 AccessibilityAbilityUtHelper::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 */ 559 HWTEST_F(AccessibilityUITestAbilityImplTest, GetChildElementInfo_002, TestSize.Level1) 560 { 561 GTEST_LOG_(INFO) << "GetChildElementInfo_002 start"; 562 563 if (!instance_) { 564 GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_"; 565 return; 566 } 567 AccessibilityElementInfo parent {}; 568 AccessibilityElementInfo 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 */ 580 HWTEST_F(AccessibilityUITestAbilityImplTest, GetByContent_001, TestSize.Level1) 581 { 582 GTEST_LOG_(INFO) << "GetByContent_001 start"; 583 584 if (!instance_) { 585 GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_"; 586 return; 587 } 588 AccessibilityAbilityUtHelper::GetInstance().SetAbilityClientNullFlag(true); 589 AccessibilityElementInfo parent {}; 590 std::vector<AccessibilityElementInfo> elementInfos {}; 591 EXPECT_EQ(instance_->GetByContent(parent, TEST, elementInfos), RET_ERR_NULLPTR); 592 AccessibilityAbilityUtHelper::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 */ 602 HWTEST_F(AccessibilityUITestAbilityImplTest, GetByContent_002, TestSize.Level1) 603 { 604 GTEST_LOG_(INFO) << "GetByContent_002 start"; 605 606 if (!instance_) { 607 GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_"; 608 return; 609 } 610 AccessibilityElementInfo parent {}; 611 std::vector<AccessibilityElementInfo> 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 */ 622 HWTEST_F(AccessibilityUITestAbilityImplTest, GetSource_001, TestSize.Level1) 623 { 624 GTEST_LOG_(INFO) << "GetSource_001 start"; 625 626 if (!instance_) { 627 GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_"; 628 return; 629 } 630 AccessibilityAbilityUtHelper::GetInstance().SetAbilityClientNullFlag(true); 631 AccessibilityEventInfo eventInfo {}; 632 AccessibilityElementInfo elementInfo {}; 633 EXPECT_EQ(instance_->GetSource(eventInfo, elementInfo), RET_ERR_NULLPTR); 634 AccessibilityAbilityUtHelper::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 */ 644 HWTEST_F(AccessibilityUITestAbilityImplTest, GetSource_002, TestSize.Level1) 645 { 646 GTEST_LOG_(INFO) << "GetSource_002 start"; 647 648 if (!instance_) { 649 GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_"; 650 return; 651 } 652 AccessibilityEventInfo eventInfo {}; 653 AccessibilityElementInfo 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 */ 664 HWTEST_F(AccessibilityUITestAbilityImplTest, GetParentElementInfo_001, TestSize.Level1) 665 { 666 GTEST_LOG_(INFO) << "GetParentElementInfo_001 start"; 667 668 if (!instance_) { 669 GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_"; 670 return; 671 } 672 AccessibilityAbilityUtHelper::GetInstance().SetAbilityClientNullFlag(true); 673 AccessibilityElementInfo child {}; 674 AccessibilityElementInfo parent {}; 675 EXPECT_EQ(instance_->GetParentElementInfo(child, parent), RET_ERR_NULLPTR); 676 AccessibilityAbilityUtHelper::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 */ 686 HWTEST_F(AccessibilityUITestAbilityImplTest, GetParentElementInfo_002, TestSize.Level1) 687 { 688 GTEST_LOG_(INFO) << "GetParentElementInfo_002 start"; 689 690 if (!instance_) { 691 GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_"; 692 return; 693 } 694 AccessibilityElementInfo child {}; 695 AccessibilityElementInfo 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 */ 706 HWTEST_F(AccessibilityUITestAbilityImplTest, ExecuteAction_001, TestSize.Level1) 707 { 708 GTEST_LOG_(INFO) << "ExecuteAction_001 start"; 709 710 if (!instance_) { 711 GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_"; 712 return; 713 } 714 AccessibilityAbilityUtHelper::GetInstance().SetAbilityClientNullFlag(true); 715 AccessibilityElementInfo elementInfo {}; 716 ActionType action = ACCESSIBILITY_ACTION_INVALID; 717 std::map<std::string, std::string> actionArguments {}; 718 EXPECT_EQ(instance_->ExecuteAction(elementInfo, action, actionArguments), RET_ERR_NULLPTR); 719 AccessibilityAbilityUtHelper::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 */ 729 HWTEST_F(AccessibilityUITestAbilityImplTest, ExecuteAction_002, TestSize.Level1) 730 { 731 GTEST_LOG_(INFO) << "ExecuteAction_002 start"; 732 733 if (!instance_) { 734 GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_"; 735 return; 736 } 737 AccessibilityElementInfo elementInfo {}; 738 ActionType action = ACCESSIBILITY_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 */ 750 HWTEST_F(AccessibilityUITestAbilityImplTest, SetTargetBundleName_001, TestSize.Level1) 751 { 752 GTEST_LOG_(INFO) << "SetTargetBundleName_001 start"; 753 754 if (!instance_) { 755 GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_"; 756 return; 757 } 758 AccessibilityAbilityUtHelper::GetInstance().SetAbilityClientNullFlag(true); 759 std::vector<std::string> targetBundleNames; 760 EXPECT_EQ(instance_->SetTargetBundleName(targetBundleNames), RET_ERR_NULLPTR); 761 AccessibilityAbilityUtHelper::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 */ 771 HWTEST_F(AccessibilityUITestAbilityImplTest, SetTargetBundleName_002, TestSize.Level1) 772 { 773 GTEST_LOG_(INFO) << "SetTargetBundleName_002 start"; 774 775 if (!instance_) { 776 GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl 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 */ 790 HWTEST_F(AccessibilityUITestAbilityImplTest, GetChildren_001, TestSize.Level1) 791 { 792 GTEST_LOG_(INFO) << "GetChildren_001 start"; 793 794 if (!instance_) { 795 GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_"; 796 return; 797 } 798 AccessibilityElementInfo parent; 799 std::vector<AccessibilityElementInfo> 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 */ 810 HWTEST_F(AccessibilityUITestAbilityImplTest, SetCacheMode_001, TestSize.Level1) 811 { 812 GTEST_LOG_(INFO) << "SetCacheMode_001 start"; 813 814 if (!instance_) { 815 GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_"; 816 return; 817 } 818 instance_->SetCacheMode(CACHE_MODE); 819 EXPECT_EQ(CACHE_MODE, AccessibilityAbilityUtHelper::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 */ 829 HWTEST_F(AccessibilityUITestAbilityImplTest, GetRootBatch_001, TestSize.Level1) 830 { 831 GTEST_LOG_(INFO) << "GetRootBatch_001 start"; 832 833 if (!instance_) { 834 GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_"; 835 return; 836 } 837 AccessibilityAbilityUtHelper::GetInstance().SetAbilityClientNullFlag(true); 838 std::vector<AccessibilityElementInfo> elementInfos; 839 EXPECT_EQ(instance_->GetRootBatch(elementInfos), RET_ERR_NULLPTR); 840 AccessibilityAbilityUtHelper::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 */ 850 HWTEST_F(AccessibilityUITestAbilityImplTest, GetRootBatch_002, TestSize.Level1) 851 { 852 GTEST_LOG_(INFO) << "GetRootBatch_002 start"; 853 854 if (!instance_) { 855 GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_"; 856 return; 857 } 858 std::vector<AccessibilityElementInfo> 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 */ 869 HWTEST_F(AccessibilityUITestAbilityImplTest, GetRootByWindowBatch_001, TestSize.Level1) 870 { 871 GTEST_LOG_(INFO) << "GetRootByWindowBatch_001 start"; 872 873 if (!instance_) { 874 GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_"; 875 return; 876 } 877 AccessibilityAbilityUtHelper::GetInstance().SetAbilityClientNullFlag(true); 878 AccessibilityWindowInfo windowInfo {}; 879 std::vector<AccessibilityElementInfo> elementInfos; 880 EXPECT_EQ(instance_->GetRootByWindowBatch(windowInfo, elementInfos, true), RET_ERR_NULLPTR); 881 AccessibilityAbilityUtHelper::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 */ 891 HWTEST_F(AccessibilityUITestAbilityImplTest, GetRootByWindowBatch_002, TestSize.Level1) 892 { 893 GTEST_LOG_(INFO) << "GetRootByWindowBatch_002 start"; 894 895 if (!instance_) { 896 GTEST_LOG_(INFO) << "Cann't get AccessibilityUITestAbilityImpl instance_"; 897 return; 898 } 899 AccessibilityWindowInfo windowInfo {}; 900 std::vector<AccessibilityElementInfo> elementInfos; 901 EXPECT_EQ(instance_->GetRootByWindowBatch(windowInfo, elementInfos, true), RET_OK); 902 903 GTEST_LOG_(INFO) << "GetRootByWindowBatch_002 end"; 904 } 905 } // namespace Accessibility 906 } // namespace OHOS