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_OK, 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 955 /** 956 * @tc.number: SetCursorPositionResult_001 957 * @tc.name: SetCursorPositionResult 958 * @tc.desc: Test function SetCursorPositionResult(cursorPosition,requestId) 959 */ 960 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetCursorPositionResult_001, TestSize.Level1) 961 { 962 GTEST_LOG_(INFO) << "SetCursorPositionResult_001 start"; 963 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 964 if (!impl_) { 965 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 966 return; 967 } 968 int32_t cursorPosition = 0; 969 int32_t requestId = REQUEST_ID; 970 requestId |= static_cast<uint32_t>(WINDOW_ID) << WINDOW_ID_MASK; 971 impl_->SetCursorPositionResult(cursorPosition, requestId); 972 EXPECT_NE(impl_.get(), nullptr); 973 impl_ = nullptr; 974 GTEST_LOG_(INFO) << "SetCursorPositionResult_001 end"; 975 } 976 977 /** 978 * @tc.number: SetCursorPositionResult_002 979 * @tc.name: SetCursorPositionResult 980 * @tc.desc: Test function SetCursorPositionResult(cursorPosition,requestId) 981 */ 982 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetCursorPositionResult_002, TestSize.Level1) 983 { 984 GTEST_LOG_(INFO) << "SetCursorPositionResult_001 start"; 985 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 986 if (!impl_) { 987 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 988 return; 989 } 990 int32_t cursorPosition = 0; 991 impl_->SetCursorPositionResult(cursorPosition, -1); 992 EXPECT_NE(impl_.get(), nullptr); 993 impl_ = nullptr; 994 GTEST_LOG_(INFO) << "SetCursorPositionResult_001 end"; 995 } 996 997 /** 998 * @tc.number: SetAccessibilityState_001 999 * @tc.name: SetAccessibilityState 1000 * @tc.desc: Test function SetAccessibilityState 1001 */ 1002 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetAccessibilityState_001, TestSize.Level1) 1003 { 1004 GTEST_LOG_(INFO) << "SetAccessibilityState_001 start"; 1005 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 1006 if (!impl_) { 1007 GTEST_LOG_(INFO) << "Cann't get SetAccessibilityState impl_"; 1008 return; 1009 } 1010 impl_->SetAccessibilityState(0); 1011 EXPECT_NE(impl_.get(), nullptr); 1012 impl_ = nullptr; 1013 GTEST_LOG_(INFO) << "SetAccessibilityState_001 end"; 1014 } 1015 1016 /** 1017 * @tc.number: SetFindAccessibilityNodeInfoResult_001 1018 * @tc.name: SetFindAccessibilityNodeInfoResult 1019 * @tc.desc: Test function SetFindAccessibilityNodeInfoResult(elementInfo,requestId,requestCode) 1020 */ 1021 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetFindAccessibilityNodeInfoResult_001, TestSize.Level1) 1022 { 1023 GTEST_LOG_(INFO) << "SetFindAccessibilityNodeInfoResult_001 start"; 1024 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 1025 if (!impl_) { 1026 GTEST_LOG_(INFO) << "Cann't get SetFindAccessibilityNodeInfoResult impl_"; 1027 return; 1028 } 1029 AccessibilityElementInfo elementInfo; 1030 int32_t requestId = -1; 1031 int32_t requestCode = FIND_ACCESSIBILITY_NODE_BY_ACCESSIBILITY_ID; 1032 impl_->SetFindAccessibilityNodeInfoResult(elementInfo, requestId, requestCode); 1033 EXPECT_NE(impl_.get(), nullptr); 1034 impl_ = nullptr; 1035 GTEST_LOG_(INFO) << "SetFindAccessibilityNodeInfoResult_001 end"; 1036 } 1037 1038 /** 1039 * @tc.number: SetFindAccessibilityNodeInfoResult_002 1040 * @tc.name: SetFindAccessibilityNodeInfoResult 1041 * @tc.desc: Test function SetFindAccessibilityNodeInfoResult(elementInfo,requestId,requestCode) 1042 */ 1043 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetFindAccessibilityNodeInfoResult_002, TestSize.Level1) 1044 { 1045 GTEST_LOG_(INFO) << "SetFindAccessibilityNodeInfoResult_002 start"; 1046 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 1047 if (!impl_) { 1048 GTEST_LOG_(INFO) << "Cann't get SetFindAccessibilityNodeInfoResult impl_"; 1049 return; 1050 } 1051 AccessibilityElementInfo elementInfo; 1052 int32_t requestId = -1; 1053 int32_t requestCode = FIND_FOCUS; 1054 impl_->SetFindAccessibilityNodeInfoResult(elementInfo, requestId, requestCode); 1055 EXPECT_NE(impl_.get(), nullptr); 1056 impl_ = nullptr; 1057 GTEST_LOG_(INFO) << "SetFindAccessibilityNodeInfoResult_002 end"; 1058 } 1059 1060 /** 1061 * @tc.number: SetFindAccessibilityNodeInfoResult_003 1062 * @tc.name: SetFindAccessibilityNodeInfoResult 1063 * @tc.desc: Test function SetFindAccessibilityNodeInfoResult(elementInfo,requestId,requestCode) 1064 */ 1065 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetFindAccessibilityNodeInfoResult_003, TestSize.Level1) 1066 { 1067 GTEST_LOG_(INFO) << "SetFindAccessibilityNodeInfoResult_003 start"; 1068 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 1069 if (!impl_) { 1070 GTEST_LOG_(INFO) << "Cann't get SetFindAccessibilityNodeInfoResult impl_"; 1071 return; 1072 } 1073 AccessibilityElementInfo elementInfo; 1074 int32_t requestId = -1; 1075 int32_t requestCode = FIND_FOCUS_SEARCH; 1076 impl_->SetFindAccessibilityNodeInfoResult(elementInfo, requestId, requestCode); 1077 EXPECT_NE(impl_.get(), nullptr); 1078 impl_ = nullptr; 1079 GTEST_LOG_(INFO) << "SetFindAccessibilityNodeInfoResult_003 end"; 1080 } 1081 1082 /** 1083 * @tc.number: SetFindAccessibilityNodeInfoResult_004 1084 * @tc.name: SetFindAccessibilityNodeInfoResult 1085 * @tc.desc: Test function SetFindAccessibilityNodeInfoResult(elementInfo,requestId,requestCode) 1086 */ 1087 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetFindAccessibilityNodeInfoResult_004, TestSize.Level1) 1088 { 1089 GTEST_LOG_(INFO) << "SetFindAccessibilityNodeInfoResult_004 start"; 1090 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 1091 if (!impl_) { 1092 GTEST_LOG_(INFO) << "Cann't get SetFindAccessibilityNodeInfoResult impl_"; 1093 return; 1094 } 1095 AccessibilityElementInfo elementInfo; 1096 int32_t requestId = -1; 1097 int32_t requestCode = FIND_ACCESSIBILITY_NODE_BY_TEXT; 1098 impl_->SetFindAccessibilityNodeInfoResult(elementInfo, requestId, requestCode); 1099 EXPECT_NE(impl_.get(), nullptr); 1100 impl_ = nullptr; 1101 GTEST_LOG_(INFO) << "SetFindAccessibilityNodeInfoResult_004 end"; 1102 } 1103 1104 /** 1105 * @tc.number: SetFindAccessibilityNodeInfosResult_001 1106 * @tc.name: SetFindAccessibilityNodeInfosResult 1107 * @tc.desc: Test function SetFindAccessibilityNodeInfosResult(elementInfos,requestId,requestCode) 1108 */ 1109 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetFindAccessibilityNodeInfosResult_001, TestSize.Level1) 1110 { 1111 GTEST_LOG_(INFO) << "SetFindAccessibilityNodeInfosResult_001 start"; 1112 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 1113 if (!impl_) { 1114 GTEST_LOG_(INFO) << "Cann't get SetFindAccessibilityNodeInfosResult_001 impl_"; 1115 return; 1116 } 1117 std::list<AccessibilityElementInfo> elementInfos; 1118 int32_t requestId = -1; 1119 int32_t requestCode = FIND_ACCESSIBILITY_NODE_BY_ACCESSIBILITY_ID; 1120 impl_->SetFindAccessibilityNodeInfosResult(elementInfos, requestId, requestCode); 1121 EXPECT_NE(impl_.get(), nullptr); 1122 impl_ = nullptr; 1123 GTEST_LOG_(INFO) << "SetFindAccessibilityNodeInfosResult_001 end"; 1124 } 1125 1126 /** 1127 * @tc.number: SetFindAccessibilityNodeInfosResult_002 1128 * @tc.name: SetFindAccessibilityNodeInfosResult 1129 * @tc.desc: Test function SetFindAccessibilityNodeInfosResult(elementInfos,requestId,requestCode) 1130 */ 1131 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetFindAccessibilityNodeInfosResult_002, TestSize.Level1) 1132 { 1133 GTEST_LOG_(INFO) << "SetFindAccessibilityNodeInfosResult_002 start"; 1134 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 1135 if (!impl_) { 1136 GTEST_LOG_(INFO) << "Cann't get SetFindAccessibilityNodeInfosResult_002 impl_"; 1137 return; 1138 } 1139 std::list<AccessibilityElementInfo> elementInfos; 1140 int32_t requestId = -1; 1141 int32_t requestCode = FIND_ACCESSIBILITY_NODE_BY_TEXT; 1142 impl_->SetFindAccessibilityNodeInfosResult(elementInfos, requestId, requestCode); 1143 EXPECT_NE(impl_.get(), nullptr); 1144 impl_ = nullptr; 1145 GTEST_LOG_(INFO) << "SetFindAccessibilityNodeInfosResult_002 end"; 1146 } 1147 1148 /** 1149 * @tc.number: SetFindAccessibilityNodeInfosResult_003 1150 * @tc.name: SetFindAccessibilityNodeInfosResult 1151 * @tc.desc: Test function SetFindAccessibilityNodeInfosResult(elementInfos,requestId,requestCode) 1152 */ 1153 HWTEST_F(AccessibilitySystemAbilityClientImplTest, SetFindAccessibilityNodeInfosResult_003, TestSize.Level1) 1154 { 1155 GTEST_LOG_(INFO) << "SetFindAccessibilityNodeInfosResult_003 start"; 1156 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 1157 if (!impl_) { 1158 GTEST_LOG_(INFO) << "Cann't get SetFindAccessibilityNodeInfosResult_003 impl_"; 1159 return; 1160 } 1161 std::list<AccessibilityElementInfo> elementInfos; 1162 int32_t requestId = -1; 1163 int32_t requestCode = FIND_FOCUS_SEARCH; 1164 impl_->SetFindAccessibilityNodeInfosResult(elementInfos, requestId, requestCode); 1165 EXPECT_NE(impl_.get(), nullptr); 1166 impl_ = nullptr; 1167 GTEST_LOG_(INFO) << "SetFindAccessibilityNodeInfosResult_003 end"; 1168 } 1169 1170 /** 1171 * @tc.number: GetFocusedWindowId_001 1172 * @tc.name: GetFocusedWindowId 1173 * @tc.desc: Test function GetFocusedWindowId 1174 */ 1175 HWTEST_F(AccessibilitySystemAbilityClientImplTest, GetFocusedWindowId_001, TestSize.Level1) 1176 { 1177 GTEST_LOG_(INFO) << "GetFocusedWindowId_001 start"; 1178 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 1179 if (!impl_) { 1180 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 1181 return; 1182 } 1183 int32_t windowId = 0; 1184 impl_->GetFocusedWindowId(windowId); 1185 EXPECT_NE(impl_.get(), nullptr); 1186 impl_ = nullptr; 1187 GTEST_LOG_(INFO) << "GetFocusedWindowId_001 end"; 1188 } 1189 1190 /** 1191 * @tc.number: LoadAccessibilityService_001 1192 * @tc.name: LoadAccessibilityService 1193 * @tc.desc: Test function LoadAccessibilityService (false) 1194 */ 1195 HWTEST_F(AccessibilitySystemAbilityClientImplTest, LoadAccessibilityService_001, TestSize.Level1) 1196 { 1197 GTEST_LOG_(INFO) << "LoadAccessibilityService_001 start"; 1198 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 1199 if (!impl_) { 1200 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 1201 return; 1202 } 1203 EXPECT_EQ(false, impl_->LoadAccessibilityService()); 1204 impl_ = nullptr; 1205 GTEST_LOG_(INFO) << "LoadAccessibilityService_001 end"; 1206 } 1207 1208 /** 1209 * @tc.number: LoadSystemAbilitySuccess_001 1210 * @tc.name: LoadSystemAbilitySuccess 1211 * @tc.desc: Test function LoadSystemAbilitySuccess 1212 */ 1213 HWTEST_F(AccessibilitySystemAbilityClientImplTest, LoadSystemAbilitySuccess_001, TestSize.Level1) 1214 { 1215 GTEST_LOG_(INFO) << "LoadSystemAbilitySuccess_001 start"; 1216 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 1217 if (!impl_) { 1218 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 1219 return; 1220 } 1221 sptr<IRemoteObject> object; 1222 impl_->LoadSystemAbilitySuccess(object); 1223 EXPECT_NE(impl_.get(), nullptr); 1224 impl_ = nullptr; 1225 GTEST_LOG_(INFO) << "LoadSystemAbilitySuccess_001 end"; 1226 } 1227 1228 /** 1229 * @tc.number: LoadSystemAbilitySuccess_002 1230 * @tc.name: LoadSystemAbilitySuccess 1231 * @tc.desc: Test function LoadSystemAbilitySuccess 1232 */ 1233 HWTEST_F(AccessibilitySystemAbilityClientImplTest, LoadSystemAbilitySuccess_002, TestSize.Level1) 1234 { 1235 GTEST_LOG_(INFO) << "LoadSystemAbilitySuccess_002 start"; 1236 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 1237 if (!impl_) { 1238 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 1239 return; 1240 } 1241 impl_->LoadSystemAbilitySuccess(nullptr); 1242 EXPECT_NE(impl_.get(), nullptr); 1243 impl_ = nullptr; 1244 GTEST_LOG_(INFO) << "LoadSystemAbilitySuccess_002 end"; 1245 } 1246 1247 /** 1248 * @tc.number: LoadSystemAbilityFail_001 1249 * @tc.name: LoadSystemAbilityFail 1250 * @tc.desc: Test function LoadSystemAbilityFail 1251 */ 1252 HWTEST_F(AccessibilitySystemAbilityClientImplTest, LoadSystemAbilityFail_001, TestSize.Level1) 1253 { 1254 GTEST_LOG_(INFO) << "LoadSystemAbilityFail_001 start"; 1255 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 1256 if (!impl_) { 1257 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 1258 return; 1259 } 1260 impl_->LoadSystemAbilityFail(); 1261 impl_ = nullptr; 1262 GTEST_LOG_(INFO) << "LoadSystemAbilityFail_001 end"; 1263 } 1264 1265 /** 1266 * @tc.number: Init_001 1267 * @tc.name: Init 1268 * @tc.desc: Test function Init AccessibilitySystemAbilityClientImpl 1269 */ 1270 HWTEST_F(AccessibilitySystemAbilityClientImplTest, Init_001, TestSize.Level1) 1271 { 1272 GTEST_LOG_(INFO) << "Init_001 start"; 1273 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 1274 if (!impl_) { 1275 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 1276 return; 1277 } 1278 impl_->LoadSystemAbilityFail(); 1279 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 1280 impl_ = nullptr; 1281 GTEST_LOG_(INFO) << "Init_001 end"; 1282 } 1283 1284 /** 1285 * @tc.number: CheckEventType_001 1286 * @tc.name: CheckEventType 1287 * @tc.desc: Test function CheckEventType SendEvent (false: TYPE_VIEW_INVALID) 1288 */ 1289 HWTEST_F(AccessibilitySystemAbilityClientImplTest, CheckEventType_001, TestSize.Level1) 1290 { 1291 GTEST_LOG_(INFO) << "CheckEventType_001 start"; 1292 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 1293 if (!impl_) { 1294 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 1295 return; 1296 } 1297 EventType eventType = TYPE_VIEW_INVALID; 1298 EXPECT_EQ(RET_ERR_INVALID_PARAM, impl_->SendEvent(eventType, 0)); 1299 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 1300 impl_ = nullptr; 1301 GTEST_LOG_(INFO) << "CheckEventType_001 end"; 1302 } 1303 1304 /** 1305 * @tc.number: CheckEventType_002 1306 * @tc.name: CheckEventType 1307 * @tc.desc: Test function CheckEventType SendEvent (false: TYPE_MAX_NUM) 1308 */ 1309 HWTEST_F(AccessibilitySystemAbilityClientImplTest, CheckEventType_002, TestSize.Level1) 1310 { 1311 GTEST_LOG_(INFO) << "CheckEventType_002 start"; 1312 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 1313 if (!impl_) { 1314 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 1315 return; 1316 } 1317 EventType eventType = TYPE_MAX_NUM; 1318 EXPECT_EQ(RET_ERR_INVALID_PARAM, impl_->SendEvent(eventType, 0)); 1319 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 1320 impl_ = nullptr; 1321 GTEST_LOG_(INFO) << "CheckEventType_002 end"; 1322 } 1323 1324 /** 1325 * @tc.number: CheckEventType_003 1326 * @tc.name: CheckEventType 1327 * @tc.desc: Test function CheckEventType SendEvent (false: TYPE_VIEW_FOCUSED_EVENT) 1328 */ 1329 HWTEST_F(AccessibilitySystemAbilityClientImplTest, CheckEventType_003, TestSize.Level1) 1330 { 1331 GTEST_LOG_(INFO) << "CheckEventType_003 start"; 1332 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 1333 if (!impl_) { 1334 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 1335 return; 1336 } 1337 EventType eventType = TYPE_VIEW_FOCUSED_EVENT; 1338 EXPECT_EQ(RET_ERR_SAMGR, impl_->SendEvent(eventType, 0)); 1339 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 1340 impl_ = nullptr; 1341 GTEST_LOG_(INFO) << "CheckEventType_003 end"; 1342 } 1343 1344 /** 1345 * @tc.number: CheckEventType_004 1346 * @tc.name: CheckEventType 1347 * @tc.desc: Test function CheckEventType SendEvent (false: TYPE_PAGE_STATE_UPDATE) 1348 */ 1349 HWTEST_F(AccessibilitySystemAbilityClientImplTest, CheckEventType_004, TestSize.Level1) 1350 { 1351 GTEST_LOG_(INFO) << "CheckEventType_004 start"; 1352 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 1353 if (!impl_) { 1354 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 1355 return; 1356 } 1357 EventType eventType = TYPE_PAGE_STATE_UPDATE; 1358 EXPECT_EQ(RET_ERR_SAMGR, impl_->SendEvent(eventType, 0)); 1359 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 1360 impl_ = nullptr; 1361 GTEST_LOG_(INFO) << "CheckEventType_004 end"; 1362 } 1363 1364 /** 1365 * @tc.number: CheckEventType_005 1366 * @tc.name: CheckEventType 1367 * @tc.desc: Test function CheckEventType SendEvent (false: TYPE_VIEW_SCROLLED_EVENT) 1368 */ 1369 HWTEST_F(AccessibilitySystemAbilityClientImplTest, CheckEventType_005, TestSize.Level1) 1370 { 1371 GTEST_LOG_(INFO) << "CheckEventType_005 start"; 1372 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 1373 if (!impl_) { 1374 GTEST_LOG_(INFO) << "Cann't get AccessibilitySystemAbilityClientImpl impl_"; 1375 return; 1376 } 1377 EventType eventType = TYPE_VIEW_SCROLLED_EVENT; 1378 EXPECT_EQ(RET_ERR_SAMGR, impl_->SendEvent(eventType, 0)); 1379 impl_ = std::make_shared<AccessibilitySystemAbilityClientImpl>(); 1380 impl_ = nullptr; 1381 GTEST_LOG_(INFO) << "CheckEventType_005 end"; 1382 } 1383 } // namespace Accessibility 1384 } // namespace OHOS