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 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: SetSearchDefaultFocusByWindowIdResult_001 690 * @tc.name: SetSearchDefaultFocusByWindowIdResult 691 * @tc.desc: Test function SetSearchDefaultFocusByWindowIdResult(success) 692 */ 693 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetSearchDefaultFocusByWindowIdResult_001, TestSize.Level1) 694 { 695 GTEST_LOG_(INFO) << "SetSearchDefaultFocusByWindowIdResult_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) << "SetSearchDefaultFocusByWindowIdResult_001" 701 "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 702 return; 703 } 704 std::shared_ptr<AccessibilityElementOperator> mockOperator = std::make_shared<MockAccessibilityElementOperator>(); 705 EXPECT_EQ(0, impl_->RegisterElementOperator(WINDOW_ID, mockOperator)); 706 int32_t requestId = REQUEST_ID; 707 requestId |= static_cast<uint32_t>(WINDOW_ID) << WINDOW_ID_MASK; 708 std::list<AccessibilityElementInfo> infos; 709 impl_->SetSearchDefaultFocusByWindowIdResult(infos, requestId); 710 EXPECT_EQ(0, infos.size()); 711 impl_ = nullptr; 712 GTEST_LOG_(INFO) << "SetSearchDefaultFocusByWindowIdResult_001 end"; 713 } 714 715 /** 716 * @tc.number: SetSearchDefaultFocusByWindowIdResult_002 717 * @tc.name: SetSearchDefaultFocusByWindowIdResult 718 * @tc.desc: Test function SetSearchDefaultFocusByWindowIdResult(no operator) 719 */ 720 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetSearchDefaultFocusByWindowIdResult_002, TestSize.Level1) 721 { 722 GTEST_LOG_(INFO) << "SetSearchDefaultFocusByWindowIdResult_002 start"; 723 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 724 if (!impl_) { 725 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 726 return; 727 } 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 impl_ = nullptr; 734 GTEST_LOG_(INFO) << "SetSearchDefaultFocusByWindowIdResult_002 end"; 735 } 736 737 /** 738 * @tc.number: SetSearchDefaultFocusByWindowIdResult_003 739 * @tc.name: SetSearchDefaultFocusByWindowIdResult 740 * @tc.desc: Test function SetSearchDefaultFocusByWindowIdResult(invalid requestId) 741 */ 742 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetSearchDefaultFocusByWindowIdResult_003, TestSize.Level1) 743 { 744 GTEST_LOG_(INFO) << "SetSearchDefaultFocusByWindowIdResult_003 start"; 745 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 746 if (!impl_) { 747 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 748 return; 749 } 750 std::list<AccessibilityElementInfo> infos; 751 impl_->SetSearchDefaultFocusByWindowIdResult(infos, -1); 752 EXPECT_EQ(0, infos.size()); 753 impl_ = nullptr; 754 GTEST_LOG_(INFO) << "SetSearchDefaultFocusByWindowIdResult_003 end"; 755 } 756 757 /** 758 * @tc.number: SetSearchElementInfoByTextResult_001 759 * @tc.name: SetSearchElementInfoByTextResult 760 * @tc.desc: Test function SetSearchElementInfoByTextResult(success) 761 */ 762 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetSearchElementInfoByTextResult_001, TestSize.Level1) 763 { 764 GTEST_LOG_(INFO) << "SetSearchElementInfoByTextResult_001 start"; 765 AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(true); 766 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 767 AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(false); 768 if (!impl_) { 769 GTEST_LOG_(INFO) << "Cann't get SetSearchElementInfoByTextResult_001 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 std::list<AccessibilityElementInfo> infos; 777 impl_->SetSearchElementInfoByTextResult(infos, requestId); 778 EXPECT_EQ(0, infos.size()); 779 impl_ = nullptr; 780 GTEST_LOG_(INFO) << "SetSearchElementInfoByTextResult_001 end"; 781 } 782 783 /** 784 * @tc.number: SetSearchElementInfoByTextResult_002 785 * @tc.name: SetSearchElementInfoByTextResult 786 * @tc.desc: Test function SetSearchElementInfoByTextResult(no operator) 787 */ 788 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetSearchElementInfoByTextResult_002, TestSize.Level1) 789 { 790 GTEST_LOG_(INFO) << "SetSearchElementInfoByTextResult_002 start"; 791 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 792 if (!impl_) { 793 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 794 return; 795 } 796 int32_t requestId = REQUEST_ID; 797 requestId |= static_cast<uint32_t>(WINDOW_ID) << WINDOW_ID_MASK; 798 std::list<AccessibilityElementInfo> infos; 799 impl_->SetSearchElementInfoByTextResult(infos, requestId); 800 EXPECT_EQ(0, infos.size()); 801 impl_ = nullptr; 802 GTEST_LOG_(INFO) << "SetSearchElementInfoByTextResult_002 end"; 803 } 804 805 /** 806 * @tc.number: SetSearchElementInfoByTextResult_003 807 * @tc.name: SetSearchElementInfoByTextResult 808 * @tc.desc: Test function SetSearchElementInfoByTextResult(invalid requestId) 809 */ 810 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetSearchElementInfoByTextResult_003, TestSize.Level1) 811 { 812 GTEST_LOG_(INFO) << "SetSearchElementInfoByTextResult_003 start"; 813 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 814 if (!impl_) { 815 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 816 return; 817 } 818 std::list<AccessibilityElementInfo> infos; 819 impl_->SetSearchElementInfoByTextResult(infos, -1); 820 EXPECT_EQ(0, infos.size()); 821 impl_ = nullptr; 822 GTEST_LOG_(INFO) << "SetSearchElementInfoByTextResult_003 end"; 823 } 824 825 /** 826 * @tc.number: SetFindFocusedElementInfoResult_001 827 * @tc.name: SetFindFocusedElementInfoResult 828 * @tc.desc: Test function SetFindFocusedElementInfoResult(success) 829 */ 830 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetFindFocusedElementInfoResult_001, TestSize.Level1) 831 { 832 GTEST_LOG_(INFO) << "SetFindFocusedElementInfoResult_001 start"; 833 AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(true); 834 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 835 AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(false); 836 if (!impl_) { 837 GTEST_LOG_(INFO) << "SetFindFocusedElementInfoResult_001" 838 "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 839 return; 840 } 841 std::shared_ptr<AccessibilityElementOperator> mockOperator = std::make_shared<MockAccessibilityElementOperator>(); 842 EXPECT_EQ(0, impl_->RegisterElementOperator(WINDOW_ID, mockOperator)); 843 int32_t requestId = REQUEST_ID; 844 requestId |= static_cast<uint32_t>(WINDOW_ID) << WINDOW_ID_MASK; 845 AccessibilityElementInfo info; 846 impl_->SetFindFocusedElementInfoResult(info, requestId); 847 impl_ = nullptr; 848 GTEST_LOG_(INFO) << "SetFindFocusedElementInfoResult_001 end"; 849 } 850 851 /** 852 * @tc.number: SetFindFocusedElementInfoResult_002 853 * @tc.name: SetFindFocusedElementInfoResult 854 * @tc.desc: Test function SetFindFocusedElementInfoResult(no operator) 855 */ 856 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetFindFocusedElementInfoResult_002, TestSize.Level1) 857 { 858 GTEST_LOG_(INFO) << "SetFindFocusedElementInfoResult_002 start"; 859 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 860 if (!impl_) { 861 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 862 return; 863 } 864 int32_t requestId = REQUEST_ID; 865 requestId |= static_cast<uint32_t>(WINDOW_ID) << WINDOW_ID_MASK; 866 AccessibilityElementInfo info; 867 impl_->SetFindFocusedElementInfoResult(info, requestId); 868 EXPECT_NE(impl_.get(), nullptr); 869 impl_ = nullptr; 870 GTEST_LOG_(INFO) << "SetFindFocusedElementInfoResult_002 end"; 871 } 872 873 /** 874 * @tc.number: SetFindFocusedElementInfoResult_003 875 * @tc.name: SetFindFocusedElementInfoResult 876 * @tc.desc: Test function SetFindFocusedElementInfoResult(invalid requestId) 877 */ 878 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetFindFocusedElementInfoResult_003, TestSize.Level1) 879 { 880 GTEST_LOG_(INFO) << "SetFindFocusedElementInfoResult_003 start"; 881 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 882 if (!impl_) { 883 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 884 return; 885 } 886 AccessibilityElementInfo info; 887 impl_->SetFindFocusedElementInfoResult(info, -1); 888 EXPECT_NE(impl_.get(), nullptr); 889 impl_ = nullptr; 890 GTEST_LOG_(INFO) << "SetFindFocusedElementInfoResult_003 end"; 891 } 892 893 /** 894 * @tc.number: SetFocusMoveSearchResult_001 895 * @tc.name: SetFocusMoveSearchResult 896 * @tc.desc: Test function SetFocusMoveSearchResult(success) 897 */ 898 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetFocusMoveSearchResult_001, TestSize.Level1) 899 { 900 GTEST_LOG_(INFO) << "SetFocusMoveSearchResult_001 start"; 901 AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(true); 902 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 903 AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(false); 904 if (!impl_) { 905 GTEST_LOG_(INFO) << "SetFocusMoveSearchResult_001 Cann't get AccessibilitySystemAbilityClientImpl impl_"; 906 return; 907 } 908 std::shared_ptr<AccessibilityElementOperator> mockOperator = std::make_shared<MockAccessibilityElementOperator>(); 909 EXPECT_EQ(0, impl_->RegisterElementOperator(WINDOW_ID, mockOperator)); 910 int32_t requestId = REQUEST_ID; 911 requestId |= static_cast<uint32_t>(WINDOW_ID) << WINDOW_ID_MASK; 912 AccessibilityElementInfo info; 913 impl_->SetFocusMoveSearchResult(info, requestId); 914 impl_ = nullptr; 915 GTEST_LOG_(INFO) << "SetFocusMoveSearchResult_001 end"; 916 } 917 918 /** 919 * @tc.number: SetFocusMoveSearchResult_002 920 * @tc.name: SetFocusMoveSearchResult 921 * @tc.desc: Test function SetFocusMoveSearchResult(no operator) 922 */ 923 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetFocusMoveSearchResult_002, TestSize.Level1) 924 { 925 GTEST_LOG_(INFO) << "SetFocusMoveSearchResult_002 start"; 926 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 927 if (!impl_) { 928 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 929 return; 930 } 931 int32_t requestId = REQUEST_ID; 932 requestId |= static_cast<uint32_t>(WINDOW_ID) << WINDOW_ID_MASK; 933 AccessibilityElementInfo info; 934 impl_->SetFocusMoveSearchResult(info, requestId); 935 EXPECT_NE(impl_.get(), nullptr); 936 impl_ = nullptr; 937 GTEST_LOG_(INFO) << "SetFocusMoveSearchResult_002 end"; 938 } 939 940 /** 941 * @tc.number: SetFocusMoveSearchResult_003 942 * @tc.name: SetFocusMoveSearchResult 943 * @tc.desc: Test function SetFocusMoveSearchResult(invalid requestId) 944 */ 945 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetFocusMoveSearchResult_003, TestSize.Level1) 946 { 947 GTEST_LOG_(INFO) << "SetFocusMoveSearchResult_003 start"; 948 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 949 if (!impl_) { 950 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 951 return; 952 } 953 AccessibilityElementInfo info; 954 impl_->SetFocusMoveSearchResult(info, -1); 955 EXPECT_NE(impl_.get(), nullptr); 956 impl_ = nullptr; 957 GTEST_LOG_(INFO) << "SetFocusMoveSearchResult_003 end"; 958 } 959 960 /** 961 * @tc.number: SetExecuteActionResult_001 962 * @tc.name: SetExecuteActionResult 963 * @tc.desc: Test function SetExecuteActionResult(success) 964 */ 965 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetExecuteActionResult_001, TestSize.Level1) 966 { 967 GTEST_LOG_(INFO) << "SetExecuteActionResult_001 start"; 968 AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(true); 969 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 970 AccessibilityCommonHelper::GetInstance().SetRemoteObjectNotNullFlag(false); 971 if (!impl_) { 972 GTEST_LOG_(INFO) << "SetExecuteActionResult_001 Cann't get AccessibilitySystemAbilityClientImpl impl_"; 973 return; 974 } 975 std::shared_ptr<AccessibilityElementOperator> mockOperator = std::make_shared<MockAccessibilityElementOperator>(); 976 EXPECT_EQ(0, impl_->RegisterElementOperator(WINDOW_ID, mockOperator)); 977 int32_t requestId = REQUEST_ID; 978 requestId |= static_cast<uint32_t>(WINDOW_ID) << WINDOW_ID_MASK; 979 impl_->SetExecuteActionResult(true, requestId); 980 impl_ = nullptr; 981 GTEST_LOG_(INFO) << "SetExecuteActionResult_001 end"; 982 } 983 984 /** 985 * @tc.number: SetExecuteActionResult_002 986 * @tc.name: SetExecuteActionResult 987 * @tc.desc: Test function SetExecuteActionResult(no operator) 988 */ 989 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetExecuteActionResult_002, TestSize.Level1) 990 { 991 GTEST_LOG_(INFO) << "SetExecuteActionResult_002 start"; 992 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 993 if (!impl_) { 994 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 995 return; 996 } 997 int32_t requestId = REQUEST_ID; 998 requestId |= static_cast<uint32_t>(WINDOW_ID) << WINDOW_ID_MASK; 999 impl_->SetExecuteActionResult(true, requestId); 1000 EXPECT_NE(impl_.get(), nullptr); 1001 impl_ = nullptr; 1002 GTEST_LOG_(INFO) << "SetExecuteActionResult_002 end"; 1003 } 1004 1005 /** 1006 * @tc.number: SetExecuteActionResult_003 1007 * @tc.name: SetExecuteActionResult 1008 * @tc.desc: Test function SetExecuteActionResult(invalid requestId) 1009 */ 1010 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetExecuteActionResult_003, TestSize.Level1) 1011 { 1012 GTEST_LOG_(INFO) << "SetExecuteActionResult_003 start"; 1013 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 1014 if (!impl_) { 1015 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 1016 return; 1017 } 1018 impl_->SetExecuteActionResult(true, -1); 1019 EXPECT_NE(impl_.get(), nullptr); 1020 impl_ = nullptr; 1021 GTEST_LOG_(INFO) << "SetExecuteActionResult_003 end"; 1022 } 1023 1024 /** 1025 * @tc.number: SetCursorPositionResult_001 1026 * @tc.name: SetCursorPositionResult 1027 * @tc.desc: Test function SetCursorPositionResult(cursorPosition,requestId) 1028 */ 1029 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetCursorPositionResult_001, TestSize.Level1) 1030 { 1031 GTEST_LOG_(INFO) << "SetCursorPositionResult_001 start"; 1032 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 1033 if (!impl_) { 1034 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 1035 return; 1036 } 1037 int32_t cursorPosition = 0; 1038 int32_t requestId = REQUEST_ID; 1039 requestId |= static_cast<uint32_t>(WINDOW_ID) << WINDOW_ID_MASK; 1040 impl_->SetCursorPositionResult(cursorPosition, requestId); 1041 EXPECT_NE(impl_.get(), nullptr); 1042 impl_ = nullptr; 1043 GTEST_LOG_(INFO) << "SetCursorPositionResult_001 end"; 1044 } 1045 1046 /** 1047 * @tc.number: SetCursorPositionResult_002 1048 * @tc.name: SetCursorPositionResult 1049 * @tc.desc: Test function SetCursorPositionResult(cursorPosition,requestId) 1050 */ 1051 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetCursorPositionResult_002, TestSize.Level1) 1052 { 1053 GTEST_LOG_(INFO) << "SetCursorPositionResult_001 start"; 1054 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 1055 if (!impl_) { 1056 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 1057 return; 1058 } 1059 int32_t cursorPosition = 0; 1060 impl_->SetCursorPositionResult(cursorPosition, -1); 1061 EXPECT_NE(impl_.get(), nullptr); 1062 impl_ = nullptr; 1063 GTEST_LOG_(INFO) << "SetCursorPositionResult_001 end"; 1064 } 1065 1066 /** 1067 * @tc.number: SetAccessibilityState_001 1068 * @tc.name: SetAccessibilityState 1069 * @tc.desc: Test function SetAccessibilityState 1070 */ 1071 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetAccessibilityState_001, TestSize.Level1) 1072 { 1073 GTEST_LOG_(INFO) << "SetAccessibilityState_001 start"; 1074 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 1075 if (!impl_) { 1076 GTEST_LOG_(INFO) << "Cann't get SetAccessibilityState impl_"; 1077 return; 1078 } 1079 impl_->SetAccessibilityState(0); 1080 EXPECT_NE(impl_.get(), nullptr); 1081 impl_ = nullptr; 1082 GTEST_LOG_(INFO) << "SetAccessibilityState_001 end"; 1083 } 1084 1085 /** 1086 * @tc.number: GetAccessibilityState_001 1087 * @tc.name: GetAccessibilityState 1088 * @tc.desc: Test function GetAccessibilityState 1089 */ 1090 HWTEST_F(AccessibilitySystemAbilityClientImplTest, GetAccessibilityState_001, TestSize.Level1) 1091 { 1092 GTEST_LOG_(INFO) << "GetAccessibilityState_001 start"; 1093 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 1094 if (!impl_) { 1095 GTEST_LOG_(INFO) << "Cann't get SetAccessibilityState impl_"; 1096 return; 1097 } 1098 impl_->SetAccessibilityState(0); 1099 EXPECT_EQ(0, impl_->GetAccessibilityState()); 1100 impl_ = nullptr; 1101 GTEST_LOG_(INFO) << "GetAccessibilityState_001 end"; 1102 } 1103 1104 /** 1105 * @tc.number: SetFindAccessibilityNodeInfoResult_001 1106 * @tc.name: SetFindAccessibilityNodeInfoResult 1107 * @tc.desc: Test function SetFindAccessibilityNodeInfoResult(elementInfo,requestId,requestCode) 1108 */ 1109 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetFindAccessibilityNodeInfoResult_001, TestSize.Level1) 1110 { 1111 GTEST_LOG_(INFO) << "SetFindAccessibilityNodeInfoResult_001 start"; 1112 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 1113 if (!impl_) { 1114 GTEST_LOG_(INFO) << "Cann't get SetFindAccessibilityNodeInfoResult impl_"; 1115 return; 1116 } 1117 AccessibilityElementInfo elementInfo; 1118 int32_t requestId = -1; 1119 int32_t requestCode = FIND_ACCESSIBILITY_NODE_BY_ACCESSIBILITY_ID; 1120 impl_->SetFindAccessibilityNodeInfoResult(elementInfo, requestId, requestCode); 1121 EXPECT_NE(impl_.get(), nullptr); 1122 impl_ = nullptr; 1123 GTEST_LOG_(INFO) << "SetFindAccessibilityNodeInfoResult_001 end"; 1124 } 1125 1126 /** 1127 * @tc.number: SetFindAccessibilityNodeInfoResult_002 1128 * @tc.name: SetFindAccessibilityNodeInfoResult 1129 * @tc.desc: Test function SetFindAccessibilityNodeInfoResult(elementInfo,requestId,requestCode) 1130 */ 1131 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetFindAccessibilityNodeInfoResult_002, TestSize.Level1) 1132 { 1133 GTEST_LOG_(INFO) << "SetFindAccessibilityNodeInfoResult_002 start"; 1134 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 1135 if (!impl_) { 1136 GTEST_LOG_(INFO) << "Cann't get SetFindAccessibilityNodeInfoResult impl_"; 1137 return; 1138 } 1139 AccessibilityElementInfo elementInfo; 1140 int32_t requestId = -1; 1141 int32_t requestCode = FIND_FOCUS; 1142 impl_->SetFindAccessibilityNodeInfoResult(elementInfo, requestId, requestCode); 1143 EXPECT_NE(impl_.get(), nullptr); 1144 impl_ = nullptr; 1145 GTEST_LOG_(INFO) << "SetFindAccessibilityNodeInfoResult_002 end"; 1146 } 1147 1148 /** 1149 * @tc.number: SetFindAccessibilityNodeInfoResult_003 1150 * @tc.name: SetFindAccessibilityNodeInfoResult 1151 * @tc.desc: Test function SetFindAccessibilityNodeInfoResult(elementInfo,requestId,requestCode) 1152 */ 1153 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetFindAccessibilityNodeInfoResult_003, TestSize.Level1) 1154 { 1155 GTEST_LOG_(INFO) << "SetFindAccessibilityNodeInfoResult_003 start"; 1156 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 1157 if (!impl_) { 1158 GTEST_LOG_(INFO) << "Cann't get SetFindAccessibilityNodeInfoResult impl_"; 1159 return; 1160 } 1161 AccessibilityElementInfo elementInfo; 1162 int32_t requestId = -1; 1163 int32_t requestCode = FIND_FOCUS_SEARCH; 1164 impl_->SetFindAccessibilityNodeInfoResult(elementInfo, requestId, requestCode); 1165 EXPECT_NE(impl_.get(), nullptr); 1166 impl_ = nullptr; 1167 GTEST_LOG_(INFO) << "SetFindAccessibilityNodeInfoResult_003 end"; 1168 } 1169 1170 /** 1171 * @tc.number: SetFindAccessibilityNodeInfoResult_004 1172 * @tc.name: SetFindAccessibilityNodeInfoResult 1173 * @tc.desc: Test function SetFindAccessibilityNodeInfoResult(elementInfo,requestId,requestCode) 1174 */ 1175 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetFindAccessibilityNodeInfoResult_004, TestSize.Level1) 1176 { 1177 GTEST_LOG_(INFO) << "SetFindAccessibilityNodeInfoResult_004 start"; 1178 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 1179 if (!impl_) { 1180 GTEST_LOG_(INFO) << "Cann't get SetFindAccessibilityNodeInfoResult impl_"; 1181 return; 1182 } 1183 AccessibilityElementInfo elementInfo; 1184 int32_t requestId = -1; 1185 int32_t requestCode = FIND_ACCESSIBILITY_NODE_BY_TEXT; 1186 impl_->SetFindAccessibilityNodeInfoResult(elementInfo, requestId, requestCode); 1187 EXPECT_NE(impl_.get(), nullptr); 1188 impl_ = nullptr; 1189 GTEST_LOG_(INFO) << "SetFindAccessibilityNodeInfoResult_004 end"; 1190 } 1191 1192 /** 1193 * @tc.number: SetFindAccessibilityNodeInfosResult_001 1194 * @tc.name: SetFindAccessibilityNodeInfosResult 1195 * @tc.desc: Test function SetFindAccessibilityNodeInfosResult(elementInfos,requestId,requestCode) 1196 */ 1197 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetFindAccessibilityNodeInfosResult_001, TestSize.Level1) 1198 { 1199 GTEST_LOG_(INFO) << "SetFindAccessibilityNodeInfosResult_001 start"; 1200 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 1201 if (!impl_) { 1202 GTEST_LOG_(INFO) << "Cann't get SetFindAccessibilityNodeInfosResult_001 impl_"; 1203 return; 1204 } 1205 std::list<AccessibilityElementInfo> elementInfos; 1206 int32_t requestId = -1; 1207 int32_t requestCode = FIND_ACCESSIBILITY_NODE_BY_ACCESSIBILITY_ID; 1208 impl_->SetFindAccessibilityNodeInfosResult(elementInfos, requestId, requestCode); 1209 EXPECT_NE(impl_.get(), nullptr); 1210 impl_ = nullptr; 1211 GTEST_LOG_(INFO) << "SetFindAccessibilityNodeInfosResult_001 end"; 1212 } 1213 1214 /** 1215 * @tc.number: SetFindAccessibilityNodeInfosResult_002 1216 * @tc.name: SetFindAccessibilityNodeInfosResult 1217 * @tc.desc: Test function SetFindAccessibilityNodeInfosResult(elementInfos,requestId,requestCode) 1218 */ 1219 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetFindAccessibilityNodeInfosResult_002, TestSize.Level1) 1220 { 1221 GTEST_LOG_(INFO) << "SetFindAccessibilityNodeInfosResult_002 start"; 1222 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 1223 if (!impl_) { 1224 GTEST_LOG_(INFO) << "Cann't get SetFindAccessibilityNodeInfosResult_002 impl_"; 1225 return; 1226 } 1227 std::list<AccessibilityElementInfo> elementInfos; 1228 int32_t requestId = -1; 1229 int32_t requestCode = FIND_ACCESSIBILITY_NODE_BY_TEXT; 1230 impl_->SetFindAccessibilityNodeInfosResult(elementInfos, requestId, requestCode); 1231 EXPECT_NE(impl_.get(), nullptr); 1232 impl_ = nullptr; 1233 GTEST_LOG_(INFO) << "SetFindAccessibilityNodeInfosResult_002 end"; 1234 } 1235 1236 /** 1237 * @tc.number: SetFindAccessibilityNodeInfosResult_003 1238 * @tc.name: SetFindAccessibilityNodeInfosResult 1239 * @tc.desc: Test function SetFindAccessibilityNodeInfosResult(elementInfos,requestId,requestCode) 1240 */ 1241 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetFindAccessibilityNodeInfosResult_003, TestSize.Level1) 1242 { 1243 GTEST_LOG_(INFO) << "SetFindAccessibilityNodeInfosResult_003 start"; 1244 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 1245 if (!impl_) { 1246 GTEST_LOG_(INFO) << "Cann't get SetFindAccessibilityNodeInfosResult_003 impl_"; 1247 return; 1248 } 1249 std::list<AccessibilityElementInfo> elementInfos; 1250 int32_t requestId = -1; 1251 int32_t requestCode = FIND_FOCUS_SEARCH; 1252 impl_->SetFindAccessibilityNodeInfosResult(elementInfos, requestId, requestCode); 1253 EXPECT_NE(impl_.get(), nullptr); 1254 impl_ = nullptr; 1255 GTEST_LOG_(INFO) << "SetFindAccessibilityNodeInfosResult_003 end"; 1256 } 1257 1258 /** 1259 * @tc.number: GetFocusedWindowId_001 1260 * @tc.name: GetFocusedWindowId 1261 * @tc.desc: Test function GetFocusedWindowId 1262 */ 1263 HWTEST_F(AccessibilitySystemAbilityClientImplTest, GetFocusedWindowId_001, TestSize.Level1) 1264 { 1265 GTEST_LOG_(INFO) << "GetFocusedWindowId_001 start"; 1266 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 1267 if (!impl_) { 1268 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 1269 return; 1270 } 1271 int32_t windowId = 0; 1272 impl_->GetFocusedWindowId(windowId); 1273 EXPECT_NE(impl_.get(), nullptr); 1274 impl_ = nullptr; 1275 GTEST_LOG_(INFO) << "GetFocusedWindowId_001 end"; 1276 } 1277 1278 /** 1279 * @tc.number: LoadAccessibilityService_001 1280 * @tc.name: LoadAccessibilityService 1281 * @tc.desc: Test function LoadAccessibilityService (false) 1282 */ 1283 HWTEST_F(AccessibilitySystemAbilityClientImplTest, LoadAccessibilityService_001, TestSize.Level1) 1284 { 1285 GTEST_LOG_(INFO) << "LoadAccessibilityService_001 start"; 1286 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 1287 if (!impl_) { 1288 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 1289 return; 1290 } 1291 EXPECT_EQ(false, impl_->LoadAccessibilityService()); 1292 impl_ = nullptr; 1293 GTEST_LOG_(INFO) << "LoadAccessibilityService_001 end"; 1294 } 1295 1296 /** 1297 * @tc.number: LoadSystemAbilitySuccess_001 1298 * @tc.name: LoadSystemAbilitySuccess 1299 * @tc.desc: Test function LoadSystemAbilitySuccess 1300 */ 1301 HWTEST_F(AccessibilitySystemAbilityClientImplTest, LoadSystemAbilitySuccess_001, TestSize.Level1) 1302 { 1303 GTEST_LOG_(INFO) << "LoadSystemAbilitySuccess_001 start"; 1304 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 1305 if (!impl_) { 1306 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 1307 return; 1308 } 1309 sptr<IRemoteObject> object; 1310 impl_->LoadSystemAbilitySuccess(object); 1311 EXPECT_NE(impl_.get(), nullptr); 1312 impl_ = nullptr; 1313 GTEST_LOG_(INFO) << "LoadSystemAbilitySuccess_001 end"; 1314 } 1315 1316 /** 1317 * @tc.number: LoadSystemAbilitySuccess_002 1318 * @tc.name: LoadSystemAbilitySuccess 1319 * @tc.desc: Test function LoadSystemAbilitySuccess 1320 */ 1321 HWTEST_F(AccessibilitySystemAbilityClientImplTest, LoadSystemAbilitySuccess_002, TestSize.Level1) 1322 { 1323 GTEST_LOG_(INFO) << "LoadSystemAbilitySuccess_002 start"; 1324 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 1325 if (!impl_) { 1326 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 1327 return; 1328 } 1329 impl_->LoadSystemAbilitySuccess(nullptr); 1330 EXPECT_NE(impl_.get(), nullptr); 1331 impl_ = nullptr; 1332 GTEST_LOG_(INFO) << "LoadSystemAbilitySuccess_002 end"; 1333 } 1334 1335 /** 1336 * @tc.number: LoadSystemAbilityFail_001 1337 * @tc.name: LoadSystemAbilityFail 1338 * @tc.desc: Test function LoadSystemAbilityFail 1339 */ 1340 HWTEST_F(AccessibilitySystemAbilityClientImplTest, LoadSystemAbilityFail_001, TestSize.Level1) 1341 { 1342 GTEST_LOG_(INFO) << "LoadSystemAbilityFail_001 start"; 1343 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 1344 if (!impl_) { 1345 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 1346 return; 1347 } 1348 impl_->LoadSystemAbilityFail(); 1349 impl_ = nullptr; 1350 GTEST_LOG_(INFO) << "LoadSystemAbilityFail_001 end"; 1351 } 1352 1353 /** 1354 * @tc.number: Init_001 1355 * @tc.name: Init 1356 * @tc.desc: Test function Init AccessibilitySystemAbilityClientImpl 1357 */ 1358 HWTEST_F(AccessibilitySystemAbilityClientImplTest, Init_001, TestSize.Level1) 1359 { 1360 GTEST_LOG_(INFO) << "Init_001 start"; 1361 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 1362 if (!impl_) { 1363 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 1364 return; 1365 } 1366 impl_->LoadSystemAbilityFail(); 1367 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 1368 impl_ = nullptr; 1369 GTEST_LOG_(INFO) << "Init_001 end"; 1370 } 1371 1372 /** 1373 * @tc.number: CheckEventType_001 1374 * @tc.name: CheckEventType 1375 * @tc.desc: Test function CheckEventType SendEvent (false: TYPE_VIEW_INVALID) 1376 */ 1377 HWTEST_F(AccessibilitySystemAbilityClientImplTest, CheckEventType_001, TestSize.Level1) 1378 { 1379 GTEST_LOG_(INFO) << "CheckEventType_001 start"; 1380 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 1381 if (!impl_) { 1382 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 1383 return; 1384 } 1385 EventType eventType = TYPE_VIEW_INVALID; 1386 EXPECT_EQ(RET_ERR_INVALID_PARAM, impl_->SendEvent(eventType, 0)); 1387 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 1388 impl_ = nullptr; 1389 GTEST_LOG_(INFO) << "CheckEventType_001 end"; 1390 } 1391 1392 /** 1393 * @tc.number: CheckEventType_002 1394 * @tc.name: CheckEventType 1395 * @tc.desc: Test function CheckEventType SendEvent (false: TYPE_MAX_NUM) 1396 */ 1397 HWTEST_F(AccessibilitySystemAbilityClientImplTest, CheckEventType_002, TestSize.Level1) 1398 { 1399 GTEST_LOG_(INFO) << "CheckEventType_002 start"; 1400 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 1401 if (!impl_) { 1402 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 1403 return; 1404 } 1405 EventType eventType = TYPE_MAX_NUM; 1406 EXPECT_EQ(RET_ERR_INVALID_PARAM, impl_->SendEvent(eventType, 0)); 1407 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 1408 impl_ = nullptr; 1409 GTEST_LOG_(INFO) << "CheckEventType_002 end"; 1410 } 1411 1412 /** 1413 * @tc.number: CheckEventType_003 1414 * @tc.name: CheckEventType 1415 * @tc.desc: Test function CheckEventType SendEvent (false: TYPE_VIEW_FOCUSED_EVENT) 1416 */ 1417 HWTEST_F(AccessibilitySystemAbilityClientImplTest, CheckEventType_003, TestSize.Level1) 1418 { 1419 GTEST_LOG_(INFO) << "CheckEventType_003 start"; 1420 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 1421 if (!impl_) { 1422 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 1423 return; 1424 } 1425 EventType eventType = TYPE_VIEW_FOCUSED_EVENT; 1426 EXPECT_EQ(RET_ERR_SAMGR, impl_->SendEvent(eventType, 0)); 1427 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 1428 impl_ = nullptr; 1429 GTEST_LOG_(INFO) << "CheckEventType_003 end"; 1430 } 1431 1432 /** 1433 * @tc.number: CheckEventType_004 1434 * @tc.name: CheckEventType 1435 * @tc.desc: Test function CheckEventType SendEvent (false: TYPE_PAGE_STATE_UPDATE) 1436 */ 1437 HWTEST_F(AccessibilitySystemAbilityClientImplTest, CheckEventType_004, TestSize.Level1) 1438 { 1439 GTEST_LOG_(INFO) << "CheckEventType_004 start"; 1440 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 1441 if (!impl_) { 1442 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 1443 return; 1444 } 1445 EventType eventType = TYPE_PAGE_STATE_UPDATE; 1446 EXPECT_EQ(RET_ERR_SAMGR, impl_->SendEvent(eventType, 0)); 1447 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 1448 impl_ = nullptr; 1449 GTEST_LOG_(INFO) << "CheckEventType_004 end"; 1450 } 1451 1452 /** 1453 * @tc.number: CheckEventType_005 1454 * @tc.name: CheckEventType 1455 * @tc.desc: Test function CheckEventType SendEvent (false: TYPE_VIEW_SCROLLED_EVENT) 1456 */ 1457 HWTEST_F(AccessibilitySystemAbilityClientImplTest, CheckEventType_005, TestSize.Level1) 1458 { 1459 GTEST_LOG_(INFO) << "CheckEventType_005 start"; 1460 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 1461 if (!impl_) { 1462 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 1463 return; 1464 } 1465 EventType eventType = TYPE_VIEW_SCROLLED_EVENT; 1466 EXPECT_EQ(RET_ERR_SAMGR, impl_->SendEvent(eventType, 0)); 1467 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 1468 impl_ = nullptr; 1469 GTEST_LOG_(INFO) << "CheckEventType_005 end"; 1470 } 1471 1472 /** 1473 * @tc.number: SetSplicElementIdTreeId_001 1474 * @tc.name: SetSplicElementIdTreeId 1475 * @tc.desc: Test function SetSplicElementIdTreeId 1476 */ 1477 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetSplicElementIdTreeId_001, TestSize.Level1) 1478 { 1479 GTEST_LOG_(INFO) << "SetSplicElementIdTreeId_001 start"; 1480 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 1481 if (!impl_) { 1482 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 1483 return; 1484 } 1485 int64_t elementId = 0; 1486 impl_->SetSplicElementIdTreeId(1, elementId); 1487 GTEST_LOG_(INFO) << "SetSplicElementIdTreeId_001 end"; 1488 } 1489 1490 /** 1491 * @tc.number: GetTreeIdAndElementIdBySplitElementId_001 1492 * @tc.name: GetTreeIdAndElementIdBySplitElementId 1493 * @tc.desc: Test function GetTreeIdAndElementIdBySplitElementId 1494 */ 1495 HWTEST_F(AccessibilitySystemAbilityClientImplTest, GetTreeIdAndElementIdBySplitElementId_001, TestSize.Level1) 1496 { 1497 GTEST_LOG_(INFO) << "GetTreeIdAndElementIdBySplitElementId_001 start"; 1498 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 1499 if (!impl_) { 1500 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 1501 return; 1502 } 1503 int64_t splitElementId; 1504 int32_t splitTreeId; 1505 1506 impl_->GetTreeIdAndElementIdBySplitElementId(-1, splitElementId, splitTreeId); 1507 EXPECT_EQ(splitElementId, -1); 1508 EXPECT_EQ(splitTreeId, -1); 1509 1510 impl_->GetTreeIdAndElementIdBySplitElementId(1, splitElementId, splitTreeId); 1511 EXPECT_EQ(splitElementId, 1); 1512 EXPECT_EQ(splitTreeId, 0); 1513 GTEST_LOG_(INFO) << "GetTreeIdAndElementIdBySplitElementId_001 end"; 1514 } 1515 } // namespace Accessibility 1516 } // namespace OHOS