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 int32_t COMPONENT_ID = 1; 31 constexpr uint32_t WINDOW_ID_MASK = 16; 32 } // namespace 33 34 class AccessibilitySystemAbilityClientImplTest : public ::testing::Test { 35 public: AccessibilitySystemAbilityClientImplTest()36 AccessibilitySystemAbilityClientImplTest() 37 {} ~AccessibilitySystemAbilityClientImplTest()38 ~AccessibilitySystemAbilityClientImplTest() 39 {} 40 std::shared_ptr<AccessibilitySystemAbilityClientImpl> impl_ = nullptr; 41 SetUpTestCase()42 static void SetUpTestCase() 43 { 44 GTEST_LOG_(INFO) << "AccessibilitySystemAbilityClientImplTest Start"; 45 } TearDownTestCase()46 static void TearDownTestCase() 47 { 48 GTEST_LOG_(INFO) << "AccessibilitySystemAbilityClientImplTest End"; 49 } SetUp()50 void SetUp() 51 { 52 GTEST_LOG_(INFO) << "AccessibilitySystemAbilityClientImplTest SetUp()"; 53 }; TearDown()54 void TearDown() 55 { 56 GTEST_LOG_(INFO) << "AccessibilitySystemAbilityClientImplTest TearDown()"; 57 } 58 }; 59 60 61 /** 62 * @tc.number: RegisterElementOperator_001 63 * @tc.name: RegisterElementOperator 64 * @tc.desc: Test function RegisterElementOperator(parameter is null) 65 */ 66 HWTEST_F(AccessibilitySystemAbilityClientImplTest, RegisterElementOperator_001, TestSize.Level1) 67 { 68 GTEST_LOG_(INFO) << "RegisterElementOperator_001 start"; 69 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 70 if (!impl_) { 71 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 72 return; 73 } 74 EXPECT_EQ(RET_ERR_INVALID_PARAM, impl_->RegisterElementOperator(WINDOW_ID, nullptr)); 75 impl_ = nullptr; 76 GTEST_LOG_(INFO) << "RegisterElementOperator_001 end"; 77 } 78 79 /** 80 * @tc.number: RegisterElementOperator_002 81 * @tc.name: RegisterElementOperator 82 * @tc.desc: Test function RegisterElementOperator(parameter is not null, proxy is null) 83 */ 84 HWTEST_F(AccessibilitySystemAbilityClientImplTest, RegisterElementOperator_002, TestSize.Level1) 85 { 86 GTEST_LOG_(INFO) << "RegisterElementOperator_002 start"; 87 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 88 if (!impl_) { 89 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 90 return; 91 } 92 std::shared_ptr<AccessibilityElementOperator> mockOperator = std::make_shared<MockAccessibilityElementOperator>(); 93 EXPECT_EQ(RET_ERR_SAMGR, impl_->RegisterElementOperator(WINDOW_ID, mockOperator)); 94 impl_ = nullptr; 95 GTEST_LOG_(INFO) << "RegisterElementOperator_002 end"; 96 } 97 98 /** 99 * @tc.number: RegisterElementOperator_003 100 * @tc.name: RegisterElementOperator 101 * @tc.desc: Test function RegisterElementOperator(register success) 102 */ 103 HWTEST_F(AccessibilitySystemAbilityClientImplTest, RegisterElementOperator_003, TestSize.Level1) 104 { 105 GTEST_LOG_(INFO) << "RegisterElementOperator_003 start"; 106 AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(true); 107 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 108 AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(false); 109 if (!impl_) { 110 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 111 return; 112 } 113 std::shared_ptr<AccessibilityElementOperator> mockOperator = std::make_shared<MockAccessibilityElementOperator>(); 114 EXPECT_EQ(RET_OK, impl_->RegisterElementOperator(WINDOW_ID, mockOperator)); 115 impl_ = nullptr; 116 GTEST_LOG_(INFO) << "RegisterElementOperator_003 end"; 117 } 118 119 /** 120 * @tc.number: RegisterElementOperator_004 121 * @tc.name: RegisterElementOperator 122 * @tc.desc: Test function RegisterElementOperator(register fail) 123 */ 124 HWTEST_F(AccessibilitySystemAbilityClientImplTest, RegisterElementOperator_004, TestSize.Level1) 125 { 126 GTEST_LOG_(INFO) << "RegisterElementOperator_004 start"; 127 AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(true); 128 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 129 AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(false); 130 if (!impl_) { 131 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 132 return; 133 } 134 std::shared_ptr<AccessibilityElementOperator> mockOperator = std::make_shared<MockAccessibilityElementOperator>(); 135 EXPECT_EQ(RET_OK, impl_->RegisterElementOperator(WINDOW_ID, mockOperator)); 136 EXPECT_EQ(RET_ERR_CONNECTION_EXIST, impl_->RegisterElementOperator(WINDOW_ID, mockOperator)); 137 impl_ = nullptr; 138 GTEST_LOG_(INFO) << "RegisterElementOperator_004 end"; 139 } 140 141 /** 142 * @tc.number: DeregisterElementOperator_001 143 * @tc.name: DeregisterElementOperator 144 * @tc.desc: Test function DeregisterElementOperator 145 */ 146 HWTEST_F(AccessibilitySystemAbilityClientImplTest, DeregisterElementOperator_001, TestSize.Level1) 147 { 148 GTEST_LOG_(INFO) << "DeregisterElementOperator_001 start"; 149 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 150 if (!impl_) { 151 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 152 return; 153 } 154 EXPECT_EQ(RET_ERR_SAMGR, impl_->DeregisterElementOperator(WINDOW_ID)); 155 impl_ = nullptr; 156 GTEST_LOG_(INFO) << "DeregisterElementOperator_001 end"; 157 } 158 159 /** 160 * @tc.number: DeregisterElementOperator_002 161 * @tc.name: DeregisterElementOperator 162 * @tc.desc: Test function DeregisterElementOperator 163 */ 164 HWTEST_F(AccessibilitySystemAbilityClientImplTest, DeregisterElementOperator_002, TestSize.Level1) 165 { 166 GTEST_LOG_(INFO) << "DeregisterElementOperator_002 start"; 167 AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(true); 168 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 169 AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(false); 170 if (!impl_) { 171 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 172 return; 173 } 174 std::shared_ptr<AccessibilityElementOperator> mockOperator = std::make_shared<MockAccessibilityElementOperator>(); 175 EXPECT_EQ(RET_OK, impl_->RegisterElementOperator(WINDOW_ID, mockOperator)); 176 EXPECT_EQ(RET_OK, impl_->DeregisterElementOperator(WINDOW_ID)); 177 impl_ = nullptr; 178 GTEST_LOG_(INFO) << "DeregisterElementOperator_002 end"; 179 } 180 181 /** 182 * @tc.number: GetAbilityList_001 183 * @tc.name: GetAbilityList 184 * @tc.desc: Test function GetAbilityList 185 */ 186 HWTEST_F(AccessibilitySystemAbilityClientImplTest, GetAbilityList_001, TestSize.Level1) 187 { 188 GTEST_LOG_(INFO) << "GetAbilityList_001 start"; 189 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 190 if (!impl_) { 191 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 192 return; 193 } 194 195 std::vector<AccessibilityAbilityInfo> infos {}; 196 auto ret = impl_->GetAbilityList(ACCESSIBILITY_ABILITY_TYPE_ALL, ABILITY_STATE_INVALID, infos); 197 EXPECT_EQ(RET_ERR_INVALID_PARAM, ret); 198 impl_ = nullptr; 199 GTEST_LOG_(INFO) << "GetAbilityList_001 end"; 200 } 201 202 /** 203 * @tc.number: GetAbilityList_002 204 * @tc.name: GetAbilityList 205 * @tc.desc: Test function GetAbilityList(proxy is null) 206 */ 207 HWTEST_F(AccessibilitySystemAbilityClientImplTest, GetAbilityList_002, TestSize.Level1) 208 { 209 GTEST_LOG_(INFO) << "GetAbilityList_002 start"; 210 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 211 if (!impl_) { 212 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 213 return; 214 } 215 216 std::vector<AccessibilityAbilityInfo> infos {}; 217 auto ret = impl_->GetAbilityList(ACCESSIBILITY_ABILITY_TYPE_ALL, ABILITY_STATE_ENABLE, infos); 218 EXPECT_EQ(RET_ERR_SAMGR, ret); 219 impl_ = nullptr; 220 GTEST_LOG_(INFO) << "GetAbilityList_002 end"; 221 } 222 223 /** 224 * @tc.number: GetAbilityList_003 225 * @tc.name: GetAbilityList 226 * @tc.desc: Test function GetAbilityList(proxy is not null) 227 */ 228 HWTEST_F(AccessibilitySystemAbilityClientImplTest, GetAbilityList_003, TestSize.Level1) 229 { 230 GTEST_LOG_(INFO) << "GetAbilityList_003 start"; 231 AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(true); 232 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 233 AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(false); 234 if (!impl_) { 235 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 236 return; 237 } 238 239 std::vector<AccessibilityAbilityInfo> infos {}; 240 auto ret = impl_->GetAbilityList(ACCESSIBILITY_ABILITY_TYPE_ALL, ABILITY_STATE_ENABLE, infos); 241 EXPECT_EQ(RET_OK, ret); 242 impl_ = nullptr; 243 GTEST_LOG_(INFO) << "GetAbilityList_003 end"; 244 } 245 246 /** 247 * @tc.number: IsEnabled_001 248 * @tc.name: IsEnabled 249 * @tc.desc: Test function IsEnabled 250 */ 251 HWTEST_F(AccessibilitySystemAbilityClientImplTest, IsEnabled_001, TestSize.Level1) 252 { 253 GTEST_LOG_(INFO) << "IsEnabled_001 start"; 254 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 255 if (!impl_) { 256 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 257 return; 258 } 259 bool isEnable = false; 260 impl_->IsEnabled(isEnable); 261 EXPECT_FALSE(isEnable); 262 impl_ = nullptr; 263 GTEST_LOG_(INFO) << "IsEnabled_001 end"; 264 } 265 266 /** 267 * @tc.number: IsTouchExplorationEnabled_001 268 * @tc.name: IsTouchExplorationEnabled 269 * @tc.desc: Test function IsTouchExplorationEnabled 270 */ 271 HWTEST_F(AccessibilitySystemAbilityClientImplTest, IsTouchExplorationEnabled_001, TestSize.Level1) 272 { 273 GTEST_LOG_(INFO) << "IsTouchExplorationEnabled_001 start"; 274 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 275 if (!impl_) { 276 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 277 return; 278 } 279 bool isEnable = false; 280 impl_->IsTouchExplorationEnabled(isEnable); 281 EXPECT_FALSE(isEnable); 282 impl_ = nullptr; 283 GTEST_LOG_(INFO) << "IsTouchExplorationEnabled_001 end"; 284 } 285 286 /** 287 * @tc.number: SendEvent_001 288 * @tc.name: SendEvent 289 * @tc.desc: Test function SendEvent(proxy is null) 290 */ 291 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SendEvent_001, TestSize.Level1) 292 { 293 GTEST_LOG_(INFO) << "SendEvent_001 start"; 294 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 295 if (!impl_) { 296 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 297 return; 298 } 299 EXPECT_EQ(RET_ERR_SAMGR, impl_->SendEvent(TYPE_VIEW_LONG_CLICKED_EVENT, COMPONENT_ID)); 300 impl_ = nullptr; 301 GTEST_LOG_(INFO) << "SendEvent_001 end"; 302 } 303 304 /** 305 * @tc.number: SendEvent_002 306 * @tc.name: SendEvent 307 * @tc.desc: Test function SendEvent(invalid type) 308 */ 309 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SendEvent_002, TestSize.Level1) 310 { 311 GTEST_LOG_(INFO) << "SendEvent_002 start"; 312 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 313 if (!impl_) { 314 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 315 return; 316 } 317 EXPECT_EQ(RET_ERR_INVALID_PARAM, impl_->SendEvent(TYPE_VIEW_INVALID, COMPONENT_ID)); 318 impl_ = nullptr; 319 GTEST_LOG_(INFO) << "SendEvent_002 end"; 320 } 321 322 /** 323 * @tc.number: SendEvent_003 324 * @tc.name: SendEvent 325 * @tc.desc: Test function SendEvent(proxy is not null) 326 */ 327 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SendEvent_003, TestSize.Level1) 328 { 329 GTEST_LOG_(INFO) << "SendEvent_003 start"; 330 AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(true); 331 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 332 AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(false); 333 if (!impl_) { 334 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 335 return; 336 } 337 EXPECT_EQ(RET_OK, impl_->SendEvent(TYPE_VIEW_LONG_CLICKED_EVENT, COMPONENT_ID)); 338 impl_ = nullptr; 339 GTEST_LOG_(INFO) << "SendEvent_003 end"; 340 } 341 342 /** 343 * @tc.number: SendEvent_004 344 * @tc.name: SendEvent 345 * @tc.desc: Test function SendEvent(proxy is null) 346 */ 347 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SendEvent_004, TestSize.Level1) 348 { 349 GTEST_LOG_(INFO) << "SendEvent_004 start"; 350 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 351 if (!impl_) { 352 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 353 return; 354 } 355 AccessibilityEventInfo event {}; 356 event.SetEventType(TYPE_VIEW_LONG_CLICKED_EVENT); 357 EXPECT_EQ(RET_ERR_SAMGR, impl_->SendEvent(event)); 358 impl_ = nullptr; 359 GTEST_LOG_(INFO) << "SendEvent_004 end"; 360 } 361 362 /** 363 * @tc.number: SendEvent_005 364 * @tc.name: SendEvent 365 * @tc.desc: Test function SendEvent(invalid type) 366 */ 367 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SendEvent_005, TestSize.Level1) 368 { 369 GTEST_LOG_(INFO) << "SendEvent_005 start"; 370 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 371 if (!impl_) { 372 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 373 return; 374 } 375 AccessibilityEventInfo event {}; 376 event.SetEventType(TYPE_VIEW_INVALID); 377 EXPECT_EQ(RET_ERR_INVALID_PARAM, impl_->SendEvent(event)); 378 impl_ = nullptr; 379 GTEST_LOG_(INFO) << "SendEvent_005 end"; 380 } 381 382 /** 383 * @tc.number: SendEvent_006 384 * @tc.name: SendEvent 385 * @tc.desc: Test function SendEvent(proxy is not null) 386 */ 387 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SendEvent_006, TestSize.Level1) 388 { 389 GTEST_LOG_(INFO) << "SendEvent_006 start"; 390 AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(true); 391 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 392 AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(false); 393 if (!impl_) { 394 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 395 return; 396 } 397 AccessibilityEventInfo event {}; 398 event.SetEventType(TYPE_VIEW_LONG_CLICKED_EVENT); 399 EXPECT_EQ(RET_OK, impl_->SendEvent(event)); 400 impl_ = nullptr; 401 GTEST_LOG_(INFO) << "SendEvent_006 end"; 402 } 403 404 /** 405 * @tc.number: SubscribeStateObserver_001 406 * @tc.name: SubscribeStateObserver 407 * @tc.desc: Test function SubscribeStateObserver 408 */ 409 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SubscribeStateObserver_001, TestSize.Level1) 410 { 411 GTEST_LOG_(INFO) << "SubscribeStateObserver_001 start"; 412 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 413 if (!impl_) { 414 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 415 return; 416 } 417 EXPECT_EQ(RET_ERR_INVALID_PARAM, impl_->SubscribeStateObserver(nullptr, EVENT_TOUCH_GUIDE_STATE_CHANGED)); 418 impl_ = nullptr; 419 GTEST_LOG_(INFO) << "SubscribeStateObserver_001 end"; 420 } 421 422 /** 423 * @tc.number: SubscribeStateObserver_002 424 * @tc.name: SubscribeStateObserver 425 * @tc.desc: Test function SubscribeStateObserver 426 */ 427 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SubscribeStateObserver_002, TestSize.Level1) 428 { 429 GTEST_LOG_(INFO) << "SubscribeStateObserver_002 start"; 430 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 431 if (!impl_) { 432 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 433 return; 434 } 435 EXPECT_EQ(RET_ERR_INVALID_PARAM, impl_->SubscribeStateObserver(nullptr, EVENT_TYPE_MAX)); 436 impl_ = nullptr; 437 GTEST_LOG_(INFO) << "SubscribeStateObserver_002 end"; 438 } 439 440 /** 441 * @tc.number: UnsubscribeStateObserver_001 442 * @tc.name: UnsubscribeStateObserver 443 * @tc.desc: Test function UnsubscribeStateObserver(invalid parameter) 444 */ 445 HWTEST_F(AccessibilitySystemAbilityClientImplTest, UnsubscribeStateObserver_001, TestSize.Level1) 446 { 447 GTEST_LOG_(INFO) << "UnsubscribeStateObserver_001 start"; 448 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 449 if (!impl_) { 450 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 451 return; 452 } 453 EXPECT_EQ(RET_ERR_INVALID_PARAM, impl_->UnsubscribeStateObserver(nullptr, EVENT_TYPE_MAX)); 454 impl_ = nullptr; 455 GTEST_LOG_(INFO) << "UnsubscribeStateObserver_001 end"; 456 } 457 458 /** 459 * @tc.number: UnsubscribeStateObserver_002 460 * @tc.name: UnsubscribeStateObserver 461 * @tc.desc: Test function UnsubscribeStateObserver(invalid parameter) 462 */ 463 HWTEST_F(AccessibilitySystemAbilityClientImplTest, UnsubscribeStateObserver_002, TestSize.Level1) 464 { 465 GTEST_LOG_(INFO) << "UnsubscribeStateObserver_002 start"; 466 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 467 if (!impl_) { 468 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 469 return; 470 } 471 EXPECT_EQ(RET_ERR_INVALID_PARAM, impl_->UnsubscribeStateObserver(nullptr, EVENT_KEVEVENT_STATE_CHANGED)); 472 impl_ = nullptr; 473 GTEST_LOG_(INFO) << "UnsubscribeStateObserver_002 end"; 474 } 475 476 /** 477 * @tc.number: ResetService_001 478 * @tc.name: ResetService 479 * @tc.desc: Test function ResetService 480 */ 481 HWTEST_F(AccessibilitySystemAbilityClientImplTest, ResetService_001, TestSize.Level1) 482 { 483 GTEST_LOG_(INFO) << "ResetService_001 start"; 484 AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(true); 485 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 486 AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(false); 487 if (!impl_) { 488 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 489 return; 490 } 491 impl_->ResetService(nullptr); 492 impl_ = nullptr; 493 GTEST_LOG_(INFO) << "ResetService_001 end"; 494 } 495 496 /** 497 * @tc.number: OnAccessibleAbilityManagerStateChanged_001 498 * @tc.name: OnAccessibleAbilityManagerStateChanged 499 * @tc.desc: Test function OnAccessibleAbilityManagerStateChanged 500 */ 501 HWTEST_F(AccessibilitySystemAbilityClientImplTest, OnAccessibleAbilityManagerStateChanged_001, TestSize.Level1) 502 { 503 GTEST_LOG_(INFO) << "OnAccessibleAbilityManagerStateChanged_001 start"; 504 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 505 if (!impl_) { 506 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 507 return; 508 } 509 uint32_t stateType = STATE_ACCESSIBILITY_ENABLED | STATE_EXPLORATION_ENABLED | 510 STATE_KEYEVENT_ENABLED | STATE_GESTURE_ENABLED; 511 impl_->OnAccessibleAbilityManagerStateChanged(stateType); 512 impl_ = nullptr; 513 GTEST_LOG_(INFO) << "OnAccessibleAbilityManagerStateChanged_001 end"; 514 } 515 516 /** 517 * @tc.number: OnAccessibleAbilityManagerStateChanged_002 518 * @tc.name: OnAccessibleAbilityManagerStateChanged 519 * @tc.desc: Test function OnAccessibleAbilityManagerStateChanged 520 */ 521 HWTEST_F(AccessibilitySystemAbilityClientImplTest, OnAccessibleAbilityManagerStateChanged_002, TestSize.Level1) 522 { 523 GTEST_LOG_(INFO) << "OnAccessibleAbilityManagerStateChanged_002 start"; 524 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 525 if (!impl_) { 526 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 527 return; 528 } 529 impl_->OnAccessibleAbilityManagerStateChanged(0); 530 impl_ = nullptr; 531 GTEST_LOG_(INFO) << "OnAccessibleAbilityManagerStateChanged_002 end"; 532 } 533 534 /** 535 * @tc.number: GetEnabledAbilities_001 536 * @tc.name: GetEnabledAbilities 537 * @tc.desc: Test function GetEnabledAbilities 538 */ 539 HWTEST_F(AccessibilitySystemAbilityClientImplTest, GetEnabledAbilities_001, TestSize.Level1) 540 { 541 GTEST_LOG_(INFO) << "GetEnabledAbilities_001 start"; 542 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 543 if (!impl_) { 544 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 545 return; 546 } 547 std::vector<std::string> enabledAbilities; 548 EXPECT_EQ(RET_ERR_SAMGR, impl_->GetEnabledAbilities(enabledAbilities)); 549 impl_ = nullptr; 550 GTEST_LOG_(INFO) << "GetEnabledAbilities_001 end"; 551 } 552 553 /** 554 * @tc.number: GetEnabledAbilities_002 555 * @tc.name: GetEnabledAbilities 556 * @tc.desc: Test function GetEnabledAbilities 557 */ 558 HWTEST_F(AccessibilitySystemAbilityClientImplTest, GetEnabledAbilities_002, TestSize.Level1) 559 { 560 GTEST_LOG_(INFO) << "GetEnabledAbilities_002 start"; 561 AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(true); 562 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 563 AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(false); 564 if (!impl_) { 565 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 566 return; 567 } 568 std::vector<std::string> enabledAbilities; 569 EXPECT_EQ(RET_OK, impl_->GetEnabledAbilities(enabledAbilities)); 570 impl_ = nullptr; 571 GTEST_LOG_(INFO) << "GetEnabledAbilities_002 end"; 572 } 573 574 /** 575 * @tc.number: SetSearchElementInfoByAccessibilityIdResult_001 576 * @tc.name: SetSearchElementInfoByAccessibilityIdResult 577 * @tc.desc: Test function SetSearchElementInfoByAccessibilityIdResult(success) 578 */ 579 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetSearchElementInfoByAccessibilityIdResult_001, TestSize.Level1) 580 { 581 GTEST_LOG_(INFO) << "SetSearchElementInfoByAccessibilityIdResult_001 start"; 582 AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(true); 583 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 584 AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(false); 585 if (!impl_) { 586 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 587 return; 588 } 589 std::shared_ptr<AccessibilityElementOperator> mockOperator = std::make_shared<MockAccessibilityElementOperator>(); 590 EXPECT_EQ(0, impl_->RegisterElementOperator(WINDOW_ID, mockOperator)); 591 int32_t requestId = REQUEST_ID; 592 requestId |= static_cast<uint32_t>(WINDOW_ID) << WINDOW_ID_MASK; 593 std::list<AccessibilityElementInfo> infos; 594 impl_->SetSearchElementInfoByAccessibilityIdResult(infos, requestId); 595 EXPECT_EQ(0, infos.size()); 596 impl_ = nullptr; 597 GTEST_LOG_(INFO) << "SetSearchElementInfoByAccessibilityIdResult_001 end"; 598 } 599 600 /** 601 * @tc.number: SetSearchElementInfoByAccessibilityIdResult_002 602 * @tc.name: SetSearchElementInfoByAccessibilityIdResult 603 * @tc.desc: Test function SetSearchElementInfoByAccessibilityIdResult(no operator) 604 */ 605 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetSearchElementInfoByAccessibilityIdResult_002, TestSize.Level1) 606 { 607 GTEST_LOG_(INFO) << "SetSearchElementInfoByAccessibilityIdResult_002 start"; 608 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 609 if (!impl_) { 610 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 611 return; 612 } 613 int32_t requestId = REQUEST_ID; 614 requestId |= static_cast<uint32_t>(WINDOW_ID) << WINDOW_ID_MASK; 615 std::list<AccessibilityElementInfo> infos; 616 impl_->SetSearchElementInfoByAccessibilityIdResult(infos, requestId); 617 EXPECT_EQ(0, infos.size()); 618 impl_ = nullptr; 619 GTEST_LOG_(INFO) << "SetSearchElementInfoByAccessibilityIdResult_002 end"; 620 } 621 622 /** 623 * @tc.number: SetSearchElementInfoByAccessibilityIdResult_003 624 * @tc.name: SetSearchElementInfoByAccessibilityIdResult 625 * @tc.desc: Test function SetSearchElementInfoByAccessibilityIdResult(invalid requestId) 626 */ 627 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetSearchElementInfoByAccessibilityIdResult_003, TestSize.Level1) 628 { 629 GTEST_LOG_(INFO) << "SetSearchElementInfoByAccessibilityIdResult_003 start"; 630 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 631 if (!impl_) { 632 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 633 return; 634 } 635 std::list<AccessibilityElementInfo> infos; 636 impl_->SetSearchElementInfoByAccessibilityIdResult(infos, -1); 637 EXPECT_EQ(0, infos.size()); 638 impl_ = nullptr; 639 GTEST_LOG_(INFO) << "SetSearchElementInfoByAccessibilityIdResult_003 end"; 640 } 641 642 /** 643 * @tc.number: SetSearchElementInfoByTextResult_001 644 * @tc.name: SetSearchElementInfoByTextResult 645 * @tc.desc: Test function SetSearchElementInfoByTextResult(success) 646 */ 647 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetSearchElementInfoByTextResult_001, TestSize.Level1) 648 { 649 GTEST_LOG_(INFO) << "SetSearchElementInfoByTextResult_001 start"; 650 AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(true); 651 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 652 AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(false); 653 if (!impl_) { 654 GTEST_LOG_(INFO) << "Cann't get SetSearchElementInfoByTextResult_001 impl_"; 655 return; 656 } 657 std::shared_ptr<AccessibilityElementOperator> mockOperator = std::make_shared<MockAccessibilityElementOperator>(); 658 EXPECT_EQ(0, impl_->RegisterElementOperator(WINDOW_ID, mockOperator)); 659 int32_t requestId = REQUEST_ID; 660 requestId |= static_cast<uint32_t>(WINDOW_ID) << WINDOW_ID_MASK; 661 std::list<AccessibilityElementInfo> infos; 662 impl_->SetSearchElementInfoByTextResult(infos, requestId); 663 EXPECT_EQ(0, infos.size()); 664 impl_ = nullptr; 665 GTEST_LOG_(INFO) << "SetSearchElementInfoByTextResult_001 end"; 666 } 667 668 /** 669 * @tc.number: SetSearchElementInfoByTextResult_002 670 * @tc.name: SetSearchElementInfoByTextResult 671 * @tc.desc: Test function SetSearchElementInfoByTextResult(no operator) 672 */ 673 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetSearchElementInfoByTextResult_002, TestSize.Level1) 674 { 675 GTEST_LOG_(INFO) << "SetSearchElementInfoByTextResult_002 start"; 676 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 677 if (!impl_) { 678 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 679 return; 680 } 681 int32_t requestId = REQUEST_ID; 682 requestId |= static_cast<uint32_t>(WINDOW_ID) << WINDOW_ID_MASK; 683 std::list<AccessibilityElementInfo> infos; 684 impl_->SetSearchElementInfoByTextResult(infos, requestId); 685 EXPECT_EQ(0, infos.size()); 686 impl_ = nullptr; 687 GTEST_LOG_(INFO) << "SetSearchElementInfoByTextResult_002 end"; 688 } 689 690 /** 691 * @tc.number: SetSearchElementInfoByTextResult_003 692 * @tc.name: SetSearchElementInfoByTextResult 693 * @tc.desc: Test function SetSearchElementInfoByTextResult(invalid requestId) 694 */ 695 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetSearchElementInfoByTextResult_003, TestSize.Level1) 696 { 697 GTEST_LOG_(INFO) << "SetSearchElementInfoByTextResult_003 start"; 698 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 699 if (!impl_) { 700 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 701 return; 702 } 703 std::list<AccessibilityElementInfo> infos; 704 impl_->SetSearchElementInfoByTextResult(infos, -1); 705 EXPECT_EQ(0, infos.size()); 706 impl_ = nullptr; 707 GTEST_LOG_(INFO) << "SetSearchElementInfoByTextResult_003 end"; 708 } 709 710 /** 711 * @tc.number: SetFindFocusedElementInfoResult_001 712 * @tc.name: SetFindFocusedElementInfoResult 713 * @tc.desc: Test function SetFindFocusedElementInfoResult(success) 714 */ 715 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetFindFocusedElementInfoResult_001, TestSize.Level1) 716 { 717 GTEST_LOG_(INFO) << "SetFindFocusedElementInfoResult_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) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 723 return; 724 } 725 std::shared_ptr<AccessibilityElementOperator> mockOperator = std::make_shared<MockAccessibilityElementOperator>(); 726 EXPECT_EQ(0, impl_->RegisterElementOperator(WINDOW_ID, mockOperator)); 727 int32_t requestId = REQUEST_ID; 728 requestId |= static_cast<uint32_t>(WINDOW_ID) << WINDOW_ID_MASK; 729 AccessibilityElementInfo info; 730 impl_->SetFindFocusedElementInfoResult(info, requestId); 731 impl_ = nullptr; 732 GTEST_LOG_(INFO) << "SetFindFocusedElementInfoResult_001 end"; 733 } 734 735 /** 736 * @tc.number: SetFindFocusedElementInfoResult_002 737 * @tc.name: SetFindFocusedElementInfoResult 738 * @tc.desc: Test function SetFindFocusedElementInfoResult(no operator) 739 */ 740 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetFindFocusedElementInfoResult_002, TestSize.Level1) 741 { 742 GTEST_LOG_(INFO) << "SetFindFocusedElementInfoResult_002 start"; 743 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 744 if (!impl_) { 745 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 746 return; 747 } 748 int32_t requestId = REQUEST_ID; 749 requestId |= static_cast<uint32_t>(WINDOW_ID) << WINDOW_ID_MASK; 750 AccessibilityElementInfo info; 751 impl_->SetFindFocusedElementInfoResult(info, requestId); 752 impl_ = nullptr; 753 GTEST_LOG_(INFO) << "SetFindFocusedElementInfoResult_002 end"; 754 } 755 756 /** 757 * @tc.number: SetFindFocusedElementInfoResult_003 758 * @tc.name: SetFindFocusedElementInfoResult 759 * @tc.desc: Test function SetFindFocusedElementInfoResult(invalid requestId) 760 */ 761 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetFindFocusedElementInfoResult_003, TestSize.Level1) 762 { 763 GTEST_LOG_(INFO) << "SetFindFocusedElementInfoResult_003 start"; 764 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 765 if (!impl_) { 766 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 767 return; 768 } 769 AccessibilityElementInfo info; 770 impl_->SetFindFocusedElementInfoResult(info, -1); 771 impl_ = nullptr; 772 GTEST_LOG_(INFO) << "SetFindFocusedElementInfoResult_003 end"; 773 } 774 775 /** 776 * @tc.number: SetFocusMoveSearchResult_001 777 * @tc.name: SetFocusMoveSearchResult 778 * @tc.desc: Test function SetFocusMoveSearchResult(success) 779 */ 780 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetFocusMoveSearchResult_001, TestSize.Level1) 781 { 782 GTEST_LOG_(INFO) << "SetFocusMoveSearchResult_001 start"; 783 AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(true); 784 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 785 AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(false); 786 if (!impl_) { 787 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 788 return; 789 } 790 std::shared_ptr<AccessibilityElementOperator> mockOperator = std::make_shared<MockAccessibilityElementOperator>(); 791 EXPECT_EQ(0, impl_->RegisterElementOperator(WINDOW_ID, mockOperator)); 792 int32_t requestId = REQUEST_ID; 793 requestId |= static_cast<uint32_t>(WINDOW_ID) << WINDOW_ID_MASK; 794 AccessibilityElementInfo info; 795 impl_->SetFocusMoveSearchResult(info, requestId); 796 impl_ = nullptr; 797 GTEST_LOG_(INFO) << "SetFocusMoveSearchResult_001 end"; 798 } 799 800 /** 801 * @tc.number: SetFocusMoveSearchResult_002 802 * @tc.name: SetFocusMoveSearchResult 803 * @tc.desc: Test function SetFocusMoveSearchResult(no operator) 804 */ 805 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetFocusMoveSearchResult_002, TestSize.Level1) 806 { 807 GTEST_LOG_(INFO) << "SetFocusMoveSearchResult_002 start"; 808 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 809 if (!impl_) { 810 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 811 return; 812 } 813 int32_t requestId = REQUEST_ID; 814 requestId |= static_cast<uint32_t>(WINDOW_ID) << WINDOW_ID_MASK; 815 AccessibilityElementInfo info; 816 impl_->SetFocusMoveSearchResult(info, requestId); 817 impl_ = nullptr; 818 GTEST_LOG_(INFO) << "SetFocusMoveSearchResult_002 end"; 819 } 820 821 /** 822 * @tc.number: SetFocusMoveSearchResult_003 823 * @tc.name: SetFocusMoveSearchResult 824 * @tc.desc: Test function SetFocusMoveSearchResult(invalid requestId) 825 */ 826 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetFocusMoveSearchResult_003, TestSize.Level1) 827 { 828 GTEST_LOG_(INFO) << "SetFocusMoveSearchResult_003 start"; 829 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 830 if (!impl_) { 831 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 832 return; 833 } 834 AccessibilityElementInfo info; 835 impl_->SetFocusMoveSearchResult(info, -1); 836 impl_ = nullptr; 837 GTEST_LOG_(INFO) << "SetFocusMoveSearchResult_003 end"; 838 } 839 840 /** 841 * @tc.number: SetExecuteActionResult_001 842 * @tc.name: SetExecuteActionResult 843 * @tc.desc: Test function SetExecuteActionResult(success) 844 */ 845 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetExecuteActionResult_001, TestSize.Level1) 846 { 847 GTEST_LOG_(INFO) << "SetExecuteActionResult_001 start"; 848 AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(true); 849 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 850 AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(false); 851 if (!impl_) { 852 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 853 return; 854 } 855 std::shared_ptr<AccessibilityElementOperator> mockOperator = std::make_shared<MockAccessibilityElementOperator>(); 856 EXPECT_EQ(0, impl_->RegisterElementOperator(WINDOW_ID, mockOperator)); 857 int32_t requestId = REQUEST_ID; 858 requestId |= static_cast<uint32_t>(WINDOW_ID) << WINDOW_ID_MASK; 859 impl_->SetExecuteActionResult(true, requestId); 860 impl_ = nullptr; 861 GTEST_LOG_(INFO) << "SetExecuteActionResult_001 end"; 862 } 863 864 /** 865 * @tc.number: SetExecuteActionResult_002 866 * @tc.name: SetExecuteActionResult 867 * @tc.desc: Test function SetExecuteActionResult(no operator) 868 */ 869 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetExecuteActionResult_002, TestSize.Level1) 870 { 871 GTEST_LOG_(INFO) << "SetExecuteActionResult_002 start"; 872 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 873 if (!impl_) { 874 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 875 return; 876 } 877 int32_t requestId = REQUEST_ID; 878 requestId |= static_cast<uint32_t>(WINDOW_ID) << WINDOW_ID_MASK; 879 impl_->SetExecuteActionResult(true, requestId); 880 impl_ = nullptr; 881 GTEST_LOG_(INFO) << "SetExecuteActionResult_002 end"; 882 } 883 884 /** 885 * @tc.number: SetExecuteActionResult_003 886 * @tc.name: SetExecuteActionResult 887 * @tc.desc: Test function SetExecuteActionResult(invalid requestId) 888 */ 889 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetExecuteActionResult_003, TestSize.Level1) 890 { 891 GTEST_LOG_(INFO) << "SetExecuteActionResult_003 start"; 892 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 893 if (!impl_) { 894 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 895 return; 896 } 897 impl_->SetExecuteActionResult(true, -1); 898 impl_ = nullptr; 899 GTEST_LOG_(INFO) << "SetExecuteActionResult_003 end"; 900 } 901 } // namespace Accessibility 902 } // namespace OHOS