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 "accessibility_def.h" 18 #include "accessibility_element_info.h" 19 20 using namespace testing; 21 using namespace testing::ext; 22 23 namespace OHOS { 24 namespace Accessibility { 25 class AccessibilityElementInfoTest : public ::testing::Test { 26 public: AccessibilityElementInfoTest()27 AccessibilityElementInfoTest() 28 {} ~AccessibilityElementInfoTest()29 ~AccessibilityElementInfoTest() 30 {} 31 32 std::shared_ptr<AccessibilityElementInfo> elementInfo_ = nullptr; 33 SetUpTestCase()34 static void SetUpTestCase() 35 { 36 GTEST_LOG_(INFO) << "AccessibilityElementInfoTest Start"; 37 } 38 TearDownTestCase()39 static void TearDownTestCase() 40 { 41 GTEST_LOG_(INFO) << "AccessibilityElementInfoTest End"; 42 } 43 SetUp()44 void SetUp() 45 { 46 elementInfo_ = std::make_shared<AccessibilityElementInfo>(); 47 ASSERT_TRUE(elementInfo_); 48 } 49 TearDown()50 void TearDown() 51 { 52 elementInfo_ = nullptr; 53 } 54 }; 55 56 class RangeInfoTest : public ::testing::Test { 57 public: RangeInfoTest()58 RangeInfoTest() 59 {} ~RangeInfoTest()60 ~RangeInfoTest() 61 {} 62 63 std::shared_ptr<RangeInfo> rangeInfo_ = nullptr; 64 SetUpTestCase()65 static void SetUpTestCase() 66 { 67 GTEST_LOG_(INFO) << "AccessibilityRangeInfoTest Start"; 68 } 69 TearDownTestCase()70 static void TearDownTestCase() 71 { 72 GTEST_LOG_(INFO) << "AccessibilityRangeInfoTest End"; 73 } 74 SetUp()75 void SetUp() 76 { 77 rangeInfo_ = std::make_shared<RangeInfo>(); 78 ASSERT_TRUE(rangeInfo_); 79 } 80 TearDown()81 void TearDown() 82 { 83 rangeInfo_ = nullptr; 84 } 85 }; 86 87 class GridInfoTest : public ::testing::Test { 88 public: GridInfoTest()89 GridInfoTest() 90 {} ~GridInfoTest()91 ~GridInfoTest() 92 {} 93 94 std::shared_ptr<GridInfo> gridInfo_ = nullptr; 95 SetUpTestCase()96 static void SetUpTestCase() 97 { 98 GTEST_LOG_(INFO) << "GridInfoTest Start"; 99 } 100 TearDownTestCase()101 static void TearDownTestCase() 102 { 103 GTEST_LOG_(INFO) << "GridInfoTest End"; 104 } 105 SetUp()106 void SetUp() 107 { 108 gridInfo_ = std::make_shared<GridInfo>(); 109 ASSERT_TRUE(gridInfo_); 110 } 111 TearDown()112 void TearDown() 113 { 114 gridInfo_ = nullptr; 115 } 116 }; 117 118 class GridItemInfoTest : public ::testing::Test { 119 public: GridItemInfoTest()120 GridItemInfoTest() 121 {} ~GridItemInfoTest()122 ~GridItemInfoTest() 123 {} 124 125 std::shared_ptr<GridItemInfo> gridItemInfo_ = nullptr; 126 SetUpTestCase()127 static void SetUpTestCase() 128 { 129 GTEST_LOG_(INFO) << "GridItemInfoTest Start"; 130 } 131 TearDownTestCase()132 static void TearDownTestCase() 133 { 134 GTEST_LOG_(INFO) << "GridItemInfoTest End"; 135 } 136 SetUp()137 void SetUp() 138 { 139 gridItemInfo_ = std::make_shared<GridItemInfo>(); 140 ASSERT_TRUE(gridItemInfo_); 141 } 142 TearDown()143 void TearDown() 144 { 145 gridItemInfo_ = nullptr; 146 } 147 }; 148 149 class AccessibleActionTest : public ::testing::Test { 150 public: AccessibleActionTest()151 AccessibleActionTest() 152 {} ~AccessibleActionTest()153 ~AccessibleActionTest() 154 {} 155 SetUpTestCase()156 static void SetUpTestCase() 157 { 158 GTEST_LOG_(INFO) << "AccessibleActionTest Start"; 159 } 160 TearDownTestCase()161 static void TearDownTestCase() 162 { 163 GTEST_LOG_(INFO) << "AccessibleActionTest End"; 164 } 165 SetUp()166 void SetUp() 167 {} 168 TearDown()169 void TearDown() 170 {} 171 }; 172 173 /** 174 * @tc.number: SetComponentId_001 175 * @tc.name: SetComponentId 176 * @tc.desc: Test function SetComponentId, GetAccessibilityId 177 */ 178 HWTEST_F(AccessibilityElementInfoTest, SetComponentId_001, TestSize.Level1) 179 { 180 GTEST_LOG_(INFO) << "SetComponentId_001 start"; 181 elementInfo_->SetComponentId(0); 182 EXPECT_EQ(elementInfo_->GetAccessibilityId(), 0); 183 GTEST_LOG_(INFO) << "SetComponentId_001 end"; 184 } 185 186 /** 187 * @tc.number: GetChildId_001 188 * @tc.name: GetChildId 189 * @tc.desc: Test function GetChildId 190 */ 191 HWTEST_F(AccessibilityElementInfoTest, GetChildId_001, TestSize.Level1) 192 { 193 GTEST_LOG_(INFO) << "GetChildId_001 start"; 194 EXPECT_EQ(elementInfo_->GetChildId(0), -1); 195 GTEST_LOG_(INFO) << "GetChildId_001 end"; 196 } 197 198 /** 199 * @tc.number: GetChildId_002 200 * @tc.name: GetChildId 201 * @tc.desc: Test function GetChildId 202 */ 203 HWTEST_F(AccessibilityElementInfoTest, GetChildId_002, TestSize.Level1) 204 { 205 GTEST_LOG_(INFO) << "GetChildId_002 start"; 206 elementInfo_->AddChild(1); 207 EXPECT_EQ(elementInfo_->GetChildId(0), 1); 208 GTEST_LOG_(INFO) << "GetChildId_002 end"; 209 } 210 211 /** 212 * @tc.number: GetChildId_003 213 * @tc.name: GetChildId 214 * @tc.desc: Test function GetChildId 215 */ 216 HWTEST_F(AccessibilityElementInfoTest, GetChildId_003, TestSize.Level1) 217 { 218 GTEST_LOG_(INFO) << "GetChildId_003 start"; 219 int64_t childId = 1; 220 int32_t index = 1; 221 elementInfo_->AddChild(childId); 222 EXPECT_EQ(elementInfo_->GetChildId(index), -1); 223 GTEST_LOG_(INFO) << "GetChildId_003 end"; 224 } 225 226 /** 227 * @tc.number: GetChildId_004 228 * @tc.name: GetChildId 229 * @tc.desc: Test function GetChildId 230 */ 231 HWTEST_F(AccessibilityElementInfoTest, GetChildId_004, TestSize.Level1) 232 { 233 GTEST_LOG_(INFO) << "GetChildId_004 start"; 234 EXPECT_EQ(elementInfo_->GetChildId(-1), -1); 235 GTEST_LOG_(INFO) << "GetChildId_004 end"; 236 } 237 238 239 /** 240 * @tc.number: GetChildCount_001 241 * @tc.name: GetChildCount 242 * @tc.desc: Test function GetChildCount 243 */ 244 HWTEST_F(AccessibilityElementInfoTest, GetChildCount_001, TestSize.Level1) 245 { 246 GTEST_LOG_(INFO) << "GetChildCount_001 start"; 247 EXPECT_EQ(elementInfo_->GetChildCount(), 0); 248 GTEST_LOG_(INFO) << "GetChildCount_001 end"; 249 } 250 251 /** 252 * @tc.number: GetChildIds_001 253 * @tc.name: GetChildIds 254 * @tc.desc: Test function GetChildIds 255 */ 256 HWTEST_F(AccessibilityElementInfoTest, GetChildIds_001, TestSize.Level1) 257 { 258 GTEST_LOG_(INFO) << "GetChildIds_001 start"; 259 EXPECT_EQ(static_cast<int>(elementInfo_->GetChildIds().size()), 0); 260 GTEST_LOG_(INFO) << "GetChildIds_001 end"; 261 } 262 263 /** 264 * @tc.number: AddChild_001 265 * @tc.name: AddChild 266 * @tc.desc: Test function AddChild 267 */ 268 HWTEST_F(AccessibilityElementInfoTest, AddChild_001, TestSize.Level1) 269 { 270 GTEST_LOG_(INFO) << "AddChild_001 start"; 271 elementInfo_->AddChild(1); 272 EXPECT_EQ(elementInfo_->GetChildCount(), 1); 273 EXPECT_EQ(static_cast<int>(elementInfo_->GetChildIds().size()), 1); 274 GTEST_LOG_(INFO) << "AddChild_001 end"; 275 } 276 277 /** 278 * @tc.number: AddChild_002 279 * @tc.name: AddChild 280 * @tc.desc: Test function AddChild 281 */ 282 HWTEST_F(AccessibilityElementInfoTest, AddChild_002, TestSize.Level1) 283 { 284 GTEST_LOG_(INFO) << "AddChild_002 start"; 285 elementInfo_->AddChild(1); 286 EXPECT_EQ(elementInfo_->GetChildCount(), 1); 287 EXPECT_EQ(static_cast<int>(elementInfo_->GetChildIds().size()), 1); 288 elementInfo_->AddChild(1); 289 EXPECT_EQ(elementInfo_->GetChildCount(), 1); 290 EXPECT_EQ(static_cast<int>(elementInfo_->GetChildIds().size()), 1); 291 GTEST_LOG_(INFO) << "AddChild_002 end"; 292 } 293 294 /** 295 * @tc.number: RemoveChild_001 296 * @tc.name: RemoveChild 297 * @tc.desc: Test function RemoveChild 298 */ 299 HWTEST_F(AccessibilityElementInfoTest, RemoveChild_001, TestSize.Level1) 300 { 301 GTEST_LOG_(INFO) << "RemoveChild_001 start"; 302 EXPECT_FALSE(elementInfo_->RemoveChild(1)); 303 GTEST_LOG_(INFO) << "RemoveChild_001 end"; 304 } 305 306 /** 307 * @tc.number: RemoveChild_002 308 * @tc.name: RemoveChild 309 * @tc.desc: Test function RemoveChild 310 */ 311 HWTEST_F(AccessibilityElementInfoTest, RemoveChild_002, TestSize.Level1) 312 { 313 GTEST_LOG_(INFO) << "RemoveChild_002 start"; 314 elementInfo_->AddChild(1); 315 EXPECT_EQ(elementInfo_->GetChildCount(), 1); 316 EXPECT_TRUE(elementInfo_->RemoveChild(1)); 317 GTEST_LOG_(INFO) << "RemoveChild_002 end"; 318 } 319 320 /** 321 * @tc.number: GetActionList_001 322 * @tc.name: GetActionList 323 * @tc.desc: Test function GetActionList 324 */ 325 HWTEST_F(AccessibilityElementInfoTest, GetActionList_001, TestSize.Level1) 326 { 327 GTEST_LOG_(INFO) << "GetActionList_001 start"; 328 EXPECT_EQ(static_cast<int>(elementInfo_->GetActionList().size()), 0); 329 GTEST_LOG_(INFO) << "GetActionList_001 end"; 330 } 331 332 /** 333 * @tc.number: AddAction_001 334 * @tc.name: AddAction 335 * @tc.desc: Test function AddAction 336 */ 337 HWTEST_F(AccessibilityElementInfoTest, AddAction_001, TestSize.Level1) 338 { 339 GTEST_LOG_(INFO) << "AddAction_001 start"; 340 AccessibleAction action(ACCESSIBILITY_ACTION_FOCUS, "test"); 341 elementInfo_->AddAction(action); 342 ASSERT_EQ(static_cast<int>(elementInfo_->GetActionList().size()), 1); 343 EXPECT_EQ(elementInfo_->GetActionList().front().GetActionType(), ACCESSIBILITY_ACTION_FOCUS); 344 EXPECT_STREQ(elementInfo_->GetActionList().front().GetDescriptionInfo().c_str(), "test"); 345 GTEST_LOG_(INFO) << "AddAction_001 end"; 346 } 347 348 /** 349 * @tc.number: DeleteAction_001 350 * @tc.name: DeleteAction 351 * @tc.desc: Test function DeleteAction 352 */ 353 HWTEST_F(AccessibilityElementInfoTest, DeleteAction_001, TestSize.Level1) 354 { 355 GTEST_LOG_(INFO) << "DeleteAction_001 start"; 356 AccessibleAction action; 357 elementInfo_->AddAction(action); 358 EXPECT_EQ(static_cast<int>(elementInfo_->GetActionList().size()), 1); 359 360 elementInfo_->DeleteAction(action); 361 EXPECT_EQ(static_cast<int>(elementInfo_->GetActionList().size()), 0); 362 GTEST_LOG_(INFO) << "DeleteAction_001 end"; 363 } 364 365 /** 366 * @tc.number: DeleteAction_002 367 * @tc.name: DeleteAction 368 * @tc.desc: Test function DeleteAction 369 */ 370 HWTEST_F(AccessibilityElementInfoTest, DeleteAction_002, TestSize.Level1) 371 { 372 GTEST_LOG_(INFO) << "DeleteAction_002 start"; 373 ActionType action = ActionType::ACCESSIBILITY_ACTION_FOCUS; 374 EXPECT_FALSE(elementInfo_->DeleteAction(action)); 375 GTEST_LOG_(INFO) << "DeleteAction_002 end"; 376 } 377 378 /** 379 * @tc.number: DeleteAction_003 380 * @tc.name: DeleteAction 381 * @tc.desc: Test function DeleteAction 382 */ 383 HWTEST_F(AccessibilityElementInfoTest, DeleteAction_003, TestSize.Level1) 384 { 385 GTEST_LOG_(INFO) << "DeleteAction_003 start"; 386 AccessibleAction action = AccessibleAction( 387 ACCESSIBILITY_ACTION_FOCUS, std::string("accessibility_action_focus")); 388 AccessibleAction actionSelect = AccessibleAction( 389 ACCESSIBILITY_ACTION_SELECT, std::string("accessiblety_action_select")); 390 elementInfo_->AddAction(action); 391 EXPECT_EQ(static_cast<int>(elementInfo_->GetActionList().size()), 1); 392 elementInfo_->DeleteAction(actionSelect); 393 EXPECT_EQ(static_cast<int>(elementInfo_->GetActionList().size()), 1); 394 GTEST_LOG_(INFO) << "DeleteAction_003 end"; 395 } 396 397 /** 398 * @tc.number: DeleteAction_004 399 * @tc.name: DeleteAction 400 * @tc.desc: Test function DeleteAction 401 */ 402 HWTEST_F(AccessibilityElementInfoTest, DeleteAction_004, TestSize.Level1) 403 { 404 GTEST_LOG_(INFO) << "DeleteAction_004 start"; 405 ActionType actionType = ActionType::ACCESSIBILITY_ACTION_FOCUS; 406 AccessibleAction action = AccessibleAction(actionType, std::string("accessibility_aciton_foucus")); 407 elementInfo_->AddAction(action); 408 EXPECT_EQ(static_cast<int>(elementInfo_->GetActionList().size()), 1); 409 EXPECT_TRUE(elementInfo_->DeleteAction(actionType)); 410 GTEST_LOG_(INFO) << "DeleteAction_004 end"; 411 } 412 413 /** 414 * @tc.number: DeleteAllActions_001 415 * @tc.name: DeleteAllActions 416 * @tc.desc: Test function DeleteAllActions 417 */ 418 HWTEST_F(AccessibilityElementInfoTest, DeleteAllActions_001, TestSize.Level1) 419 { 420 GTEST_LOG_(INFO) << "DeleteAllActions_001 start"; 421 AccessibleAction action; 422 elementInfo_->AddAction(action); 423 EXPECT_EQ(static_cast<int>(elementInfo_->GetActionList().size()), 1); 424 425 elementInfo_->DeleteAllActions(); 426 EXPECT_EQ(static_cast<int>(elementInfo_->GetActionList().size()), 0); 427 GTEST_LOG_(INFO) << "DeleteAllActions_001 end"; 428 } 429 430 /** 431 * @tc.number: SetTextLengthLimit_001 432 * @tc.name: SetTextLengthLimit 433 * @tc.desc: Test function SetTextLengthLimit, GetTextLengthLimit 434 */ 435 HWTEST_F(AccessibilityElementInfoTest, SetTextLengthLimit_001, TestSize.Level1) 436 { 437 GTEST_LOG_(INFO) << "SetTextLengthLimit_001 start"; 438 elementInfo_->SetTextLengthLimit(1); 439 EXPECT_EQ(elementInfo_->GetTextLengthLimit(), 1); 440 GTEST_LOG_(INFO) << "SetTextLengthLimit_001 end"; 441 } 442 443 /** 444 * @tc.number: SetWindowId_001 445 * @tc.name: SetWindowId 446 * @tc.desc: Test function SetWindowId, GetWindowId 447 */ 448 HWTEST_F(AccessibilityElementInfoTest, SetWindowId_001, TestSize.Level1) 449 { 450 GTEST_LOG_(INFO) << "SetWindowId_001 start"; 451 elementInfo_->SetWindowId(1); 452 EXPECT_EQ(elementInfo_->GetWindowId(), 1); 453 GTEST_LOG_(INFO) << "SetWindowId_001 end"; 454 } 455 456 /** 457 * @tc.number: SetParent_001 458 * @tc.name: SetParent 459 * @tc.desc: Test function SetParent, GetParentNodeId 460 */ 461 HWTEST_F(AccessibilityElementInfoTest, SetParent_001, TestSize.Level1) 462 { 463 GTEST_LOG_(INFO) << "SetParent_001 start"; 464 elementInfo_->SetParent(1); 465 EXPECT_EQ(elementInfo_->GetParentNodeId(), 1); 466 GTEST_LOG_(INFO) << "SetParent_001 end"; 467 } 468 469 /** 470 * @tc.number: SetRectInScreen_001 471 * @tc.name: SetRectInScreen 472 * @tc.desc: Test function SetRectInScreen, GetRectInScreen 473 */ 474 HWTEST_F(AccessibilityElementInfoTest, SetRectInScreen_001, TestSize.Level1) 475 { 476 GTEST_LOG_(INFO) << "SetRectInScreen_001 start"; 477 Rect bounds(1, 1, 1, 1); 478 elementInfo_->SetRectInScreen(bounds); 479 EXPECT_EQ(elementInfo_->GetRectInScreen().GetLeftTopXScreenPostion(), 1); 480 EXPECT_EQ(elementInfo_->GetRectInScreen().GetLeftTopYScreenPostion(), 1); 481 EXPECT_EQ(elementInfo_->GetRectInScreen().GetRightBottomXScreenPostion(), 1); 482 EXPECT_EQ(elementInfo_->GetRectInScreen().GetRightBottomYScreenPostion(), 1); 483 GTEST_LOG_(INFO) << "SetRectInScreen_001 end"; 484 } 485 486 /** 487 * @tc.number: SetCheckable_001 488 * @tc.name: SetCheckable 489 * @tc.desc: Test function SetCheckable, IsCheckable 490 */ 491 HWTEST_F(AccessibilityElementInfoTest, SetCheckable_001, TestSize.Level1) 492 { 493 GTEST_LOG_(INFO) << "SetCheckable_001 start"; 494 elementInfo_->SetCheckable(true); 495 EXPECT_TRUE(elementInfo_->IsCheckable()); 496 GTEST_LOG_(INFO) << "SetCheckable_001 end"; 497 } 498 499 /** 500 * @tc.number: SetChecked_001 501 * @tc.name: SetChecked 502 * @tc.desc: Test function SetChecked, IsChecked 503 */ 504 HWTEST_F(AccessibilityElementInfoTest, SetChecked_001, TestSize.Level1) 505 { 506 GTEST_LOG_(INFO) << "SetChecked_001 start"; 507 elementInfo_->SetChecked(true); 508 EXPECT_TRUE(elementInfo_->IsChecked()); 509 GTEST_LOG_(INFO) << "SetChecked_001 end"; 510 } 511 512 /** 513 * @tc.number: SetFocusable_001 514 * @tc.name: SetFocusable 515 * @tc.desc: Test function SetFocusable, IsFocusable 516 */ 517 HWTEST_F(AccessibilityElementInfoTest, SetFocusable_001, TestSize.Level1) 518 { 519 GTEST_LOG_(INFO) << "SetFocusable_001 start"; 520 elementInfo_->SetFocusable(true); 521 EXPECT_TRUE(elementInfo_->IsFocusable()); 522 GTEST_LOG_(INFO) << "SetFocusable_001 end"; 523 } 524 525 /** 526 * @tc.number: SetFocused_001 527 * @tc.name: SetFocused 528 * @tc.desc: Test function SetFocused, IsFocused 529 */ 530 HWTEST_F(AccessibilityElementInfoTest, SetFocused_001, TestSize.Level1) 531 { 532 GTEST_LOG_(INFO) << "SetFocused_001 start"; 533 elementInfo_->SetFocused(true); 534 EXPECT_TRUE(elementInfo_->IsFocused()); 535 GTEST_LOG_(INFO) << "SetFocused_001 end"; 536 } 537 538 /** 539 * @tc.number: SetVisible_001 540 * @tc.name: SetVisible 541 * @tc.desc: Test function SetVisible, IsVisible 542 */ 543 HWTEST_F(AccessibilityElementInfoTest, SetVisible_001, TestSize.Level1) 544 { 545 GTEST_LOG_(INFO) << "SetVisible_001 start"; 546 elementInfo_->SetVisible(true); 547 EXPECT_TRUE(elementInfo_->IsVisible()); 548 GTEST_LOG_(INFO) << "SetVisible_001 end"; 549 } 550 551 /** 552 * @tc.number: SetAccessibilityFocus_001 553 * @tc.name: SetAccessibilityFocus 554 * @tc.desc: Test function SetAccessibilityFocus, HasAccessibilityFocus 555 */ 556 HWTEST_F(AccessibilityElementInfoTest, SetAccessibilityFocus_001, TestSize.Level1) 557 { 558 GTEST_LOG_(INFO) << "SetAccessibilityFocus_001 start"; 559 elementInfo_->SetAccessibilityFocus(true); 560 EXPECT_TRUE(elementInfo_->HasAccessibilityFocus()); 561 GTEST_LOG_(INFO) << "SetAccessibilityFocus_001 end"; 562 } 563 564 /** 565 * @tc.number: SetSelected_001 566 * @tc.name: SetSelected 567 * @tc.desc: Test function SetSelected, IsSelected 568 */ 569 HWTEST_F(AccessibilityElementInfoTest, SetSelected_001, TestSize.Level1) 570 { 571 GTEST_LOG_(INFO) << "SetSelected_001 start"; 572 elementInfo_->SetSelected(true); 573 EXPECT_TRUE(elementInfo_->IsSelected()); 574 GTEST_LOG_(INFO) << "SetSelected_001 end"; 575 } 576 577 /** 578 * @tc.number: SetClickable_001 579 * @tc.name: SetClickable 580 * @tc.desc: Test function SetClickable, IsClickable 581 */ 582 HWTEST_F(AccessibilityElementInfoTest, SetClickable_001, TestSize.Level1) 583 { 584 GTEST_LOG_(INFO) << "SetClickable_001 start"; 585 elementInfo_->SetClickable(true); 586 EXPECT_TRUE(elementInfo_->IsClickable()); 587 GTEST_LOG_(INFO) << "SetClickable_001 end"; 588 } 589 590 /** 591 * @tc.number: SetLongClickable_001 592 * @tc.name: SetLongClickable 593 * @tc.desc: Test function SetLongClickable, IsLongClickable 594 */ 595 HWTEST_F(AccessibilityElementInfoTest, SetLongClickable_001, TestSize.Level1) 596 { 597 GTEST_LOG_(INFO) << "SetLongClickable_001 start"; 598 elementInfo_->SetLongClickable(true); 599 EXPECT_TRUE(elementInfo_->IsLongClickable()); 600 GTEST_LOG_(INFO) << "SetLongClickable_001 end"; 601 } 602 603 /** 604 * @tc.number: SetEnabled_001 605 * @tc.name: SetEnabled 606 * @tc.desc: Test function SetEnabled, IsEnabled 607 */ 608 HWTEST_F(AccessibilityElementInfoTest, SetEnabled_001, TestSize.Level1) 609 { 610 GTEST_LOG_(INFO) << "SetEnabled_001 start"; 611 elementInfo_->SetEnabled(true); 612 EXPECT_TRUE(elementInfo_->IsEnabled()); 613 GTEST_LOG_(INFO) << "SetEnabled_001 end"; 614 } 615 616 /** 617 * @tc.number: SetPassword_001 618 * @tc.name: SetPassword 619 * @tc.desc: Test function SetPassword, IsPassword 620 */ 621 HWTEST_F(AccessibilityElementInfoTest, SetPassword_001, TestSize.Level1) 622 { 623 GTEST_LOG_(INFO) << "SetPassword_001 start"; 624 elementInfo_->SetPassword(true); 625 EXPECT_TRUE(elementInfo_->IsPassword()); 626 GTEST_LOG_(INFO) << "SetPassword_001 end"; 627 } 628 629 /** 630 * @tc.number: SetScrollable_001 631 * @tc.name: SetScrollable 632 * @tc.desc: Test function SetScrollable, IsScrollable 633 */ 634 HWTEST_F(AccessibilityElementInfoTest, SetScrollable_001, TestSize.Level1) 635 { 636 GTEST_LOG_(INFO) << "SetScrollable_001 start"; 637 elementInfo_->SetScrollable(true); 638 EXPECT_TRUE(elementInfo_->IsScrollable()); 639 GTEST_LOG_(INFO) << "SetScrollable_001 end"; 640 } 641 642 /** 643 * @tc.number: SetEditable_001 644 * @tc.name: SetEditable 645 * @tc.desc: Test function SetEditable, IsEditable 646 */ 647 HWTEST_F(AccessibilityElementInfoTest, SetEditable_001, TestSize.Level1) 648 { 649 GTEST_LOG_(INFO) << "SetEditable_001 start"; 650 elementInfo_->SetEditable(true); 651 EXPECT_TRUE(elementInfo_->IsEditable()); 652 GTEST_LOG_(INFO) << "SetEditable_001 end"; 653 } 654 655 /** 656 * @tc.number: SetPluraLineSupported_001 657 * @tc.name: SetPluraLineSupported 658 * @tc.desc: Test function SetPluraLineSupported, IsPluraLineSupported 659 */ 660 HWTEST_F(AccessibilityElementInfoTest, SetPluraLineSupported_001, TestSize.Level1) 661 { 662 GTEST_LOG_(INFO) << "SetPluraLineSupported_001 start"; 663 elementInfo_->SetPluraLineSupported(true); 664 EXPECT_TRUE(elementInfo_->IsPluraLineSupported()); 665 GTEST_LOG_(INFO) << "SetPluraLineSupported_001 end"; 666 } 667 668 /** 669 * @tc.number: SetPopupSupported_001 670 * @tc.name: SetPopupSupported 671 * @tc.desc: Test function SetPopupSupported, IsPopupSupported 672 */ 673 HWTEST_F(AccessibilityElementInfoTest, SetPopupSupported_001, TestSize.Level1) 674 { 675 GTEST_LOG_(INFO) << "SetPopupSupported_001 start"; 676 elementInfo_->SetPopupSupported(true); 677 EXPECT_TRUE(elementInfo_->IsPopupSupported()); 678 GTEST_LOG_(INFO) << "SetPopupSupported_001 end"; 679 } 680 681 /** 682 * @tc.number: SetDeletable_001 683 * @tc.name: SetDeletable 684 * @tc.desc: Test function SetDeletable, IsDeletable 685 */ 686 HWTEST_F(AccessibilityElementInfoTest, SetDeletable_001, TestSize.Level1) 687 { 688 GTEST_LOG_(INFO) << "SetDeletable_001 start"; 689 elementInfo_->SetDeletable(true); 690 EXPECT_TRUE(elementInfo_->IsDeletable()); 691 GTEST_LOG_(INFO) << "SetDeletable_001 end"; 692 } 693 694 /** 695 * @tc.number: SetEssential_001 696 * @tc.name: SetEssential 697 * @tc.desc: Test function SetEssential, IsEssential 698 */ 699 HWTEST_F(AccessibilityElementInfoTest, SetEssential_001, TestSize.Level1) 700 { 701 GTEST_LOG_(INFO) << "SetEssential_001 start"; 702 elementInfo_->SetEssential(true); 703 EXPECT_TRUE(elementInfo_->IsEssential()); 704 GTEST_LOG_(INFO) << "SetEssential_001 end"; 705 } 706 707 /** 708 * @tc.number: SetHinting_001 709 * @tc.name: SetHinting 710 * @tc.desc: Test function SetHinting, IsGivingHint 711 */ 712 HWTEST_F(AccessibilityElementInfoTest, SetHinting_001, TestSize.Level1) 713 { 714 GTEST_LOG_(INFO) << "SetHinting_001 start"; 715 elementInfo_->SetHinting(true); 716 EXPECT_TRUE(elementInfo_->IsGivingHint()); 717 GTEST_LOG_(INFO) << "SetHinting_001 end"; 718 } 719 720 /** 721 * @tc.number: SetBundleName_001 722 * @tc.name: SetBundleName 723 * @tc.desc: Test function SetBundleName, GetBundleName 724 */ 725 HWTEST_F(AccessibilityElementInfoTest, SetBundleName_001, TestSize.Level1) 726 { 727 GTEST_LOG_(INFO) << "SetBundleName_001 start"; 728 elementInfo_->SetBundleName("test"); 729 EXPECT_STREQ(elementInfo_->GetBundleName().c_str(), "test"); 730 GTEST_LOG_(INFO) << "SetBundleName_001 end"; 731 } 732 733 /** 734 * @tc.number: SetComponentType_001 735 * @tc.name: SetComponentType 736 * @tc.desc: Test function SetComponentType, GetComponentType 737 */ 738 HWTEST_F(AccessibilityElementInfoTest, SetComponentType_001, TestSize.Level1) 739 { 740 GTEST_LOG_(INFO) << "SetComponentType_001 start"; 741 elementInfo_->SetComponentType("test"); 742 EXPECT_STREQ(elementInfo_->GetComponentType().c_str(), "test"); 743 GTEST_LOG_(INFO) << "SetComponentType_001 end"; 744 } 745 746 /** 747 * @tc.number: SetContent_001 748 * @tc.name: SetContent 749 * @tc.desc: Test function SetContent, GetContent 750 */ 751 HWTEST_F(AccessibilityElementInfoTest, SetContent_001, TestSize.Level1) 752 { 753 GTEST_LOG_(INFO) << "SetContent_001 start"; 754 elementInfo_->SetContent("test"); 755 EXPECT_STREQ(elementInfo_->GetContent().c_str(), "test"); 756 GTEST_LOG_(INFO) << "SetContent_001 end"; 757 } 758 759 /** 760 * @tc.number: SetHint_001 761 * @tc.name: SetHint 762 * @tc.desc: Test function SetHint, GetHint 763 */ 764 HWTEST_F(AccessibilityElementInfoTest, SetHint_001, TestSize.Level1) 765 { 766 GTEST_LOG_(INFO) << "SetHint_001 start"; 767 elementInfo_->SetHint("test"); 768 EXPECT_STREQ(elementInfo_->GetHint().c_str(), "test"); 769 GTEST_LOG_(INFO) << "SetHint_001 end"; 770 } 771 772 /** 773 * @tc.number: SetDescriptionInfo_001 774 * @tc.name: SetDescriptionInfo 775 * @tc.desc: Test function SetDescriptionInfo, GetDescriptionInfo 776 */ 777 HWTEST_F(AccessibilityElementInfoTest, SetDescriptionInfo_001, TestSize.Level1) 778 { 779 GTEST_LOG_(INFO) << "SetDescriptionInfo_001 start"; 780 elementInfo_->SetDescriptionInfo("test"); 781 EXPECT_STREQ(elementInfo_->GetDescriptionInfo().c_str(), "test"); 782 GTEST_LOG_(INFO) << "SetDescriptionInfo_001 end"; 783 } 784 785 /** 786 * @tc.number: SetComponentResourceId_001 787 * @tc.name: SetComponentResourceId 788 * @tc.desc: Test function SetComponentResourceId, GetComponentResourceId 789 */ 790 HWTEST_F(AccessibilityElementInfoTest, SetComponentResourceId_001, TestSize.Level1) 791 { 792 GTEST_LOG_(INFO) << "SetComponentResourceId_001 start"; 793 elementInfo_->SetComponentResourceId("test"); 794 EXPECT_STREQ(elementInfo_->GetComponentResourceId().c_str(), "test"); 795 GTEST_LOG_(INFO) << "SetComponentResourceId_001 end"; 796 } 797 798 /** 799 * @tc.number: SetLiveRegion_001 800 * @tc.name: SetLiveRegion 801 * @tc.desc: Test function SetLiveRegion, GetLiveRegion 802 */ 803 HWTEST_F(AccessibilityElementInfoTest, SetLiveRegion_001, TestSize.Level1) 804 { 805 GTEST_LOG_(INFO) << "SetLiveRegion_001 start"; 806 elementInfo_->SetLiveRegion(1); 807 EXPECT_EQ(elementInfo_->GetLiveRegion(), 1); 808 GTEST_LOG_(INFO) << "SetLiveRegion_001 end"; 809 } 810 811 /** 812 * @tc.number: SetContentInvalid_001 813 * @tc.name: SetContentInvalid 814 * @tc.desc: Test function SetContentInvalid, GetContentInvalid 815 */ 816 HWTEST_F(AccessibilityElementInfoTest, SetContentInvalid_001, TestSize.Level1) 817 { 818 GTEST_LOG_(INFO) << "SetContentInvalid_001 start"; 819 elementInfo_->SetContentInvalid(false); 820 EXPECT_FALSE(elementInfo_->GetContentInvalid()); 821 GTEST_LOG_(INFO) << "SetContentInvalid_001 end"; 822 } 823 824 /** 825 * @tc.number: SetError_001 826 * @tc.name: SetError 827 * @tc.desc: Test function SetError, GetError 828 */ 829 HWTEST_F(AccessibilityElementInfoTest, SetError_001, TestSize.Level1) 830 { 831 GTEST_LOG_(INFO) << "SetError_001 start"; 832 elementInfo_->SetError("test"); 833 EXPECT_STREQ(elementInfo_->GetError().c_str(), "test"); 834 GTEST_LOG_(INFO) << "SetError_001 end"; 835 } 836 837 /** 838 * @tc.number: SetLabeled_001 839 * @tc.name: SetLabeled 840 * @tc.desc: Test function SetLabeled, GetLabeledAccessibilityId 841 */ 842 HWTEST_F(AccessibilityElementInfoTest, SetLabeled_001, TestSize.Level1) 843 { 844 GTEST_LOG_(INFO) << "SetLabeled_001 start"; 845 elementInfo_->SetLabeled(1); 846 EXPECT_EQ(elementInfo_->GetLabeledAccessibilityId(), 1); 847 GTEST_LOG_(INFO) << "SetLabeled_001 end"; 848 } 849 850 /** 851 * @tc.number: SetAccessibilityId_001 852 * @tc.name: SetAccessibilityId 853 * @tc.desc: Test function SetAccessibilityId, GetAccessibilityId 854 */ 855 HWTEST_F(AccessibilityElementInfoTest, SetAccessibilityId_001, TestSize.Level1) 856 { 857 GTEST_LOG_(INFO) << "SetAccessibilityId_001 start"; 858 elementInfo_->SetAccessibilityId(1); 859 EXPECT_EQ(elementInfo_->GetAccessibilityId(), 1); 860 GTEST_LOG_(INFO) << "SetAccessibilityId_001 end"; 861 } 862 863 /** 864 * @tc.number: SetRange_001 865 * @tc.name: SetRange 866 * @tc.desc: Test function SetRange, GetRange 867 */ 868 HWTEST_F(AccessibilityElementInfoTest, SetRange_001, TestSize.Level1) 869 { 870 GTEST_LOG_(INFO) << "SetRange_001 start"; 871 RangeInfo rangeInfo(1, 1, 1); 872 elementInfo_->SetRange(rangeInfo); 873 EXPECT_EQ(elementInfo_->GetRange().GetMin(), 1); 874 EXPECT_EQ(elementInfo_->GetRange().GetMax(), 1); 875 EXPECT_EQ(elementInfo_->GetRange().GetCurrent(), 1); 876 GTEST_LOG_(INFO) << "SetRange_001 end"; 877 } 878 879 /** 880 * @tc.number: SetSelectedBegin_001 881 * @tc.name: SetSelectedBegin 882 * @tc.desc: Test function SetSelectedBegin, GetSelectedBegin 883 */ 884 HWTEST_F(AccessibilityElementInfoTest, SetSelectedBegin_001, TestSize.Level1) 885 { 886 GTEST_LOG_(INFO) << "SetSelectedBegin_001 start"; 887 elementInfo_->SetSelectedBegin(1); 888 EXPECT_EQ(elementInfo_->GetSelectedBegin(), 1); 889 GTEST_LOG_(INFO) << "SetSelectedBegin_001 end"; 890 } 891 892 /** 893 * @tc.number: SetSelectedEnd_001 894 * @tc.name: SetSelectedEnd 895 * @tc.desc: Test function SetSelectedEnd, GetSelectedEnd 896 */ 897 HWTEST_F(AccessibilityElementInfoTest, SetSelectedEnd_001, TestSize.Level1) 898 { 899 GTEST_LOG_(INFO) << "SetSelectedEnd_001 start"; 900 elementInfo_->SetSelectedEnd(1); 901 EXPECT_EQ(elementInfo_->GetSelectedEnd(), 1); 902 GTEST_LOG_(INFO) << "SetSelectedEnd_001 end"; 903 } 904 905 /** 906 * @tc.number: SetGrid_001 907 * @tc.name: SetGrid 908 * @tc.desc: Test function SetGrid, GetGrid 909 */ 910 HWTEST_F(AccessibilityElementInfoTest, SetGrid_001, TestSize.Level1) 911 { 912 GTEST_LOG_(INFO) << "SetGrid_001 start"; 913 GridInfo grid(1, 1, 1); 914 elementInfo_->SetGrid(grid); 915 EXPECT_EQ(elementInfo_->GetGrid().GetRowCount(), 1); 916 EXPECT_EQ(elementInfo_->GetGrid().GetColumnCount(), 1); 917 EXPECT_EQ(elementInfo_->GetGrid().GetSelectionMode(), 1); 918 GTEST_LOG_(INFO) << "SetGrid_001 end"; 919 } 920 921 /** 922 * @tc.number: SetGridItem_001 923 * @tc.name: SetGridItem 924 * @tc.desc: Test function SetGridItem, GetGridItem 925 */ 926 HWTEST_F(AccessibilityElementInfoTest, SetGridItem_001, TestSize.Level1) 927 { 928 GTEST_LOG_(INFO) << "SetGridItem_001 start"; 929 GridItemInfo gridItem(1, 1, 1, 1, true, true); 930 elementInfo_->SetGridItem(gridItem); 931 EXPECT_EQ(elementInfo_->GetGridItem().GetColumnIndex(), 1); 932 EXPECT_EQ(elementInfo_->GetGridItem().GetRowIndex(), 1); 933 EXPECT_EQ(elementInfo_->GetGridItem().GetColumnSpan(), 1); 934 EXPECT_EQ(elementInfo_->GetGridItem().GetRowSpan(), 1); 935 EXPECT_TRUE(elementInfo_->GetGridItem().IsHeading()); 936 EXPECT_TRUE(elementInfo_->GetGridItem().IsSelected()); 937 GTEST_LOG_(INFO) << "SetGridItem_001 end"; 938 } 939 940 /** 941 * @tc.number: SetCurrentIndex_001 942 * @tc.name: SetCurrentIndex 943 * @tc.desc: Test function SetCurrentIndex, GetCurrentIndex 944 */ 945 HWTEST_F(AccessibilityElementInfoTest, SetCurrentIndex_001, TestSize.Level1) 946 { 947 GTEST_LOG_(INFO) << "SetCurrentIndex_001 start"; 948 elementInfo_->SetCurrentIndex(1); 949 EXPECT_EQ(elementInfo_->GetCurrentIndex(), 1); 950 GTEST_LOG_(INFO) << "SetCurrentIndex_001 end"; 951 } 952 953 /** 954 * @tc.number: SetBeginIndex_001 955 * @tc.name: SetBeginIndex 956 * @tc.desc: Test function SetBeginIndex, GetBeginIndex 957 */ 958 HWTEST_F(AccessibilityElementInfoTest, SetBeginIndex_001, TestSize.Level1) 959 { 960 GTEST_LOG_(INFO) << "SetBeginIndex_001 start"; 961 elementInfo_->SetBeginIndex(1); 962 EXPECT_EQ(elementInfo_->GetBeginIndex(), 1); 963 GTEST_LOG_(INFO) << "SetBeginIndex_001 end"; 964 } 965 966 /** 967 * @tc.number: SetEndIndex_001 968 * @tc.name: SetEndIndex 969 * @tc.desc: Test function SetEndIndex, GetEndIndex 970 */ 971 HWTEST_F(AccessibilityElementInfoTest, SetEndIndex_001, TestSize.Level1) 972 { 973 GTEST_LOG_(INFO) << "SetEndIndex_001 start"; 974 elementInfo_->SetEndIndex(1); 975 EXPECT_EQ(elementInfo_->GetEndIndex(), 1); 976 GTEST_LOG_(INFO) << "SetEndIndex_001 end"; 977 } 978 979 /** 980 * @tc.number: SetInputType_001 981 * @tc.name: SetInputType 982 * @tc.desc: Test function SetInputType, GetInputType 983 */ 984 HWTEST_F(AccessibilityElementInfoTest, SetInputType_001, TestSize.Level1) 985 { 986 GTEST_LOG_(INFO) << "SetInputType_001 start"; 987 elementInfo_->SetInputType(1); 988 EXPECT_EQ(elementInfo_->GetInputType(), 1); 989 GTEST_LOG_(INFO) << "SetInputType_001 end"; 990 } 991 992 /** 993 * @tc.number: SetValidElement_001 994 * @tc.name: SetValidElement 995 * @tc.desc: Test function SetValidElement, IsValidElement 996 */ 997 HWTEST_F(AccessibilityElementInfoTest, SetValidElement_001, TestSize.Level1) 998 { 999 GTEST_LOG_(INFO) << "SetValidElement_001 start"; 1000 elementInfo_->SetValidElement(false); 1001 EXPECT_FALSE(elementInfo_->IsValidElement()); 1002 GTEST_LOG_(INFO) << "SetValidElement_001 end"; 1003 } 1004 1005 /** 1006 * @tc.number: SetInspectorKey_001 1007 * @tc.name: SetInspectorKey 1008 * @tc.desc: Test function SetInspectorKey, GetInspectorKey 1009 */ 1010 HWTEST_F(AccessibilityElementInfoTest, SetInspectorKey_001, TestSize.Level1) 1011 { 1012 GTEST_LOG_(INFO) << "SetInspectorKey_001 start"; 1013 elementInfo_->SetInspectorKey("test"); 1014 EXPECT_STREQ(elementInfo_->GetInspectorKey().c_str(), "test"); 1015 GTEST_LOG_(INFO) << "SetInspectorKey_001 end"; 1016 } 1017 1018 /** 1019 * @tc.number: SetPagePath_001 1020 * @tc.name: SetPagePath 1021 * @tc.desc: Test function SetPagePath, GetPagePath 1022 */ 1023 HWTEST_F(AccessibilityElementInfoTest, SetPagePath_001, TestSize.Level1) 1024 { 1025 GTEST_LOG_(INFO) << "SetPagePath_001 start"; 1026 elementInfo_->SetPagePath("test"); 1027 EXPECT_STREQ(elementInfo_->GetPagePath().c_str(), "test"); 1028 GTEST_LOG_(INFO) << "SetPagePath_001 end"; 1029 } 1030 1031 /** 1032 * @tc.number: SetPageId_001 1033 * @tc.name: SetPageId 1034 * @tc.desc: Test function SetPageId, GetPageId 1035 */ 1036 HWTEST_F(AccessibilityElementInfoTest, SetPageId_001, TestSize.Level1) 1037 { 1038 GTEST_LOG_(INFO) << "SetPageId_001 start"; 1039 elementInfo_->SetPageId(1); 1040 EXPECT_EQ(elementInfo_->GetPageId(), 1); 1041 GTEST_LOG_(INFO) << "SetPageId_001 end"; 1042 } 1043 1044 /** 1045 * @tc.number: SetTextMovementStep_001 1046 * @tc.name: SetTextMovementStep 1047 * @tc.desc: Test function SetTextMovementStep, GetTextMovementStep 1048 */ 1049 HWTEST_F(AccessibilityElementInfoTest, SetTextMovementStep_001, TestSize.Level1) 1050 { 1051 GTEST_LOG_(INFO) << "SetTextMovementStep_001 start"; 1052 elementInfo_->SetTextMovementStep(STEP_CHARACTER); 1053 EXPECT_EQ(elementInfo_->GetTextMovementStep(), STEP_CHARACTER); 1054 GTEST_LOG_(INFO) << "SetTextMovementStep_001 end"; 1055 } 1056 1057 /** 1058 * @tc.number: SetItemCounts_001 1059 * @tc.name: SetItemCounts 1060 * @tc.desc: Test function SetItemCounts, GetItemCounts 1061 */ 1062 HWTEST_F(AccessibilityElementInfoTest, SetItemCounts_001, TestSize.Level1) 1063 { 1064 GTEST_LOG_(INFO) << "SetItemCounts_001 start"; 1065 elementInfo_->SetItemCounts(1); 1066 EXPECT_EQ(elementInfo_->GetItemCounts(), 1); 1067 GTEST_LOG_(INFO) << "SetItemCounts_001 end"; 1068 } 1069 1070 /** 1071 * @tc.number: SetTriggerAction_001 1072 * @tc.name: SetTriggerAction 1073 * @tc.desc: Test function SetTriggerAction, GetTriggerAction 1074 */ 1075 HWTEST_F(AccessibilityElementInfoTest, SetTriggerAction_001, TestSize.Level1) 1076 { 1077 GTEST_LOG_(INFO) << "SetTriggerAction_001 start"; 1078 elementInfo_->SetTriggerAction(ACCESSIBILITY_ACTION_FOCUS); 1079 EXPECT_EQ(elementInfo_->GetTriggerAction(), ACCESSIBILITY_ACTION_FOCUS); 1080 GTEST_LOG_(INFO) << "SetTriggerAction_001 end"; 1081 } 1082 1083 /** 1084 * @tc.number: SetContentList_001 1085 * @tc.name: SetContentList 1086 * @tc.desc: Test function SetContentList, GetContentList 1087 */ 1088 HWTEST_F(AccessibilityElementInfoTest, SetContentList_001, TestSize.Level1) 1089 { 1090 GTEST_LOG_(INFO) << "SetContentList_001 start"; 1091 std::vector<std::string> contentList; 1092 contentList.push_back("test"); 1093 elementInfo_->SetContentList(contentList); 1094 1095 std::vector<std::string> result; 1096 elementInfo_->GetContentList(result); 1097 ASSERT_EQ(static_cast<int>(result.size()), 1); 1098 EXPECT_STREQ(result.front().c_str(), "test"); 1099 GTEST_LOG_(INFO) << "SetContentList_001 end"; 1100 } 1101 1102 /** 1103 * @tc.number: SetLatestContent_001 1104 * @tc.name: SetLatestContent 1105 * @tc.desc: Test function SetLatestContent, GetLatestContent 1106 */ 1107 HWTEST_F(AccessibilityElementInfoTest, SetLatestContent_001, TestSize.Level1) 1108 { 1109 GTEST_LOG_(INFO) << "SetLatestContent_001 start"; 1110 elementInfo_->SetLatestContent("test"); 1111 EXPECT_STREQ(elementInfo_->GetLatestContent().c_str(), "test"); 1112 GTEST_LOG_(INFO) << "SetLatestContent_001 end"; 1113 } 1114 1115 /** 1116 * @tc.number: SetMin_001 1117 * @tc.name: SetMin 1118 * @tc.desc: Test function SetMin, GetMin 1119 */ 1120 HWTEST_F(RangeInfoTest, SetMin_001, TestSize.Level1) 1121 { 1122 GTEST_LOG_(INFO) << "SetMin_001 start"; 1123 rangeInfo_->SetMin(1); 1124 EXPECT_EQ(rangeInfo_->GetMin(), 1); 1125 GTEST_LOG_(INFO) << "SetMin_001 end"; 1126 } 1127 1128 /** 1129 * @tc.number: SetMax_001 1130 * @tc.name: SetMax 1131 * @tc.desc: Test function SetMax, GetMax 1132 */ 1133 HWTEST_F(RangeInfoTest, SetMax_001, TestSize.Level1) 1134 { 1135 GTEST_LOG_(INFO) << "SetMax_001 start"; 1136 rangeInfo_->SetMax(10); 1137 EXPECT_EQ(rangeInfo_->GetMax(), 10); 1138 GTEST_LOG_(INFO) << "SetMax_001 end"; 1139 } 1140 1141 /** 1142 * @tc.number: SetCurrent_001 1143 * @tc.name: SetCurrent 1144 * @tc.desc: Test function SetCurrent, GetMax 1145 */ 1146 HWTEST_F(RangeInfoTest, SetCurrent_001, TestSize.Level1) 1147 { 1148 GTEST_LOG_(INFO) << "SetCurrent_001 start"; 1149 rangeInfo_->SetCurrent(5); 1150 EXPECT_EQ(rangeInfo_->GetCurrent(), 5); 1151 GTEST_LOG_(INFO) << "SetCurrent_001 end"; 1152 } 1153 1154 /** 1155 * @tc.number: SetGrid_001 1156 * @tc.name: SetGrid 1157 * @tc.desc: Test function SetGrid, GetRowCount, GetColumnCount, GetSelectionMode 1158 */ 1159 HWTEST_F(GridInfoTest, SetGrid_001, TestSize.Level1) 1160 { 1161 GTEST_LOG_(INFO) << "SetGrid_001 start"; 1162 gridInfo_->SetGrid(1, 2, 3); 1163 EXPECT_EQ(gridInfo_->GetRowCount(), 1); 1164 EXPECT_EQ(gridInfo_->GetColumnCount(), 2); 1165 EXPECT_EQ(gridInfo_->GetSelectionMode(), 3); 1166 GTEST_LOG_(INFO) << "SetGrid_001 end"; 1167 } 1168 1169 /** 1170 * @tc.number: SetGrid_002 1171 * @tc.name: SetGrid 1172 * @tc.desc: Test function SetGrid, GetRowCount, GetColumnCount, GetSelectionMode 1173 */ 1174 HWTEST_F(GridInfoTest, SetGrid_002, TestSize.Level1) 1175 { 1176 GTEST_LOG_(INFO) << "SetGrid_002 start"; 1177 GridInfo grid(11, 12, 13); 1178 gridInfo_->SetGrid(grid); 1179 EXPECT_EQ(gridInfo_->GetRowCount(), 11); 1180 EXPECT_EQ(gridInfo_->GetColumnCount(), 12); 1181 EXPECT_EQ(gridInfo_->GetSelectionMode(), 13); 1182 GTEST_LOG_(INFO) << "SetGrid_002 end"; 1183 } 1184 1185 /** 1186 * @tc.number: SetGridItemInfo_001 1187 * @tc.name: SetGridItemInfo 1188 * @tc.desc: Test function SetGridItemInfo, GetRowIndex, GetRowSpan, GetColumnIndex, GetColumnSpan, IsHeading, 1189 * IsSelected 1190 */ 1191 HWTEST_F(GridItemInfoTest, SetGridItemInfo_001, TestSize.Level1) 1192 { 1193 GTEST_LOG_(INFO) << "SetGridItemInfo_001 start"; 1194 gridItemInfo_->SetGridItemInfo(1, 1, 1, 1, true, true); 1195 EXPECT_EQ(gridItemInfo_->GetRowIndex(), 1); 1196 EXPECT_EQ(gridItemInfo_->GetRowSpan(), 1); 1197 EXPECT_EQ(gridItemInfo_->GetColumnIndex(), 1); 1198 EXPECT_EQ(gridItemInfo_->GetColumnSpan(), 1); 1199 EXPECT_TRUE(gridItemInfo_->IsHeading()); 1200 EXPECT_TRUE(gridItemInfo_->IsSelected()); 1201 GTEST_LOG_(INFO) << "SetGridItemInfo_001 end"; 1202 } 1203 1204 /** 1205 * @tc.number: SetGridItemInfo_002 1206 * @tc.name: SetGridItemInfo 1207 * @tc.desc: Test function SetGridItemInfo, GetRowIndex, GetRowSpan, GetColumnIndex, GetColumnSpan, IsHeading, 1208 * IsSelected 1209 */ 1210 HWTEST_F(GridItemInfoTest, SetGridItemInfo_002, TestSize.Level1) 1211 { 1212 GTEST_LOG_(INFO) << "SetGridItemInfo_002 start"; 1213 GridItemInfo itemInfo(11, 12, 13, 14, false, false); 1214 gridItemInfo_->SetGridItemInfo(itemInfo); 1215 EXPECT_EQ(gridItemInfo_->GetRowIndex(), 11); 1216 EXPECT_EQ(gridItemInfo_->GetRowSpan(), 12); 1217 EXPECT_EQ(gridItemInfo_->GetColumnIndex(), 13); 1218 EXPECT_EQ(gridItemInfo_->GetColumnSpan(), 14); 1219 EXPECT_FALSE(gridItemInfo_->IsHeading()); 1220 EXPECT_FALSE(gridItemInfo_->IsSelected()); 1221 GTEST_LOG_(INFO) << "SetGridItemInfo_002 end"; 1222 } 1223 1224 /** 1225 * @tc.number: AccessibleAction_001 1226 * @tc.name: AccessibleAction 1227 * @tc.desc: Test function AccessibleAction, GetActionType, GetDescriptionInfo 1228 */ 1229 HWTEST_F(AccessibleActionTest, AccessibleAction_001, TestSize.Level1) 1230 { 1231 GTEST_LOG_(INFO) << "AccessibleAction_001 start"; 1232 std::shared_ptr<AccessibleAction> action = std::make_shared<AccessibleAction>(ACCESSIBILITY_ACTION_FOCUS, "test"); 1233 ASSERT_TRUE(action); 1234 EXPECT_EQ(action->GetActionType(), ACCESSIBILITY_ACTION_FOCUS); 1235 EXPECT_STREQ(action->GetDescriptionInfo().c_str(), "test"); 1236 action = nullptr; 1237 GTEST_LOG_(INFO) << "AccessibleAction_001 end"; 1238 } 1239 1240 /** 1241 * @tc.number: AccessibleAction_002 1242 * @tc.name: AccessibleAction 1243 * @tc.desc: Test function AccessibleAction, GetActionType, GetDescriptionInfo 1244 */ 1245 HWTEST_F(AccessibleActionTest, AccessibleAction_002, TestSize.Level1) 1246 { 1247 GTEST_LOG_(INFO) << "AccessibleAction_002 start"; 1248 std::shared_ptr<AccessibleAction> action = std::make_shared<AccessibleAction>(); 1249 ASSERT_TRUE(action); 1250 EXPECT_EQ(action->GetActionType(), ACCESSIBILITY_ACTION_INVALID); 1251 EXPECT_STREQ(action->GetDescriptionInfo().c_str(), ""); 1252 action = nullptr; 1253 GTEST_LOG_(INFO) << "AccessibleAction_002 end"; 1254 } 1255 1256 /** 1257 * @tc.number: Rect_001 1258 * @tc.name: Rect 1259 * @tc.desc: Test function Rect. 1260 */ 1261 HWTEST_F(AccessibilityElementInfoTest, Rect_001, TestSize.Level1) 1262 { 1263 GTEST_LOG_(INFO) << "Rect_001 start"; 1264 Rect rect(1, 1, 1, 1); 1265 EXPECT_EQ(rect.GetLeftTopXScreenPostion(), 1); 1266 EXPECT_EQ(rect.GetLeftTopYScreenPostion(), 1); 1267 EXPECT_EQ(rect.GetRightBottomXScreenPostion(), 1); 1268 EXPECT_EQ(rect.GetRightBottomYScreenPostion(), 1); 1269 GTEST_LOG_(INFO) << "Rect_001 end"; 1270 } 1271 1272 /** 1273 * @tc.number: SetAccessibilityText_001 1274 * @tc.name: SetAccessibilityText 1275 * @tc.desc: Test function SetAccessibilityText, GetAccessibilityText 1276 */ 1277 HWTEST_F(AccessibilityElementInfoTest, SetAccessibilityText_001, TestSize.Level1) 1278 { 1279 GTEST_LOG_(INFO) << "SetAccessibilityText_001 start"; 1280 elementInfo_->SetAccessibilityText("test"); 1281 EXPECT_STREQ(elementInfo_->GetAccessibilityText().c_str(), "test"); 1282 GTEST_LOG_(INFO) << "SetAccessibilityText_001 end"; 1283 } 1284 1285 /** 1286 * @tc.number: SetTextType_001 1287 * @tc.name: SetTextType 1288 * @tc.desc: Test function SetTextType, GetTextType 1289 */ 1290 HWTEST_F(AccessibilityElementInfoTest, SetTextType_001, TestSize.Level1) 1291 { 1292 GTEST_LOG_(INFO) << "SetTextType_001 start"; 1293 elementInfo_->SetTextType("test"); 1294 EXPECT_STREQ(elementInfo_->GetTextType().c_str(), "test"); 1295 GTEST_LOG_(INFO) << "SetTextType_001 end"; 1296 } 1297 1298 /** 1299 * @tc.number: SetOffset_001 1300 * @tc.name: SetOffset 1301 * @tc.desc: Test function SetOffset, GetOffset 1302 */ 1303 HWTEST_F(AccessibilityElementInfoTest, SetOffset_001, TestSize.Level1) 1304 { 1305 GTEST_LOG_(INFO) << "SetOffset_001 start"; 1306 elementInfo_->SetOffset(6.6f); 1307 EXPECT_FLOAT_EQ(elementInfo_->GetOffset(), 6.6f); 1308 GTEST_LOG_(INFO) << "SetOffset_001 end"; 1309 } 1310 1311 /** 1312 * @tc.number: SetChildTreeIdAndWinId_001 1313 * @tc.name: SetChildTreeIdAndWinId 1314 * @tc.desc: Test function SetChildTreeIdAndWinId GetChildTreeId GetChildWindowId 1315 */ 1316 HWTEST_F(AccessibilityElementInfoTest, SetChildTreeIdAndWinId_001, TestSize.Level1) 1317 { 1318 GTEST_LOG_(INFO) << "SetChildTreeIdAndWinId_001 start"; 1319 elementInfo_->SetChildTreeIdAndWinId(1, 2); 1320 EXPECT_EQ(elementInfo_->GetChildTreeId(), 1); 1321 EXPECT_EQ(elementInfo_->GetChildWindowId(), 2); 1322 GTEST_LOG_(INFO) << "SetChildTreeIdAndWinId_001 end"; 1323 } 1324 1325 /** 1326 * @tc.number: SetBelongTreeId_001 1327 * @tc.name: SetBelongTreeId 1328 * @tc.desc: Test function SetBelongTreeId, GetBelongTreeId 1329 */ 1330 HWTEST_F(AccessibilityElementInfoTest, SetBelongTreeId_001, TestSize.Level1) 1331 { 1332 GTEST_LOG_(INFO) << "SetBelongTreeId_001 start"; 1333 elementInfo_->SetBelongTreeId(1); 1334 EXPECT_EQ(elementInfo_->GetBelongTreeId(), 1); 1335 GTEST_LOG_(INFO) << "SetBelongTreeId_001 end"; 1336 } 1337 1338 /** 1339 * @tc.number: SetParentWindowId_001 1340 * @tc.name: SetParentWindowId 1341 * @tc.desc: Test function SetParentWindowId, GetParentWindowId 1342 */ 1343 HWTEST_F(AccessibilityElementInfoTest, SetParentWindowId_001, TestSize.Level1) 1344 { 1345 GTEST_LOG_(INFO) << "SetParentWindowId_001 start"; 1346 elementInfo_->SetParentWindowId(1); 1347 EXPECT_EQ(elementInfo_->GetParentWindowId(), 1); 1348 GTEST_LOG_(INFO) << "SetParentWindowId_001 end"; 1349 } 1350 1351 /** 1352 * @tc.number: SetAccessibilityGroup_001 1353 * @tc.name: SetAccessibilityGroup 1354 * @tc.desc: Test function SetAccessibilityGroup, GetAccessibilityGroup 1355 */ 1356 HWTEST_F(AccessibilityElementInfoTest, SetAccessibilityGroup_001, TestSize.Level1) 1357 { 1358 GTEST_LOG_(INFO) << "SetAccessibilityGroup_001 start"; 1359 elementInfo_->SetAccessibilityGroup(false); 1360 EXPECT_FALSE(elementInfo_->GetAccessibilityGroup()); 1361 GTEST_LOG_(INFO) << "SetAccessibilityGroup_001 end"; 1362 } 1363 1364 /** 1365 * @tc.number: SetAccessibilityLevel_001 1366 * @tc.name: SetAccessibilityLevel 1367 * @tc.desc: Test function SetAccessibilityLevel, GetAccessibilityLevel 1368 */ 1369 HWTEST_F(AccessibilityElementInfoTest, SetAccessibilityLevel_001, TestSize.Level1) 1370 { 1371 GTEST_LOG_(INFO) << "SetAccessibilityLevel_001 start"; 1372 elementInfo_->SetAccessibilityLevel("test"); 1373 EXPECT_STREQ(elementInfo_->GetAccessibilityLevel().c_str(), "test"); 1374 GTEST_LOG_(INFO) << "SetAccessibilityLevel_001 end"; 1375 } 1376 1377 /** 1378 * @tc.number: SetZIndex_001 1379 * @tc.name: SetZIndex 1380 * @tc.desc: Test function SetZIndex, GetZIndex 1381 */ 1382 HWTEST_F(AccessibilityElementInfoTest, SetZIndex_001, TestSize.Level1) 1383 { 1384 GTEST_LOG_(INFO) << "SetZIndex_001 start"; 1385 elementInfo_->SetZIndex(1); 1386 EXPECT_EQ(elementInfo_->GetZIndex(), 1); 1387 GTEST_LOG_(INFO) << "SetZIndex_001 end"; 1388 } 1389 1390 /** 1391 * @tc.number: SetOpacity_001 1392 * @tc.name: SetOpacity 1393 * @tc.desc: Test function SetOpacity, GetOpacity 1394 */ 1395 HWTEST_F(AccessibilityElementInfoTest, SetOpacity_001, TestSize.Level1) 1396 { 1397 GTEST_LOG_(INFO) << "SetOpacity_001 start"; 1398 elementInfo_->SetOpacity(0.5f); 1399 EXPECT_FLOAT_EQ(elementInfo_->GetOpacity(), 0.5f); 1400 GTEST_LOG_(INFO) << "SetOpacity_001 end"; 1401 } 1402 1403 /** 1404 * @tc.number: SetBackgroundColor_001 1405 * @tc.name: SetBackgroundColor 1406 * @tc.desc: Test function SetBackgroundColor, GetBackgroundColor 1407 */ 1408 HWTEST_F(AccessibilityElementInfoTest, SetBackgroundColor_001, TestSize.Level1) 1409 { 1410 GTEST_LOG_(INFO) << "SetBackgroundColor_001 start"; 1411 elementInfo_->SetBackgroundColor("test"); 1412 EXPECT_STREQ(elementInfo_->GetBackgroundColor().c_str(), "test"); 1413 GTEST_LOG_(INFO) << "SetBackgroundColor_001 end"; 1414 } 1415 1416 /** 1417 * @tc.number: SetBackgroundImage_001 1418 * @tc.name: SetBackgroundImage 1419 * @tc.desc: Test function SetBackgroundImage, GetBackgroundImage 1420 */ 1421 HWTEST_F(AccessibilityElementInfoTest, SetBackgroundImage_001, TestSize.Level1) 1422 { 1423 GTEST_LOG_(INFO) << "SetBackgroundImage_001 start"; 1424 elementInfo_->SetBackgroundImage("test"); 1425 EXPECT_STREQ(elementInfo_->GetBackgroundImage().c_str(), "test"); 1426 GTEST_LOG_(INFO) << "SetBackgroundImage_001 end"; 1427 } 1428 1429 /** 1430 * @tc.number: SetBlur_001 1431 * @tc.name: SetBlur 1432 * @tc.desc: Test function SetBlur, GetBlur 1433 */ 1434 HWTEST_F(AccessibilityElementInfoTest, SetBlur_001, TestSize.Level1) 1435 { 1436 GTEST_LOG_(INFO) << "SetBlur_001 start"; 1437 elementInfo_->SetBlur("test"); 1438 EXPECT_STREQ(elementInfo_->GetBlur().c_str(), "test"); 1439 GTEST_LOG_(INFO) << "SetBlur_001 end"; 1440 } 1441 1442 /** 1443 * @tc.number: SetHitTestBehavior_001 1444 * @tc.name: SetHitTestBehavior 1445 * @tc.desc: Test function SetHitTestBehavior, GetHitTestBehavior 1446 */ 1447 HWTEST_F(AccessibilityElementInfoTest, SetHitTestBehavior_001, TestSize.Level1) 1448 { 1449 GTEST_LOG_(INFO) << "SetHitTestBehavior_001 start"; 1450 elementInfo_->SetHitTestBehavior("test"); 1451 EXPECT_STREQ(elementInfo_->GetHitTestBehavior().c_str(), "test"); 1452 GTEST_LOG_(INFO) << "SetHitTestBehavior_001 end"; 1453 } 1454 } // namespace Accessibility 1455 } // namespace OHOS