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: SendEvent_007 406 * @tc.name: SendEvent 407 * @tc.desc: Test function SendEvent(proxy is null) 408 */ 409 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SendEvent_007, TestSize.Level1) 410 { 411 GTEST_LOG_(INFO) << "SendEvent_007 start"; 412 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 413 if (!impl_) { 414 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 415 return; 416 } 417 AccessibilityEventInfo event {}; 418 event.SetEventType(TYPE_VIEW_FOCUSED_EVENT); 419 EXPECT_EQ(RET_ERR_SAMGR, impl_->SendEvent(event)); 420 impl_ = nullptr; 421 GTEST_LOG_(INFO) << "SendEvent_007 end"; 422 } 423 424 /** 425 * @tc.number: SubscribeStateObserver_001 426 * @tc.name: SubscribeStateObserver 427 * @tc.desc: Test function SubscribeStateObserver 428 */ 429 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SubscribeStateObserver_001, TestSize.Level1) 430 { 431 GTEST_LOG_(INFO) << "SubscribeStateObserver_001 start"; 432 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 433 if (!impl_) { 434 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 435 return; 436 } 437 EXPECT_EQ(RET_ERR_INVALID_PARAM, impl_->SubscribeStateObserver(nullptr, EVENT_TOUCH_GUIDE_STATE_CHANGED)); 438 impl_ = nullptr; 439 GTEST_LOG_(INFO) << "SubscribeStateObserver_001 end"; 440 } 441 442 /** 443 * @tc.number: SubscribeStateObserver_002 444 * @tc.name: SubscribeStateObserver 445 * @tc.desc: Test function SubscribeStateObserver 446 */ 447 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SubscribeStateObserver_002, TestSize.Level1) 448 { 449 GTEST_LOG_(INFO) << "SubscribeStateObserver_002 start"; 450 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 451 if (!impl_) { 452 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 453 return; 454 } 455 EXPECT_EQ(RET_ERR_INVALID_PARAM, impl_->SubscribeStateObserver(nullptr, EVENT_TYPE_MAX)); 456 impl_ = nullptr; 457 GTEST_LOG_(INFO) << "SubscribeStateObserver_002 end"; 458 } 459 460 /** 461 * @tc.number: UnsubscribeStateObserver_001 462 * @tc.name: UnsubscribeStateObserver 463 * @tc.desc: Test function UnsubscribeStateObserver(invalid parameter) 464 */ 465 HWTEST_F(AccessibilitySystemAbilityClientImplTest, UnsubscribeStateObserver_001, TestSize.Level1) 466 { 467 GTEST_LOG_(INFO) << "UnsubscribeStateObserver_001 start"; 468 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 469 if (!impl_) { 470 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 471 return; 472 } 473 EXPECT_EQ(RET_ERR_INVALID_PARAM, impl_->UnsubscribeStateObserver(nullptr, EVENT_TYPE_MAX)); 474 impl_ = nullptr; 475 GTEST_LOG_(INFO) << "UnsubscribeStateObserver_001 end"; 476 } 477 478 /** 479 * @tc.number: UnsubscribeStateObserver_002 480 * @tc.name: UnsubscribeStateObserver 481 * @tc.desc: Test function UnsubscribeStateObserver(invalid parameter) 482 */ 483 HWTEST_F(AccessibilitySystemAbilityClientImplTest, UnsubscribeStateObserver_002, TestSize.Level1) 484 { 485 GTEST_LOG_(INFO) << "UnsubscribeStateObserver_002 start"; 486 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 487 if (!impl_) { 488 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 489 return; 490 } 491 EXPECT_EQ(RET_ERR_INVALID_PARAM, impl_->UnsubscribeStateObserver(nullptr, EVENT_KEVEVENT_STATE_CHANGED)); 492 impl_ = nullptr; 493 GTEST_LOG_(INFO) << "UnsubscribeStateObserver_002 end"; 494 } 495 496 /** 497 * @tc.number: ResetService_001 498 * @tc.name: ResetService 499 * @tc.desc: Test function ResetService 500 */ 501 HWTEST_F(AccessibilitySystemAbilityClientImplTest, ResetService_001, TestSize.Level1) 502 { 503 GTEST_LOG_(INFO) << "ResetService_001 start"; 504 AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(true); 505 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 506 AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(false); 507 if (!impl_) { 508 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 509 return; 510 } 511 impl_->ResetService(nullptr); 512 EXPECT_NE(impl_.get(), nullptr); 513 impl_ = nullptr; 514 GTEST_LOG_(INFO) << "ResetService_001 end"; 515 } 516 517 /** 518 * @tc.number: ResetService_002 519 * @tc.name: ResetService 520 * @tc.desc: Test function ResetService 521 */ 522 HWTEST_F(AccessibilitySystemAbilityClientImplTest, ResetService_002, TestSize.Level1) 523 { 524 GTEST_LOG_(INFO) << "ResetService_002 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 return; 531 } 532 wptr<IRemoteObject> object; 533 impl_->ResetService(object); 534 EXPECT_NE(impl_.get(), nullptr); 535 impl_ = nullptr; 536 GTEST_LOG_(INFO) << "ResetService_002 end"; 537 } 538 539 /** 540 * @tc.number: OnAccessibleAbilityManagerStateChanged_001 541 * @tc.name: OnAccessibleAbilityManagerStateChanged 542 * @tc.desc: Test function OnAccessibleAbilityManagerStateChanged 543 */ 544 HWTEST_F(AccessibilitySystemAbilityClientImplTest, OnAccessibleAbilityManagerStateChanged_001, TestSize.Level1) 545 { 546 GTEST_LOG_(INFO) << "OnAccessibleAbilityManagerStateChanged_001 start"; 547 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 548 if (!impl_) { 549 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 550 return; 551 } 552 uint32_t stateType = STATE_ACCESSIBILITY_ENABLED | STATE_EXPLORATION_ENABLED | 553 STATE_KEYEVENT_ENABLED | STATE_GESTURE_ENABLED; 554 impl_->OnAccessibleAbilityManagerStateChanged(stateType); 555 EXPECT_NE(impl_.get(), nullptr); 556 impl_ = nullptr; 557 GTEST_LOG_(INFO) << "OnAccessibleAbilityManagerStateChanged_001 end"; 558 } 559 560 /** 561 * @tc.number: OnAccessibleAbilityManagerStateChanged_002 562 * @tc.name: OnAccessibleAbilityManagerStateChanged 563 * @tc.desc: Test function OnAccessibleAbilityManagerStateChanged 564 */ 565 HWTEST_F(AccessibilitySystemAbilityClientImplTest, OnAccessibleAbilityManagerStateChanged_002, TestSize.Level1) 566 { 567 GTEST_LOG_(INFO) << "OnAccessibleAbilityManagerStateChanged_002 start"; 568 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 569 if (!impl_) { 570 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 571 return; 572 } 573 impl_->OnAccessibleAbilityManagerStateChanged(0); 574 EXPECT_NE(impl_.get(), nullptr); 575 impl_ = nullptr; 576 GTEST_LOG_(INFO) << "OnAccessibleAbilityManagerStateChanged_002 end"; 577 } 578 579 /** 580 * @tc.number: GetEnabledAbilities_001 581 * @tc.name: GetEnabledAbilities 582 * @tc.desc: Test function GetEnabledAbilities 583 */ 584 HWTEST_F(AccessibilitySystemAbilityClientImplTest, GetEnabledAbilities_001, TestSize.Level1) 585 { 586 GTEST_LOG_(INFO) << "GetEnabledAbilities_001 start"; 587 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 588 if (!impl_) { 589 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 590 return; 591 } 592 std::vector<std::string> enabledAbilities; 593 EXPECT_EQ(RET_ERR_SAMGR, impl_->GetEnabledAbilities(enabledAbilities)); 594 impl_ = nullptr; 595 GTEST_LOG_(INFO) << "GetEnabledAbilities_001 end"; 596 } 597 598 /** 599 * @tc.number: GetEnabledAbilities_002 600 * @tc.name: GetEnabledAbilities 601 * @tc.desc: Test function GetEnabledAbilities 602 */ 603 HWTEST_F(AccessibilitySystemAbilityClientImplTest, GetEnabledAbilities_002, TestSize.Level1) 604 { 605 GTEST_LOG_(INFO) << "GetEnabledAbilities_002 start"; 606 AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(true); 607 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 608 AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(false); 609 if (!impl_) { 610 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 611 return; 612 } 613 std::vector<std::string> enabledAbilities; 614 EXPECT_EQ(RET_OK, impl_->GetEnabledAbilities(enabledAbilities)); 615 impl_ = nullptr; 616 GTEST_LOG_(INFO) << "GetEnabledAbilities_002 end"; 617 } 618 619 /** 620 * @tc.number: SetSearchElementInfoByAccessibilityIdResult_001 621 * @tc.name: SetSearchElementInfoByAccessibilityIdResult 622 * @tc.desc: Test function SetSearchElementInfoByAccessibilityIdResult(success) 623 */ 624 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetSearchElementInfoByAccessibilityIdResult_001, TestSize.Level1) 625 { 626 GTEST_LOG_(INFO) << "SetSearchElementInfoByAccessibilityIdResult_001 start"; 627 AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(true); 628 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 629 AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(false); 630 if (!impl_) { 631 GTEST_LOG_(INFO) << "SetSearchElementInfoByAccessibilityIdResult_001" 632 "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 633 return; 634 } 635 std::shared_ptr<AccessibilityElementOperator> mockOperator = std::make_shared<MockAccessibilityElementOperator>(); 636 EXPECT_EQ(0, impl_->RegisterElementOperator(WINDOW_ID, mockOperator)); 637 int32_t requestId = REQUEST_ID; 638 requestId |= static_cast<uint32_t>(WINDOW_ID) << WINDOW_ID_MASK; 639 std::list<AccessibilityElementInfo> infos; 640 impl_->SetSearchElementInfoByAccessibilityIdResult(infos, requestId); 641 EXPECT_EQ(0, infos.size()); 642 impl_ = nullptr; 643 GTEST_LOG_(INFO) << "SetSearchElementInfoByAccessibilityIdResult_001 end"; 644 } 645 646 /** 647 * @tc.number: SetSearchElementInfoByAccessibilityIdResult_002 648 * @tc.name: SetSearchElementInfoByAccessibilityIdResult 649 * @tc.desc: Test function SetSearchElementInfoByAccessibilityIdResult(no operator) 650 */ 651 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetSearchElementInfoByAccessibilityIdResult_002, TestSize.Level1) 652 { 653 GTEST_LOG_(INFO) << "SetSearchElementInfoByAccessibilityIdResult_002 start"; 654 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 655 if (!impl_) { 656 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 657 return; 658 } 659 int32_t requestId = REQUEST_ID; 660 requestId |= static_cast<uint32_t>(WINDOW_ID) << WINDOW_ID_MASK; 661 std::list<AccessibilityElementInfo> infos; 662 impl_->SetSearchElementInfoByAccessibilityIdResult(infos, requestId); 663 EXPECT_EQ(0, infos.size()); 664 impl_ = nullptr; 665 GTEST_LOG_(INFO) << "SetSearchElementInfoByAccessibilityIdResult_002 end"; 666 } 667 668 /** 669 * @tc.number: SetSearchElementInfoByAccessibilityIdResult_003 670 * @tc.name: SetSearchElementInfoByAccessibilityIdResult 671 * @tc.desc: Test function SetSearchElementInfoByAccessibilityIdResult(invalid requestId) 672 */ 673 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetSearchElementInfoByAccessibilityIdResult_003, TestSize.Level1) 674 { 675 GTEST_LOG_(INFO) << "SetSearchElementInfoByAccessibilityIdResult_003 start"; 676 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 677 if (!impl_) { 678 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 679 return; 680 } 681 std::list<AccessibilityElementInfo> infos; 682 impl_->SetSearchElementInfoByAccessibilityIdResult(infos, -1); 683 EXPECT_EQ(0, infos.size()); 684 impl_ = nullptr; 685 GTEST_LOG_(INFO) << "SetSearchElementInfoByAccessibilityIdResult_003 end"; 686 } 687 688 /** 689 * @tc.number: SetSearchElementInfoByTextResult_001 690 * @tc.name: SetSearchElementInfoByTextResult 691 * @tc.desc: Test function SetSearchElementInfoByTextResult(success) 692 */ 693 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetSearchElementInfoByTextResult_001, TestSize.Level1) 694 { 695 GTEST_LOG_(INFO) << "SetSearchElementInfoByTextResult_001 start"; 696 AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(true); 697 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 698 AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(false); 699 if (!impl_) { 700 GTEST_LOG_(INFO) << "Cann't get SetSearchElementInfoByTextResult_001 impl_"; 701 return; 702 } 703 std::shared_ptr<AccessibilityElementOperator> mockOperator = std::make_shared<MockAccessibilityElementOperator>(); 704 EXPECT_EQ(0, impl_->RegisterElementOperator(WINDOW_ID, mockOperator)); 705 int32_t requestId = REQUEST_ID; 706 requestId |= static_cast<uint32_t>(WINDOW_ID) << WINDOW_ID_MASK; 707 std::list<AccessibilityElementInfo> infos; 708 impl_->SetSearchElementInfoByTextResult(infos, requestId); 709 EXPECT_EQ(0, infos.size()); 710 impl_ = nullptr; 711 GTEST_LOG_(INFO) << "SetSearchElementInfoByTextResult_001 end"; 712 } 713 714 /** 715 * @tc.number: SetSearchElementInfoByTextResult_002 716 * @tc.name: SetSearchElementInfoByTextResult 717 * @tc.desc: Test function SetSearchElementInfoByTextResult(no operator) 718 */ 719 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetSearchElementInfoByTextResult_002, TestSize.Level1) 720 { 721 GTEST_LOG_(INFO) << "SetSearchElementInfoByTextResult_002 start"; 722 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 723 if (!impl_) { 724 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 725 return; 726 } 727 int32_t requestId = REQUEST_ID; 728 requestId |= static_cast<uint32_t>(WINDOW_ID) << WINDOW_ID_MASK; 729 std::list<AccessibilityElementInfo> infos; 730 impl_->SetSearchElementInfoByTextResult(infos, requestId); 731 EXPECT_EQ(0, infos.size()); 732 impl_ = nullptr; 733 GTEST_LOG_(INFO) << "SetSearchElementInfoByTextResult_002 end"; 734 } 735 736 /** 737 * @tc.number: SetSearchElementInfoByTextResult_003 738 * @tc.name: SetSearchElementInfoByTextResult 739 * @tc.desc: Test function SetSearchElementInfoByTextResult(invalid requestId) 740 */ 741 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetSearchElementInfoByTextResult_003, TestSize.Level1) 742 { 743 GTEST_LOG_(INFO) << "SetSearchElementInfoByTextResult_003 start"; 744 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 745 if (!impl_) { 746 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 747 return; 748 } 749 std::list<AccessibilityElementInfo> infos; 750 impl_->SetSearchElementInfoByTextResult(infos, -1); 751 EXPECT_EQ(0, infos.size()); 752 impl_ = nullptr; 753 GTEST_LOG_(INFO) << "SetSearchElementInfoByTextResult_003 end"; 754 } 755 756 /** 757 * @tc.number: SetFindFocusedElementInfoResult_001 758 * @tc.name: SetFindFocusedElementInfoResult 759 * @tc.desc: Test function SetFindFocusedElementInfoResult(success) 760 */ 761 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetFindFocusedElementInfoResult_001, TestSize.Level1) 762 { 763 GTEST_LOG_(INFO) << "SetFindFocusedElementInfoResult_001 start"; 764 AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(true); 765 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 766 AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(false); 767 if (!impl_) { 768 GTEST_LOG_(INFO) << "SetFindFocusedElementInfoResult_001" 769 "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 770 return; 771 } 772 std::shared_ptr<AccessibilityElementOperator> mockOperator = std::make_shared<MockAccessibilityElementOperator>(); 773 EXPECT_EQ(0, impl_->RegisterElementOperator(WINDOW_ID, mockOperator)); 774 int32_t requestId = REQUEST_ID; 775 requestId |= static_cast<uint32_t>(WINDOW_ID) << WINDOW_ID_MASK; 776 AccessibilityElementInfo info; 777 impl_->SetFindFocusedElementInfoResult(info, requestId); 778 impl_ = nullptr; 779 GTEST_LOG_(INFO) << "SetFindFocusedElementInfoResult_001 end"; 780 } 781 782 /** 783 * @tc.number: SetFindFocusedElementInfoResult_002 784 * @tc.name: SetFindFocusedElementInfoResult 785 * @tc.desc: Test function SetFindFocusedElementInfoResult(no operator) 786 */ 787 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetFindFocusedElementInfoResult_002, TestSize.Level1) 788 { 789 GTEST_LOG_(INFO) << "SetFindFocusedElementInfoResult_002 start"; 790 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 791 if (!impl_) { 792 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 793 return; 794 } 795 int32_t requestId = REQUEST_ID; 796 requestId |= static_cast<uint32_t>(WINDOW_ID) << WINDOW_ID_MASK; 797 AccessibilityElementInfo info; 798 impl_->SetFindFocusedElementInfoResult(info, requestId); 799 EXPECT_NE(impl_.get(), nullptr); 800 impl_ = nullptr; 801 GTEST_LOG_(INFO) << "SetFindFocusedElementInfoResult_002 end"; 802 } 803 804 /** 805 * @tc.number: SetFindFocusedElementInfoResult_003 806 * @tc.name: SetFindFocusedElementInfoResult 807 * @tc.desc: Test function SetFindFocusedElementInfoResult(invalid requestId) 808 */ 809 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetFindFocusedElementInfoResult_003, TestSize.Level1) 810 { 811 GTEST_LOG_(INFO) << "SetFindFocusedElementInfoResult_003 start"; 812 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 813 if (!impl_) { 814 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 815 return; 816 } 817 AccessibilityElementInfo info; 818 impl_->SetFindFocusedElementInfoResult(info, -1); 819 EXPECT_NE(impl_.get(), nullptr); 820 impl_ = nullptr; 821 GTEST_LOG_(INFO) << "SetFindFocusedElementInfoResult_003 end"; 822 } 823 824 /** 825 * @tc.number: SetFocusMoveSearchResult_001 826 * @tc.name: SetFocusMoveSearchResult 827 * @tc.desc: Test function SetFocusMoveSearchResult(success) 828 */ 829 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetFocusMoveSearchResult_001, TestSize.Level1) 830 { 831 GTEST_LOG_(INFO) << "SetFocusMoveSearchResult_001 start"; 832 AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(true); 833 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 834 AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(false); 835 if (!impl_) { 836 GTEST_LOG_(INFO) << "SetFocusMoveSearchResult_001 Cann't get AccessibilitySystemAbilityClientImpl impl_"; 837 return; 838 } 839 std::shared_ptr<AccessibilityElementOperator> mockOperator = std::make_shared<MockAccessibilityElementOperator>(); 840 EXPECT_EQ(0, impl_->RegisterElementOperator(WINDOW_ID, mockOperator)); 841 int32_t requestId = REQUEST_ID; 842 requestId |= static_cast<uint32_t>(WINDOW_ID) << WINDOW_ID_MASK; 843 AccessibilityElementInfo info; 844 impl_->SetFocusMoveSearchResult(info, requestId); 845 impl_ = nullptr; 846 GTEST_LOG_(INFO) << "SetFocusMoveSearchResult_001 end"; 847 } 848 849 /** 850 * @tc.number: SetFocusMoveSearchResult_002 851 * @tc.name: SetFocusMoveSearchResult 852 * @tc.desc: Test function SetFocusMoveSearchResult(no operator) 853 */ 854 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetFocusMoveSearchResult_002, TestSize.Level1) 855 { 856 GTEST_LOG_(INFO) << "SetFocusMoveSearchResult_002 start"; 857 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 858 if (!impl_) { 859 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 860 return; 861 } 862 int32_t requestId = REQUEST_ID; 863 requestId |= static_cast<uint32_t>(WINDOW_ID) << WINDOW_ID_MASK; 864 AccessibilityElementInfo info; 865 impl_->SetFocusMoveSearchResult(info, requestId); 866 EXPECT_NE(impl_.get(), nullptr); 867 impl_ = nullptr; 868 GTEST_LOG_(INFO) << "SetFocusMoveSearchResult_002 end"; 869 } 870 871 /** 872 * @tc.number: SetFocusMoveSearchResult_003 873 * @tc.name: SetFocusMoveSearchResult 874 * @tc.desc: Test function SetFocusMoveSearchResult(invalid requestId) 875 */ 876 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetFocusMoveSearchResult_003, TestSize.Level1) 877 { 878 GTEST_LOG_(INFO) << "SetFocusMoveSearchResult_003 start"; 879 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 880 if (!impl_) { 881 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 882 return; 883 } 884 AccessibilityElementInfo info; 885 impl_->SetFocusMoveSearchResult(info, -1); 886 EXPECT_NE(impl_.get(), nullptr); 887 impl_ = nullptr; 888 GTEST_LOG_(INFO) << "SetFocusMoveSearchResult_003 end"; 889 } 890 891 /** 892 * @tc.number: SetExecuteActionResult_001 893 * @tc.name: SetExecuteActionResult 894 * @tc.desc: Test function SetExecuteActionResult(success) 895 */ 896 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetExecuteActionResult_001, TestSize.Level1) 897 { 898 GTEST_LOG_(INFO) << "SetExecuteActionResult_001 start"; 899 AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(true); 900 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 901 AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(false); 902 if (!impl_) { 903 GTEST_LOG_(INFO) << "SetExecuteActionResult_001 Cann't get AccessibilitySystemAbilityClientImpl impl_"; 904 return; 905 } 906 std::shared_ptr<AccessibilityElementOperator> mockOperator = std::make_shared<MockAccessibilityElementOperator>(); 907 EXPECT_EQ(0, impl_->RegisterElementOperator(WINDOW_ID, mockOperator)); 908 int32_t requestId = REQUEST_ID; 909 requestId |= static_cast<uint32_t>(WINDOW_ID) << WINDOW_ID_MASK; 910 impl_->SetExecuteActionResult(true, requestId); 911 impl_ = nullptr; 912 GTEST_LOG_(INFO) << "SetExecuteActionResult_001 end"; 913 } 914 915 /** 916 * @tc.number: SetExecuteActionResult_002 917 * @tc.name: SetExecuteActionResult 918 * @tc.desc: Test function SetExecuteActionResult(no operator) 919 */ 920 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetExecuteActionResult_002, TestSize.Level1) 921 { 922 GTEST_LOG_(INFO) << "SetExecuteActionResult_002 start"; 923 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 924 if (!impl_) { 925 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 926 return; 927 } 928 int32_t requestId = REQUEST_ID; 929 requestId |= static_cast<uint32_t>(WINDOW_ID) << WINDOW_ID_MASK; 930 impl_->SetExecuteActionResult(true, requestId); 931 EXPECT_NE(impl_.get(), nullptr); 932 impl_ = nullptr; 933 GTEST_LOG_(INFO) << "SetExecuteActionResult_002 end"; 934 } 935 936 /** 937 * @tc.number: SetExecuteActionResult_003 938 * @tc.name: SetExecuteActionResult 939 * @tc.desc: Test function SetExecuteActionResult(invalid requestId) 940 */ 941 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetExecuteActionResult_003, TestSize.Level1) 942 { 943 GTEST_LOG_(INFO) << "SetExecuteActionResult_003 start"; 944 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 945 if (!impl_) { 946 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 947 return; 948 } 949 impl_->SetExecuteActionResult(true, -1); 950 EXPECT_NE(impl_.get(), nullptr); 951 impl_ = nullptr; 952 GTEST_LOG_(INFO) << "SetExecuteActionResult_003 end"; 953 } 954 } // namespace Accessibility 955 } // namespace OHOS