1 /* 2 * Copyright (C) 2022 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 #include <gtest/gtest.h> 17 #include <memory> 18 #include "accessibility_common_helper.h" 19 #include "accessibility_system_ability_client_impl.h" 20 #include "mock_accessibility_element_operator.h" 21 22 using namespace testing; 23 using namespace testing::ext; 24 25 namespace OHOS { 26 namespace Accessibility { 27 namespace { 28 constexpr int32_t WINDOW_ID = 1; 29 constexpr int32_t REQUEST_ID = 1; 30 constexpr int64_t COMPONENT_ID = 1; 31 constexpr int64_t ELEMENT_ID = 1; 32 constexpr uint32_t WINDOW_ID_MASK = 16; 33 constexpr int32_t GET_SOURCE_MODE = 0; 34 constexpr int32_t ROOT_TREE_ID = 0; 35 } // namespace 36 37 class AccessibilitySystemAbilityClientImplTest : public ::testing::Test { 38 public: AccessibilitySystemAbilityClientImplTest()39 AccessibilitySystemAbilityClientImplTest() 40 {} ~AccessibilitySystemAbilityClientImplTest()41 ~AccessibilitySystemAbilityClientImplTest() 42 {} 43 std::shared_ptr<AccessibilitySystemAbilityClientImpl> impl_ = nullptr; 44 SetUpTestCase()45 static void SetUpTestCase() 46 { 47 GTEST_LOG_(INFO) << "AccessibilitySystemAbilityClientImplTest Start"; 48 } TearDownTestCase()49 static void TearDownTestCase() 50 { 51 GTEST_LOG_(INFO) << "AccessibilitySystemAbilityClientImplTest End"; 52 } SetUp()53 void SetUp() 54 { 55 GTEST_LOG_(INFO) << "AccessibilitySystemAbilityClientImplTest SetUp()"; 56 }; TearDown()57 void TearDown() 58 { 59 GTEST_LOG_(INFO) << "AccessibilitySystemAbilityClientImplTest TearDown()"; 60 } 61 }; 62 63 64 /** 65 * @tc.number: RegisterElementOperator_001 66 * @tc.name: RegisterElementOperator 67 * @tc.desc: Test function RegisterElementOperator(parameter is null) 68 */ 69 HWTEST_F(AccessibilitySystemAbilityClientImplTest, RegisterElementOperator_001, TestSize.Level1) 70 { 71 GTEST_LOG_(INFO) << "RegisterElementOperator_001 start"; 72 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 73 if (!impl_) { 74 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 75 } else { 76 EXPECT_EQ(RET_ERR_INVALID_PARAM, impl_->RegisterElementOperator(WINDOW_ID, nullptr)); 77 } 78 impl_ = nullptr; 79 GTEST_LOG_(INFO) << "RegisterElementOperator_001 end"; 80 } 81 82 /** 83 * @tc.number: RegisterElementOperator_002 84 * @tc.name: RegisterElementOperator 85 * @tc.desc: Test function RegisterElementOperator(parameter is not null, proxy is null) 86 */ 87 HWTEST_F(AccessibilitySystemAbilityClientImplTest, RegisterElementOperator_002, TestSize.Level1) 88 { 89 GTEST_LOG_(INFO) << "RegisterElementOperator_002 start"; 90 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 91 if (!impl_) { 92 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 93 } else { 94 std::shared_ptr<AccessibilityElementOperator> mockOperator 95 = std::make_shared<MockAccessibilityElementOperator>(); 96 EXPECT_EQ(RET_ERR_SAMGR, impl_->RegisterElementOperator(WINDOW_ID, mockOperator)); 97 } 98 impl_ = nullptr; 99 GTEST_LOG_(INFO) << "RegisterElementOperator_002 end"; 100 } 101 102 /** 103 * @tc.number: RegisterElementOperator_003 104 * @tc.name: RegisterElementOperator 105 * @tc.desc: Test function RegisterElementOperator(register success) 106 */ 107 HWTEST_F(AccessibilitySystemAbilityClientImplTest, RegisterElementOperator_003, TestSize.Level1) 108 { 109 GTEST_LOG_(INFO) << "RegisterElementOperator_003 start"; 110 AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(true); 111 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 112 AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(false); 113 if (!impl_) { 114 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 115 } else { 116 std::shared_ptr<AccessibilityElementOperator> mockOperator 117 = std::make_shared<MockAccessibilityElementOperator>(); 118 EXPECT_EQ(RET_OK, impl_->RegisterElementOperator(WINDOW_ID, mockOperator)); 119 } 120 impl_ = nullptr; 121 GTEST_LOG_(INFO) << "RegisterElementOperator_003 end"; 122 } 123 124 /** 125 * @tc.number: RegisterElementOperator_004 126 * @tc.name: RegisterElementOperator 127 * @tc.desc: Test function RegisterElementOperator(register fail) 128 */ 129 HWTEST_F(AccessibilitySystemAbilityClientImplTest, RegisterElementOperator_004, TestSize.Level1) 130 { 131 GTEST_LOG_(INFO) << "RegisterElementOperator_004 start"; 132 AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(true); 133 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 134 AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(false); 135 if (!impl_) { 136 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 137 } else { 138 std::shared_ptr<AccessibilityElementOperator> mockOperator 139 = std::make_shared<MockAccessibilityElementOperator>(); 140 EXPECT_EQ(RET_OK, impl_->RegisterElementOperator(WINDOW_ID, mockOperator)); 141 EXPECT_EQ(RET_ERR_CONNECTION_EXIST, impl_->RegisterElementOperator(WINDOW_ID, mockOperator)); 142 } 143 impl_ = nullptr; 144 GTEST_LOG_(INFO) << "RegisterElementOperator_004 end"; 145 } 146 147 /** 148 * @tc.number: DeregisterElementOperator_001 149 * @tc.name: DeregisterElementOperator 150 * @tc.desc: Test function DeregisterElementOperator 151 */ 152 HWTEST_F(AccessibilitySystemAbilityClientImplTest, DeregisterElementOperator_001, TestSize.Level1) 153 { 154 GTEST_LOG_(INFO) << "DeregisterElementOperator_001 start"; 155 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 156 if (!impl_) { 157 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 158 } else { 159 EXPECT_EQ(RET_ERR_SAMGR, impl_->DeregisterElementOperator(WINDOW_ID)); 160 } 161 impl_ = nullptr; 162 GTEST_LOG_(INFO) << "DeregisterElementOperator_001 end"; 163 } 164 165 /** 166 * @tc.number: DeregisterElementOperator_002 167 * @tc.name: DeregisterElementOperator 168 * @tc.desc: Test function DeregisterElementOperator 169 */ 170 HWTEST_F(AccessibilitySystemAbilityClientImplTest, DeregisterElementOperator_002, TestSize.Level1) 171 { 172 GTEST_LOG_(INFO) << "DeregisterElementOperator_002 start"; 173 AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(true); 174 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 175 AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(false); 176 if (!impl_) { 177 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 178 } else { 179 std::shared_ptr<AccessibilityElementOperator> mockOperator 180 = std::make_shared<MockAccessibilityElementOperator>(); 181 EXPECT_EQ(RET_OK, impl_->RegisterElementOperator(WINDOW_ID, mockOperator)); 182 EXPECT_EQ(RET_OK, impl_->DeregisterElementOperator(WINDOW_ID)); 183 } 184 impl_ = nullptr; 185 GTEST_LOG_(INFO) << "DeregisterElementOperator_002 end"; 186 } 187 188 /** 189 * @tc.number: GetAbilityList_001 190 * @tc.name: GetAbilityList 191 * @tc.desc: Test function GetAbilityList 192 */ 193 HWTEST_F(AccessibilitySystemAbilityClientImplTest, GetAbilityList_001, TestSize.Level1) 194 { 195 GTEST_LOG_(INFO) << "GetAbilityList_001 start"; 196 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 197 if (!impl_) { 198 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 199 } else { 200 std::vector<AccessibilityAbilityInfo> infos {}; 201 auto ret = impl_->GetAbilityList(ACCESSIBILITY_ABILITY_TYPE_ALL, ABILITY_STATE_INVALID, infos); 202 EXPECT_EQ(RET_ERR_INVALID_PARAM, ret); 203 } 204 impl_ = nullptr; 205 GTEST_LOG_(INFO) << "GetAbilityList_001 end"; 206 } 207 208 /** 209 * @tc.number: GetAbilityList_002 210 * @tc.name: GetAbilityList 211 * @tc.desc: Test function GetAbilityList(proxy is null) 212 */ 213 HWTEST_F(AccessibilitySystemAbilityClientImplTest, GetAbilityList_002, TestSize.Level1) 214 { 215 GTEST_LOG_(INFO) << "GetAbilityList_002 start"; 216 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 217 if (!impl_) { 218 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 219 } else { 220 std::vector<AccessibilityAbilityInfo> infos {}; 221 auto ret = impl_->GetAbilityList(ACCESSIBILITY_ABILITY_TYPE_ALL, ABILITY_STATE_ENABLE, infos); 222 EXPECT_EQ(RET_ERR_SAMGR, ret); 223 } 224 impl_ = nullptr; 225 GTEST_LOG_(INFO) << "GetAbilityList_002 end"; 226 } 227 228 /** 229 * @tc.number: GetAbilityList_003 230 * @tc.name: GetAbilityList 231 * @tc.desc: Test function GetAbilityList(proxy is not null) 232 */ 233 HWTEST_F(AccessibilitySystemAbilityClientImplTest, GetAbilityList_003, TestSize.Level1) 234 { 235 GTEST_LOG_(INFO) << "GetAbilityList_003 start"; 236 AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(true); 237 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 238 AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(false); 239 if (!impl_) { 240 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 241 } else { 242 std::vector<AccessibilityAbilityInfo> infos {}; 243 auto ret = impl_->GetAbilityList(ACCESSIBILITY_ABILITY_TYPE_ALL, ABILITY_STATE_ENABLE, infos); 244 EXPECT_EQ(RET_OK, ret); 245 } 246 impl_ = nullptr; 247 GTEST_LOG_(INFO) << "GetAbilityList_003 end"; 248 } 249 250 /** 251 * @tc.number: IsEnabled_001 252 * @tc.name: IsEnabled 253 * @tc.desc: Test function IsEnabled 254 */ 255 HWTEST_F(AccessibilitySystemAbilityClientImplTest, IsEnabled_001, TestSize.Level1) 256 { 257 GTEST_LOG_(INFO) << "IsEnabled_001 start"; 258 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 259 if (!impl_) { 260 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 261 } else { 262 bool isEnable = false; 263 impl_->IsEnabled(isEnable); 264 EXPECT_FALSE(isEnable); 265 } 266 impl_ = nullptr; 267 GTEST_LOG_(INFO) << "IsEnabled_001 end"; 268 } 269 270 /** 271 * @tc.number: IsTouchExplorationEnabled_001 272 * @tc.name: IsTouchExplorationEnabled 273 * @tc.desc: Test function IsTouchExplorationEnabled 274 */ 275 HWTEST_F(AccessibilitySystemAbilityClientImplTest, IsTouchExplorationEnabled_001, TestSize.Level1) 276 { 277 GTEST_LOG_(INFO) << "IsTouchExplorationEnabled_001 start"; 278 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 279 if (!impl_) { 280 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 281 } else { 282 bool isEnable = false; 283 impl_->IsTouchExplorationEnabled(isEnable); 284 EXPECT_FALSE(isEnable); 285 } 286 impl_ = nullptr; 287 GTEST_LOG_(INFO) << "IsTouchExplorationEnabled_001 end"; 288 } 289 290 /** 291 * @tc.number: IsScreenReaderEnabled_001 292 * @tc.name: IsScreenReaderEnabled 293 * @tc.desc: Test function IsScreenReaderEnabled 294 */ 295 HWTEST_F(AccessibilitySystemAbilityClientImplTest, IsScreenReaderEnabled_001, TestSize.Level1) 296 { 297 GTEST_LOG_(INFO) << "IsScreenReaderEnabled_001 start"; 298 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 299 ASSERT_TRUE(impl_); 300 bool isEnable = false; 301 impl_->IsScreenReaderEnabled(isEnable); 302 EXPECT_FALSE(isEnable); 303 impl_ = nullptr; 304 GTEST_LOG_(INFO) << "IsScreenReaderEnabled_001 end"; 305 } 306 307 /** 308 * @tc.number: SendEvent_001 309 * @tc.name: SendEvent 310 * @tc.desc: Test function SendEvent(proxy is null) 311 */ 312 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SendEvent_001, TestSize.Level1) 313 { 314 GTEST_LOG_(INFO) << "SendEvent_001 start"; 315 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 316 if (!impl_) { 317 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 318 } else { 319 EXPECT_EQ(RET_ERR_SAMGR, impl_->SendEvent(TYPE_VIEW_LONG_CLICKED_EVENT, COMPONENT_ID)); 320 } 321 impl_ = nullptr; 322 GTEST_LOG_(INFO) << "SendEvent_001 end"; 323 } 324 325 /** 326 * @tc.number: SendEvent_002 327 * @tc.name: SendEvent 328 * @tc.desc: Test function SendEvent(invalid type) 329 */ 330 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SendEvent_002, TestSize.Level1) 331 { 332 GTEST_LOG_(INFO) << "SendEvent_002 start"; 333 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 334 if (!impl_) { 335 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 336 } else { 337 EXPECT_EQ(RET_ERR_INVALID_PARAM, impl_->SendEvent(TYPE_VIEW_INVALID, COMPONENT_ID)); 338 } 339 impl_ = nullptr; 340 GTEST_LOG_(INFO) << "SendEvent_002 end"; 341 } 342 343 /** 344 * @tc.number: SendEvent_003 345 * @tc.name: SendEvent 346 * @tc.desc: Test function SendEvent(proxy is not null) 347 */ 348 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SendEvent_003, TestSize.Level1) 349 { 350 GTEST_LOG_(INFO) << "SendEvent_003 start"; 351 AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(true); 352 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 353 AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(false); 354 if (!impl_) { 355 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 356 } else { 357 EXPECT_EQ(RET_OK, impl_->SendEvent(TYPE_VIEW_LONG_CLICKED_EVENT, COMPONENT_ID)); 358 } 359 impl_ = nullptr; 360 GTEST_LOG_(INFO) << "SendEvent_003 end"; 361 } 362 363 /** 364 * @tc.number: SendEvent_004 365 * @tc.name: SendEvent 366 * @tc.desc: Test function SendEvent(proxy is null) 367 */ 368 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SendEvent_004, TestSize.Level1) 369 { 370 GTEST_LOG_(INFO) << "SendEvent_004 start"; 371 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 372 if (!impl_) { 373 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 374 } else { 375 AccessibilityEventInfo event {}; 376 event.SetEventType(TYPE_VIEW_LONG_CLICKED_EVENT); 377 EXPECT_EQ(RET_ERR_SAMGR, impl_->SendEvent(event)); 378 } 379 impl_ = nullptr; 380 GTEST_LOG_(INFO) << "SendEvent_004 end"; 381 } 382 383 /** 384 * @tc.number: SendEvent_005 385 * @tc.name: SendEvent 386 * @tc.desc: Test function SendEvent(invalid type) 387 */ 388 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SendEvent_005, TestSize.Level1) 389 { 390 GTEST_LOG_(INFO) << "SendEvent_005 start"; 391 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 392 if (!impl_) { 393 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 394 } else { 395 AccessibilityEventInfo event {}; 396 event.SetEventType(TYPE_VIEW_INVALID); 397 EXPECT_EQ(RET_ERR_INVALID_PARAM, impl_->SendEvent(event)); 398 } 399 impl_ = nullptr; 400 GTEST_LOG_(INFO) << "SendEvent_005 end"; 401 } 402 403 /** 404 * @tc.number: SendEvent_006 405 * @tc.name: SendEvent 406 * @tc.desc: Test function SendEvent(proxy is not null) 407 */ 408 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SendEvent_006, TestSize.Level1) 409 { 410 GTEST_LOG_(INFO) << "SendEvent_006 start"; 411 AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(true); 412 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 413 AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(false); 414 if (!impl_) { 415 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 416 } else { 417 AccessibilityEventInfo event {}; 418 event.SetEventType(TYPE_VIEW_LONG_CLICKED_EVENT); 419 EXPECT_EQ(RET_OK, impl_->SendEvent(event)); 420 } 421 impl_ = nullptr; 422 GTEST_LOG_(INFO) << "SendEvent_006 end"; 423 } 424 425 /** 426 * @tc.number: SendEvent_007 427 * @tc.name: SendEvent 428 * @tc.desc: Test function SendEvent(proxy is null) 429 */ 430 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SendEvent_007, TestSize.Level1) 431 { 432 GTEST_LOG_(INFO) << "SendEvent_007 start"; 433 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 434 if (!impl_) { 435 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 436 } else { 437 AccessibilityEventInfo event {}; 438 event.SetEventType(TYPE_VIEW_FOCUSED_EVENT); 439 EXPECT_EQ(RET_ERR_SAMGR, impl_->SendEvent(event)); 440 } 441 impl_ = nullptr; 442 GTEST_LOG_(INFO) << "SendEvent_007 end"; 443 } 444 445 /** 446 * @tc.number: SubscribeStateObserver_001 447 * @tc.name: SubscribeStateObserver 448 * @tc.desc: Test function SubscribeStateObserver 449 */ 450 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SubscribeStateObserver_001, TestSize.Level1) 451 { 452 GTEST_LOG_(INFO) << "SubscribeStateObserver_001 start"; 453 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 454 if (!impl_) { 455 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 456 } else { 457 EXPECT_EQ(RET_ERR_INVALID_PARAM, impl_->SubscribeStateObserver(nullptr, EVENT_TOUCH_GUIDE_STATE_CHANGED)); 458 } 459 impl_ = nullptr; 460 GTEST_LOG_(INFO) << "SubscribeStateObserver_001 end"; 461 } 462 463 /** 464 * @tc.number: SubscribeStateObserver_002 465 * @tc.name: SubscribeStateObserver 466 * @tc.desc: Test function SubscribeStateObserver 467 */ 468 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SubscribeStateObserver_002, TestSize.Level1) 469 { 470 GTEST_LOG_(INFO) << "SubscribeStateObserver_002 start"; 471 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 472 if (!impl_) { 473 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 474 } else { 475 EXPECT_EQ(RET_ERR_INVALID_PARAM, impl_->SubscribeStateObserver(nullptr, EVENT_TYPE_MAX)); 476 } 477 impl_ = nullptr; 478 GTEST_LOG_(INFO) << "SubscribeStateObserver_002 end"; 479 } 480 481 /** 482 * @tc.number: UnsubscribeStateObserver_001 483 * @tc.name: UnsubscribeStateObserver 484 * @tc.desc: Test function UnsubscribeStateObserver(invalid parameter) 485 */ 486 HWTEST_F(AccessibilitySystemAbilityClientImplTest, UnsubscribeStateObserver_001, TestSize.Level1) 487 { 488 GTEST_LOG_(INFO) << "UnsubscribeStateObserver_001 start"; 489 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 490 if (!impl_) { 491 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 492 } else { 493 EXPECT_EQ(RET_ERR_INVALID_PARAM, impl_->UnsubscribeStateObserver(nullptr, EVENT_TYPE_MAX)); 494 } 495 impl_ = nullptr; 496 GTEST_LOG_(INFO) << "UnsubscribeStateObserver_001 end"; 497 } 498 499 /** 500 * @tc.number: UnsubscribeStateObserver_002 501 * @tc.name: UnsubscribeStateObserver 502 * @tc.desc: Test function UnsubscribeStateObserver(invalid parameter) 503 */ 504 HWTEST_F(AccessibilitySystemAbilityClientImplTest, UnsubscribeStateObserver_002, TestSize.Level1) 505 { 506 GTEST_LOG_(INFO) << "UnsubscribeStateObserver_002 start"; 507 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 508 if (!impl_) { 509 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 510 } else { 511 EXPECT_EQ(RET_ERR_INVALID_PARAM, impl_->UnsubscribeStateObserver(nullptr, EVENT_KEVEVENT_STATE_CHANGED)); 512 } 513 impl_ = nullptr; 514 GTEST_LOG_(INFO) << "UnsubscribeStateObserver_002 end"; 515 } 516 517 /** 518 * @tc.number: ResetService_001 519 * @tc.name: ResetService 520 * @tc.desc: Test function ResetService 521 */ 522 HWTEST_F(AccessibilitySystemAbilityClientImplTest, ResetService_001, TestSize.Level1) 523 { 524 GTEST_LOG_(INFO) << "ResetService_001 start"; 525 AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(true); 526 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 527 AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(false); 528 if (!impl_) { 529 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 530 } else { 531 impl_->ResetService(nullptr); 532 EXPECT_NE(impl_.get(), nullptr); 533 } 534 impl_ = nullptr; 535 GTEST_LOG_(INFO) << "ResetService_001 end"; 536 } 537 538 /** 539 * @tc.number: ResetService_002 540 * @tc.name: ResetService 541 * @tc.desc: Test function ResetService 542 */ 543 HWTEST_F(AccessibilitySystemAbilityClientImplTest, ResetService_002, TestSize.Level1) 544 { 545 GTEST_LOG_(INFO) << "ResetService_002 start"; 546 AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(true); 547 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 548 AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(false); 549 if (!impl_) { 550 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 551 } else { 552 wptr<IRemoteObject> object; 553 impl_->ResetService(object); 554 EXPECT_NE(impl_.get(), nullptr); 555 } 556 impl_ = nullptr; 557 GTEST_LOG_(INFO) << "ResetService_002 end"; 558 } 559 560 /** 561 * @tc.number: OnAccessibleAbilityManagerStateChanged_001 562 * @tc.name: OnAccessibleAbilityManagerStateChanged 563 * @tc.desc: Test function OnAccessibleAbilityManagerStateChanged 564 */ 565 HWTEST_F(AccessibilitySystemAbilityClientImplTest, OnAccessibleAbilityManagerStateChanged_001, TestSize.Level1) 566 { 567 GTEST_LOG_(INFO) << "OnAccessibleAbilityManagerStateChanged_001 start"; 568 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 569 if (!impl_) { 570 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 571 } else { 572 uint32_t stateType = STATE_ACCESSIBILITY_ENABLED | STATE_EXPLORATION_ENABLED 573 | STATE_KEYEVENT_ENABLED | STATE_GESTURE_ENABLED; 574 impl_->OnAccessibleAbilityManagerStateChanged(stateType); 575 EXPECT_NE(impl_.get(), nullptr); 576 } 577 impl_ = nullptr; 578 GTEST_LOG_(INFO) << "OnAccessibleAbilityManagerStateChanged_001 end"; 579 } 580 581 /** 582 * @tc.number: OnAccessibleAbilityManagerStateChanged_002 583 * @tc.name: OnAccessibleAbilityManagerStateChanged 584 * @tc.desc: Test function OnAccessibleAbilityManagerStateChanged 585 */ 586 HWTEST_F(AccessibilitySystemAbilityClientImplTest, OnAccessibleAbilityManagerStateChanged_002, TestSize.Level1) 587 { 588 GTEST_LOG_(INFO) << "OnAccessibleAbilityManagerStateChanged_002 start"; 589 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 590 if (!impl_) { 591 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 592 } else { 593 impl_->OnAccessibleAbilityManagerStateChanged(0); 594 EXPECT_NE(impl_.get(), nullptr); 595 } 596 impl_ = nullptr; 597 GTEST_LOG_(INFO) << "OnAccessibleAbilityManagerStateChanged_002 end"; 598 } 599 600 /** 601 * @tc.number: GetEnabledAbilities_001 602 * @tc.name: GetEnabledAbilities 603 * @tc.desc: Test function GetEnabledAbilities 604 */ 605 HWTEST_F(AccessibilitySystemAbilityClientImplTest, GetEnabledAbilities_001, TestSize.Level1) 606 { 607 GTEST_LOG_(INFO) << "GetEnabledAbilities_001 start"; 608 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 609 if (!impl_) { 610 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 611 } else { 612 std::vector<std::string> enabledAbilities; 613 EXPECT_EQ(RET_ERR_SAMGR, impl_->GetEnabledAbilities(enabledAbilities)); 614 } 615 impl_ = nullptr; 616 GTEST_LOG_(INFO) << "GetEnabledAbilities_001 end"; 617 } 618 619 /** 620 * @tc.number: GetEnabledAbilities_002 621 * @tc.name: GetEnabledAbilities 622 * @tc.desc: Test function GetEnabledAbilities 623 */ 624 HWTEST_F(AccessibilitySystemAbilityClientImplTest, GetEnabledAbilities_002, TestSize.Level1) 625 { 626 GTEST_LOG_(INFO) << "GetEnabledAbilities_002 start"; 627 AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(true); 628 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 629 AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(false); 630 if (!impl_) { 631 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 632 } else { 633 std::vector<std::string> enabledAbilities; 634 EXPECT_EQ(RET_OK, impl_->GetEnabledAbilities(enabledAbilities)); 635 } 636 impl_ = nullptr; 637 GTEST_LOG_(INFO) << "GetEnabledAbilities_002 end"; 638 } 639 640 /** 641 * @tc.number: SetSearchElementInfoByAccessibilityIdResult_001 642 * @tc.name: SetSearchElementInfoByAccessibilityIdResult 643 * @tc.desc: Test function SetSearchElementInfoByAccessibilityIdResult(success) 644 */ 645 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetSearchElementInfoByAccessibilityIdResult_001, TestSize.Level1) 646 { 647 GTEST_LOG_(INFO) << "SetSearchElementInfoByAccessibilityIdResult_001 start"; 648 AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(true); 649 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 650 AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(false); 651 if (!impl_) { 652 GTEST_LOG_(INFO) << "SetSearchElementInfoByAccessibilityIdResult_001" 653 "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 654 } else { 655 std::shared_ptr<AccessibilityElementOperator> mockOperator 656 = std::make_shared<MockAccessibilityElementOperator>(); 657 EXPECT_EQ(0, impl_->RegisterElementOperator(WINDOW_ID, mockOperator)); 658 int32_t requestId = REQUEST_ID; 659 requestId |= static_cast<uint32_t>(WINDOW_ID) << WINDOW_ID_MASK; 660 std::list<AccessibilityElementInfo> infos; 661 impl_->SetSearchElementInfoByAccessibilityIdResult(infos, requestId); 662 EXPECT_EQ(0, infos.size()); 663 } 664 impl_ = nullptr; 665 GTEST_LOG_(INFO) << "SetSearchElementInfoByAccessibilityIdResult_001 end"; 666 } 667 668 /** 669 * @tc.number: SetSearchElementInfoByAccessibilityIdResult_002 670 * @tc.name: SetSearchElementInfoByAccessibilityIdResult 671 * @tc.desc: Test function SetSearchElementInfoByAccessibilityIdResult(no operator) 672 */ 673 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetSearchElementInfoByAccessibilityIdResult_002, TestSize.Level1) 674 { 675 GTEST_LOG_(INFO) << "SetSearchElementInfoByAccessibilityIdResult_002 start"; 676 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 677 if (!impl_) { 678 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 679 } else { 680 int32_t requestId = REQUEST_ID; 681 requestId |= static_cast<uint32_t>(WINDOW_ID) << WINDOW_ID_MASK; 682 std::list<AccessibilityElementInfo> infos; 683 impl_->SetSearchElementInfoByAccessibilityIdResult(infos, requestId); 684 EXPECT_EQ(0, infos.size()); 685 } 686 impl_ = nullptr; 687 GTEST_LOG_(INFO) << "SetSearchElementInfoByAccessibilityIdResult_002 end"; 688 } 689 690 /** 691 * @tc.number: SetSearchElementInfoByAccessibilityIdResult_003 692 * @tc.name: SetSearchElementInfoByAccessibilityIdResult 693 * @tc.desc: Test function SetSearchElementInfoByAccessibilityIdResult(invalid requestId) 694 */ 695 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetSearchElementInfoByAccessibilityIdResult_003, TestSize.Level1) 696 { 697 GTEST_LOG_(INFO) << "SetSearchElementInfoByAccessibilityIdResult_003 start"; 698 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 699 if (!impl_) { 700 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 701 } else { 702 std::list<AccessibilityElementInfo> infos; 703 impl_->SetSearchElementInfoByAccessibilityIdResult(infos, -1); 704 EXPECT_EQ(0, infos.size()); 705 } 706 impl_ = nullptr; 707 GTEST_LOG_(INFO) << "SetSearchElementInfoByAccessibilityIdResult_003 end"; 708 } 709 710 /** 711 * @tc.number: SetSearchDefaultFocusByWindowIdResult_001 712 * @tc.name: SetSearchDefaultFocusByWindowIdResult 713 * @tc.desc: Test function SetSearchDefaultFocusByWindowIdResult(success) 714 */ 715 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetSearchDefaultFocusByWindowIdResult_001, TestSize.Level1) 716 { 717 GTEST_LOG_(INFO) << "SetSearchDefaultFocusByWindowIdResult_001 start"; 718 AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(true); 719 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 720 AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(false); 721 if (!impl_) { 722 GTEST_LOG_(INFO) << "SetSearchDefaultFocusByWindowIdResult_001" 723 "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 724 } else { 725 std::shared_ptr<AccessibilityElementOperator> mockOperator 726 = std::make_shared<MockAccessibilityElementOperator>(); 727 EXPECT_EQ(0, impl_->RegisterElementOperator(WINDOW_ID, mockOperator)); 728 int32_t requestId = REQUEST_ID; 729 requestId |= static_cast<uint32_t>(WINDOW_ID) << WINDOW_ID_MASK; 730 std::list<AccessibilityElementInfo> infos; 731 impl_->SetSearchDefaultFocusByWindowIdResult(infos, requestId); 732 EXPECT_EQ(0, infos.size()); 733 } 734 impl_ = nullptr; 735 GTEST_LOG_(INFO) << "SetSearchDefaultFocusByWindowIdResult_001 end"; 736 } 737 738 /** 739 * @tc.number: SetSearchDefaultFocusByWindowIdResult_002 740 * @tc.name: SetSearchDefaultFocusByWindowIdResult 741 * @tc.desc: Test function SetSearchDefaultFocusByWindowIdResult(no operator) 742 */ 743 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetSearchDefaultFocusByWindowIdResult_002, TestSize.Level1) 744 { 745 GTEST_LOG_(INFO) << "SetSearchDefaultFocusByWindowIdResult_002 start"; 746 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 747 if (!impl_) { 748 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 749 } else { 750 int32_t requestId = REQUEST_ID; 751 requestId |= static_cast<uint32_t>(WINDOW_ID) << WINDOW_ID_MASK; 752 std::list<AccessibilityElementInfo> infos; 753 impl_->SetSearchDefaultFocusByWindowIdResult(infos, requestId); 754 EXPECT_EQ(0, infos.size()); 755 } 756 impl_ = nullptr; 757 GTEST_LOG_(INFO) << "SetSearchDefaultFocusByWindowIdResult_002 end"; 758 } 759 760 /** 761 * @tc.number: SetSearchDefaultFocusByWindowIdResult_003 762 * @tc.name: SetSearchDefaultFocusByWindowIdResult 763 * @tc.desc: Test function SetSearchDefaultFocusByWindowIdResult(invalid requestId) 764 */ 765 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetSearchDefaultFocusByWindowIdResult_003, TestSize.Level1) 766 { 767 GTEST_LOG_(INFO) << "SetSearchDefaultFocusByWindowIdResult_003 start"; 768 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 769 if (!impl_) { 770 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 771 } else { 772 std::list<AccessibilityElementInfo> infos; 773 impl_->SetSearchDefaultFocusByWindowIdResult(infos, -1); 774 EXPECT_EQ(0, infos.size()); 775 } 776 impl_ = nullptr; 777 GTEST_LOG_(INFO) << "SetSearchDefaultFocusByWindowIdResult_003 end"; 778 } 779 780 /** 781 * @tc.number: SetSearchElementInfoByTextResult_001 782 * @tc.name: SetSearchElementInfoByTextResult 783 * @tc.desc: Test function SetSearchElementInfoByTextResult(success) 784 */ 785 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetSearchElementInfoByTextResult_001, TestSize.Level1) 786 { 787 GTEST_LOG_(INFO) << "SetSearchElementInfoByTextResult_001 start"; 788 AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(true); 789 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 790 AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(false); 791 if (!impl_) { 792 GTEST_LOG_(INFO) << "Cann't get SetSearchElementInfoByTextResult_001 impl_"; 793 } else { 794 std::shared_ptr<AccessibilityElementOperator> mockOperator 795 = std::make_shared<MockAccessibilityElementOperator>(); 796 EXPECT_EQ(0, impl_->RegisterElementOperator(WINDOW_ID, mockOperator)); 797 int32_t requestId = REQUEST_ID; 798 requestId |= static_cast<uint32_t>(WINDOW_ID) << WINDOW_ID_MASK; 799 std::list<AccessibilityElementInfo> infos; 800 impl_->SetSearchElementInfoByTextResult(infos, requestId); 801 EXPECT_EQ(0, infos.size()); 802 } 803 impl_ = nullptr; 804 GTEST_LOG_(INFO) << "SetSearchElementInfoByTextResult_001 end"; 805 } 806 807 /** 808 * @tc.number: SetSearchElementInfoByTextResult_002 809 * @tc.name: SetSearchElementInfoByTextResult 810 * @tc.desc: Test function SetSearchElementInfoByTextResult(no operator) 811 */ 812 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetSearchElementInfoByTextResult_002, TestSize.Level1) 813 { 814 GTEST_LOG_(INFO) << "SetSearchElementInfoByTextResult_002 start"; 815 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 816 if (!impl_) { 817 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 818 } else { 819 int32_t requestId = REQUEST_ID; 820 requestId |= static_cast<uint32_t>(WINDOW_ID) << WINDOW_ID_MASK; 821 std::list<AccessibilityElementInfo> infos; 822 impl_->SetSearchElementInfoByTextResult(infos, requestId); 823 EXPECT_EQ(0, infos.size()); 824 } 825 impl_ = nullptr; 826 GTEST_LOG_(INFO) << "SetSearchElementInfoByTextResult_002 end"; 827 } 828 829 /** 830 * @tc.number: SetSearchElementInfoByTextResult_003 831 * @tc.name: SetSearchElementInfoByTextResult 832 * @tc.desc: Test function SetSearchElementInfoByTextResult(invalid requestId) 833 */ 834 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetSearchElementInfoByTextResult_003, TestSize.Level1) 835 { 836 GTEST_LOG_(INFO) << "SetSearchElementInfoByTextResult_003 start"; 837 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 838 if (!impl_) { 839 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 840 } else { 841 std::list<AccessibilityElementInfo> infos; 842 impl_->SetSearchElementInfoByTextResult(infos, -1); 843 EXPECT_EQ(0, infos.size()); 844 } 845 impl_ = nullptr; 846 GTEST_LOG_(INFO) << "SetSearchElementInfoByTextResult_003 end"; 847 } 848 849 /** 850 * @tc.number: SetFindFocusedElementInfoResult_001 851 * @tc.name: SetFindFocusedElementInfoResult 852 * @tc.desc: Test function SetFindFocusedElementInfoResult(success) 853 */ 854 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetFindFocusedElementInfoResult_001, TestSize.Level1) 855 { 856 GTEST_LOG_(INFO) << "SetFindFocusedElementInfoResult_001 start"; 857 AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(true); 858 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 859 AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(false); 860 if (!impl_) { 861 GTEST_LOG_(INFO) << "SetFindFocusedElementInfoResult_001" 862 "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 863 } else { 864 std::shared_ptr<AccessibilityElementOperator> mockOperator 865 = std::make_shared<MockAccessibilityElementOperator>(); 866 EXPECT_EQ(0, impl_->RegisterElementOperator(WINDOW_ID, mockOperator)); 867 int32_t requestId = REQUEST_ID; 868 requestId |= static_cast<uint32_t>(WINDOW_ID) << WINDOW_ID_MASK; 869 AccessibilityElementInfo info; 870 impl_->SetFindFocusedElementInfoResult(info, requestId); 871 } 872 impl_ = nullptr; 873 GTEST_LOG_(INFO) << "SetFindFocusedElementInfoResult_001 end"; 874 } 875 876 /** 877 * @tc.number: SetFindFocusedElementInfoResult_002 878 * @tc.name: SetFindFocusedElementInfoResult 879 * @tc.desc: Test function SetFindFocusedElementInfoResult(no operator) 880 */ 881 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetFindFocusedElementInfoResult_002, TestSize.Level1) 882 { 883 GTEST_LOG_(INFO) << "SetFindFocusedElementInfoResult_002 start"; 884 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 885 if (!impl_) { 886 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 887 } else { 888 int32_t requestId = REQUEST_ID; 889 requestId |= static_cast<uint32_t>(WINDOW_ID) << WINDOW_ID_MASK; 890 AccessibilityElementInfo info; 891 impl_->SetFindFocusedElementInfoResult(info, requestId); 892 EXPECT_NE(impl_.get(), nullptr); 893 } 894 impl_ = nullptr; 895 GTEST_LOG_(INFO) << "SetFindFocusedElementInfoResult_002 end"; 896 } 897 898 /** 899 * @tc.number: SetFindFocusedElementInfoResult_003 900 * @tc.name: SetFindFocusedElementInfoResult 901 * @tc.desc: Test function SetFindFocusedElementInfoResult(invalid requestId) 902 */ 903 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetFindFocusedElementInfoResult_003, TestSize.Level1) 904 { 905 GTEST_LOG_(INFO) << "SetFindFocusedElementInfoResult_003 start"; 906 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 907 if (!impl_) { 908 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 909 } else { 910 AccessibilityElementInfo info; 911 impl_->SetFindFocusedElementInfoResult(info, -1); 912 EXPECT_NE(impl_.get(), nullptr); 913 } 914 impl_ = nullptr; 915 GTEST_LOG_(INFO) << "SetFindFocusedElementInfoResult_003 end"; 916 } 917 918 /** 919 * @tc.number: SetFocusMoveSearchResult_001 920 * @tc.name: SetFocusMoveSearchResult 921 * @tc.desc: Test function SetFocusMoveSearchResult(success) 922 */ 923 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetFocusMoveSearchResult_001, TestSize.Level1) 924 { 925 GTEST_LOG_(INFO) << "SetFocusMoveSearchResult_001 start"; 926 AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(true); 927 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 928 AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(false); 929 if (!impl_) { 930 GTEST_LOG_(INFO) << "SetFocusMoveSearchResult_001 Cann't get AccessibilitySystemAbilityClientImpl impl_"; 931 } else { 932 std::shared_ptr<AccessibilityElementOperator> mockOperator 933 = std::make_shared<MockAccessibilityElementOperator>(); 934 EXPECT_EQ(0, impl_->RegisterElementOperator(WINDOW_ID, mockOperator)); 935 int32_t requestId = REQUEST_ID; 936 requestId |= static_cast<uint32_t>(WINDOW_ID) << WINDOW_ID_MASK; 937 AccessibilityElementInfo info; 938 impl_->SetFocusMoveSearchResult(info, requestId); 939 } 940 impl_ = nullptr; 941 GTEST_LOG_(INFO) << "SetFocusMoveSearchResult_001 end"; 942 } 943 944 /** 945 * @tc.number: SetFocusMoveSearchResult_002 946 * @tc.name: SetFocusMoveSearchResult 947 * @tc.desc: Test function SetFocusMoveSearchResult(no operator) 948 */ 949 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetFocusMoveSearchResult_002, TestSize.Level1) 950 { 951 GTEST_LOG_(INFO) << "SetFocusMoveSearchResult_002 start"; 952 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 953 if (!impl_) { 954 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 955 } else { 956 int32_t requestId = REQUEST_ID; 957 requestId |= static_cast<uint32_t>(WINDOW_ID) << WINDOW_ID_MASK; 958 AccessibilityElementInfo info; 959 impl_->SetFocusMoveSearchResult(info, requestId); 960 EXPECT_NE(impl_.get(), nullptr); 961 } 962 impl_ = nullptr; 963 GTEST_LOG_(INFO) << "SetFocusMoveSearchResult_002 end"; 964 } 965 966 /** 967 * @tc.number: SetFocusMoveSearchResult_003 968 * @tc.name: SetFocusMoveSearchResult 969 * @tc.desc: Test function SetFocusMoveSearchResult(invalid requestId) 970 */ 971 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetFocusMoveSearchResult_003, TestSize.Level1) 972 { 973 GTEST_LOG_(INFO) << "SetFocusMoveSearchResult_003 start"; 974 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 975 if (!impl_) { 976 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 977 } else { 978 AccessibilityElementInfo info; 979 impl_->SetFocusMoveSearchResult(info, -1); 980 EXPECT_NE(impl_.get(), nullptr); 981 } 982 impl_ = nullptr; 983 GTEST_LOG_(INFO) << "SetFocusMoveSearchResult_003 end"; 984 } 985 986 /** 987 * @tc.number: SetExecuteActionResult_001 988 * @tc.name: SetExecuteActionResult 989 * @tc.desc: Test function SetExecuteActionResult(success) 990 */ 991 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetExecuteActionResult_001, TestSize.Level1) 992 { 993 GTEST_LOG_(INFO) << "SetExecuteActionResult_001 start"; 994 AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(true); 995 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 996 AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(false); 997 if (!impl_) { 998 GTEST_LOG_(INFO) << "SetExecuteActionResult_001 Cann't get AccessibilitySystemAbilityClientImpl impl_"; 999 } else { 1000 std::shared_ptr<AccessibilityElementOperator> mockOperator 1001 = std::make_shared<MockAccessibilityElementOperator>(); 1002 EXPECT_EQ(0, impl_->RegisterElementOperator(WINDOW_ID, mockOperator)); 1003 int32_t requestId = REQUEST_ID; 1004 requestId |= static_cast<uint32_t>(WINDOW_ID) << WINDOW_ID_MASK; 1005 impl_->SetExecuteActionResult(true, requestId); 1006 } 1007 impl_ = nullptr; 1008 GTEST_LOG_(INFO) << "SetExecuteActionResult_001 end"; 1009 } 1010 1011 /** 1012 * @tc.number: SetExecuteActionResult_002 1013 * @tc.name: SetExecuteActionResult 1014 * @tc.desc: Test function SetExecuteActionResult(no operator) 1015 */ 1016 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetExecuteActionResult_002, TestSize.Level1) 1017 { 1018 GTEST_LOG_(INFO) << "SetExecuteActionResult_002 start"; 1019 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 1020 if (!impl_) { 1021 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 1022 } else { 1023 int32_t requestId = REQUEST_ID; 1024 requestId |= static_cast<uint32_t>(WINDOW_ID) << WINDOW_ID_MASK; 1025 impl_->SetExecuteActionResult(true, requestId); 1026 EXPECT_NE(impl_.get(), nullptr); 1027 } 1028 impl_ = nullptr; 1029 GTEST_LOG_(INFO) << "SetExecuteActionResult_002 end"; 1030 } 1031 1032 /** 1033 * @tc.number: SetExecuteActionResult_003 1034 * @tc.name: SetExecuteActionResult 1035 * @tc.desc: Test function SetExecuteActionResult(invalid requestId) 1036 */ 1037 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetExecuteActionResult_003, TestSize.Level1) 1038 { 1039 GTEST_LOG_(INFO) << "SetExecuteActionResult_003 start"; 1040 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 1041 if (!impl_) { 1042 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 1043 } else { 1044 impl_->SetExecuteActionResult(true, -1); 1045 EXPECT_NE(impl_.get(), nullptr); 1046 } 1047 impl_ = nullptr; 1048 GTEST_LOG_(INFO) << "SetExecuteActionResult_003 end"; 1049 } 1050 1051 /** 1052 * @tc.number: SetCursorPositionResult_001 1053 * @tc.name: SetCursorPositionResult 1054 * @tc.desc: Test function SetCursorPositionResult(cursorPosition,requestId) 1055 */ 1056 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetCursorPositionResult_001, TestSize.Level1) 1057 { 1058 GTEST_LOG_(INFO) << "SetCursorPositionResult_001 start"; 1059 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 1060 if (!impl_) { 1061 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 1062 } else { 1063 int32_t cursorPosition = 0; 1064 int32_t requestId = REQUEST_ID; 1065 requestId |= static_cast<uint32_t>(WINDOW_ID) << WINDOW_ID_MASK; 1066 impl_->SetCursorPositionResult(cursorPosition, requestId); 1067 EXPECT_NE(impl_.get(), nullptr); 1068 } 1069 impl_ = nullptr; 1070 GTEST_LOG_(INFO) << "SetCursorPositionResult_001 end"; 1071 } 1072 1073 /** 1074 * @tc.number: SetCursorPositionResult_002 1075 * @tc.name: SetCursorPositionResult 1076 * @tc.desc: Test function SetCursorPositionResult(cursorPosition,requestId) 1077 */ 1078 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetCursorPositionResult_002, TestSize.Level1) 1079 { 1080 GTEST_LOG_(INFO) << "SetCursorPositionResult_001 start"; 1081 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 1082 if (!impl_) { 1083 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 1084 } else { 1085 int32_t cursorPosition = 0; 1086 impl_->SetCursorPositionResult(cursorPosition, -1); 1087 EXPECT_NE(impl_.get(), nullptr); 1088 } 1089 impl_ = nullptr; 1090 GTEST_LOG_(INFO) << "SetCursorPositionResult_001 end"; 1091 } 1092 1093 /** 1094 * @tc.number: SetAccessibilityState_001 1095 * @tc.name: SetAccessibilityState 1096 * @tc.desc: Test function SetAccessibilityState 1097 */ 1098 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetAccessibilityState_001, TestSize.Level1) 1099 { 1100 GTEST_LOG_(INFO) << "SetAccessibilityState_001 start"; 1101 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 1102 if (!impl_) { 1103 GTEST_LOG_(INFO) << "Cann't get SetAccessibilityState impl_"; 1104 } else { 1105 impl_->SetAccessibilityState(0); 1106 EXPECT_NE(impl_.get(), nullptr); 1107 } 1108 impl_ = nullptr; 1109 GTEST_LOG_(INFO) << "SetAccessibilityState_001 end"; 1110 } 1111 1112 /** 1113 * @tc.number: GetAccessibilityState_001 1114 * @tc.name: GetAccessibilityState 1115 * @tc.desc: Test function GetAccessibilityState 1116 */ 1117 HWTEST_F(AccessibilitySystemAbilityClientImplTest, GetAccessibilityState_001, TestSize.Level1) 1118 { 1119 GTEST_LOG_(INFO) << "GetAccessibilityState_001 start"; 1120 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 1121 if (!impl_) { 1122 GTEST_LOG_(INFO) << "Cann't get SetAccessibilityState impl_"; 1123 } else { 1124 impl_->SetAccessibilityState(0); 1125 EXPECT_EQ(0, impl_->GetAccessibilityState()); 1126 } 1127 impl_ = nullptr; 1128 GTEST_LOG_(INFO) << "GetAccessibilityState_001 end"; 1129 } 1130 1131 /** 1132 * @tc.number: SetFindAccessibilityNodeInfoResult_001 1133 * @tc.name: SetFindAccessibilityNodeInfoResult 1134 * @tc.desc: Test function SetFindAccessibilityNodeInfoResult(elementInfo,requestId,requestCode) 1135 */ 1136 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetFindAccessibilityNodeInfoResult_001, TestSize.Level1) 1137 { 1138 GTEST_LOG_(INFO) << "SetFindAccessibilityNodeInfoResult_001 start"; 1139 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 1140 if (!impl_) { 1141 GTEST_LOG_(INFO) << "Cann't get SetFindAccessibilityNodeInfoResult impl_"; 1142 } else { 1143 AccessibilityElementInfo elementInfo; 1144 int32_t requestId = -1; 1145 int32_t requestCode = FIND_ACCESSIBILITY_NODE_BY_ACCESSIBILITY_ID; 1146 impl_->SetFindAccessibilityNodeInfoResult(elementInfo, requestId, requestCode); 1147 EXPECT_NE(impl_.get(), nullptr); 1148 } 1149 impl_ = nullptr; 1150 GTEST_LOG_(INFO) << "SetFindAccessibilityNodeInfoResult_001 end"; 1151 } 1152 1153 /** 1154 * @tc.number: SetFindAccessibilityNodeInfoResult_002 1155 * @tc.name: SetFindAccessibilityNodeInfoResult 1156 * @tc.desc: Test function SetFindAccessibilityNodeInfoResult(elementInfo,requestId,requestCode) 1157 */ 1158 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetFindAccessibilityNodeInfoResult_002, TestSize.Level1) 1159 { 1160 GTEST_LOG_(INFO) << "SetFindAccessibilityNodeInfoResult_002 start"; 1161 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 1162 if (!impl_) { 1163 GTEST_LOG_(INFO) << "Cann't get SetFindAccessibilityNodeInfoResult impl_"; 1164 } else { 1165 AccessibilityElementInfo elementInfo; 1166 int32_t requestId = -1; 1167 int32_t requestCode = FIND_FOCUS; 1168 impl_->SetFindAccessibilityNodeInfoResult(elementInfo, requestId, requestCode); 1169 EXPECT_NE(impl_.get(), nullptr); 1170 } 1171 impl_ = nullptr; 1172 GTEST_LOG_(INFO) << "SetFindAccessibilityNodeInfoResult_002 end"; 1173 } 1174 1175 /** 1176 * @tc.number: SetFindAccessibilityNodeInfoResult_003 1177 * @tc.name: SetFindAccessibilityNodeInfoResult 1178 * @tc.desc: Test function SetFindAccessibilityNodeInfoResult(elementInfo,requestId,requestCode) 1179 */ 1180 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetFindAccessibilityNodeInfoResult_003, TestSize.Level1) 1181 { 1182 GTEST_LOG_(INFO) << "SetFindAccessibilityNodeInfoResult_003 start"; 1183 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 1184 if (!impl_) { 1185 GTEST_LOG_(INFO) << "Cann't get SetFindAccessibilityNodeInfoResult impl_"; 1186 } else { 1187 AccessibilityElementInfo elementInfo; 1188 int32_t requestId = -1; 1189 int32_t requestCode = FIND_FOCUS_SEARCH; 1190 impl_->SetFindAccessibilityNodeInfoResult(elementInfo, requestId, requestCode); 1191 EXPECT_NE(impl_.get(), nullptr); 1192 } 1193 impl_ = nullptr; 1194 GTEST_LOG_(INFO) << "SetFindAccessibilityNodeInfoResult_003 end"; 1195 } 1196 1197 /** 1198 * @tc.number: SetFindAccessibilityNodeInfoResult_004 1199 * @tc.name: SetFindAccessibilityNodeInfoResult 1200 * @tc.desc: Test function SetFindAccessibilityNodeInfoResult(elementInfo,requestId,requestCode) 1201 */ 1202 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetFindAccessibilityNodeInfoResult_004, TestSize.Level1) 1203 { 1204 GTEST_LOG_(INFO) << "SetFindAccessibilityNodeInfoResult_004 start"; 1205 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 1206 if (!impl_) { 1207 GTEST_LOG_(INFO) << "Cann't get SetFindAccessibilityNodeInfoResult impl_"; 1208 } else { 1209 AccessibilityElementInfo elementInfo; 1210 int32_t requestId = -1; 1211 int32_t requestCode = FIND_ACCESSIBILITY_NODE_BY_TEXT; 1212 impl_->SetFindAccessibilityNodeInfoResult(elementInfo, requestId, requestCode); 1213 EXPECT_NE(impl_.get(), nullptr); 1214 } 1215 impl_ = nullptr; 1216 GTEST_LOG_(INFO) << "SetFindAccessibilityNodeInfoResult_004 end"; 1217 } 1218 1219 /** 1220 * @tc.number: SetFindAccessibilityNodeInfosResult_001 1221 * @tc.name: SetFindAccessibilityNodeInfosResult 1222 * @tc.desc: Test function SetFindAccessibilityNodeInfosResult(elementInfos,requestId,requestCode) 1223 */ 1224 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetFindAccessibilityNodeInfosResult_001, TestSize.Level1) 1225 { 1226 GTEST_LOG_(INFO) << "SetFindAccessibilityNodeInfosResult_001 start"; 1227 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 1228 if (!impl_) { 1229 GTEST_LOG_(INFO) << "Cann't get SetFindAccessibilityNodeInfosResult_001 impl_"; 1230 } else { 1231 std::list<AccessibilityElementInfo> elementInfos; 1232 int32_t requestId = -1; 1233 int32_t requestCode = FIND_ACCESSIBILITY_NODE_BY_ACCESSIBILITY_ID; 1234 impl_->SetFindAccessibilityNodeInfosResult(elementInfos, requestId, requestCode); 1235 EXPECT_NE(impl_.get(), nullptr); 1236 } 1237 impl_ = nullptr; 1238 GTEST_LOG_(INFO) << "SetFindAccessibilityNodeInfosResult_001 end"; 1239 } 1240 1241 /** 1242 * @tc.number: SetFindAccessibilityNodeInfosResult_002 1243 * @tc.name: SetFindAccessibilityNodeInfosResult 1244 * @tc.desc: Test function SetFindAccessibilityNodeInfosResult(elementInfos,requestId,requestCode) 1245 */ 1246 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetFindAccessibilityNodeInfosResult_002, TestSize.Level1) 1247 { 1248 GTEST_LOG_(INFO) << "SetFindAccessibilityNodeInfosResult_002 start"; 1249 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 1250 if (!impl_) { 1251 GTEST_LOG_(INFO) << "Cann't get SetFindAccessibilityNodeInfosResult_002 impl_"; 1252 } else { 1253 std::list<AccessibilityElementInfo> elementInfos; 1254 int32_t requestId = -1; 1255 int32_t requestCode = FIND_ACCESSIBILITY_NODE_BY_TEXT; 1256 impl_->SetFindAccessibilityNodeInfosResult(elementInfos, requestId, requestCode); 1257 EXPECT_NE(impl_.get(), nullptr); 1258 } 1259 impl_ = nullptr; 1260 GTEST_LOG_(INFO) << "SetFindAccessibilityNodeInfosResult_002 end"; 1261 } 1262 1263 /** 1264 * @tc.number: SetFindAccessibilityNodeInfosResult_003 1265 * @tc.name: SetFindAccessibilityNodeInfosResult 1266 * @tc.desc: Test function SetFindAccessibilityNodeInfosResult(elementInfos,requestId,requestCode) 1267 */ 1268 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetFindAccessibilityNodeInfosResult_003, TestSize.Level1) 1269 { 1270 GTEST_LOG_(INFO) << "SetFindAccessibilityNodeInfosResult_003 start"; 1271 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 1272 ASSERT_TRUE(impl_); 1273 std::list<AccessibilityElementInfo> elementInfos; 1274 int32_t requestId = -1; 1275 int32_t requestCode = FIND_FOCUS_SEARCH; 1276 impl_->SetFindAccessibilityNodeInfosResult(elementInfos, requestId, requestCode); 1277 EXPECT_NE(impl_.get(), nullptr); 1278 impl_ = nullptr; 1279 GTEST_LOG_(INFO) << "SetFindAccessibilityNodeInfosResult_003 end"; 1280 } 1281 1282 /** 1283 * @tc.number: GetFocusedWindowId_001 1284 * @tc.name: GetFocusedWindowId 1285 * @tc.desc: Test function GetFocusedWindowId 1286 */ 1287 HWTEST_F(AccessibilitySystemAbilityClientImplTest, GetFocusedWindowId_001, TestSize.Level1) 1288 { 1289 GTEST_LOG_(INFO) << "GetFocusedWindowId_001 start"; 1290 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 1291 if (!impl_) { 1292 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 1293 } else { 1294 int32_t windowId = 0; 1295 impl_->GetFocusedWindowId(windowId); 1296 EXPECT_NE(impl_.get(), nullptr); 1297 } 1298 impl_ = nullptr; 1299 GTEST_LOG_(INFO) << "GetFocusedWindowId_001 end"; 1300 } 1301 1302 /** 1303 * @tc.number: LoadAccessibilityService_001 1304 * @tc.name: LoadAccessibilityService 1305 * @tc.desc: Test function LoadAccessibilityService (false) 1306 */ 1307 HWTEST_F(AccessibilitySystemAbilityClientImplTest, LoadAccessibilityService_001, TestSize.Level1) 1308 { 1309 GTEST_LOG_(INFO) << "LoadAccessibilityService_001 start"; 1310 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 1311 if (!impl_) { 1312 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 1313 } else { 1314 EXPECT_EQ(false, impl_->LoadAccessibilityService()); 1315 } 1316 impl_ = nullptr; 1317 GTEST_LOG_(INFO) << "LoadAccessibilityService_001 end"; 1318 } 1319 1320 /** 1321 * @tc.number: LoadSystemAbilitySuccess_001 1322 * @tc.name: LoadSystemAbilitySuccess 1323 * @tc.desc: Test function LoadSystemAbilitySuccess 1324 */ 1325 HWTEST_F(AccessibilitySystemAbilityClientImplTest, LoadSystemAbilitySuccess_001, TestSize.Level1) 1326 { 1327 GTEST_LOG_(INFO) << "LoadSystemAbilitySuccess_001 start"; 1328 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 1329 if (!impl_) { 1330 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 1331 } else { 1332 sptr<IRemoteObject> object; 1333 impl_->LoadSystemAbilitySuccess(object); 1334 EXPECT_NE(impl_.get(), nullptr); 1335 } 1336 impl_ = nullptr; 1337 GTEST_LOG_(INFO) << "LoadSystemAbilitySuccess_001 end"; 1338 } 1339 1340 /** 1341 * @tc.number: LoadSystemAbilitySuccess_002 1342 * @tc.name: LoadSystemAbilitySuccess 1343 * @tc.desc: Test function LoadSystemAbilitySuccess 1344 */ 1345 HWTEST_F(AccessibilitySystemAbilityClientImplTest, LoadSystemAbilitySuccess_002, TestSize.Level1) 1346 { 1347 GTEST_LOG_(INFO) << "LoadSystemAbilitySuccess_002 start"; 1348 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 1349 if (!impl_) { 1350 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 1351 } else { 1352 impl_->LoadSystemAbilitySuccess(nullptr); 1353 EXPECT_NE(impl_.get(), nullptr); 1354 } 1355 impl_ = nullptr; 1356 GTEST_LOG_(INFO) << "LoadSystemAbilitySuccess_002 end"; 1357 } 1358 1359 /** 1360 * @tc.number: LoadSystemAbilityFail_001 1361 * @tc.name: LoadSystemAbilityFail 1362 * @tc.desc: Test function LoadSystemAbilityFail 1363 */ 1364 HWTEST_F(AccessibilitySystemAbilityClientImplTest, LoadSystemAbilityFail_001, TestSize.Level1) 1365 { 1366 GTEST_LOG_(INFO) << "LoadSystemAbilityFail_001 start"; 1367 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 1368 if (!impl_) { 1369 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 1370 } else { 1371 impl_->LoadSystemAbilityFail(); 1372 EXPECT_NE(impl_.get(), nullptr); 1373 } 1374 impl_ = nullptr; 1375 GTEST_LOG_(INFO) << "LoadSystemAbilityFail_001 end"; 1376 } 1377 1378 /** 1379 * @tc.number: Init_001 1380 * @tc.name: Init 1381 * @tc.desc: Test function Init AccessibilitySystemAbilityClientImpl 1382 */ 1383 HWTEST_F(AccessibilitySystemAbilityClientImplTest, Init_001, TestSize.Level1) 1384 { 1385 GTEST_LOG_(INFO) << "Init_001 start"; 1386 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 1387 if (!impl_) { 1388 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 1389 } else { 1390 impl_->LoadSystemAbilityFail(); 1391 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 1392 EXPECT_NE(impl_.get(), nullptr); 1393 } 1394 impl_ = nullptr; 1395 GTEST_LOG_(INFO) << "Init_001 end"; 1396 } 1397 1398 /** 1399 * @tc.number: CheckEventType_001 1400 * @tc.name: CheckEventType 1401 * @tc.desc: Test function CheckEventType SendEvent (false: TYPE_VIEW_INVALID) 1402 */ 1403 HWTEST_F(AccessibilitySystemAbilityClientImplTest, CheckEventType_001, TestSize.Level1) 1404 { 1405 GTEST_LOG_(INFO) << "CheckEventType_001 start"; 1406 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 1407 if (!impl_) { 1408 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 1409 } else { 1410 EventType eventType = TYPE_VIEW_INVALID; 1411 EXPECT_EQ(RET_ERR_INVALID_PARAM, impl_->SendEvent(eventType, 0)); 1412 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 1413 } 1414 impl_ = nullptr; 1415 GTEST_LOG_(INFO) << "CheckEventType_001 end"; 1416 } 1417 1418 /** 1419 * @tc.number: CheckEventType_002 1420 * @tc.name: CheckEventType 1421 * @tc.desc: Test function CheckEventType SendEvent (false: TYPE_MAX_NUM) 1422 */ 1423 HWTEST_F(AccessibilitySystemAbilityClientImplTest, CheckEventType_002, TestSize.Level1) 1424 { 1425 GTEST_LOG_(INFO) << "CheckEventType_002 start"; 1426 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 1427 if (!impl_) { 1428 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 1429 } else { 1430 EventType eventType = TYPE_MAX_NUM; 1431 EXPECT_EQ(RET_ERR_INVALID_PARAM, impl_->SendEvent(eventType, 0)); 1432 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 1433 } 1434 impl_ = nullptr; 1435 GTEST_LOG_(INFO) << "CheckEventType_002 end"; 1436 } 1437 1438 /** 1439 * @tc.number: CheckEventType_003 1440 * @tc.name: CheckEventType 1441 * @tc.desc: Test function CheckEventType SendEvent (false: TYPE_VIEW_FOCUSED_EVENT) 1442 */ 1443 HWTEST_F(AccessibilitySystemAbilityClientImplTest, CheckEventType_003, TestSize.Level1) 1444 { 1445 GTEST_LOG_(INFO) << "CheckEventType_003 start"; 1446 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 1447 if (!impl_) { 1448 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 1449 } else { 1450 EventType eventType = TYPE_VIEW_FOCUSED_EVENT; 1451 EXPECT_EQ(RET_ERR_SAMGR, impl_->SendEvent(eventType, 0)); 1452 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 1453 } 1454 impl_ = nullptr; 1455 GTEST_LOG_(INFO) << "CheckEventType_003 end"; 1456 } 1457 1458 /** 1459 * @tc.number: CheckEventType_004 1460 * @tc.name: CheckEventType 1461 * @tc.desc: Test function CheckEventType SendEvent (false: TYPE_PAGE_STATE_UPDATE) 1462 */ 1463 HWTEST_F(AccessibilitySystemAbilityClientImplTest, CheckEventType_004, TestSize.Level1) 1464 { 1465 GTEST_LOG_(INFO) << "CheckEventType_004 start"; 1466 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 1467 if (!impl_) { 1468 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 1469 } else { 1470 EventType eventType = TYPE_PAGE_STATE_UPDATE; 1471 EXPECT_EQ(RET_ERR_SAMGR, impl_->SendEvent(eventType, 0)); 1472 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 1473 } 1474 impl_ = nullptr; 1475 GTEST_LOG_(INFO) << "CheckEventType_004 end"; 1476 } 1477 1478 /** 1479 * @tc.number: CheckEventType_005 1480 * @tc.name: CheckEventType 1481 * @tc.desc: Test function CheckEventType SendEvent (false: TYPE_VIEW_SCROLLED_EVENT) 1482 */ 1483 HWTEST_F(AccessibilitySystemAbilityClientImplTest, CheckEventType_005, TestSize.Level1) 1484 { 1485 GTEST_LOG_(INFO) << "CheckEventType_005 start"; 1486 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 1487 if (!impl_) { 1488 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 1489 } else { 1490 EventType eventType = TYPE_VIEW_SCROLLED_EVENT; 1491 EXPECT_EQ(RET_ERR_SAMGR, impl_->SendEvent(eventType, 0)); 1492 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 1493 } 1494 impl_ = nullptr; 1495 GTEST_LOG_(INFO) << "CheckEventType_005 end"; 1496 } 1497 1498 /** 1499 * @tc.number: SetSplicElementIdTreeId_001 1500 * @tc.name: SetSplicElementIdTreeId 1501 * @tc.desc: Test function SetSplicElementIdTreeId 1502 */ 1503 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetSplicElementIdTreeId_001, TestSize.Level1) 1504 { 1505 GTEST_LOG_(INFO) << "SetSplicElementIdTreeId_001 start"; 1506 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 1507 if (!impl_) { 1508 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 1509 } else { 1510 int64_t elementId = 0; 1511 impl_->SetSplicElementIdTreeId(1, elementId); 1512 EXPECT_NE(elementId, 0); 1513 } 1514 impl_ = nullptr; 1515 GTEST_LOG_(INFO) << "SetSplicElementIdTreeId_001 end"; 1516 } 1517 1518 /** 1519 * @tc.number: GetTreeIdAndElementIdBySplitElementId_001 1520 * @tc.name: GetTreeIdAndElementIdBySplitElementId 1521 * @tc.desc: Test function GetTreeIdAndElementIdBySplitElementId 1522 */ 1523 HWTEST_F(AccessibilitySystemAbilityClientImplTest, GetTreeIdAndElementIdBySplitElementId_001, TestSize.Level1) 1524 { 1525 GTEST_LOG_(INFO) << "GetTreeIdAndElementIdBySplitElementId_001 start"; 1526 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 1527 if (!impl_) { 1528 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 1529 } else { 1530 int64_t splitElementId; 1531 int32_t splitTreeId; 1532 impl_->GetTreeIdAndElementIdBySplitElementId(-1, splitElementId, splitTreeId); 1533 EXPECT_EQ(splitElementId, -1); 1534 EXPECT_EQ(splitTreeId, -1); 1535 impl_->GetTreeIdAndElementIdBySplitElementId(1, splitElementId, splitTreeId); 1536 EXPECT_EQ(splitElementId, 1); 1537 EXPECT_EQ(splitTreeId, 0); 1538 } 1539 impl_ = nullptr; 1540 GTEST_LOG_(INFO) << "GetTreeIdAndElementIdBySplitElementId_001 end"; 1541 } 1542 1543 /** 1544 * @tc.number: SetSearchElementInfoBySpecificPropertyResult_001 1545 * @tc.name: SetSearchElementInfoBySpecificPropertyResult 1546 * @tc.desc: Test function SetSearchElementInfoBySpecificPropertyResult(success) 1547 */ 1548 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetSearchElementInfoBySpecificPropertyResult_001, TestSize.Level1) 1549 { 1550 GTEST_LOG_(INFO) << "SetSearchElementInfoBySpecificPropertyResult_001 start"; 1551 AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(true); 1552 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 1553 AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(false); 1554 if (!impl_) { 1555 GTEST_LOG_(INFO) << "SetSearchElementInfoBySpecificPropertyResult_001" 1556 "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 1557 } else { 1558 std::shared_ptr<AccessibilityElementOperator> mockOperator 1559 = std::make_shared<MockAccessibilityElementOperator>(); 1560 EXPECT_EQ(0, impl_->RegisterElementOperator(WINDOW_ID, mockOperator)); 1561 int32_t requestId = REQUEST_ID; 1562 requestId |= static_cast<uint32_t>(WINDOW_ID) << WINDOW_ID_MASK; 1563 std::list<AccessibilityElementInfo> infos; 1564 std::list<AccessibilityElementInfo> treeInfos; 1565 impl_->SetSearchElementInfoBySpecificPropertyResult(infos, treeInfos, requestId); 1566 EXPECT_EQ(0, infos.size()); 1567 EXPECT_EQ(0, treeInfos.size()); 1568 } 1569 impl_ = nullptr; 1570 GTEST_LOG_(INFO) << "SetSearchElementInfoBySpecificPropertyResult_001 end"; 1571 } 1572 1573 /** 1574 * @tc.number: SetSearchElementInfoBySpecificPropertyResult_002 1575 * @tc.name: SetSearchElementInfoBySpecificPropertyResult 1576 * @tc.desc: Test function SetSearchElementInfoBySpecificPropertyResult(no operator) 1577 */ 1578 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetSearchElementInfoBySpecificPropertyResult_002, TestSize.Level1) 1579 { 1580 GTEST_LOG_(INFO) << "SetSearchElementInfoBySpecificPropertyResult_002 start"; 1581 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 1582 if (!impl_) { 1583 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 1584 } else { 1585 int32_t requestId = REQUEST_ID; 1586 requestId |= static_cast<uint32_t>(WINDOW_ID) << WINDOW_ID_MASK; 1587 std::list<AccessibilityElementInfo> infos; 1588 std::list<AccessibilityElementInfo> treeInfos; 1589 impl_->SetSearchElementInfoBySpecificPropertyResult(infos, treeInfos, requestId); 1590 EXPECT_EQ(0, infos.size()); 1591 EXPECT_EQ(0, treeInfos.size()); 1592 } 1593 impl_ = nullptr; 1594 GTEST_LOG_(INFO) << "SetSearchElementInfoBySpecificPropertyResult_002 end"; 1595 } 1596 1597 /** 1598 * @tc.number: SetSearchElementInfoBySpecificPropertyResult_003 1599 * @tc.name: SetSearchElementInfoBySpecificPropertyResult 1600 * @tc.desc: Test function SetSearchElementInfoBySpecificPropertyResult(invalid requestId) 1601 */ 1602 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetSearchElementInfoBySpecificPropertyResult_003, TestSize.Level1) 1603 { 1604 GTEST_LOG_(INFO) << "SetSearchElementInfoBySpecificPropertyResult_003 start"; 1605 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 1606 if (!impl_) { 1607 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 1608 } else { 1609 std::list<AccessibilityElementInfo> infos; 1610 std::list<AccessibilityElementInfo> treeInfos; 1611 impl_->SetSearchElementInfoBySpecificPropertyResult(infos, treeInfos, -1); 1612 EXPECT_EQ(0, infos.size()); 1613 EXPECT_EQ(0, treeInfos.size()); 1614 } 1615 impl_ = nullptr; 1616 GTEST_LOG_(INFO) << "SetSearchElementInfoBySpecificPropertyResult_003 end"; 1617 } 1618 1619 /** 1620 * @tc.number: SetSearchElementInfoBySpecificPropertyResult_004 1621 * @tc.name: SetSearchElementInfoBySpecificPropertyResult 1622 * @tc.desc: Test function SetSearchElementInfoBySpecificPropertyResult with serviceProxy_ is nullptr 1623 */ 1624 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetSearchElementInfoBySpecificPropertyResult_004, TestSize.Level1) 1625 { 1626 GTEST_LOG_(INFO) << "SetSearchElementInfoBySpecificPropertyResult_004 start"; 1627 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 1628 ASSERT_TRUE(impl_); 1629 std::list<AccessibilityElementInfo> infos; 1630 std::list<AccessibilityElementInfo> treeInfos; 1631 int32_t requestId = REQUEST_ID; 1632 impl_->SetSearchElementInfoBySpecificPropertyResult(infos, treeInfos, requestId); 1633 EXPECT_EQ(0, infos.size()); 1634 EXPECT_EQ(0, treeInfos.size()); 1635 impl_ = nullptr; 1636 GTEST_LOG_(INFO) << "SetSearchElementInfoBySpecificPropertyResult_004 end"; 1637 } 1638 1639 /** 1640 * @tc.number: SetSearchElementInfoBySpecificPropertyResult_005 1641 * @tc.name: SetSearchElementInfoBySpecificPropertyResult 1642 * @tc.desc: Test function SetSearchElementInfoBySpecificPropertyResult with callback nullptr 1643 */ 1644 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetSearchElementInfoBySpecificPropertyResult_005, TestSize.Level1) 1645 { 1646 GTEST_LOG_(INFO) << "SetSearchElementInfoBySpecificPropertyResult_005 start"; 1647 AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(true); 1648 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 1649 AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(false); 1650 ASSERT_TRUE(impl_); 1651 std::list<AccessibilityElementInfo> infos; 1652 std::list<AccessibilityElementInfo> treeInfos; 1653 AccessibilityElementInfo info; 1654 infos.push_back(info); 1655 int32_t requestId = 99999; 1656 impl_->SetSearchElementInfoBySpecificPropertyResult(infos, treeInfos, requestId); 1657 EXPECT_EQ(1, infos.size()); 1658 EXPECT_EQ(0, treeInfos.size()); 1659 impl_ = nullptr; 1660 GTEST_LOG_(INFO) << "SetSearchElementInfoBySpecificPropertyResult_005 end"; 1661 } 1662 } // namespace Accessibility 1663 } // namespace OHOS