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