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