1 /* 2 * Copyright (C) 2022-2025 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 <vector> 17 #include <gtest/gtest.h> 18 #include "accessibility_config.h" 19 #include "parameter.h" 20 #include "system_ability_definition.h" 21 22 using namespace testing; 23 using namespace testing::ext; 24 25 namespace OHOS { 26 namespace AccessibilityConfig { 27 namespace { 28 constexpr float BRIGHTNESS_DISCOUNT_VALUE = 0.2f; 29 } // namespace 30 31 class AccessibilityConfigImplTest : public ::testing::Test { 32 public: AccessibilityConfigImplTest()33 AccessibilityConfigImplTest() 34 {} ~AccessibilityConfigImplTest()35 ~AccessibilityConfigImplTest() 36 {} 37 SetUpTestCase()38 static void SetUpTestCase() 39 { 40 GTEST_LOG_(INFO) << "AccessibilityConfigImplTest Start"; 41 } TearDownTestCase()42 static void TearDownTestCase() 43 { 44 GTEST_LOG_(INFO) << "AccessibilityConfigImplTest End"; 45 } SetUp()46 void SetUp() 47 { 48 GTEST_LOG_(INFO) << "AccessibilityConfigImplTest SetUp()"; 49 }; TearDown()50 void TearDown() 51 { 52 GTEST_LOG_(INFO) << "AccessibilityConfigImplTest TearDown()"; 53 } 54 }; 55 56 class MockAccessibilityConfigObserverImpl : public OHOS::AccessibilityConfig::AccessibilityConfigObserver { 57 public: 58 MockAccessibilityConfigObserverImpl() = default; OnConfigChanged(const OHOS::AccessibilityConfig::CONFIG_ID id,const OHOS::AccessibilityConfig::ConfigValue & value)59 void OnConfigChanged(const OHOS::AccessibilityConfig::CONFIG_ID id, 60 const OHOS::AccessibilityConfig::ConfigValue& value) override 61 {} 62 }; 63 64 class MockAccessibilityEnableAbilityListsObserverImpl : 65 public OHOS::AccessibilityConfig::AccessibilityEnableAbilityListsObserver { 66 public: 67 MockAccessibilityEnableAbilityListsObserverImpl() = default; OnEnableAbilityListsStateChanged()68 void OnEnableAbilityListsStateChanged() override 69 {} OnInstallAbilityListsStateChanged()70 void OnInstallAbilityListsStateChanged() override 71 {} 72 }; 73 74 /** 75 * @tc.number: SetCaptionProperty_002 76 * @tc.name: SetCaptionProperty_002 77 * @tc.desc: Test function SetCaptionsProperty GetCaptionsProperty 78 */ 79 HWTEST_F(AccessibilityConfigImplTest, SetCaptionProperty_002, TestSize.Level1) 80 { 81 GTEST_LOG_(INFO) << "SetCaptionProperty_002 start"; 82 83 CaptionProperty caption; 84 CaptionProperty value; 85 caption.SetFontFamily("sansSerif"); 86 87 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 88 instance.SetCaptionsProperty(caption); 89 instance.GetCaptionsProperty(value); 90 EXPECT_STREQ(value.GetFontFamily().c_str(), "default"); 91 GTEST_LOG_(INFO) << "SetCaptionProperty_002 end"; 92 } 93 94 /** 95 * @tc.number: SetCaptionProperty_003 96 * @tc.name: SetCaptionProperty_003 97 * @tc.desc: Test function SetCaptionsProperty GetCaptionsProperty 98 */ 99 HWTEST_F(AccessibilityConfigImplTest, SetCaptionProperty_003, TestSize.Level1) 100 { 101 GTEST_LOG_(INFO) << "SetCaptionProperty_003 start"; 102 103 CaptionProperty caption; 104 CaptionProperty value; 105 caption.SetFontFamily("default"); 106 107 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 108 instance.SetCaptionsProperty(caption); 109 instance.GetCaptionsProperty(value); 110 EXPECT_STREQ(value.GetFontFamily().c_str(), "default"); 111 GTEST_LOG_(INFO) << "SetCaptionProperty_003 end"; 112 } 113 114 /** 115 * @tc.number: SetCaptionProperty_004 116 * @tc.name: SetCaptionProperty_004 117 * @tc.desc: Test function SetCaptionsProperty GetCaptionsProperty 118 */ 119 HWTEST_F(AccessibilityConfigImplTest, SetCaptionProperty_004, TestSize.Level1) 120 { 121 GTEST_LOG_(INFO) << "SetCaptionProperty_004 start"; 122 123 CaptionProperty caption; 124 CaptionProperty value; 125 caption.SetFontFamily("casual"); 126 127 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 128 instance.SetCaptionsProperty(caption); 129 instance.GetCaptionsProperty(value); 130 EXPECT_STREQ(value.GetFontFamily().c_str(), "default"); 131 GTEST_LOG_(INFO) << "SetCaptionProperty_004 end"; 132 } 133 134 /** 135 * @tc.number: SetCaptionProperty_005 136 * @tc.name: SetCaptionProperty_005 137 * @tc.desc: Test function SetCaptionsProperty GetCaptionsProperty 138 */ 139 HWTEST_F(AccessibilityConfigImplTest, SetCaptionProperty_005, TestSize.Level1) 140 { 141 GTEST_LOG_(INFO) << "SetCaptionProperty_005 start"; 142 143 CaptionProperty caption; 144 CaptionProperty value; 145 caption.SetFontFamily("cursive"); 146 147 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 148 instance.SetCaptionsProperty(caption); 149 instance.GetCaptionsProperty(value); 150 EXPECT_STREQ(value.GetFontFamily().c_str(), "default"); 151 GTEST_LOG_(INFO) << "SetCaptionProperty_005 end"; 152 } 153 154 /** 155 * @tc.number: SetCaptionProperty_006 156 * @tc.name: SetCaptionProperty_006 157 * @tc.desc: Test function SetCaptionsProperty GetCaptionsProperty 158 */ 159 HWTEST_F(AccessibilityConfigImplTest, SetCaptionProperty_006, TestSize.Level1) 160 { 161 GTEST_LOG_(INFO) << "SetCaptionProperty_006 start"; 162 163 CaptionProperty caption; 164 CaptionProperty value; 165 caption.SetFontFamily("smallCapitals"); 166 167 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 168 instance.SetCaptionsProperty(caption); 169 instance.GetCaptionsProperty(value); 170 EXPECT_STREQ(value.GetFontFamily().c_str(), "default"); 171 GTEST_LOG_(INFO) << "SetCaptionProperty_006 end"; 172 } 173 174 /** 175 * @tc.number: SetCaptionProperty_007 176 * @tc.name: SetCaptionProperty_007 177 * @tc.desc: Test function SetCaptionsProperty GetCaptionsProperty 178 */ 179 HWTEST_F(AccessibilityConfigImplTest, SetCaptionProperty_007, TestSize.Level1) 180 { 181 GTEST_LOG_(INFO) << "SetCaptionProperty_007 start"; 182 183 CaptionProperty caption; 184 CaptionProperty value; 185 caption.SetFontFamily("monospacedSansSerif"); 186 187 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 188 instance.SetCaptionsProperty(caption); 189 instance.GetCaptionsProperty(value); 190 EXPECT_STREQ(value.GetFontFamily().c_str(), "default"); 191 GTEST_LOG_(INFO) << "SetCaptionProperty_007 end"; 192 } 193 194 /** 195 * @tc.number: SetScreenMagnificationState_002 196 * @tc.name: SetScreenMagnificationState_002 197 * @tc.desc: Test function SetScreenMagnificationState GetScreenMagnificationState 198 */ 199 HWTEST_F(AccessibilityConfigImplTest, SetScreenMagnificationState_002, TestSize.Level1) 200 { 201 GTEST_LOG_(INFO) << "SetScreenMagnificationState_002 start"; 202 203 bool state = true; 204 bool value = false; 205 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 206 instance.SetScreenMagnificationState(state); 207 instance.GetScreenMagnificationState(value); 208 EXPECT_FALSE(value); 209 GTEST_LOG_(INFO) << "SetScreenMagnificationState_002 end"; 210 } 211 212 /** 213 * @tc.number: SetScreenMagnificationState_003 214 * @tc.name: SetScreenMagnificationState_003 215 * @tc.desc: Test function SetScreenMagnificationState GetScreenMagnificationState 216 */ 217 HWTEST_F(AccessibilityConfigImplTest, SetScreenMagnificationState_003, TestSize.Level1) 218 { 219 GTEST_LOG_(INFO) << "SetScreenMagnificationState_003 start"; 220 221 bool state = false; 222 bool value = true; 223 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 224 instance.SetScreenMagnificationState(state); 225 instance.GetScreenMagnificationState(value); 226 EXPECT_TRUE(value); 227 GTEST_LOG_(INFO) << "SetScreenMagnificationState_003 end"; 228 } 229 230 /** 231 * @tc.number: SetScreenMagnificationState_004 232 * @tc.name: SetScreenMagnificationState_004 233 * @tc.desc: Test function SetScreenMagnificationState GetScreenMagnificationState 234 */ 235 HWTEST_F(AccessibilityConfigImplTest, SetScreenMagnificationState_004, TestSize.Level1) 236 { 237 GTEST_LOG_(INFO) << "SetScreenMagnificationState_004 start"; 238 239 bool state = false; 240 bool value = false; 241 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 242 instance.SetScreenMagnificationState(state); 243 instance.GetScreenMagnificationState(value); 244 EXPECT_FALSE(value); 245 GTEST_LOG_(INFO) << "SetScreenMagnificationState_004 end"; 246 } 247 248 /** 249 * @tc.number: SetScreenMagnificationState_005 250 * @tc.name: SetScreenMagnificationState_005 251 * @tc.desc: Test function SetScreenMagnificationState GetScreenMagnificationState 252 */ 253 HWTEST_F(AccessibilityConfigImplTest, SetScreenMagnificationState_005, TestSize.Level1) 254 { 255 GTEST_LOG_(INFO) << "SetScreenMagnificationState_005 start"; 256 257 bool state = true; 258 bool value = true; 259 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 260 instance.SetScreenMagnificationState(state); 261 instance.GetScreenMagnificationState(value); 262 EXPECT_TRUE(value); 263 GTEST_LOG_(INFO) << "SetScreenMagnificationState_005 end"; 264 } 265 266 /** 267 * @tc.number: SetShortKeyState_002 268 * @tc.name: SetShortKeyState_002 269 * @tc.desc: Test function SetShortKeyState GetShortKeyState 270 * @tc.require: issueI5NTXH 271 */ 272 HWTEST_F(AccessibilityConfigImplTest, SetShortKeyState_002, TestSize.Level1) 273 { 274 GTEST_LOG_(INFO) << "SetShortKeyState_002 start"; 275 276 bool state = true; 277 bool value = false; 278 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 279 instance.SetShortKeyState(state); 280 instance.GetShortKeyState(value); 281 EXPECT_FALSE(value); 282 GTEST_LOG_(INFO) << "SetShortKeyState_002 end"; 283 } 284 285 /** 286 * @tc.number: SetShortKeyState_003 287 * @tc.name: SetShortKeyState_003 288 * @tc.desc: Test function SetShortKeyState GetShortKeyState 289 * @tc.require: issueI5NTXH 290 */ 291 HWTEST_F(AccessibilityConfigImplTest, SetShortKeyState_003, TestSize.Level1) 292 { 293 GTEST_LOG_(INFO) << "SetShortKeyState_003 start"; 294 295 bool state = false; 296 bool value = true; 297 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 298 instance.SetShortKeyState(state); 299 instance.GetShortKeyState(value); 300 EXPECT_TRUE(value); 301 GTEST_LOG_(INFO) << "SetShortKeyState_003 end"; 302 } 303 304 /** 305 * @tc.number: SetShortKeyState_004 306 * @tc.name: SetShortKeyState_004 307 * @tc.desc: Test function SetShortKeyState GetShortKeyState 308 * @tc.require: issueI5NTXH 309 */ 310 HWTEST_F(AccessibilityConfigImplTest, SetShortKeyState_004, TestSize.Level1) 311 { 312 GTEST_LOG_(INFO) << "SetShortKeyState_004 start"; 313 314 bool state = false; 315 bool value = false; 316 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 317 instance.SetShortKeyState(state); 318 instance.GetShortKeyState(value); 319 EXPECT_FALSE(value); 320 GTEST_LOG_(INFO) << "SetShortKeyState_004 end"; 321 } 322 323 /** 324 * @tc.number: SetShortKeyState_005 325 * @tc.name: SetShortKeyState_005 326 * @tc.desc: Test function SetShortKeyState GetShortKeyState 327 * @tc.require: issueI5NTXH 328 */ 329 HWTEST_F(AccessibilityConfigImplTest, SetShortKeyState_005, TestSize.Level1) 330 { 331 GTEST_LOG_(INFO) << "SetShortKeyState_005 start"; 332 333 bool state = true; 334 bool value = true; 335 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 336 instance.SetShortKeyState(state); 337 instance.GetShortKeyState(value); 338 EXPECT_TRUE(value); 339 GTEST_LOG_(INFO) << "SetShortKeyState_005 end"; 340 } 341 342 /** 343 * @tc.number: SetMouseKeyState_002 344 * @tc.name: SetMouseKeyState_002 345 * @tc.desc: Test function SetMouseKeyState GetMouseKeyState 346 * @tc.require: issueI5NTXA 347 */ 348 HWTEST_F(AccessibilityConfigImplTest, SetMouseKeyState_002, TestSize.Level1) 349 { 350 GTEST_LOG_(INFO) << "SetMouseKeyState_002 start"; 351 bool state = true; 352 bool value = false; 353 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 354 instance.SetMouseKeyState(state); 355 instance.GetMouseKeyState(value); 356 EXPECT_FALSE(value); 357 GTEST_LOG_(INFO) << "SetMouseKeyState_002 end"; 358 } 359 360 /** 361 * @tc.number: SetMouseKeyState_003 362 * @tc.name: SetMouseKeyState_003 363 * @tc.desc: Test function SetMouseKeyState GetMouseKeyState 364 * @tc.require: issueI5NTXA 365 */ 366 HWTEST_F(AccessibilityConfigImplTest, SetMouseKeyState_003, TestSize.Level1) 367 { 368 GTEST_LOG_(INFO) << "SetMouseKeyState_003 start"; 369 bool state = false; 370 bool value = true; 371 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 372 instance.SetMouseKeyState(state); 373 instance.GetMouseKeyState(value); 374 EXPECT_TRUE(value); 375 GTEST_LOG_(INFO) << "SetMouseKeyState_003 end"; 376 } 377 378 /** 379 * @tc.number: SetMouseKeyState_004 380 * @tc.name: SetMouseKeyState_004 381 * @tc.desc: Test function SetMouseKeyState GetMouseKeyState 382 * @tc.require: issueI5NTXA 383 */ 384 HWTEST_F(AccessibilityConfigImplTest, SetMouseKeyState_004, TestSize.Level1) 385 { 386 GTEST_LOG_(INFO) << "SetMouseKeyState_004 start"; 387 bool state = false; 388 bool value = false; 389 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 390 instance.SetMouseKeyState(state); 391 instance.GetMouseKeyState(value); 392 EXPECT_FALSE(value); 393 GTEST_LOG_(INFO) << "SetMouseKeyState_004 end"; 394 } 395 396 /** 397 * @tc.number: SetMouseKeyState_005 398 * @tc.name: SetMouseKeyState_005 399 * @tc.desc: Test function SetMouseKeyState GetMouseKeyState 400 * @tc.require: issueI5NTXA 401 */ 402 HWTEST_F(AccessibilityConfigImplTest, SetMouseKeyState_005, TestSize.Level1) 403 { 404 GTEST_LOG_(INFO) << "SetMouseKeyState_005 start"; 405 bool state = true; 406 bool value = true; 407 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 408 instance.SetMouseKeyState(state); 409 instance.GetMouseKeyState(value); 410 EXPECT_TRUE(value); 411 GTEST_LOG_(INFO) << "SetMouseKeyState_005 end"; 412 } 413 414 /** 415 * @tc.number: SetCaptionsState_002 416 * @tc.name: SetCaptionsState_002 417 * @tc.desc: Test function SetCaptionsState GetCaptionsState 418 */ 419 HWTEST_F(AccessibilityConfigImplTest, SetCaptionsState_002, TestSize.Level1) 420 { 421 GTEST_LOG_(INFO) << "SetCaptionsState_002 start"; 422 423 bool state = true; 424 bool value = false; 425 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 426 instance.SetCaptionsState(state); 427 instance.GetCaptionsState(value); 428 EXPECT_FALSE(value); 429 GTEST_LOG_(INFO) << "SetCaptionsState_002 end"; 430 } 431 432 /** 433 * @tc.number: SetCaptionsState_003 434 * @tc.name: SetCaptionsState_003 435 * @tc.desc: Test function SetCaptionsState GetCaptionsState 436 */ 437 HWTEST_F(AccessibilityConfigImplTest, SetCaptionsState_003, TestSize.Level1) 438 { 439 GTEST_LOG_(INFO) << "SetCaptionsState_003 start"; 440 441 bool state = false; 442 bool value = true; 443 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 444 instance.SetCaptionsState(state); 445 instance.GetCaptionsState(value); 446 EXPECT_TRUE(value); 447 GTEST_LOG_(INFO) << "SetCaptionsState_003 end"; 448 } 449 450 /** 451 * @tc.number: SetCaptionsState_004 452 * @tc.name: SetCaptionsState_004 453 * @tc.desc: Test function SetCaptionsState GetCaptionsState 454 */ 455 HWTEST_F(AccessibilityConfigImplTest, SetCaptionsState_004, TestSize.Level1) 456 { 457 GTEST_LOG_(INFO) << "SetCaptionsState_004 start"; 458 459 bool state = false; 460 bool value = false; 461 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 462 instance.SetCaptionsState(state); 463 instance.GetCaptionsState(value); 464 EXPECT_FALSE(value); 465 GTEST_LOG_(INFO) << "SetCaptionsState_004 end"; 466 } 467 468 /** 469 * @tc.number: SetCaptionsState_005 470 * @tc.name: SetCaptionsState_005 471 * @tc.desc: Test function SetCaptionsState GetCaptionsState 472 */ 473 HWTEST_F(AccessibilityConfigImplTest, SetCaptionsState_005, TestSize.Level1) 474 { 475 GTEST_LOG_(INFO) << "SetCaptionsState_005 start"; 476 477 bool state = true; 478 bool value = true; 479 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 480 instance.SetCaptionsState(state); 481 instance.GetCaptionsState(value); 482 EXPECT_TRUE(value); 483 GTEST_LOG_(INFO) << "SetCaptionsState_005 end"; 484 } 485 486 /** 487 * @tc.number: SetMouseAutoClick_002 488 * @tc.name: SetMouseAutoClick_002 489 * @tc.desc: Test function SetMouseAutoClick GetMouseAutoClick 490 * @tc.require: issueI5NTXC 491 */ 492 HWTEST_F(AccessibilityConfigImplTest, SetMouseAutoClick_002, TestSize.Level1) 493 { 494 GTEST_LOG_(INFO) << "SetMouseAutoClick_002 start"; 495 496 int32_t time = 10; 497 int32_t value = 0; 498 std::vector<int> info; 499 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 500 instance.SetMouseAutoClick(time); 501 instance.GetMouseAutoClick(value); 502 EXPECT_EQ(info.size(), 0); 503 GTEST_LOG_(INFO) << "SetMouseAutoClick_002 end"; 504 } 505 506 /** 507 * @tc.number: SetMouseAutoClick_003 508 * @tc.name: SetMouseAutoClick_003 509 * @tc.desc: Test function SetMouseAutoClick GetMouseAutoClick 510 * @tc.require: issueI5NTXC 511 */ 512 HWTEST_F(AccessibilityConfigImplTest, SetMouseAutoClick_003, TestSize.Level1) 513 { 514 GTEST_LOG_(INFO) << "SetMouseAutoClick_003 start"; 515 516 int32_t time = 10; 517 int32_t value = 0; 518 std::vector<int> info; 519 info.push_back(1); 520 info.push_back(2); 521 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 522 instance.SetMouseAutoClick(time); 523 instance.GetMouseAutoClick(value); 524 EXPECT_EQ(info.size(), 2); 525 GTEST_LOG_(INFO) << "SetMouseAutoClick_003 end"; 526 } 527 528 /** 529 * @tc.number: SetMouseAutoClick_004 530 * @tc.name: SetMouseAutoClick_004 531 * @tc.desc: Test function SetMouseAutoClick GetMouseAutoClick 532 * @tc.require: issueI5NTXC 533 */ 534 HWTEST_F(AccessibilityConfigImplTest, SetMouseAutoClick_004, TestSize.Level1) 535 { 536 GTEST_LOG_(INFO) << "SetMouseAutoClick_004 start"; 537 538 int32_t time = 0; 539 int32_t value = -1; 540 std::vector<int32_t> info; 541 info.push_back(value); 542 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 543 instance.SetMouseAutoClick(time); 544 instance.GetMouseAutoClick(value); 545 EXPECT_EQ(info.size(), 1); 546 GTEST_LOG_(INFO) << "SetMouseAutoClick_004 end"; 547 } 548 549 /** 550 * @tc.number: SetShortkeyTarget_002 551 * @tc.name: SetShortkeyTarget_002 552 * @tc.desc: Test function SetShortkeyTarget GetShortkeyTarget 553 * @tc.require: issueI5NTXH 554 */ 555 HWTEST_F(AccessibilityConfigImplTest, SetShortkeyTarget_002, TestSize.Level1) 556 { 557 GTEST_LOG_(INFO) << "SetShortkeyTarget_002 start"; 558 559 std::string name = "test"; 560 std::string value = ""; 561 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 562 instance.SetShortkeyTarget(name); 563 instance.GetShortkeyTarget(value); 564 EXPECT_STREQ(value.c_str(), ""); 565 GTEST_LOG_(INFO) << "SetShortkeyTarget_002 end"; 566 } 567 568 /** 569 * @tc.number: SetShortkeyTarget_003 570 * @tc.name: SetShortkeyTarget_003 571 * @tc.desc: Test function SetShortkeyTarget GetShortkeyTarget 572 * @tc.require: issueI5NTXH 573 */ 574 HWTEST_F(AccessibilityConfigImplTest, SetShortkeyTarget_003, TestSize.Level1) 575 { 576 GTEST_LOG_(INFO) << "SetShortkeyTarget_003 start"; 577 578 std::string name = ""; 579 std::string value = ""; 580 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 581 instance.SetShortkeyTarget(name); 582 instance.GetShortkeyTarget(value); 583 EXPECT_STREQ(value.c_str(), ""); 584 GTEST_LOG_(INFO) << "SetShortkeyTarget_003 end"; 585 } 586 587 /** 588 * @tc.number: SetShortkeyMultiTarget_001 589 * @tc.name: SetShortkeyMultiTarget_001 590 * @tc.desc: Test function SetShortkeyMultiTarget GetShortkeyMultiTarget 591 * @tc.require: issueI5NTXH 592 */ 593 HWTEST_F(AccessibilityConfigImplTest, GetShortkeyMultiTarget_001, TestSize.Level1) 594 { 595 GTEST_LOG_(INFO) << "SetShortkeyMultiTarget_001 start"; 596 597 std::vector<std::string> name = {"test"}; 598 std::vector<std::string> value = {"test"}; 599 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 600 instance.SetShortkeyMultiTarget(name); 601 instance.GetShortkeyMultiTarget(value); 602 EXPECT_EQ(value.size(), 1); 603 GTEST_LOG_(INFO) << "SetShortkeyMultiTarget_001 end"; 604 } 605 606 /** 607 * @tc.number: SetShortkeyMultiTarget_002 608 * @tc.name: SetShortkeyMultiTarget_002 609 * @tc.desc: Test function SetShortkeyMultiTarget GetShortkeyMultiTarget 610 * @tc.require: issueI5NTXH 611 */ 612 HWTEST_F(AccessibilityConfigImplTest, SetShortkeyMultiTarget_002, TestSize.Level1) 613 { 614 GTEST_LOG_(INFO) << "SetShortkeyMultiTarget_002 start"; 615 616 std::vector<std::string> name = {"test"}; 617 std::vector<std::string> value = {}; 618 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 619 instance.SetShortkeyMultiTarget(name); 620 instance.GetShortkeyMultiTarget(value); 621 EXPECT_EQ(value.size(), 0); 622 GTEST_LOG_(INFO) << "SetShortkeyMultiTarget_002 end"; 623 } 624 625 /** 626 * @tc.number: SetDaltonizationState_002 627 * @tc.name: SetDaltonizationState_002 628 * @tc.desc: Test function SetDaltonizationState GetDaltonizationState 629 * @tc.require: issueI5NTX9 630 */ 631 HWTEST_F(AccessibilityConfigImplTest, SetDaltonizationState_002, TestSize.Level1) 632 { 633 GTEST_LOG_(INFO) << "SetDaltonizationState_002 start"; 634 635 bool state = true; 636 bool value = false; 637 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 638 instance.SetDaltonizationState(state); 639 instance.GetDaltonizationState(value); 640 EXPECT_FALSE(value); 641 GTEST_LOG_(INFO) << "SetDaltonizationState_002 end"; 642 } 643 644 /** 645 * @tc.number: SetDaltonizationState_003 646 * @tc.name: SetDaltonizationState_003 647 * @tc.desc: Test function SetDaltonizationState GetDaltonizationState 648 * @tc.require: issueI5NTX9 649 */ 650 HWTEST_F(AccessibilityConfigImplTest, SetDaltonizationState_003, TestSize.Level1) 651 { 652 GTEST_LOG_(INFO) << "SetDaltonizationState_003 start"; 653 654 bool state = false; 655 bool value = true; 656 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 657 instance.SetDaltonizationState(state); 658 instance.GetDaltonizationState(value); 659 EXPECT_TRUE(value); 660 GTEST_LOG_(INFO) << "SetDaltonizationState_003 end"; 661 } 662 663 /** 664 * @tc.number: SetDaltonizationState_004 665 * @tc.name: SetDaltonizationState_004 666 * @tc.desc: Test function SetDaltonizationState GetDaltonizationState 667 * @tc.require: issueI5NTX9 668 */ 669 HWTEST_F(AccessibilityConfigImplTest, SetDaltonizationState_004, TestSize.Level1) 670 { 671 GTEST_LOG_(INFO) << "SetDaltonizationState_004 start"; 672 673 bool state = false; 674 bool value = false; 675 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 676 instance.SetDaltonizationState(state); 677 instance.GetDaltonizationState(value); 678 EXPECT_FALSE(value); 679 GTEST_LOG_(INFO) << "SetDaltonizationState_004 end"; 680 } 681 682 /** 683 * @tc.number: SetDaltonizationState_005 684 * @tc.name: SetDaltonizationState_005 685 * @tc.desc: Test function SetDaltonizationState GetDaltonizationState 686 * @tc.require: issueI5NTX9 687 */ 688 HWTEST_F(AccessibilityConfigImplTest, SetDaltonizationState_005, TestSize.Level1) 689 { 690 GTEST_LOG_(INFO) << "SetDaltonizationState_005 start"; 691 692 bool state = true; 693 bool value = true; 694 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 695 instance.SetDaltonizationState(state); 696 instance.GetDaltonizationState(value); 697 EXPECT_TRUE(value); 698 GTEST_LOG_(INFO) << "SetDaltonizationState_005 end"; 699 } 700 701 /** 702 * @tc.number: SetHighContrastTextState_002 703 * @tc.name: SetHighContrastTextState_002 704 * @tc.desc: Test function SetHighContrastTextState GetHighContrastTextState 705 * @tc.require: issueI5NTX9 706 */ 707 HWTEST_F(AccessibilityConfigImplTest, SetHighContrastTextState_002, TestSize.Level1) 708 { 709 GTEST_LOG_(INFO) << "SetHighContrastTextState_002 start"; 710 711 bool state = true; 712 bool value = false; 713 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 714 instance.SetHighContrastTextState(state); 715 instance.GetHighContrastTextState(value); 716 EXPECT_FALSE(value); 717 GTEST_LOG_(INFO) << "SetHighContrastTextState_002 end"; 718 } 719 720 /** 721 * @tc.number: SetHighContrastTextState_003 722 * @tc.name: SetHighContrastTextState_003 723 * @tc.desc: Test function SetHighContrastTextState GetHighContrastTextState 724 * @tc.require: issueI5NTX9 725 */ 726 HWTEST_F(AccessibilityConfigImplTest, SetHighContrastTextState_003, TestSize.Level1) 727 { 728 GTEST_LOG_(INFO) << "SetHighContrastTextState_003 start"; 729 730 bool state = false; 731 bool value = true; 732 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 733 instance.SetHighContrastTextState(state); 734 instance.GetHighContrastTextState(value); 735 EXPECT_TRUE(value); 736 GTEST_LOG_(INFO) << "SetHighContrastTextState_003 end"; 737 } 738 739 /** 740 * @tc.number: SetHighContrastTextState_004 741 * @tc.name: SetHighContrastTextState_004 742 * @tc.desc: Test function SetHighContrastTextState GetHighContrastTextState 743 * @tc.require: issueI5NTX9 744 */ 745 HWTEST_F(AccessibilityConfigImplTest, SetHighContrastTextState_004, TestSize.Level1) 746 { 747 GTEST_LOG_(INFO) << "SetHighContrastTextState_004 start"; 748 749 bool state = false; 750 bool value = false; 751 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 752 instance.SetHighContrastTextState(state); 753 instance.GetHighContrastTextState(value); 754 EXPECT_FALSE(value); 755 GTEST_LOG_(INFO) << "SetHighContrastTextState_004 end"; 756 } 757 758 /** 759 * @tc.number: SetHighContrastTextState_005 760 * @tc.name: SetHighContrastTextState_005 761 * @tc.desc: Test function SetHighContrastTextState GetHighContrastTextState 762 * @tc.require: issueI5NTX9 763 */ 764 HWTEST_F(AccessibilityConfigImplTest, SetHighContrastTextState_005, TestSize.Level1) 765 { 766 GTEST_LOG_(INFO) << "SetHighContrastTextState_005 start"; 767 768 bool state = true; 769 bool value = true; 770 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 771 instance.SetHighContrastTextState(state); 772 instance.GetHighContrastTextState(value); 773 EXPECT_TRUE(value); 774 GTEST_LOG_(INFO) << "SetHighContrastTextState_005 end"; 775 } 776 777 /** 778 * @tc.number: SetInvertColorState_002 779 * @tc.name: SetInvertColorState_002 780 * @tc.desc: Test function SetInvertColorState GetInvertColorState 781 * @tc.require: issueI5NTX7 782 */ 783 HWTEST_F(AccessibilityConfigImplTest, SetInvertColorState_002, TestSize.Level1) 784 { 785 GTEST_LOG_(INFO) << "SetInvertColorState_002 start"; 786 787 bool state = true; 788 bool value = false; 789 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 790 instance.SetInvertColorState(state); 791 instance.GetInvertColorState(value); 792 EXPECT_FALSE(value); 793 GTEST_LOG_(INFO) << "SetInvertColorState_002 end"; 794 } 795 796 /** 797 * @tc.number: SetInvertColorState_003 798 * @tc.name: SetInvertColorState_003 799 * @tc.desc: Test function SetInvertColorState GetInvertColorState 800 * @tc.require: issueI5NTX7 801 */ 802 HWTEST_F(AccessibilityConfigImplTest, SetInvertColorState_003, TestSize.Level1) 803 { 804 GTEST_LOG_(INFO) << "SetInvertColorState_003 start"; 805 806 bool state = false; 807 bool value = true; 808 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 809 instance.SetInvertColorState(state); 810 instance.GetInvertColorState(value); 811 EXPECT_TRUE(value); 812 GTEST_LOG_(INFO) << "SetInvertColorState_003 end"; 813 } 814 815 /** 816 * @tc.number: SetInvertColorState_004 817 * @tc.name: SetInvertColorState_004 818 * @tc.desc: Test function SetInvertColorState GetInvertColorState 819 * @tc.require: issueI5NTX7 820 */ 821 HWTEST_F(AccessibilityConfigImplTest, SetInvertColorState_004, TestSize.Level1) 822 { 823 GTEST_LOG_(INFO) << "SetInvertColorState_004 start"; 824 825 bool state = false; 826 bool value = false; 827 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 828 instance.SetInvertColorState(state); 829 instance.GetInvertColorState(value); 830 EXPECT_FALSE(value); 831 GTEST_LOG_(INFO) << "SetInvertColorState_004 end"; 832 } 833 834 /** 835 * @tc.number: SetInvertColorState_005 836 * @tc.name: SetInvertColorState_005 837 * @tc.desc: Test function SetInvertColorState GetInvertColorState 838 * @tc.require: issueI5NTX7 839 */ 840 HWTEST_F(AccessibilityConfigImplTest, SetInvertColorState_005, TestSize.Level1) 841 { 842 GTEST_LOG_(INFO) << "SetInvertColorState_005 start"; 843 844 bool state = true; 845 bool value = true; 846 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 847 instance.SetInvertColorState(state); 848 instance.GetInvertColorState(value); 849 EXPECT_TRUE(value); 850 GTEST_LOG_(INFO) << "SetInvertColorState_005 end"; 851 } 852 853 /** 854 * @tc.number: SetDaltonizationColorFilter_002 855 * @tc.name: SetDaltonizationColorFilter_002 856 * @tc.desc: Test function SetDaltonizationColorFilter GetDaltonizationColorFilter 857 * @tc.require: issueI5NTX8 858 */ 859 HWTEST_F(AccessibilityConfigImplTest, SetDaltonizationColorFilter_002, TestSize.Level1) 860 { 861 GTEST_LOG_(INFO) << "SetDaltonizationColorFilter_002 start"; 862 863 DALTONIZATION_TYPE type = Protanomaly; 864 DALTONIZATION_TYPE value = Normal; 865 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 866 instance.SetDaltonizationColorFilter(type); 867 instance.GetDaltonizationColorFilter(value); 868 EXPECT_EQ(0, static_cast<uint32_t>(value)); 869 GTEST_LOG_(INFO) << "SetDaltonizationColorFilter_002 end"; 870 } 871 872 /** 873 * @tc.number: SetDaltonizationColorFilter_003 874 * @tc.name: SetDaltonizationColorFilter_003 875 * @tc.desc: Test function SetDaltonizationColorFilter GetDaltonizationColorFilter 876 * @tc.require: issueI5NTX8 877 */ 878 HWTEST_F(AccessibilityConfigImplTest, SetDaltonizationColorFilter_003, TestSize.Level1) 879 { 880 GTEST_LOG_(INFO) << "SetDaltonizationColorFilter_003 start"; 881 882 DALTONIZATION_TYPE type = Deuteranomaly; 883 DALTONIZATION_TYPE value = Normal; 884 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 885 instance.SetDaltonizationColorFilter(type); 886 instance.GetDaltonizationColorFilter(value); 887 EXPECT_EQ(0, static_cast<uint32_t>(value)); 888 GTEST_LOG_(INFO) << "SetDaltonizationColorFilter_003 end"; 889 } 890 891 /** 892 * @tc.number: SetDaltonizationColorFilter_004 893 * @tc.name: SetDaltonizationColorFilter_004 894 * @tc.desc: Test function SetDaltonizationColorFilter GetDaltonizationColorFilter 895 * @tc.require: issueI5NTX8 896 */ 897 HWTEST_F(AccessibilityConfigImplTest, SetDaltonizationColorFilter_004, TestSize.Level1) 898 { 899 GTEST_LOG_(INFO) << "SetDaltonizationColorFilter_004 start"; 900 901 DALTONIZATION_TYPE type = Tritanomaly; 902 DALTONIZATION_TYPE value = Normal; 903 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 904 instance.SetDaltonizationColorFilter(type); 905 instance.GetDaltonizationColorFilter(value); 906 EXPECT_EQ(0, static_cast<uint32_t>(value)); 907 GTEST_LOG_(INFO) << "SetDaltonizationColorFilter_004 end"; 908 } 909 910 /** 911 * @tc.number: SetDaltonizationColorFilter_005 912 * @tc.name: SetDaltonizationColorFilter_005 913 * @tc.desc: Test function SetDaltonizationColorFilter GetDaltonizationColorFilter 914 * @tc.require: issueI5NTX8 915 */ 916 HWTEST_F(AccessibilityConfigImplTest, SetDaltonizationColorFilter_005, TestSize.Level1) 917 { 918 GTEST_LOG_(INFO) << "SetDaltonizationColorFilter_005 start"; 919 920 DALTONIZATION_TYPE type = Normal; 921 DALTONIZATION_TYPE value = Normal; 922 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 923 instance.SetDaltonizationColorFilter(type); 924 instance.GetDaltonizationColorFilter(value); 925 EXPECT_EQ(0, static_cast<uint32_t>(value)); 926 GTEST_LOG_(INFO) << "SetDaltonizationColorFilter_005 end"; 927 } 928 929 /** 930 * @tc.number: SetContentTimeout_002 931 * @tc.name: SetContentTimeout_002 932 * @tc.desc: Test function SetContentTimeout GetContentTimeout 933 * @tc.require: issueI5NTXF 934 */ 935 HWTEST_F(AccessibilityConfigImplTest, SetContentTimeout_002, TestSize.Level1) 936 { 937 GTEST_LOG_(INFO) << "SetContentTimeout_002 start"; 938 939 uint32_t timer = 10; 940 uint32_t value = 0; 941 std::vector<int> info; 942 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 943 instance.SetContentTimeout(timer); 944 instance.GetContentTimeout(value); 945 EXPECT_EQ(info.size(), 0); 946 GTEST_LOG_(INFO) << "SetContentTimeout_002 end"; 947 } 948 949 /** 950 * @tc.number: SetContentTimeout_003 951 * @tc.name: SetContentTimeout_003 952 * @tc.desc: Test function SetContentTimeout GetContentTimeout 953 * @tc.require: issueI5NTXF 954 */ 955 HWTEST_F(AccessibilityConfigImplTest, SetContentTimeout_003, TestSize.Level1) 956 { 957 GTEST_LOG_(INFO) << "SetContentTimeout_003 start"; 958 959 uint32_t timer = 0; 960 uint32_t value = -1; 961 std::vector<int> info; 962 info.push_back(value); 963 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 964 instance.SetContentTimeout(timer); 965 instance.GetContentTimeout(value); 966 EXPECT_EQ(info.size(), 1); 967 GTEST_LOG_(INFO) << "SetContentTimeout_003 end"; 968 } 969 970 /** 971 * @tc.number: SetAnimationOffState_002 972 * @tc.name: SetAnimationOffState_002 973 * @tc.desc: Test function SetAnimationOffState GetAnimationOffState 974 * @tc.require: issueI5NTXG 975 */ 976 HWTEST_F(AccessibilityConfigImplTest, SetAnimationOffState_002, TestSize.Level1) 977 { 978 GTEST_LOG_(INFO) << "SetAnimationOffState_002 start"; 979 980 bool state = true; 981 bool value = false; 982 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 983 instance.SetAnimationOffState(state); 984 instance.GetAnimationOffState(value); 985 EXPECT_FALSE(value); 986 GTEST_LOG_(INFO) << "SetAnimationOffState_002 end"; 987 } 988 989 /** 990 * @tc.number: SetAnimationOffState_003 991 * @tc.name: SetAnimationOffState_003 992 * @tc.desc: Test function SetAnimationOffState GetAnimationOffState 993 * @tc.require: issueI5NTXG 994 */ 995 HWTEST_F(AccessibilityConfigImplTest, SetAnimationOffState_003, TestSize.Level1) 996 { 997 GTEST_LOG_(INFO) << "SetAnimationOffState_003 start"; 998 999 bool state = false; 1000 bool value = true; 1001 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 1002 instance.SetAnimationOffState(state); 1003 instance.GetAnimationOffState(value); 1004 EXPECT_TRUE(value); 1005 GTEST_LOG_(INFO) << "SetAnimationOffState_003 end"; 1006 } 1007 1008 /** 1009 * @tc.number: SetAnimationOffState_004 1010 * @tc.name: SetAnimationOffState_004 1011 * @tc.desc: Test function SetAnimationOffState GetAnimationOffState 1012 * @tc.require: issueI5NTXG 1013 */ 1014 HWTEST_F(AccessibilityConfigImplTest, SetAnimationOffState_004, TestSize.Level1) 1015 { 1016 GTEST_LOG_(INFO) << "SetAnimationOffState_004 start"; 1017 1018 bool state = false; 1019 bool value = false; 1020 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 1021 instance.SetAnimationOffState(state); 1022 instance.GetAnimationOffState(value); 1023 EXPECT_FALSE(value); 1024 GTEST_LOG_(INFO) << "SetAnimationOffState_004 end"; 1025 } 1026 1027 /** 1028 * @tc.number: SetAnimationOffState_005 1029 * @tc.name: SetAnimationOffState_005 1030 * @tc.desc: Test function SetAnimationOffState GetAnimationOffState 1031 * @tc.require: issueI5NTXG 1032 */ 1033 HWTEST_F(AccessibilityConfigImplTest, SetAnimationOffState_005, TestSize.Level1) 1034 { 1035 GTEST_LOG_(INFO) << "SetAnimationOffState_005 start"; 1036 1037 bool state = true; 1038 bool value = true; 1039 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 1040 instance.SetAnimationOffState(state); 1041 instance.GetAnimationOffState(value); 1042 EXPECT_TRUE(value); 1043 GTEST_LOG_(INFO) << "SetAnimationOffState_005 end"; 1044 } 1045 1046 /** 1047 * @tc.number: SetBrightnessDiscount_002 1048 * @tc.name: SetBrightnessDiscount_002 1049 * @tc.desc: Test function SetBrightnessDiscount GetBrightnessDiscount 1050 * @tc.require: issueI5NTXE 1051 */ 1052 HWTEST_F(AccessibilityConfigImplTest, SetBrightnessDiscount_002, TestSize.Level1) 1053 { 1054 GTEST_LOG_(INFO) << "SetBrightnessDiscount_002 start"; 1055 1056 float brightness = BRIGHTNESS_DISCOUNT_VALUE; 1057 float value = 0; 1058 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 1059 instance.SetBrightnessDiscount(brightness); 1060 instance.GetBrightnessDiscount(value); 1061 EXPECT_FLOAT_EQ(0, value); 1062 GTEST_LOG_(INFO) << "SetBrightnessDiscount_002 end"; 1063 } 1064 1065 /** 1066 * @tc.number: SetAudioMonoState_002 1067 * @tc.name: SetAudioMonoState_002 1068 * @tc.desc: Test function SetAudioMonoState GetAudioMonoState 1069 */ 1070 HWTEST_F(AccessibilityConfigImplTest, SetAudioMonoState_002, TestSize.Level1) 1071 { 1072 GTEST_LOG_(INFO) << "SetAudioMonoState_002 start"; 1073 1074 bool state = true; 1075 bool value = false; 1076 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 1077 instance.SetAudioMonoState(state); 1078 instance.GetAudioMonoState(value); 1079 EXPECT_FALSE(value); 1080 GTEST_LOG_(INFO) << "SetAudioMonoState_002 end"; 1081 } 1082 1083 /** 1084 * @tc.number: SetAudioMonoState_003 1085 * @tc.name: SetAudioMonoState_003 1086 * @tc.desc: Test function SetAudioMonoState GetAudioMonoState 1087 */ 1088 HWTEST_F(AccessibilityConfigImplTest, SetAudioMonoState_003, TestSize.Level1) 1089 { 1090 GTEST_LOG_(INFO) << "SetAudioMonoState_003 start"; 1091 1092 bool state = false; 1093 bool value = true; 1094 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 1095 instance.SetAudioMonoState(state); 1096 instance.GetAudioMonoState(value); 1097 EXPECT_TRUE(value); 1098 GTEST_LOG_(INFO) << "SetAudioMonoState_003 end"; 1099 } 1100 1101 /** 1102 * @tc.number: SetAudioMonoState_004 1103 * @tc.name: SetAudioMonoState_004 1104 * @tc.desc: Test function SetAudioMonoState GetAudioMonoState 1105 */ 1106 HWTEST_F(AccessibilityConfigImplTest, SetAudioMonoState_004, TestSize.Level1) 1107 { 1108 GTEST_LOG_(INFO) << "SetAudioMonoState_004 start"; 1109 1110 bool state = false; 1111 bool value = false; 1112 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 1113 instance.SetAudioMonoState(state); 1114 instance.GetAudioMonoState(value); 1115 EXPECT_FALSE(value); 1116 GTEST_LOG_(INFO) << "SetAudioMonoState_004 end"; 1117 } 1118 1119 /** 1120 * @tc.number: SetAudioMonoState_005 1121 * @tc.name: SetAudioMonoState_005 1122 * @tc.desc: Test function SetAudioMonoState GetAudioMonoState 1123 */ 1124 HWTEST_F(AccessibilityConfigImplTest, SetAudioMonoState_005, TestSize.Level1) 1125 { 1126 GTEST_LOG_(INFO) << "SetAudioMonoState_005 start"; 1127 1128 bool state = true; 1129 bool value = true; 1130 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 1131 instance.SetAudioMonoState(state); 1132 instance.GetAudioMonoState(value); 1133 EXPECT_TRUE(value); 1134 GTEST_LOG_(INFO) << "SetAudioMonoState_005 end"; 1135 } 1136 1137 /** 1138 * @tc.number: SetAudioBalance_002 1139 * @tc.name: SetAudioBalance_002 1140 * @tc.desc: Test function SetAudioBalance GetAudioBalance 1141 */ 1142 HWTEST_F(AccessibilityConfigImplTest, SetAudioBalance_002, TestSize.Level1) 1143 { 1144 GTEST_LOG_(INFO) << "SetAudioBalance_002 start"; 1145 float balance = -1.0; 1146 float value = 0; 1147 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 1148 instance.SetAudioBalance(balance); 1149 instance.GetAudioBalance(value); 1150 EXPECT_FLOAT_EQ(0, value); 1151 GTEST_LOG_(INFO) << "SetAudioBalance_002 end"; 1152 } 1153 1154 /** 1155 * @tc.number: SetAudioBalance_003 1156 * @tc.name: SetAudioBalance_003 1157 * @tc.desc: Test function SetAudioBalance GetAudioBalance 1158 */ 1159 HWTEST_F(AccessibilityConfigImplTest, SetAudioBalance_003, TestSize.Level1) 1160 { 1161 GTEST_LOG_(INFO) << "SetAudioBalance_003 start"; 1162 float balance = 1.0; 1163 float value = 0; 1164 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 1165 instance.SetAudioBalance(balance); 1166 instance.GetAudioBalance(value); 1167 EXPECT_FLOAT_EQ(0, value); 1168 GTEST_LOG_(INFO) << "SetAudioBalance_003 end"; 1169 } 1170 1171 /** 1172 * @tc.number: SetClickResponseTime_002 1173 * @tc.name: SetClickResponseTime_002 1174 * @tc.desc: Test function SetClickResponseTime GetClickResponseTime 1175 */ 1176 HWTEST_F(AccessibilityConfigImplTest, SetClickResponseTime_002, TestSize.Level1) 1177 { 1178 GTEST_LOG_(INFO) << "SetClickResponseTime_002 start"; 1179 CLICK_RESPONSE_TIME time = ResponseDelayMedium; 1180 CLICK_RESPONSE_TIME value = ResponseDelayShort; 1181 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 1182 instance.SetClickResponseTime(time); 1183 instance.GetClickResponseTime(value); 1184 EXPECT_EQ(0, static_cast<uint32_t>(value)); 1185 GTEST_LOG_(INFO) << "SetClickResponseTime_002 end"; 1186 } 1187 1188 /** 1189 * @tc.number: SetClickResponseTime_003 1190 * @tc.name: SetClickResponseTime_003 1191 * @tc.desc: Test function SetClickResponseTime GetClickResponseTime 1192 */ 1193 HWTEST_F(AccessibilityConfigImplTest, SetClickResponseTime_003, TestSize.Level1) 1194 { 1195 GTEST_LOG_(INFO) << "SetClickResponseTime_003 start"; 1196 CLICK_RESPONSE_TIME time = ResponseDelayShort; 1197 CLICK_RESPONSE_TIME value = ResponseDelayShort; 1198 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 1199 instance.SetClickResponseTime(time); 1200 instance.GetClickResponseTime(value); 1201 EXPECT_EQ(0, static_cast<uint32_t>(value)); 1202 GTEST_LOG_(INFO) << "SetClickResponseTime_003 end"; 1203 } 1204 1205 /** 1206 * @tc.number: SetClickResponseTime_004 1207 * @tc.name: SetClickResponseTime_004 1208 * @tc.desc: Test function SetClickResponseTime GetClickResponseTime 1209 */ 1210 HWTEST_F(AccessibilityConfigImplTest, SetClickResponseTime_004, TestSize.Level1) 1211 { 1212 GTEST_LOG_(INFO) << "SetClickResponseTime_004 start"; 1213 CLICK_RESPONSE_TIME time = ResponseDelayLong; 1214 CLICK_RESPONSE_TIME value = ResponseDelayShort; 1215 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 1216 instance.SetClickResponseTime(time); 1217 instance.GetClickResponseTime(value); 1218 EXPECT_EQ(0, static_cast<uint32_t>(value)); 1219 GTEST_LOG_(INFO) << "SetClickResponseTime_004 end"; 1220 } 1221 1222 1223 /** 1224 * @tc.number: SetIgnoreRepeatClickState_002 1225 * @tc.name: SetIgnoreRepeatClickState_002 1226 * @tc.desc: Test function SetIgnoreRepeatClickState GetIgnoreRepeatClickState 1227 */ 1228 HWTEST_F(AccessibilityConfigImplTest, SetIgnoreRepeatClickState_002, TestSize.Level1) 1229 { 1230 GTEST_LOG_(INFO) << "SetIgnoreRepeatClickState_002 start"; 1231 bool state = true; 1232 bool value = false; 1233 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 1234 instance.SetIgnoreRepeatClickState(state); 1235 instance.GetIgnoreRepeatClickState(value); 1236 EXPECT_FALSE(value == true); 1237 GTEST_LOG_(INFO) << "SetIgnoreRepeatClickState_002 end"; 1238 } 1239 1240 /** 1241 * @tc.number: SetIgnoreRepeatClickState_003 1242 * @tc.name: SetIgnoreRepeatClickState_003 1243 * @tc.desc: Test function SetIgnoreRepeatClickState GetIgnoreRepeatClickState 1244 */ 1245 HWTEST_F(AccessibilityConfigImplTest, SetIgnoreRepeatClickState_003, TestSize.Level1) 1246 { 1247 GTEST_LOG_(INFO) << "SetIgnoreRepeatClickState_003 start"; 1248 bool state = false; 1249 bool value = true; 1250 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 1251 instance.SetIgnoreRepeatClickState(state); 1252 instance.GetIgnoreRepeatClickState(value); 1253 EXPECT_FALSE(value == false); 1254 GTEST_LOG_(INFO) << "SetIgnoreRepeatClickState_003 end"; 1255 } 1256 1257 /** 1258 * @tc.number: SetIgnoreRepeatClickState_004 1259 * @tc.name: SetIgnoreRepeatClickState_004 1260 * @tc.desc: Test function SetIgnoreRepeatClickState GetIgnoreRepeatClickState 1261 */ 1262 HWTEST_F(AccessibilityConfigImplTest, SetIgnoreRepeatClickState_004, TestSize.Level1) 1263 { 1264 GTEST_LOG_(INFO) << "SetIgnoreRepeatClickState_004 start"; 1265 bool state = false; 1266 bool value = true; 1267 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 1268 instance.SetIgnoreRepeatClickState(state); 1269 instance.GetIgnoreRepeatClickState(value); 1270 EXPECT_FALSE(value == false); 1271 GTEST_LOG_(INFO) << "SetIgnoreRepeatClickState_004 end"; 1272 } 1273 1274 /** 1275 * @tc.number: SetIgnoreRepeatClickState_005 1276 * @tc.name: SetIgnoreRepeatClickState_005 1277 * @tc.desc: Test function SetIgnoreRepeatClickState GetIgnoreRepeatClickState 1278 */ 1279 HWTEST_F(AccessibilityConfigImplTest, SetIgnoreRepeatClickState_005, TestSize.Level1) 1280 { 1281 GTEST_LOG_(INFO) << "SetIgnoreRepeatClickState_005 start"; 1282 bool state = true; 1283 bool value = false; 1284 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 1285 instance.SetIgnoreRepeatClickState(state); 1286 instance.GetIgnoreRepeatClickState(value); 1287 EXPECT_FALSE(value == true); 1288 GTEST_LOG_(INFO) << "SetIgnoreRepeatClickState_005 end"; 1289 } 1290 1291 /** 1292 * @tc.number: SetIgnoreRepeatClickTime_002 1293 * @tc.name: SetIgnoreRepeatClickTime_002 1294 * @tc.desc: Test function SetIgnoreRepeatClickTime SetIgnoreRepeatClickTime 1295 */ 1296 HWTEST_F(AccessibilityConfigImplTest, SetIgnoreRepeatClickTime_002, TestSize.Level1) 1297 { 1298 GTEST_LOG_(INFO) << "SetIgnoreRepeatClickTime_002 start"; 1299 IGNORE_REPEAT_CLICK_TIME time = RepeatClickTimeoutShort; 1300 IGNORE_REPEAT_CLICK_TIME value = RepeatClickTimeoutShortest; 1301 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 1302 instance.SetIgnoreRepeatClickTime(time); 1303 instance.GetIgnoreRepeatClickTime(value); 1304 EXPECT_EQ(0, static_cast<uint32_t>(value)); 1305 GTEST_LOG_(INFO) << "SetIgnoreRepeatClickTime_002 end"; 1306 } 1307 1308 /** 1309 * @tc.number: SetIgnoreRepeatClickTime_004 1310 * @tc.name: SetIgnoreRepeatClickTime_004 1311 * @tc.desc: Test function SetIgnoreRepeatClickTime SetIgnoreRepeatClickTime 1312 */ 1313 HWTEST_F(AccessibilityConfigImplTest, SetIgnoreRepeatClickTime_004, TestSize.Level1) 1314 { 1315 GTEST_LOG_(INFO) << "SetIgnoreRepeatClickTime_004 start"; 1316 IGNORE_REPEAT_CLICK_TIME time = RepeatClickTimeoutMedium; 1317 IGNORE_REPEAT_CLICK_TIME value = RepeatClickTimeoutShortest; 1318 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 1319 instance.SetIgnoreRepeatClickTime(time); 1320 instance.GetIgnoreRepeatClickTime(value); 1321 EXPECT_EQ(0, static_cast<uint32_t>(value)); 1322 GTEST_LOG_(INFO) << "SetIgnoreRepeatClickTime_004 end"; 1323 } 1324 1325 /** 1326 * @tc.number: ConnectToService_001 1327 * @tc.name: ConnectToService_001 1328 * @tc.desc: Test function ConnectToService 1329 */ 1330 HWTEST_F(AccessibilityConfigImplTest, ConnectToService_001, TestSize.Level1) 1331 { 1332 GTEST_LOG_(INFO) << "ConnectToService_001 start"; 1333 1334 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 1335 WaitParameter(NULL, NULL, 1); 1336 instance.InitializeContext(); 1337 WaitParameter(NULL, NULL, 0); 1338 GTEST_LOG_(INFO) << "ConnectToService_001 end"; 1339 } 1340 1341 /** 1342 * @tc.number: SetCaptionProperty_001 1343 * @tc.name: SetCaptionProperty_001 1344 * @tc.desc: Test function SetCaptionsProperty GetCaptionsProperty 1345 */ 1346 HWTEST_F(AccessibilityConfigImplTest, SetCaptionProperty_001, TestSize.Level1) 1347 { 1348 GTEST_LOG_(INFO) << "SetCaptionProperty_001 start"; 1349 1350 CaptionProperty caption; 1351 caption.SetFontFamily("default"); 1352 CaptionProperty value; 1353 1354 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 1355 instance.InitializeContext(); 1356 instance.SetCaptionsProperty(caption); 1357 instance.GetCaptionsProperty(value); 1358 EXPECT_STREQ("default", value.GetFontFamily().c_str()); 1359 GTEST_LOG_(INFO) << "SetCaptionProperty_001 end"; 1360 } 1361 1362 /** 1363 * @tc.number: SetScreenMagnificationState_001 1364 * @tc.name: SetScreenMagnificationState_001 1365 * @tc.desc: Test function SetScreenMagnificationState GetScreenMagnificationState 1366 */ 1367 HWTEST_F(AccessibilityConfigImplTest, SetScreenMagnificationState_001, TestSize.Level1) 1368 { 1369 GTEST_LOG_(INFO) << "SetScreenMagnificationState_001 start"; 1370 1371 bool state = true; 1372 bool value = false; 1373 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 1374 instance.InitializeContext(); 1375 instance.SetScreenMagnificationState(state); 1376 instance.GetScreenMagnificationState(value); 1377 EXPECT_TRUE(value); 1378 GTEST_LOG_(INFO) << "SetScreenMagnificationState_001 end"; 1379 } 1380 1381 /** 1382 * @tc.number: SetShortKeyState_001 1383 * @tc.name: SetShortKeyState_001 1384 * @tc.desc: Test function SetShortKeyState GetShortKeyState 1385 * @tc.require: issueI5NTXH 1386 */ 1387 HWTEST_F(AccessibilityConfigImplTest, SetShortKeyState_001, TestSize.Level1) 1388 { 1389 GTEST_LOG_(INFO) << "SetShortKeyState_001 start"; 1390 bool state = true; 1391 bool value = false; 1392 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 1393 instance.InitializeContext(); 1394 instance.SetShortKeyState(state); 1395 instance.GetShortKeyState(value); 1396 EXPECT_TRUE(value); 1397 GTEST_LOG_(INFO) << "SetShortKeyState_001 end"; 1398 } 1399 1400 /** 1401 * @tc.number: SetMouseKeyState_001 1402 * @tc.name: SetMouseKeyState_001 1403 * @tc.desc: Test function SetMouseKeyState GetMouseKeyState 1404 * @tc.require: issueI5NTXA 1405 */ 1406 HWTEST_F(AccessibilityConfigImplTest, SetMouseKeyState_001, TestSize.Level1) 1407 { 1408 GTEST_LOG_(INFO) << "SetMouseKeyState_001 start"; 1409 bool state = true; 1410 bool value = false; 1411 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 1412 instance.InitializeContext(); 1413 instance.SetMouseKeyState(state); 1414 instance.GetMouseKeyState(value); 1415 EXPECT_TRUE(value); 1416 GTEST_LOG_(INFO) << "SetMouseKeyState_001 end"; 1417 } 1418 1419 /** 1420 * @tc.number: SetCaptionsState_001 1421 * @tc.name: SetCaptionsState_001 1422 * @tc.desc: Test function SetCaptionsState GetCaptionsState 1423 */ 1424 HWTEST_F(AccessibilityConfigImplTest, SetCaptionsState_001, TestSize.Level1) 1425 { 1426 GTEST_LOG_(INFO) << "SetCaptionsState_001 start"; 1427 1428 bool state = true; 1429 bool value = false; 1430 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 1431 instance.InitializeContext(); 1432 instance.SetCaptionsState(state); 1433 instance.GetCaptionsState(value); 1434 EXPECT_TRUE(value); 1435 GTEST_LOG_(INFO) << "SetCaptionsState_001 end"; 1436 } 1437 1438 /** 1439 * @tc.number: SetMouseAutoClick_001 1440 * @tc.name: SetMouseAutoClick_001 1441 * @tc.desc: Test function SetMouseAutoClick GetMouseAutoClick 1442 * @tc.require: issueI5NTXC 1443 */ 1444 HWTEST_F(AccessibilityConfigImplTest, SetMouseAutoClick_001, TestSize.Level1) 1445 { 1446 GTEST_LOG_(INFO) << "SetMouseAutoClick_001 start"; 1447 1448 int32_t time = 10; 1449 int32_t value = 0; 1450 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 1451 instance.InitializeContext(); 1452 instance.SetMouseAutoClick(time); 1453 instance.GetMouseAutoClick(value); 1454 EXPECT_EQ(10, value); 1455 GTEST_LOG_(INFO) << "SetMouseAutoClick_001 end"; 1456 } 1457 1458 /** 1459 * @tc.number: SetShortkeyTarget_001 1460 * @tc.name: SetShortkeyTarget_001 1461 * @tc.desc: Test function SetShortkeyTarget GetShortkeyTarget 1462 * @tc.require: issueI5NTXH 1463 */ 1464 HWTEST_F(AccessibilityConfigImplTest, SetShortkeyTarget_001, TestSize.Level1) 1465 { 1466 GTEST_LOG_(INFO) << "SetShortkeyTarget_001 start"; 1467 1468 std::string name = "test"; 1469 std::string value = ""; 1470 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 1471 instance.InitializeContext(); 1472 instance.SetShortkeyTarget(name); 1473 instance.GetShortkeyTarget(value); 1474 EXPECT_STREQ(name.c_str(), "test"); 1475 GTEST_LOG_(INFO) << "SetShortkeyTarget_001 end"; 1476 } 1477 1478 /** 1479 * @tc.number: SetDaltonizationState_001 1480 * @tc.name: SetDaltonizationState_001 1481 * @tc.desc: Test function SetDaltonizationState GetDaltonizationState 1482 * @tc.require: issueI5NTX9 1483 */ 1484 HWTEST_F(AccessibilityConfigImplTest, SetDaltonizationState_001, TestSize.Level1) 1485 { 1486 GTEST_LOG_(INFO) << "SetDaltonizationState_001 start"; 1487 1488 bool state = true; 1489 bool value = false; 1490 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 1491 instance.InitializeContext(); 1492 instance.SetDaltonizationState(state); 1493 instance.GetDaltonizationState(value); 1494 EXPECT_TRUE(value); 1495 GTEST_LOG_(INFO) << "SetDaltonizationState_001 end"; 1496 } 1497 1498 /** 1499 * @tc.number: SetHighContrastTextState_001 1500 * @tc.name: SetHighContrastTextState_001 1501 * @tc.desc: Test function SetHighContrastTextState GetHighContrastTextState 1502 * @tc.require: issueI5NTX9 1503 */ 1504 HWTEST_F(AccessibilityConfigImplTest, SetHighContrastTextState_001, TestSize.Level1) 1505 { 1506 GTEST_LOG_(INFO) << "SetHighContrastTextState_001 start"; 1507 1508 bool state = true; 1509 bool value = false; 1510 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 1511 instance.InitializeContext(); 1512 instance.SetHighContrastTextState(state); 1513 instance.GetHighContrastTextState(value); 1514 EXPECT_TRUE(value); 1515 GTEST_LOG_(INFO) << "SetHighContrastTextState_001 end"; 1516 } 1517 1518 /** 1519 * @tc.number: SetInvertColorState_001 1520 * @tc.name: SetInvertColorState_001 1521 * @tc.desc: Test function SetInvertColorState GetInvertColorState 1522 * @tc.require: issueI5NTX7 1523 */ 1524 HWTEST_F(AccessibilityConfigImplTest, SetInvertColorState_001, TestSize.Level1) 1525 { 1526 GTEST_LOG_(INFO) << "SetInvertColorState_001 start"; 1527 1528 bool state = true; 1529 bool value = false; 1530 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 1531 instance.InitializeContext(); 1532 instance.SetInvertColorState(state); 1533 instance.GetInvertColorState(value); 1534 EXPECT_TRUE(value); 1535 GTEST_LOG_(INFO) << "SetInvertColorState_001 end"; 1536 } 1537 1538 /** 1539 * @tc.number: SetDaltonizationColorFilter_001 1540 * @tc.name: SetDaltonizationColorFilter_001 1541 * @tc.desc: Test function SetDaltonizationColorFilter GetDaltonizationColorFilter 1542 * @tc.require: issueI5NTX8 1543 */ 1544 HWTEST_F(AccessibilityConfigImplTest, SetDaltonizationColorFilter_001, TestSize.Level1) 1545 { 1546 GTEST_LOG_(INFO) << "SetDaltonizationColorFilter_001 start"; 1547 1548 DALTONIZATION_TYPE type = Protanomaly; 1549 DALTONIZATION_TYPE value = Normal; 1550 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 1551 instance.InitializeContext(); 1552 instance.SetDaltonizationColorFilter(type); 1553 instance.GetDaltonizationColorFilter(value); 1554 EXPECT_EQ(1, static_cast<uint32_t>(value)); 1555 GTEST_LOG_(INFO) << "SetDaltonizationColorFilter_001 end"; 1556 } 1557 1558 /** 1559 * @tc.number: SetContentTimeout_001 1560 * @tc.name: SetContentTimeout_001 1561 * @tc.desc: Test function SetContentTimeout GetContentTimeout 1562 * @tc.require: issueI5NTXF 1563 */ 1564 HWTEST_F(AccessibilityConfigImplTest, SetContentTimeout_001, TestSize.Level1) 1565 { 1566 GTEST_LOG_(INFO) << "SetContentTimeout_001 start"; 1567 1568 uint32_t timer = 10; 1569 uint32_t value = 0; 1570 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 1571 instance.InitializeContext(); 1572 instance.SetContentTimeout(timer); 1573 instance.GetContentTimeout(value); 1574 EXPECT_EQ(10, value); 1575 GTEST_LOG_(INFO) << "SetContentTimeout_001 end"; 1576 } 1577 1578 /** 1579 * @tc.number: SetAnimationOffState_001 1580 * @tc.name: SetAnimationOffState_001 1581 * @tc.desc: Test function SetAnimationOffState GetAnimationOffState 1582 * @tc.require: issueI5NTXG 1583 */ 1584 HWTEST_F(AccessibilityConfigImplTest, SetAnimationOffState_001, TestSize.Level1) 1585 { 1586 GTEST_LOG_(INFO) << "SetAnimationOffState_001 start"; 1587 1588 bool state = true; 1589 bool value = false; 1590 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 1591 instance.InitializeContext(); 1592 instance.SetAnimationOffState(state); 1593 instance.GetAnimationOffState(value); 1594 EXPECT_TRUE(value); 1595 GTEST_LOG_(INFO) << "SetAnimationOffState_001 end"; 1596 } 1597 1598 /** 1599 * @tc.number: SetBrightnessDiscount_001 1600 * @tc.name: SetBrightnessDiscount_001 1601 * @tc.desc: Test function SetBrightnessDiscount GetBrightnessDiscount 1602 * @tc.require: issueI5NTXE 1603 */ 1604 HWTEST_F(AccessibilityConfigImplTest, SetBrightnessDiscount_001, TestSize.Level1) 1605 { 1606 GTEST_LOG_(INFO) << "SetBrightnessDiscount_001 start"; 1607 1608 float brightness = 0; 1609 float value = BRIGHTNESS_DISCOUNT_VALUE; 1610 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 1611 instance.InitializeContext(); 1612 instance.SetBrightnessDiscount(brightness); 1613 instance.GetBrightnessDiscount(value); 1614 EXPECT_FLOAT_EQ(brightness, value); 1615 GTEST_LOG_(INFO) << "SetBrightnessDiscount_001 end"; 1616 } 1617 1618 /** 1619 * @tc.number: SetAudioMonoState_001 1620 * @tc.name: SetAudioMonoState_001 1621 * @tc.desc: Test function SetAudioMonoState GetAudioMonoState 1622 */ 1623 HWTEST_F(AccessibilityConfigImplTest, SetAudioMonoState_001, TestSize.Level1) 1624 { 1625 GTEST_LOG_(INFO) << "SetAudioMonoState_001 start"; 1626 1627 bool state = true; 1628 bool value = false; 1629 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 1630 instance.InitializeContext(); 1631 instance.SetAudioMonoState(state); 1632 instance.GetAudioMonoState(value); 1633 EXPECT_TRUE(value); 1634 GTEST_LOG_(INFO) << "SetAudioMonoState_001 end"; 1635 } 1636 1637 /** 1638 * @tc.number: SetAudioBalance_001 1639 * @tc.name: SetAudioBalance_001 1640 * @tc.desc: Test function SetAudioBalance GetAudioBalance 1641 */ 1642 HWTEST_F(AccessibilityConfigImplTest, SetAudioBalance_001, TestSize.Level1) 1643 { 1644 GTEST_LOG_(INFO) << "SetAudioBalance_001 start"; 1645 float balance = 0; 1646 float value = 0; 1647 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 1648 instance.InitializeContext(); 1649 instance.SetAudioBalance(balance); 1650 instance.GetAudioBalance(value); 1651 EXPECT_FLOAT_EQ(0, value); 1652 sleep(1); 1653 GTEST_LOG_(INFO) << "SetAudioBalance_001 end"; 1654 } 1655 1656 /** 1657 * @tc.number: SetClickResponseTime_001 1658 * @tc.name: SetClickResponseTime_001 1659 * @tc.desc: Test function SetClickResponseTime GetClickResponseTime 1660 */ 1661 HWTEST_F(AccessibilityConfigImplTest, SetClickResponseTime_001, TestSize.Level1) 1662 { 1663 GTEST_LOG_(INFO) << "SetClickResponseTime_001 start"; 1664 CLICK_RESPONSE_TIME time = ResponseDelayMedium; 1665 CLICK_RESPONSE_TIME value = ResponseDelayShort; 1666 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 1667 instance.InitializeContext(); 1668 instance.SetClickResponseTime(time); 1669 instance.GetClickResponseTime(value); 1670 EXPECT_EQ(ResponseDelayMedium, static_cast<uint32_t>(value)); 1671 GTEST_LOG_(INFO) << "SetClickResponseTime_001 end"; 1672 } 1673 1674 /** 1675 * @tc.number: SetIgnoreRepeatClickState_001 1676 * @tc.name: SetIgnoreRepeatClickState_001 1677 * @tc.desc: Test function SetIgnoreRepeatClickState GetIgnoreRepeatClickState 1678 */ 1679 HWTEST_F(AccessibilityConfigImplTest, SetIgnoreRepeatClickState_001, TestSize.Level1) 1680 { 1681 GTEST_LOG_(INFO) << "SetIgnoreRepeatClickState_001 start"; 1682 bool state = true; 1683 bool value = false; 1684 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 1685 instance.InitializeContext(); 1686 instance.SetIgnoreRepeatClickState(state); 1687 instance.GetIgnoreRepeatClickState(value); 1688 EXPECT_TRUE(value); 1689 GTEST_LOG_(INFO) << "SetIgnoreRepeatClickState_001 end"; 1690 } 1691 1692 /** 1693 * @tc.number: SetIgnoreRepeatClickTime_001 1694 * @tc.name: SetIgnoreRepeatClickTime_001 1695 * @tc.desc: Test function SetIgnoreRepeatClickTime SetIgnoreRepeatClickTime 1696 */ 1697 HWTEST_F(AccessibilityConfigImplTest, SetIgnoreRepeatClickTime_001, TestSize.Level1) 1698 { 1699 GTEST_LOG_(INFO) << "SetIgnoreRepeatClickTime_001 start"; 1700 IGNORE_REPEAT_CLICK_TIME time = RepeatClickTimeoutShort; 1701 IGNORE_REPEAT_CLICK_TIME value = RepeatClickTimeoutShortest; 1702 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 1703 instance.InitializeContext(); 1704 instance.SetIgnoreRepeatClickTime(time); 1705 instance.GetIgnoreRepeatClickTime(value); 1706 EXPECT_EQ(RepeatClickTimeoutShort, static_cast<uint32_t>(value)); 1707 GTEST_LOG_(INFO) << "SetIgnoreRepeatClickTime_001 end"; 1708 } 1709 1710 /** 1711 * @tc.number: SetIgnoreRepeatClickTime_003 1712 * @tc.name: SetIgnoreRepeatClickTime_003 1713 * @tc.desc: Test function SetIgnoreRepeatClickTime SetIgnoreRepeatClickTime 1714 */ 1715 HWTEST_F(AccessibilityConfigImplTest, SetIgnoreRepeatClickTime_003, TestSize.Level1) 1716 { 1717 GTEST_LOG_(INFO) << "SetIgnoreRepeatClickTime_003 start"; 1718 IGNORE_REPEAT_CLICK_TIME time = RepeatClickTimeoutLong; 1719 IGNORE_REPEAT_CLICK_TIME value = RepeatClickTimeoutLongest; 1720 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 1721 instance.InitializeContext(); 1722 instance.SetIgnoreRepeatClickTime(time); 1723 instance.GetIgnoreRepeatClickTime(value); 1724 EXPECT_EQ(RepeatClickTimeoutLong, static_cast<uint32_t>(value)); 1725 GTEST_LOG_(INFO) << "SetIgnoreRepeatClickTime_003 end"; 1726 } 1727 1728 /** 1729 * @tc.number: ConfigNotify_001 1730 * @tc.name: ConfigNotify_001 1731 * @tc.desc: Test function OnConfigStateChanged 1732 */ 1733 HWTEST_F(AccessibilityConfigImplTest, ConfigNotify_001, TestSize.Level1) 1734 { 1735 GTEST_LOG_(INFO) << "ConfigNotify_001 start"; 1736 float balance = -1.0; 1737 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 1738 std::shared_ptr<MockAccessibilityConfigObserverImpl> observer = 1739 std::make_shared<MockAccessibilityConfigObserverImpl>(); 1740 instance.InitializeContext(); 1741 for (int32_t index = 0; index < static_cast<int32_t>(CONFIG_ID_MAX); index ++) { 1742 instance.SubscribeConfigObserver(static_cast<CONFIG_ID>(index), observer, false); 1743 } 1744 instance.SetAudioBalance(balance); 1745 sleep(1); 1746 for (int32_t index = 0; index < static_cast<int32_t>(CONFIG_ID_MAX); index ++) { 1747 instance.UnsubscribeConfigObserver(static_cast<CONFIG_ID>(index), observer); 1748 } 1749 GTEST_LOG_(INFO) << "ConfigNotify_001 end"; 1750 } 1751 1752 /** 1753 * @tc.number: ConfigNotify_002 1754 * @tc.name: ConfigNotify_002 1755 * @tc.desc: Test function OnConfigStateChanged 1756 */ 1757 HWTEST_F(AccessibilityConfigImplTest, ConfigNotify_002, TestSize.Level1) 1758 { 1759 GTEST_LOG_(INFO) << "ConfigNotify_002 start"; 1760 float balance = 0; 1761 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 1762 std::shared_ptr<MockAccessibilityConfigObserverImpl> observer = 1763 std::make_shared<MockAccessibilityConfigObserverImpl>(); 1764 instance.InitializeContext(); 1765 for (int32_t index = 0; index < static_cast<int32_t>(CONFIG_ID_MAX); index ++) { 1766 instance.SubscribeConfigObserver(static_cast<CONFIG_ID>(index), observer); 1767 } 1768 instance.SetAudioBalance(balance); 1769 sleep(1); 1770 EXPECT_EQ(Accessibility::RET_OK, instance.GetAudioBalance(balance)); 1771 GTEST_LOG_(INFO) << "ConfigNotify_002 end"; 1772 } 1773 1774 /** 1775 * @tc.number: ConfigNotify_003 1776 * @tc.name: ConfigNotify_003 1777 * @tc.desc: Test function OnConfigStateChanged 1778 */ 1779 HWTEST_F(AccessibilityConfigImplTest, ConfigNotify_003, TestSize.Level1) 1780 { 1781 GTEST_LOG_(INFO) << "ConfigNotify_003 start"; 1782 float balance = -1.0; 1783 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 1784 instance.InitializeContext(); 1785 for (int32_t index = 0; index < static_cast<int32_t>(CONFIG_ID_MAX); index ++) { 1786 instance.SubscribeConfigObserver(static_cast<CONFIG_ID>(index), nullptr); 1787 } 1788 instance.SetAudioBalance(balance); 1789 sleep(1); 1790 EXPECT_EQ(Accessibility::RET_OK, instance.GetAudioBalance(balance)); 1791 GTEST_LOG_(INFO) << "ConfigNotify_003 end"; 1792 } 1793 1794 /** 1795 * @tc.number: SubscribeConfigObserver_001 1796 * @tc.name: SubscribeConfigObserver_001 1797 * @tc.desc: Test function SubscribeConfigObserver 1798 */ 1799 HWTEST_F(AccessibilityConfigImplTest, SubscribeConfigObserver_001, TestSize.Level1) 1800 { 1801 GTEST_LOG_(INFO) << "SubscribeConfigObserver_001 start"; 1802 1803 std::shared_ptr<AccessibilityConfigObserver> observer = nullptr; 1804 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 1805 instance.InitializeContext(); 1806 EXPECT_EQ(Accessibility::RET_OK, 1807 instance.SubscribeConfigObserver(CONFIG_HIGH_CONTRAST_TEXT, observer)); 1808 GTEST_LOG_(INFO) << "SubscribeConfigObserver_001 end"; 1809 } 1810 1811 /** 1812 * @tc.number: UnsubscribeConfigObserver_001 1813 * @tc.name: UnsubscribeConfigObserver_001 1814 * @tc.desc: Test function UnsubscribeConfigObserver 1815 */ 1816 HWTEST_F(AccessibilityConfigImplTest, UnsubscribeConfigObserver_001, TestSize.Level1) 1817 { 1818 GTEST_LOG_(INFO) << "UnsubscribeConfigObserver_001 start"; 1819 1820 std::shared_ptr<AccessibilityConfigObserver> observer = nullptr; 1821 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 1822 instance.InitializeContext(); 1823 EXPECT_EQ(Accessibility::RET_OK, 1824 instance.UnsubscribeConfigObserver(CONFIG_HIGH_CONTRAST_TEXT, observer)); 1825 GTEST_LOG_(INFO) << "UnsubscribeConfigObserver_001 end"; 1826 } 1827 1828 /** 1829 * @tc.number: UnsubscribeConfigObserver_002 1830 * @tc.name: UnsubscribeConfigObserver_002 1831 * @tc.desc: Test function UnsubscribeConfigObserver 1832 */ 1833 HWTEST_F(AccessibilityConfigImplTest, UnsubscribeConfigObserver_002, TestSize.Level1) 1834 { 1835 GTEST_LOG_(INFO) << "UnsubscribeConfigObserver_002 start"; 1836 1837 std::shared_ptr<AccessibilityConfigObserver> observer = nullptr; 1838 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 1839 instance.InitializeContext(); 1840 EXPECT_EQ(Accessibility::RET_OK, 1841 instance.UnsubscribeConfigObserver(CONFIG_ID_MAX, observer)); 1842 GTEST_LOG_(INFO) << "UnsubscribeConfigObserver_002 end"; 1843 } 1844 1845 /** 1846 * @tc.number: SubscribeEnableAbilityListsObserver_001 1847 * @tc.name: SubscribeEnableAbilityListsObserver_001 1848 * @tc.desc: Test function SubscribeEnableAbilityListsObserver 1849 */ 1850 HWTEST_F(AccessibilityConfigImplTest, SubscribeEnableAbilityListsObserver_001, TestSize.Level1) 1851 { 1852 GTEST_LOG_(INFO) << "SubscribeEnableAbilityListsObserver_001 start"; 1853 1854 std::shared_ptr<AccessibilityEnableAbilityListsObserver> observer = 1855 std::make_shared<MockAccessibilityEnableAbilityListsObserverImpl>(); 1856 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 1857 instance.InitializeContext(); 1858 EXPECT_EQ(Accessibility::RET_OK, 1859 instance.SubscribeEnableAbilityListsObserver(observer)); 1860 GTEST_LOG_(INFO) << "SubscribeEnableAbilityListsObserver_001 end"; 1861 } 1862 1863 /** 1864 * @tc.number: UnsubscribeEnableAbilityListsObserver_001 1865 * @tc.name: UnsubscribeEnableAbilityListsObserver_001 1866 * @tc.desc: Test function UnsubscribeEnableAbilityListsObserver 1867 */ 1868 HWTEST_F(AccessibilityConfigImplTest, UnsubscribeEnableAbilityListsObserver_001, TestSize.Level1) 1869 { 1870 GTEST_LOG_(INFO) << "UnsubscribeEnableAbilityListsObserver_001 start"; 1871 1872 std::shared_ptr<AccessibilityEnableAbilityListsObserver> observer = nullptr; 1873 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 1874 instance.InitializeContext(); 1875 instance.SubscribeEnableAbilityListsObserver(observer); 1876 instance.UnsubscribeEnableAbilityListsObserver(observer); 1877 EXPECT_EQ(Accessibility::RET_OK, 1878 instance.UnsubscribeEnableAbilityListsObserver(observer)); 1879 GTEST_LOG_(INFO) << "UnsubscribeEnableAbilityListsObserver_001 end"; 1880 } 1881 1882 /** 1883 * @tc.number: UnsubscribeEnableAbilityListsObserver_002 1884 * @tc.name: UnsubscribeEnableAbilityListsObserver_002 1885 * @tc.desc: Test function UnsubscribeEnableAbilityListsObserver 1886 */ 1887 HWTEST_F(AccessibilityConfigImplTest, UnsubscribeEnableAbilityListsObserver_002, TestSize.Level1) 1888 { 1889 GTEST_LOG_(INFO) << "UnsubscribeEnableAbilityListsObserver_002 start"; 1890 1891 std::shared_ptr<AccessibilityEnableAbilityListsObserver> observer = nullptr; 1892 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 1893 instance.InitializeContext(); 1894 instance.UnsubscribeEnableAbilityListsObserver(observer); 1895 GTEST_LOG_(INFO) << "UnsubscribeEnableAbilityListsObserver_002 end"; 1896 } 1897 1898 /** 1899 * @tc.number: EnableAbility_001 1900 * @tc.name: EnableAbility_001 1901 * @tc.desc: Test function EnableAbility 1902 */ 1903 HWTEST_F(AccessibilityConfigImplTest, EnableAbility_001, TestSize.Level1) 1904 { 1905 GTEST_LOG_(INFO) << "EnableAbility_001 start"; 1906 1907 std::string name = "test"; 1908 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 1909 instance.InitializeContext(); 1910 EXPECT_EQ(Accessibility::RET_OK, instance.EnableAbility(name, 0)); 1911 sleep(1); 1912 GTEST_LOG_(INFO) << "EnableAbility_001 end"; 1913 } 1914 1915 /** 1916 * @tc.number: DisableAbility_001 1917 * @tc.name: DisableAbility_001 1918 * @tc.desc: Test function DisableAbility 1919 */ 1920 HWTEST_F(AccessibilityConfigImplTest, DisableAbility_001, TestSize.Level1) 1921 { 1922 GTEST_LOG_(INFO) << "DisableAbility_001 start"; 1923 1924 std::string name = "test"; 1925 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 1926 instance.InitializeContext(); 1927 EXPECT_EQ(Accessibility::RET_OK, instance.DisableAbility(name)); 1928 GTEST_LOG_(INFO) << "DisableAbility_001 end"; 1929 } 1930 1931 /** 1932 * @tc.number: SetMagnificationState_001 1933 * @tc.name: SetMagnificationState_001 1934 * @tc.desc: Test function SetMagnificationState 1935 */ 1936 HWTEST_F(AccessibilityConfigImplTest, SetMagnificationState_001, TestSize.Level1) 1937 { 1938 GTEST_LOG_(INFO) << "SetMagnificationState_001 start"; 1939 1940 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 1941 instance.InitializeContext(); 1942 EXPECT_EQ(Accessibility::RET_OK, instance.SetMagnificationState(false)); 1943 GTEST_LOG_(INFO) << "SetMagnificationState_001 end"; 1944 } 1945 1946 /** 1947 * @tc.number: SetEnhanceConfig_001 1948 * @tc.name: SetEnhanceConfig_001 1949 * @tc.desc: Test function SetEnhanceConfig 1950 */ 1951 HWTEST_F(AccessibilityConfigImplTest, SetEnhanceConfig_001, TestSize.Level1) 1952 { 1953 GTEST_LOG_(INFO) << "SetEnhanceConfig_001 start"; 1954 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 1955 EXPECT_NE(Accessibility::RET_OK, instance.SetEnhanceConfig(nullptr, 0)); 1956 GTEST_LOG_(INFO) << "SetEnhanceConfig_001 end"; 1957 } 1958 } // namespace AccessibilityConfig 1959 } // namespace OHOS