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 <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 {} 70 }; 71 72 /** 73 * @tc.number: SetCaptionProperty_002 74 * @tc.name: SetCaptionProperty_002 75 * @tc.desc: Test function SetCaptionsProperty GetCaptionsProperty 76 */ 77 HWTEST_F(AccessibilityConfigImplTest, SetCaptionProperty_002, TestSize.Level1) 78 { 79 GTEST_LOG_(INFO) << "SetCaptionProperty_002 start"; 80 81 CaptionProperty caption; 82 CaptionProperty value; 83 caption.SetFontFamily("sansSerif"); 84 85 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 86 instance.SetCaptionsProperty(caption); 87 instance.GetCaptionsProperty(value); 88 EXPECT_STREQ(value.GetFontFamily().c_str(), "default"); 89 GTEST_LOG_(INFO) << "SetCaptionProperty_002 end"; 90 } 91 92 /** 93 * @tc.number: SetScreenMagnificationState_002 94 * @tc.name: SetScreenMagnificationState_002 95 * @tc.desc: Test function SetScreenMagnificationState GetScreenMagnificationState 96 */ 97 HWTEST_F(AccessibilityConfigImplTest, SetScreenMagnificationState_002, TestSize.Level1) 98 { 99 GTEST_LOG_(INFO) << "SetScreenMagnificationState_002 start"; 100 101 bool state = true; 102 bool value = false; 103 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 104 instance.SetScreenMagnificationState(state); 105 instance.GetScreenMagnificationState(value); 106 EXPECT_FALSE(value); 107 GTEST_LOG_(INFO) << "SetScreenMagnificationState_002 end"; 108 } 109 110 /** 111 * @tc.number: SetShortKeyState_002 112 * @tc.name: SetShortKeyState_002 113 * @tc.desc: Test function SetShortKeyState GetShortKeyState 114 * @tc.require: issueI5NTXH 115 */ 116 HWTEST_F(AccessibilityConfigImplTest, SetShortKeyState_002, TestSize.Level1) 117 { 118 GTEST_LOG_(INFO) << "SetShortKeyState_002 start"; 119 120 bool state = true; 121 bool value = false; 122 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 123 instance.SetShortKeyState(state); 124 instance.GetShortKeyState(value); 125 EXPECT_FALSE(value); 126 GTEST_LOG_(INFO) << "SetShortKeyState_002 end"; 127 } 128 129 /** 130 * @tc.number: SetMouseKeyState_002 131 * @tc.name: SetMouseKeyState_002 132 * @tc.desc: Test function SetMouseKeyState GetMouseKeyState 133 * @tc.require: issueI5NTXA 134 */ 135 HWTEST_F(AccessibilityConfigImplTest, SetMouseKeyState_002, TestSize.Level1) 136 { 137 GTEST_LOG_(INFO) << "SetMouseKeyState_002 start"; 138 bool state = true; 139 bool value = false; 140 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 141 instance.SetMouseKeyState(state); 142 instance.GetMouseKeyState(value); 143 EXPECT_FALSE(value); 144 GTEST_LOG_(INFO) << "SetMouseKeyState_002 end"; 145 } 146 147 /** 148 * @tc.number: SetCaptionsState_002 149 * @tc.name: SetCaptionsState_002 150 * @tc.desc: Test function SetCaptionsState GetCaptionsState 151 */ 152 HWTEST_F(AccessibilityConfigImplTest, SetCaptionsState_002, TestSize.Level1) 153 { 154 GTEST_LOG_(INFO) << "SetCaptionsState_002 start"; 155 156 bool state = true; 157 bool value = false; 158 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 159 instance.SetCaptionsState(state); 160 instance.GetCaptionsState(value); 161 EXPECT_FALSE(value); 162 GTEST_LOG_(INFO) << "SetCaptionsState_002 end"; 163 } 164 165 /** 166 * @tc.number: SetMouseAutoClick_002 167 * @tc.name: SetMouseAutoClick_002 168 * @tc.desc: Test function SetMouseAutoClick GetMouseAutoClick 169 * @tc.require: issueI5NTXC 170 */ 171 HWTEST_F(AccessibilityConfigImplTest, SetMouseAutoClick_002, TestSize.Level1) 172 { 173 GTEST_LOG_(INFO) << "SetMouseAutoClick_002 start"; 174 175 int32_t time = 10; 176 int32_t value = 0; 177 std::vector<int> info; 178 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 179 instance.SetMouseAutoClick(time); 180 instance.GetMouseAutoClick(value); 181 EXPECT_EQ(info.size(), 0); 182 GTEST_LOG_(INFO) << "SetMouseAutoClick_002 end"; 183 } 184 185 /** 186 * @tc.number: SetShortkeyTarget_002 187 * @tc.name: SetShortkeyTarget_002 188 * @tc.desc: Test function SetShortkeyTarget GetShortkeyTarget 189 * @tc.require: issueI5NTXH 190 */ 191 HWTEST_F(AccessibilityConfigImplTest, SetShortkeyTarget_002, TestSize.Level1) 192 { 193 GTEST_LOG_(INFO) << "SetShortkeyTarget_002 start"; 194 195 std::string name = "test"; 196 std::string value = ""; 197 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 198 instance.SetShortkeyTarget(name); 199 instance.GetShortkeyTarget(value); 200 EXPECT_STREQ(value.c_str(), ""); 201 GTEST_LOG_(INFO) << "SetShortkeyTarget_002 end"; 202 } 203 204 /** 205 * @tc.number: SetHighContrastTextState_002 206 * @tc.name: SetHighContrastTextState_002 207 * @tc.desc: Test function SetHighContrastTextState GetHighContrastTextState 208 * @tc.require: issueI5NTX9 209 */ 210 HWTEST_F(AccessibilityConfigImplTest, SetHighContrastTextState_002, TestSize.Level1) 211 { 212 GTEST_LOG_(INFO) << "SetHighContrastTextState_002 start"; 213 214 bool state = true; 215 bool value = false; 216 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 217 instance.SetHighContrastTextState(state); 218 instance.GetHighContrastTextState(value); 219 EXPECT_FALSE(value); 220 GTEST_LOG_(INFO) << "SetHighContrastTextState_002 end"; 221 } 222 223 /** 224 * @tc.number: SetInvertColorState_002 225 * @tc.name: SetInvertColorState_002 226 * @tc.desc: Test function SetInvertColorState GetInvertColorState 227 * @tc.require: issueI5NTX7 228 */ 229 HWTEST_F(AccessibilityConfigImplTest, SetInvertColorState_002, TestSize.Level1) 230 { 231 GTEST_LOG_(INFO) << "SetInvertColorState_002 start"; 232 233 bool state = true; 234 bool value = false; 235 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 236 instance.SetInvertColorState(state); 237 instance.GetInvertColorState(value); 238 EXPECT_FALSE(value); 239 GTEST_LOG_(INFO) << "SetInvertColorState_002 end"; 240 } 241 242 /** 243 * @tc.number: SetDaltonizationColorFilter_002 244 * @tc.name: SetDaltonizationColorFilter_002 245 * @tc.desc: Test function SetDaltonizationColorFilter GetDaltonizationColorFilter 246 * @tc.require: issueI5NTX8 247 */ 248 HWTEST_F(AccessibilityConfigImplTest, SetDaltonizationColorFilter_002, TestSize.Level1) 249 { 250 GTEST_LOG_(INFO) << "SetDaltonizationColorFilter_002 start"; 251 252 DALTONIZATION_TYPE type = Protanomaly; 253 DALTONIZATION_TYPE value = Normal; 254 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 255 instance.SetDaltonizationColorFilter(type); 256 instance.GetDaltonizationColorFilter(value); 257 EXPECT_EQ(0, static_cast<uint32_t>(value)); 258 GTEST_LOG_(INFO) << "SetDaltonizationColorFilter_002 end"; 259 } 260 261 /** 262 * @tc.number: SetContentTimeout_002 263 * @tc.name: SetContentTimeout_002 264 * @tc.desc: Test function SetContentTimeout GetContentTimeout 265 * @tc.require: issueI5NTXF 266 */ 267 HWTEST_F(AccessibilityConfigImplTest, SetContentTimeout_002, TestSize.Level1) 268 { 269 GTEST_LOG_(INFO) << "SetContentTimeout_002 start"; 270 271 uint32_t timer = 10; 272 uint32_t value = 0; 273 std::vector<int> info; 274 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 275 instance.SetContentTimeout(timer); 276 instance.GetContentTimeout(value); 277 EXPECT_EQ(info.size(), 0); 278 GTEST_LOG_(INFO) << "SetContentTimeout_002 end"; 279 } 280 281 /** 282 * @tc.number: SetAnimationOffState_002 283 * @tc.name: SetAnimationOffState_002 284 * @tc.desc: Test function SetAnimationOffState GetAnimationOffState 285 * @tc.require: issueI5NTXG 286 */ 287 HWTEST_F(AccessibilityConfigImplTest, SetAnimationOffState_002, TestSize.Level1) 288 { 289 GTEST_LOG_(INFO) << "SetAnimationOffState_002 start"; 290 291 bool state = true; 292 bool value = false; 293 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 294 instance.SetAnimationOffState(state); 295 instance.GetAnimationOffState(value); 296 EXPECT_FALSE(value); 297 GTEST_LOG_(INFO) << "SetAnimationOffState_002 end"; 298 } 299 300 /** 301 * @tc.number: SetBrightnessDiscount_002 302 * @tc.name: SetBrightnessDiscount_002 303 * @tc.desc: Test function SetBrightnessDiscount GetBrightnessDiscount 304 * @tc.require: issueI5NTXE 305 */ 306 HWTEST_F(AccessibilityConfigImplTest, SetBrightnessDiscount_002, TestSize.Level1) 307 { 308 GTEST_LOG_(INFO) << "SetBrightnessDiscount_002 start"; 309 310 float brightness = BRIGHTNESS_DISCOUNT_VALUE; 311 float value = 0; 312 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 313 instance.SetBrightnessDiscount(brightness); 314 instance.GetBrightnessDiscount(value); 315 EXPECT_FLOAT_EQ(0, value); 316 GTEST_LOG_(INFO) << "SetBrightnessDiscount_002 end"; 317 } 318 319 /** 320 * @tc.number: SetAudioMonoState_002 321 * @tc.name: SetAudioMonoState_002 322 * @tc.desc: Test function SetAudioMonoState GetAudioMonoState 323 */ 324 HWTEST_F(AccessibilityConfigImplTest, SetAudioMonoState_002, TestSize.Level1) 325 { 326 GTEST_LOG_(INFO) << "SetAudioMonoState_002 start"; 327 328 bool state = true; 329 bool value = false; 330 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 331 instance.SetAudioMonoState(state); 332 instance.GetAudioMonoState(value); 333 EXPECT_FALSE(value); 334 GTEST_LOG_(INFO) << "SetAudioMonoState_002 end"; 335 } 336 337 /** 338 * @tc.number: SetAudioBalance_002 339 * @tc.name: SetAudioBalance_002 340 * @tc.desc: Test function SetAudioBalance GetAudioBalance 341 */ 342 HWTEST_F(AccessibilityConfigImplTest, SetAudioBalance_002, TestSize.Level1) 343 { 344 GTEST_LOG_(INFO) << "SetAudioBalance_002 start"; 345 float balance = -1.0; 346 float value = 0; 347 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 348 instance.SetAudioBalance(balance); 349 instance.GetAudioBalance(value); 350 EXPECT_FLOAT_EQ(0, value); 351 GTEST_LOG_(INFO) << "SetAudioBalance_002 end"; 352 } 353 354 /** 355 * @tc.number: ConnectToService_001 356 * @tc.name: ConnectToService_001 357 * @tc.desc: Test function ConnectToService 358 */ 359 HWTEST_F(AccessibilityConfigImplTest, ConnectToService_001, TestSize.Level1) 360 { 361 GTEST_LOG_(INFO) << "ConnectToService_001 start"; 362 363 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 364 WaitParameter(NULL, NULL, 1); 365 instance.InitializeContext(); 366 WaitParameter(NULL, NULL, 0); 367 GTEST_LOG_(INFO) << "ConnectToService_001 end"; 368 } 369 370 /** 371 * @tc.number: SetCaptionProperty_001 372 * @tc.name: SetCaptionProperty_001 373 * @tc.desc: Test function SetCaptionsProperty GetCaptionsProperty 374 */ 375 HWTEST_F(AccessibilityConfigImplTest, SetCaptionProperty_001, TestSize.Level1) 376 { 377 GTEST_LOG_(INFO) << "SetCaptionProperty_001 start"; 378 379 CaptionProperty caption; 380 caption.SetFontFamily("sansSerif"); 381 CaptionProperty value; 382 383 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 384 instance.InitializeContext(); 385 instance.SetCaptionsProperty(caption); 386 instance.GetCaptionsProperty(value); 387 EXPECT_STREQ(caption.GetFontFamily().c_str(), value.GetFontFamily().c_str()); 388 GTEST_LOG_(INFO) << "SetCaptionProperty_001 end"; 389 } 390 391 /** 392 * @tc.number: SetScreenMagnificationState_001 393 * @tc.name: SetScreenMagnificationState_001 394 * @tc.desc: Test function SetScreenMagnificationState GetScreenMagnificationState 395 */ 396 HWTEST_F(AccessibilityConfigImplTest, SetScreenMagnificationState_001, TestSize.Level1) 397 { 398 GTEST_LOG_(INFO) << "SetScreenMagnificationState_001 start"; 399 400 bool state = true; 401 bool value = false; 402 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 403 instance.InitializeContext(); 404 instance.SetScreenMagnificationState(state); 405 instance.GetScreenMagnificationState(value); 406 EXPECT_TRUE(value); 407 GTEST_LOG_(INFO) << "SetScreenMagnificationState_001 end"; 408 } 409 410 /** 411 * @tc.number: SetShortKeyState_001 412 * @tc.name: SetShortKeyState_001 413 * @tc.desc: Test function SetShortKeyState GetShortKeyState 414 * @tc.require: issueI5NTXH 415 */ 416 HWTEST_F(AccessibilityConfigImplTest, SetShortKeyState_001, TestSize.Level1) 417 { 418 GTEST_LOG_(INFO) << "SetShortKeyState_001 start"; 419 bool state = true; 420 bool value = false; 421 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 422 instance.InitializeContext(); 423 instance.SetShortKeyState(state); 424 instance.GetShortKeyState(value); 425 EXPECT_TRUE(value); 426 GTEST_LOG_(INFO) << "SetShortKeyState_001 end"; 427 } 428 429 /** 430 * @tc.number: SetMouseKeyState_001 431 * @tc.name: SetMouseKeyState_001 432 * @tc.desc: Test function SetMouseKeyState GetMouseKeyState 433 * @tc.require: issueI5NTXA 434 */ 435 HWTEST_F(AccessibilityConfigImplTest, SetMouseKeyState_001, TestSize.Level1) 436 { 437 GTEST_LOG_(INFO) << "SetMouseKeyState_001 start"; 438 bool state = true; 439 bool value = false; 440 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 441 instance.InitializeContext(); 442 instance.SetMouseKeyState(state); 443 instance.GetMouseKeyState(value); 444 EXPECT_TRUE(value); 445 GTEST_LOG_(INFO) << "SetMouseKeyState_001 end"; 446 } 447 448 /** 449 * @tc.number: SetCaptionsState_001 450 * @tc.name: SetCaptionsState_001 451 * @tc.desc: Test function SetCaptionsState GetCaptionsState 452 */ 453 HWTEST_F(AccessibilityConfigImplTest, SetCaptionsState_001, TestSize.Level1) 454 { 455 GTEST_LOG_(INFO) << "SetCaptionsState_001 start"; 456 457 bool state = true; 458 bool value = false; 459 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 460 instance.InitializeContext(); 461 instance.SetCaptionsState(state); 462 instance.GetCaptionsState(value); 463 EXPECT_TRUE(value); 464 GTEST_LOG_(INFO) << "SetCaptionsState_001 end"; 465 } 466 467 /** 468 * @tc.number: SetMouseAutoClick_001 469 * @tc.name: SetMouseAutoClick_001 470 * @tc.desc: Test function SetMouseAutoClick GetMouseAutoClick 471 * @tc.require: issueI5NTXC 472 */ 473 HWTEST_F(AccessibilityConfigImplTest, SetMouseAutoClick_001, TestSize.Level1) 474 { 475 GTEST_LOG_(INFO) << "SetMouseAutoClick_001 start"; 476 477 int32_t time = 10; 478 int32_t value = 0; 479 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 480 instance.InitializeContext(); 481 instance.SetMouseAutoClick(time); 482 instance.GetMouseAutoClick(value); 483 EXPECT_EQ(time, value); 484 GTEST_LOG_(INFO) << "SetMouseAutoClick_001 end"; 485 } 486 487 /** 488 * @tc.number: SetShortkeyTarget_001 489 * @tc.name: SetShortkeyTarget_001 490 * @tc.desc: Test function SetShortkeyTarget GetShortkeyTarget 491 * @tc.require: issueI5NTXH 492 */ 493 HWTEST_F(AccessibilityConfigImplTest, SetShortkeyTarget_001, TestSize.Level1) 494 { 495 GTEST_LOG_(INFO) << "SetShortkeyTarget_001 start"; 496 497 std::string name = "test"; 498 std::string value = ""; 499 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 500 instance.InitializeContext(); 501 instance.SetShortkeyTarget(name); 502 instance.GetShortkeyTarget(value); 503 EXPECT_STREQ(name.c_str(), value.c_str()); 504 GTEST_LOG_(INFO) << "SetShortkeyTarget_001 end"; 505 } 506 507 /** 508 * @tc.number: SetHighContrastTextState_001 509 * @tc.name: SetHighContrastTextState_001 510 * @tc.desc: Test function SetHighContrastTextState GetHighContrastTextState 511 * @tc.require: issueI5NTX9 512 */ 513 HWTEST_F(AccessibilityConfigImplTest, SetHighContrastTextState_001, TestSize.Level1) 514 { 515 GTEST_LOG_(INFO) << "SetHighContrastTextState_001 start"; 516 517 bool state = true; 518 bool value = false; 519 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 520 instance.InitializeContext(); 521 instance.SetHighContrastTextState(state); 522 instance.GetHighContrastTextState(value); 523 EXPECT_TRUE(value); 524 GTEST_LOG_(INFO) << "SetHighContrastTextState_001 end"; 525 } 526 527 /** 528 * @tc.number: SetInvertColorState_001 529 * @tc.name: SetInvertColorState_001 530 * @tc.desc: Test function SetInvertColorState GetInvertColorState 531 * @tc.require: issueI5NTX7 532 */ 533 HWTEST_F(AccessibilityConfigImplTest, SetInvertColorState_001, TestSize.Level1) 534 { 535 GTEST_LOG_(INFO) << "SetInvertColorState_001 start"; 536 537 bool state = true; 538 bool value = false; 539 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 540 instance.InitializeContext(); 541 instance.SetInvertColorState(state); 542 instance.GetInvertColorState(value); 543 EXPECT_TRUE(value); 544 GTEST_LOG_(INFO) << "SetInvertColorState_001 end"; 545 } 546 547 /** 548 * @tc.number: SetDaltonizationColorFilter_001 549 * @tc.name: SetDaltonizationColorFilter_001 550 * @tc.desc: Test function SetDaltonizationColorFilter GetDaltonizationColorFilter 551 * @tc.require: issueI5NTX8 552 */ 553 HWTEST_F(AccessibilityConfigImplTest, SetDaltonizationColorFilter_001, TestSize.Level1) 554 { 555 GTEST_LOG_(INFO) << "SetDaltonizationColorFilter_001 start"; 556 557 DALTONIZATION_TYPE type = Protanomaly; 558 DALTONIZATION_TYPE value = Normal; 559 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 560 instance.InitializeContext(); 561 instance.SetDaltonizationColorFilter(type); 562 instance.GetDaltonizationColorFilter(value); 563 EXPECT_EQ(static_cast<uint32_t>(type), static_cast<uint32_t>(value)); 564 GTEST_LOG_(INFO) << "SetDaltonizationColorFilter_001 end"; 565 } 566 567 /** 568 * @tc.number: SetContentTimeout_001 569 * @tc.name: SetContentTimeout_001 570 * @tc.desc: Test function SetContentTimeout GetContentTimeout 571 * @tc.require: issueI5NTXF 572 */ 573 HWTEST_F(AccessibilityConfigImplTest, SetContentTimeout_001, TestSize.Level1) 574 { 575 GTEST_LOG_(INFO) << "SetContentTimeout_001 start"; 576 577 uint32_t timer = 10; 578 uint32_t value = 0; 579 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 580 instance.InitializeContext(); 581 instance.SetContentTimeout(timer); 582 instance.GetContentTimeout(value); 583 EXPECT_EQ(timer, value); 584 GTEST_LOG_(INFO) << "SetContentTimeout_001 end"; 585 } 586 587 /** 588 * @tc.number: SetAnimationOffState_001 589 * @tc.name: SetAnimationOffState_001 590 * @tc.desc: Test function SetAnimationOffState GetAnimationOffState 591 * @tc.require: issueI5NTXG 592 */ 593 HWTEST_F(AccessibilityConfigImplTest, SetAnimationOffState_001, TestSize.Level1) 594 { 595 GTEST_LOG_(INFO) << "SetAnimationOffState_001 start"; 596 597 bool state = true; 598 bool value = false; 599 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 600 instance.InitializeContext(); 601 instance.SetAnimationOffState(state); 602 instance.GetAnimationOffState(value); 603 EXPECT_TRUE(value); 604 GTEST_LOG_(INFO) << "SetAnimationOffState_001 end"; 605 } 606 607 /** 608 * @tc.number: SetBrightnessDiscount_001 609 * @tc.name: SetBrightnessDiscount_001 610 * @tc.desc: Test function SetBrightnessDiscount GetBrightnessDiscount 611 * @tc.require: issueI5NTXE 612 */ 613 HWTEST_F(AccessibilityConfigImplTest, SetBrightnessDiscount_001, TestSize.Level1) 614 { 615 GTEST_LOG_(INFO) << "SetBrightnessDiscount_001 start"; 616 617 float brightness = 0; 618 float value = BRIGHTNESS_DISCOUNT_VALUE; 619 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 620 instance.InitializeContext(); 621 instance.SetBrightnessDiscount(brightness); 622 instance.GetBrightnessDiscount(value); 623 EXPECT_FLOAT_EQ(brightness, value); 624 GTEST_LOG_(INFO) << "SetBrightnessDiscount_001 end"; 625 } 626 627 /** 628 * @tc.number: SetAudioMonoState_001 629 * @tc.name: SetAudioMonoState_001 630 * @tc.desc: Test function SetAudioMonoState GetAudioMonoState 631 */ 632 HWTEST_F(AccessibilityConfigImplTest, SetAudioMonoState_001, TestSize.Level1) 633 { 634 GTEST_LOG_(INFO) << "SetAudioMonoState_001 start"; 635 636 bool state = true; 637 bool value = false; 638 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 639 instance.InitializeContext(); 640 instance.SetAudioMonoState(state); 641 instance.GetAudioMonoState(value); 642 EXPECT_TRUE(value); 643 GTEST_LOG_(INFO) << "SetAudioMonoState_001 end"; 644 } 645 646 /** 647 * @tc.number: SetAudioBalance_001 648 * @tc.name: SetAudioBalance_001 649 * @tc.desc: Test function SetAudioBalance GetAudioBalance 650 */ 651 HWTEST_F(AccessibilityConfigImplTest, SetAudioBalance_001, TestSize.Level1) 652 { 653 GTEST_LOG_(INFO) << "SetAudioBalance_001 start"; 654 float balance = 0; 655 float value = 0; 656 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 657 instance.InitializeContext(); 658 instance.SetAudioBalance(balance); 659 instance.GetAudioBalance(value); 660 EXPECT_FLOAT_EQ(balance, value); 661 sleep(1); 662 GTEST_LOG_(INFO) << "SetAudioBalance_001 end"; 663 } 664 665 /** 666 * @tc.number: ConfigNotify_001 667 * @tc.name: ConfigNotify_001 668 * @tc.desc: Test function OnConfigStateChanged 669 */ 670 HWTEST_F(AccessibilityConfigImplTest, ConfigNotify_001, TestSize.Level1) 671 { 672 GTEST_LOG_(INFO) << "ConfigNotify_001 start"; 673 float balance = -1.0; 674 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 675 std::shared_ptr<MockAccessibilityConfigObserverImpl> observer = 676 std::make_shared<MockAccessibilityConfigObserverImpl>(); 677 instance.InitializeContext(); 678 for (int32_t index = 0; index < static_cast<int32_t>(CONFIG_ID_MAX); index ++) { 679 instance.SubscribeConfigObserver(static_cast<CONFIG_ID>(index), observer, false); 680 } 681 instance.SetAudioBalance(balance); 682 sleep(1); 683 instance.SetAudioBalance(balance); 684 sleep(1); 685 for (int32_t index = 0; index < static_cast<int32_t>(CONFIG_ID_MAX); index ++) { 686 instance.UnsubscribeConfigObserver(static_cast<CONFIG_ID>(index), observer); 687 } 688 GTEST_LOG_(INFO) << "ConfigNotify_001 end"; 689 } 690 691 /** 692 * @tc.number: ConfigNotify_002 693 * @tc.name: ConfigNotify_002 694 * @tc.desc: Test function OnConfigStateChanged 695 */ 696 HWTEST_F(AccessibilityConfigImplTest, ConfigNotify_002, TestSize.Level1) 697 { 698 GTEST_LOG_(INFO) << "ConfigNotify_002 start"; 699 float balance = 0; 700 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 701 std::shared_ptr<MockAccessibilityConfigObserverImpl> observer = 702 std::make_shared<MockAccessibilityConfigObserverImpl>(); 703 instance.InitializeContext(); 704 for (int32_t index = 0; index < static_cast<int32_t>(CONFIG_ID_MAX); index ++) { 705 instance.SubscribeConfigObserver(static_cast<CONFIG_ID>(index), observer); 706 } 707 instance.SetAudioBalance(balance); 708 sleep(1); 709 GTEST_LOG_(INFO) << "ConfigNotify_002 end"; 710 } 711 712 /** 713 * @tc.number: ConfigNotify_003 714 * @tc.name: ConfigNotify_003 715 * @tc.desc: Test function OnConfigStateChanged 716 */ 717 HWTEST_F(AccessibilityConfigImplTest, ConfigNotify_003, TestSize.Level1) 718 { 719 GTEST_LOG_(INFO) << "ConfigNotify_003 start"; 720 float balance = -1.0; 721 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 722 instance.InitializeContext(); 723 for (int32_t index = 0; index < static_cast<int32_t>(CONFIG_ID_MAX); index ++) { 724 instance.SubscribeConfigObserver(static_cast<CONFIG_ID>(index), nullptr); 725 } 726 instance.SetAudioBalance(balance); 727 sleep(1); 728 GTEST_LOG_(INFO) << "ConfigNotify_003 end"; 729 } 730 731 /** 732 * @tc.number: SubscribeConfigObserver_001 733 * @tc.name: SubscribeConfigObserver_001 734 * @tc.desc: Test function SubscribeConfigObserver 735 */ 736 HWTEST_F(AccessibilityConfigImplTest, SubscribeConfigObserver_001, TestSize.Level1) 737 { 738 GTEST_LOG_(INFO) << "SubscribeConfigObserver_001 start"; 739 740 std::shared_ptr<AccessibilityConfigObserver> observer = nullptr; 741 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 742 instance.InitializeContext(); 743 instance.SubscribeConfigObserver(CONFIG_HIGH_CONTRAST_TEXT, observer); 744 GTEST_LOG_(INFO) << "SubscribeConfigObserver_001 end"; 745 } 746 747 /** 748 * @tc.number: UnsubscribeConfigObserver_001 749 * @tc.name: UnsubscribeConfigObserver_001 750 * @tc.desc: Test function UnsubscribeConfigObserver 751 */ 752 HWTEST_F(AccessibilityConfigImplTest, UnsubscribeConfigObserver_001, TestSize.Level1) 753 { 754 GTEST_LOG_(INFO) << "UnsubscribeConfigObserver_001 start"; 755 756 std::shared_ptr<AccessibilityConfigObserver> observer = nullptr; 757 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 758 instance.InitializeContext(); 759 instance.UnsubscribeConfigObserver(CONFIG_HIGH_CONTRAST_TEXT, observer); 760 GTEST_LOG_(INFO) << "UnsubscribeConfigObserver_001 end"; 761 } 762 763 /** 764 * @tc.number: SubscribeEnableAbilityListsObserver_001 765 * @tc.name: SubscribeEnableAbilityListsObserver_001 766 * @tc.desc: Test function SubscribeEnableAbilityListsObserver 767 */ 768 HWTEST_F(AccessibilityConfigImplTest, SubscribeEnableAbilityListsObserver_001, TestSize.Level1) 769 { 770 GTEST_LOG_(INFO) << "SubscribeEnableAbilityListsObserver_001 start"; 771 772 std::shared_ptr<AccessibilityEnableAbilityListsObserver> observer = 773 std::make_shared<MockAccessibilityEnableAbilityListsObserverImpl>(); 774 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 775 instance.InitializeContext(); 776 instance.SubscribeEnableAbilityListsObserver(observer); 777 GTEST_LOG_(INFO) << "SubscribeEnableAbilityListsObserver_001 end"; 778 } 779 780 /** 781 * @tc.number: UnsubscribeEnableAbilityListsObserver_001 782 * @tc.name: UnsubscribeEnableAbilityListsObserver_001 783 * @tc.desc: Test function UnsubscribeEnableAbilityListsObserver 784 */ 785 HWTEST_F(AccessibilityConfigImplTest, UnsubscribeEnableAbilityListsObserver_001, TestSize.Level1) 786 { 787 GTEST_LOG_(INFO) << "UnsubscribeEnableAbilityListsObserver_001 start"; 788 789 std::shared_ptr<AccessibilityEnableAbilityListsObserver> observer = nullptr; 790 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 791 instance.InitializeContext(); 792 instance.SubscribeEnableAbilityListsObserver(observer); 793 instance.UnsubscribeEnableAbilityListsObserver(observer); 794 GTEST_LOG_(INFO) << "UnsubscribeEnableAbilityListsObserver_001 end"; 795 } 796 797 /** 798 * @tc.number: EnableAbility_001 799 * @tc.name: EnableAbility_001 800 * @tc.desc: Test function EnableAbility 801 */ 802 HWTEST_F(AccessibilityConfigImplTest, EnableAbility_001, TestSize.Level1) 803 { 804 GTEST_LOG_(INFO) << "EnableAbility_001 start"; 805 806 std::string name = "test"; 807 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 808 instance.InitializeContext(); 809 EXPECT_EQ(Accessibility::RET_OK, instance.EnableAbility(name, 0)); 810 sleep(1); 811 GTEST_LOG_(INFO) << "EnableAbility_001 end"; 812 } 813 814 /** 815 * @tc.number: DisableAbility_001 816 * @tc.name: DisableAbility_001 817 * @tc.desc: Test function DisableAbility 818 */ 819 HWTEST_F(AccessibilityConfigImplTest, DisableAbility_001, TestSize.Level1) 820 { 821 GTEST_LOG_(INFO) << "DisableAbility_001 start"; 822 823 std::string name = "test"; 824 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 825 instance.InitializeContext(); 826 EXPECT_EQ(Accessibility::RET_OK, instance.DisableAbility(name)); 827 GTEST_LOG_(INFO) << "DisableAbility_001 end"; 828 } 829 } // namespace AccessibilityConfig 830 } // namespace OHOS