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: SetShortkeyMultiTarget_002 206 * @tc.name: SetShortkeyMultiTarget_002 207 * @tc.desc: Test function SetShortkeyMultiTarget GetShortkeyMultiTarget 208 * @tc.require: issueI5NTXH 209 */ 210 HWTEST_F(AccessibilityConfigImplTest, SetShortkeyMultiTarget_002, TestSize.Level1) 211 { 212 GTEST_LOG_(INFO) << "SetShortkeyMultiTarget_002 start"; 213 214 std::vector<std::string> name = {"test"}; 215 std::vector<std::string> value = {}; 216 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 217 instance.SetShortkeyMultiTarget(name); 218 instance.GetShortkeyMultiTarget(value); 219 EXPECT_EQ(value.size(), 0); 220 GTEST_LOG_(INFO) << "SetShortkeyMultiTarget_002 end"; 221 } 222 223 /** 224 * @tc.number: SetDaltonizationState_002 225 * @tc.name: SetDaltonizationState_002 226 * @tc.desc: Test function SetDaltonizationState GetDaltonizationState 227 * @tc.require: issueI5NTX9 228 */ 229 HWTEST_F(AccessibilityConfigImplTest, SetDaltonizationState_002, TestSize.Level1) 230 { 231 GTEST_LOG_(INFO) << "SetDaltonizationState_002 start"; 232 233 bool state = true; 234 bool value = false; 235 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 236 instance.SetDaltonizationState(state); 237 instance.GetDaltonizationState(value); 238 EXPECT_FALSE(value); 239 GTEST_LOG_(INFO) << "SetDaltonizationState_002 end"; 240 } 241 242 /** 243 * @tc.number: SetHighContrastTextState_002 244 * @tc.name: SetHighContrastTextState_002 245 * @tc.desc: Test function SetHighContrastTextState GetHighContrastTextState 246 * @tc.require: issueI5NTX9 247 */ 248 HWTEST_F(AccessibilityConfigImplTest, SetHighContrastTextState_002, TestSize.Level1) 249 { 250 GTEST_LOG_(INFO) << "SetHighContrastTextState_002 start"; 251 252 bool state = true; 253 bool value = false; 254 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 255 instance.SetHighContrastTextState(state); 256 instance.GetHighContrastTextState(value); 257 EXPECT_FALSE(value); 258 GTEST_LOG_(INFO) << "SetHighContrastTextState_002 end"; 259 } 260 261 /** 262 * @tc.number: SetInvertColorState_002 263 * @tc.name: SetInvertColorState_002 264 * @tc.desc: Test function SetInvertColorState GetInvertColorState 265 * @tc.require: issueI5NTX7 266 */ 267 HWTEST_F(AccessibilityConfigImplTest, SetInvertColorState_002, TestSize.Level1) 268 { 269 GTEST_LOG_(INFO) << "SetInvertColorState_002 start"; 270 271 bool state = true; 272 bool value = false; 273 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 274 instance.SetInvertColorState(state); 275 instance.GetInvertColorState(value); 276 EXPECT_FALSE(value); 277 GTEST_LOG_(INFO) << "SetInvertColorState_002 end"; 278 } 279 280 /** 281 * @tc.number: SetDaltonizationColorFilter_002 282 * @tc.name: SetDaltonizationColorFilter_002 283 * @tc.desc: Test function SetDaltonizationColorFilter GetDaltonizationColorFilter 284 * @tc.require: issueI5NTX8 285 */ 286 HWTEST_F(AccessibilityConfigImplTest, SetDaltonizationColorFilter_002, TestSize.Level1) 287 { 288 GTEST_LOG_(INFO) << "SetDaltonizationColorFilter_002 start"; 289 290 DALTONIZATION_TYPE type = Protanomaly; 291 DALTONIZATION_TYPE value = Normal; 292 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 293 instance.SetDaltonizationColorFilter(type); 294 instance.GetDaltonizationColorFilter(value); 295 EXPECT_EQ(0, static_cast<uint32_t>(value)); 296 GTEST_LOG_(INFO) << "SetDaltonizationColorFilter_002 end"; 297 } 298 299 /** 300 * @tc.number: SetContentTimeout_002 301 * @tc.name: SetContentTimeout_002 302 * @tc.desc: Test function SetContentTimeout GetContentTimeout 303 * @tc.require: issueI5NTXF 304 */ 305 HWTEST_F(AccessibilityConfigImplTest, SetContentTimeout_002, TestSize.Level1) 306 { 307 GTEST_LOG_(INFO) << "SetContentTimeout_002 start"; 308 309 uint32_t timer = 10; 310 uint32_t value = 0; 311 std::vector<int> info; 312 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 313 instance.SetContentTimeout(timer); 314 instance.GetContentTimeout(value); 315 EXPECT_EQ(info.size(), 0); 316 GTEST_LOG_(INFO) << "SetContentTimeout_002 end"; 317 } 318 319 /** 320 * @tc.number: SetAnimationOffState_002 321 * @tc.name: SetAnimationOffState_002 322 * @tc.desc: Test function SetAnimationOffState GetAnimationOffState 323 * @tc.require: issueI5NTXG 324 */ 325 HWTEST_F(AccessibilityConfigImplTest, SetAnimationOffState_002, TestSize.Level1) 326 { 327 GTEST_LOG_(INFO) << "SetAnimationOffState_002 start"; 328 329 bool state = true; 330 bool value = false; 331 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 332 instance.SetAnimationOffState(state); 333 instance.GetAnimationOffState(value); 334 EXPECT_FALSE(value); 335 GTEST_LOG_(INFO) << "SetAnimationOffState_002 end"; 336 } 337 338 /** 339 * @tc.number: SetBrightnessDiscount_002 340 * @tc.name: SetBrightnessDiscount_002 341 * @tc.desc: Test function SetBrightnessDiscount GetBrightnessDiscount 342 * @tc.require: issueI5NTXE 343 */ 344 HWTEST_F(AccessibilityConfigImplTest, SetBrightnessDiscount_002, TestSize.Level1) 345 { 346 GTEST_LOG_(INFO) << "SetBrightnessDiscount_002 start"; 347 348 float brightness = BRIGHTNESS_DISCOUNT_VALUE; 349 float value = 0; 350 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 351 instance.SetBrightnessDiscount(brightness); 352 instance.GetBrightnessDiscount(value); 353 EXPECT_FLOAT_EQ(0, value); 354 GTEST_LOG_(INFO) << "SetBrightnessDiscount_002 end"; 355 } 356 357 /** 358 * @tc.number: SetAudioMonoState_002 359 * @tc.name: SetAudioMonoState_002 360 * @tc.desc: Test function SetAudioMonoState GetAudioMonoState 361 */ 362 HWTEST_F(AccessibilityConfigImplTest, SetAudioMonoState_002, TestSize.Level1) 363 { 364 GTEST_LOG_(INFO) << "SetAudioMonoState_002 start"; 365 366 bool state = true; 367 bool value = false; 368 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 369 instance.SetAudioMonoState(state); 370 instance.GetAudioMonoState(value); 371 EXPECT_FALSE(value); 372 GTEST_LOG_(INFO) << "SetAudioMonoState_002 end"; 373 } 374 375 /** 376 * @tc.number: SetAudioBalance_002 377 * @tc.name: SetAudioBalance_002 378 * @tc.desc: Test function SetAudioBalance GetAudioBalance 379 */ 380 HWTEST_F(AccessibilityConfigImplTest, SetAudioBalance_002, TestSize.Level1) 381 { 382 GTEST_LOG_(INFO) << "SetAudioBalance_002 start"; 383 float balance = -1.0; 384 float value = 0; 385 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 386 instance.SetAudioBalance(balance); 387 instance.GetAudioBalance(value); 388 EXPECT_FLOAT_EQ(0, value); 389 GTEST_LOG_(INFO) << "SetAudioBalance_002 end"; 390 } 391 392 /** 393 * @tc.number: SetClickResponseTime_002 394 * @tc.name: SetClickResponseTime_002 395 * @tc.desc: Test function SetClickResponseTime GetClickResponseTime 396 */ 397 HWTEST_F(AccessibilityConfigImplTest, SetClickResponseTime_002, TestSize.Level1) 398 { 399 GTEST_LOG_(INFO) << "SetClickResponseTime_002 start"; 400 CLICK_RESPONSE_TIME time = ResponseDelayMedium; 401 CLICK_RESPONSE_TIME value = ResponseDelayShort; 402 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 403 instance.SetClickResponseTime(time); 404 instance.GetClickResponseTime(value); 405 EXPECT_EQ(0, static_cast<uint32_t>(value)); 406 GTEST_LOG_(INFO) << "SetClickResponseTime_002 end"; 407 } 408 409 /** 410 * @tc.number: SetIgnoreRepeatClickState_002 411 * @tc.name: SetIgnoreRepeatClickState_002 412 * @tc.desc: Test function SetIgnoreRepeatClickState GetIgnoreRepeatClickState 413 */ 414 HWTEST_F(AccessibilityConfigImplTest, SetIgnoreRepeatClickState_002, TestSize.Level1) 415 { 416 GTEST_LOG_(INFO) << "SetIgnoreRepeatClickState_002 start"; 417 bool state = true; 418 bool value = false; 419 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 420 instance.SetIgnoreRepeatClickState(state); 421 instance.GetIgnoreRepeatClickState(value); 422 EXPECT_EQ(false, value); 423 GTEST_LOG_(INFO) << "SetIgnoreRepeatClickState_002 end"; 424 } 425 426 /** 427 * @tc.number: SetIgnoreRepeatClickTime_002 428 * @tc.name: SetIgnoreRepeatClickTime_002 429 * @tc.desc: Test function SetIgnoreRepeatClickTime SetIgnoreRepeatClickTime 430 */ 431 HWTEST_F(AccessibilityConfigImplTest, SetIgnoreRepeatClickTime_002, TestSize.Level1) 432 { 433 GTEST_LOG_(INFO) << "SetIgnoreRepeatClickTime_002 start"; 434 IGNORE_REPEAT_CLICK_TIME time = RepeatClickTimeoutShort; 435 IGNORE_REPEAT_CLICK_TIME value = RepeatClickTimeoutShortest; 436 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 437 instance.SetIgnoreRepeatClickTime(time); 438 instance.GetIgnoreRepeatClickTime(value); 439 EXPECT_EQ(0, static_cast<uint32_t>(value)); 440 GTEST_LOG_(INFO) << "SetIgnoreRepeatClickTime_002 end"; 441 } 442 443 /** 444 * @tc.number: ConnectToService_001 445 * @tc.name: ConnectToService_001 446 * @tc.desc: Test function ConnectToService 447 */ 448 HWTEST_F(AccessibilityConfigImplTest, ConnectToService_001, TestSize.Level1) 449 { 450 GTEST_LOG_(INFO) << "ConnectToService_001 start"; 451 452 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 453 WaitParameter(NULL, NULL, 1); 454 instance.InitializeContext(); 455 WaitParameter(NULL, NULL, 0); 456 GTEST_LOG_(INFO) << "ConnectToService_001 end"; 457 } 458 459 /** 460 * @tc.number: SetCaptionProperty_001 461 * @tc.name: SetCaptionProperty_001 462 * @tc.desc: Test function SetCaptionsProperty GetCaptionsProperty 463 */ 464 HWTEST_F(AccessibilityConfigImplTest, SetCaptionProperty_001, TestSize.Level1) 465 { 466 GTEST_LOG_(INFO) << "SetCaptionProperty_001 start"; 467 468 CaptionProperty caption; 469 caption.SetFontFamily("sansSerif"); 470 CaptionProperty value; 471 472 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 473 instance.InitializeContext(); 474 instance.SetCaptionsProperty(caption); 475 instance.GetCaptionsProperty(value); 476 EXPECT_STREQ(caption.GetFontFamily().c_str(), value.GetFontFamily().c_str()); 477 GTEST_LOG_(INFO) << "SetCaptionProperty_001 end"; 478 } 479 480 /** 481 * @tc.number: SetScreenMagnificationState_001 482 * @tc.name: SetScreenMagnificationState_001 483 * @tc.desc: Test function SetScreenMagnificationState GetScreenMagnificationState 484 */ 485 HWTEST_F(AccessibilityConfigImplTest, SetScreenMagnificationState_001, TestSize.Level1) 486 { 487 GTEST_LOG_(INFO) << "SetScreenMagnificationState_001 start"; 488 489 bool state = true; 490 bool value = false; 491 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 492 instance.InitializeContext(); 493 instance.SetScreenMagnificationState(state); 494 instance.GetScreenMagnificationState(value); 495 EXPECT_TRUE(value); 496 GTEST_LOG_(INFO) << "SetScreenMagnificationState_001 end"; 497 } 498 499 /** 500 * @tc.number: SetShortKeyState_001 501 * @tc.name: SetShortKeyState_001 502 * @tc.desc: Test function SetShortKeyState GetShortKeyState 503 * @tc.require: issueI5NTXH 504 */ 505 HWTEST_F(AccessibilityConfigImplTest, SetShortKeyState_001, TestSize.Level1) 506 { 507 GTEST_LOG_(INFO) << "SetShortKeyState_001 start"; 508 bool state = true; 509 bool value = false; 510 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 511 instance.InitializeContext(); 512 instance.SetShortKeyState(state); 513 instance.GetShortKeyState(value); 514 EXPECT_TRUE(value); 515 GTEST_LOG_(INFO) << "SetShortKeyState_001 end"; 516 } 517 518 /** 519 * @tc.number: SetMouseKeyState_001 520 * @tc.name: SetMouseKeyState_001 521 * @tc.desc: Test function SetMouseKeyState GetMouseKeyState 522 * @tc.require: issueI5NTXA 523 */ 524 HWTEST_F(AccessibilityConfigImplTest, SetMouseKeyState_001, TestSize.Level1) 525 { 526 GTEST_LOG_(INFO) << "SetMouseKeyState_001 start"; 527 bool state = true; 528 bool value = false; 529 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 530 instance.InitializeContext(); 531 instance.SetMouseKeyState(state); 532 instance.GetMouseKeyState(value); 533 EXPECT_TRUE(value); 534 GTEST_LOG_(INFO) << "SetMouseKeyState_001 end"; 535 } 536 537 /** 538 * @tc.number: SetCaptionsState_001 539 * @tc.name: SetCaptionsState_001 540 * @tc.desc: Test function SetCaptionsState GetCaptionsState 541 */ 542 HWTEST_F(AccessibilityConfigImplTest, SetCaptionsState_001, TestSize.Level1) 543 { 544 GTEST_LOG_(INFO) << "SetCaptionsState_001 start"; 545 546 bool state = true; 547 bool value = false; 548 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 549 instance.InitializeContext(); 550 instance.SetCaptionsState(state); 551 instance.GetCaptionsState(value); 552 EXPECT_TRUE(value); 553 GTEST_LOG_(INFO) << "SetCaptionsState_001 end"; 554 } 555 556 /** 557 * @tc.number: SetMouseAutoClick_001 558 * @tc.name: SetMouseAutoClick_001 559 * @tc.desc: Test function SetMouseAutoClick GetMouseAutoClick 560 * @tc.require: issueI5NTXC 561 */ 562 HWTEST_F(AccessibilityConfigImplTest, SetMouseAutoClick_001, TestSize.Level1) 563 { 564 GTEST_LOG_(INFO) << "SetMouseAutoClick_001 start"; 565 566 int32_t time = 10; 567 int32_t value = 0; 568 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 569 instance.InitializeContext(); 570 instance.SetMouseAutoClick(time); 571 instance.GetMouseAutoClick(value); 572 EXPECT_EQ(time, value); 573 GTEST_LOG_(INFO) << "SetMouseAutoClick_001 end"; 574 } 575 576 /** 577 * @tc.number: SetShortkeyTarget_001 578 * @tc.name: SetShortkeyTarget_001 579 * @tc.desc: Test function SetShortkeyTarget GetShortkeyTarget 580 * @tc.require: issueI5NTXH 581 */ 582 HWTEST_F(AccessibilityConfigImplTest, SetShortkeyTarget_001, TestSize.Level1) 583 { 584 GTEST_LOG_(INFO) << "SetShortkeyTarget_001 start"; 585 586 std::string name = "test"; 587 std::string value = ""; 588 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 589 instance.InitializeContext(); 590 instance.SetShortkeyTarget(name); 591 instance.GetShortkeyTarget(value); 592 EXPECT_STREQ(name.c_str(), value.c_str()); 593 GTEST_LOG_(INFO) << "SetShortkeyTarget_001 end"; 594 } 595 596 /** 597 * @tc.number: SetDaltonizationState_001 598 * @tc.name: SetDaltonizationState_001 599 * @tc.desc: Test function SetDaltonizationState GetDaltonizationState 600 * @tc.require: issueI5NTX9 601 */ 602 HWTEST_F(AccessibilityConfigImplTest, SetDaltonizationState_001, TestSize.Level1) 603 { 604 GTEST_LOG_(INFO) << "SetDaltonizationState_001 start"; 605 606 bool state = true; 607 bool value = false; 608 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 609 instance.InitializeContext(); 610 instance.SetDaltonizationState(state); 611 instance.GetDaltonizationState(value); 612 EXPECT_TRUE(value); 613 GTEST_LOG_(INFO) << "SetDaltonizationState_001 end"; 614 } 615 616 /** 617 * @tc.number: SetHighContrastTextState_001 618 * @tc.name: SetHighContrastTextState_001 619 * @tc.desc: Test function SetHighContrastTextState GetHighContrastTextState 620 * @tc.require: issueI5NTX9 621 */ 622 HWTEST_F(AccessibilityConfigImplTest, SetHighContrastTextState_001, TestSize.Level1) 623 { 624 GTEST_LOG_(INFO) << "SetHighContrastTextState_001 start"; 625 626 bool state = true; 627 bool value = false; 628 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 629 instance.InitializeContext(); 630 instance.SetHighContrastTextState(state); 631 instance.GetHighContrastTextState(value); 632 EXPECT_TRUE(value); 633 GTEST_LOG_(INFO) << "SetHighContrastTextState_001 end"; 634 } 635 636 /** 637 * @tc.number: SetInvertColorState_001 638 * @tc.name: SetInvertColorState_001 639 * @tc.desc: Test function SetInvertColorState GetInvertColorState 640 * @tc.require: issueI5NTX7 641 */ 642 HWTEST_F(AccessibilityConfigImplTest, SetInvertColorState_001, TestSize.Level1) 643 { 644 GTEST_LOG_(INFO) << "SetInvertColorState_001 start"; 645 646 bool state = true; 647 bool value = false; 648 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 649 instance.InitializeContext(); 650 instance.SetInvertColorState(state); 651 instance.GetInvertColorState(value); 652 EXPECT_TRUE(value); 653 GTEST_LOG_(INFO) << "SetInvertColorState_001 end"; 654 } 655 656 /** 657 * @tc.number: SetDaltonizationColorFilter_001 658 * @tc.name: SetDaltonizationColorFilter_001 659 * @tc.desc: Test function SetDaltonizationColorFilter GetDaltonizationColorFilter 660 * @tc.require: issueI5NTX8 661 */ 662 HWTEST_F(AccessibilityConfigImplTest, SetDaltonizationColorFilter_001, TestSize.Level1) 663 { 664 GTEST_LOG_(INFO) << "SetDaltonizationColorFilter_001 start"; 665 666 DALTONIZATION_TYPE type = Protanomaly; 667 DALTONIZATION_TYPE value = Normal; 668 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 669 instance.InitializeContext(); 670 instance.SetDaltonizationColorFilter(type); 671 instance.GetDaltonizationColorFilter(value); 672 EXPECT_EQ(static_cast<uint32_t>(type), static_cast<uint32_t>(value)); 673 GTEST_LOG_(INFO) << "SetDaltonizationColorFilter_001 end"; 674 } 675 676 /** 677 * @tc.number: SetContentTimeout_001 678 * @tc.name: SetContentTimeout_001 679 * @tc.desc: Test function SetContentTimeout GetContentTimeout 680 * @tc.require: issueI5NTXF 681 */ 682 HWTEST_F(AccessibilityConfigImplTest, SetContentTimeout_001, TestSize.Level1) 683 { 684 GTEST_LOG_(INFO) << "SetContentTimeout_001 start"; 685 686 uint32_t timer = 10; 687 uint32_t value = 0; 688 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 689 instance.InitializeContext(); 690 instance.SetContentTimeout(timer); 691 instance.GetContentTimeout(value); 692 EXPECT_EQ(timer, value); 693 GTEST_LOG_(INFO) << "SetContentTimeout_001 end"; 694 } 695 696 /** 697 * @tc.number: SetAnimationOffState_001 698 * @tc.name: SetAnimationOffState_001 699 * @tc.desc: Test function SetAnimationOffState GetAnimationOffState 700 * @tc.require: issueI5NTXG 701 */ 702 HWTEST_F(AccessibilityConfigImplTest, SetAnimationOffState_001, TestSize.Level1) 703 { 704 GTEST_LOG_(INFO) << "SetAnimationOffState_001 start"; 705 706 bool state = true; 707 bool value = false; 708 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 709 instance.InitializeContext(); 710 instance.SetAnimationOffState(state); 711 instance.GetAnimationOffState(value); 712 EXPECT_TRUE(value); 713 GTEST_LOG_(INFO) << "SetAnimationOffState_001 end"; 714 } 715 716 /** 717 * @tc.number: SetBrightnessDiscount_001 718 * @tc.name: SetBrightnessDiscount_001 719 * @tc.desc: Test function SetBrightnessDiscount GetBrightnessDiscount 720 * @tc.require: issueI5NTXE 721 */ 722 HWTEST_F(AccessibilityConfigImplTest, SetBrightnessDiscount_001, TestSize.Level1) 723 { 724 GTEST_LOG_(INFO) << "SetBrightnessDiscount_001 start"; 725 726 float brightness = 0; 727 float value = BRIGHTNESS_DISCOUNT_VALUE; 728 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 729 instance.InitializeContext(); 730 instance.SetBrightnessDiscount(brightness); 731 instance.GetBrightnessDiscount(value); 732 EXPECT_FLOAT_EQ(brightness, value); 733 GTEST_LOG_(INFO) << "SetBrightnessDiscount_001 end"; 734 } 735 736 /** 737 * @tc.number: SetAudioMonoState_001 738 * @tc.name: SetAudioMonoState_001 739 * @tc.desc: Test function SetAudioMonoState GetAudioMonoState 740 */ 741 HWTEST_F(AccessibilityConfigImplTest, SetAudioMonoState_001, TestSize.Level1) 742 { 743 GTEST_LOG_(INFO) << "SetAudioMonoState_001 start"; 744 745 bool state = true; 746 bool value = false; 747 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 748 instance.InitializeContext(); 749 instance.SetAudioMonoState(state); 750 instance.GetAudioMonoState(value); 751 EXPECT_TRUE(value); 752 GTEST_LOG_(INFO) << "SetAudioMonoState_001 end"; 753 } 754 755 /** 756 * @tc.number: SetAudioBalance_001 757 * @tc.name: SetAudioBalance_001 758 * @tc.desc: Test function SetAudioBalance GetAudioBalance 759 */ 760 HWTEST_F(AccessibilityConfigImplTest, SetAudioBalance_001, TestSize.Level1) 761 { 762 GTEST_LOG_(INFO) << "SetAudioBalance_001 start"; 763 float balance = 0; 764 float value = 0; 765 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 766 instance.InitializeContext(); 767 instance.SetAudioBalance(balance); 768 instance.GetAudioBalance(value); 769 EXPECT_FLOAT_EQ(balance, value); 770 sleep(1); 771 GTEST_LOG_(INFO) << "SetAudioBalance_001 end"; 772 } 773 774 /** 775 * @tc.number: SetClickResponseTime_001 776 * @tc.name: SetClickResponseTime_001 777 * @tc.desc: Test function SetClickResponseTime GetClickResponseTime 778 */ 779 HWTEST_F(AccessibilityConfigImplTest, SetClickResponseTime_001, TestSize.Level1) 780 { 781 GTEST_LOG_(INFO) << "SetClickResponseTime_001 start"; 782 CLICK_RESPONSE_TIME time = ResponseDelayMedium; 783 CLICK_RESPONSE_TIME value = ResponseDelayShort; 784 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 785 instance.InitializeContext(); 786 instance.SetClickResponseTime(time); 787 instance.GetClickResponseTime(value); 788 EXPECT_EQ(1, static_cast<uint32_t>(value)); 789 GTEST_LOG_(INFO) << "SetClickResponseTime_001 end"; 790 } 791 792 /** 793 * @tc.number: SetIgnoreRepeatClickState_001 794 * @tc.name: SetIgnoreRepeatClickState_001 795 * @tc.desc: Test function SetIgnoreRepeatClickState GetIgnoreRepeatClickState 796 */ 797 HWTEST_F(AccessibilityConfigImplTest, SetIgnoreRepeatClickState_001, TestSize.Level1) 798 { 799 GTEST_LOG_(INFO) << "SetIgnoreRepeatClickState_001 start"; 800 bool state = true; 801 bool value = false; 802 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 803 instance.InitializeContext(); 804 instance.SetIgnoreRepeatClickState(state); 805 instance.GetIgnoreRepeatClickState(value); 806 EXPECT_EQ(true, value); 807 GTEST_LOG_(INFO) << "SetIgnoreRepeatClickState_001 end"; 808 } 809 810 /** 811 * @tc.number: SetIgnoreRepeatClickTime_001 812 * @tc.name: SetIgnoreRepeatClickTime_001 813 * @tc.desc: Test function SetIgnoreRepeatClickTime SetIgnoreRepeatClickTime 814 */ 815 HWTEST_F(AccessibilityConfigImplTest, SetIgnoreRepeatClickTime_001, TestSize.Level1) 816 { 817 GTEST_LOG_(INFO) << "SetIgnoreRepeatClickTime_001 start"; 818 IGNORE_REPEAT_CLICK_TIME time = RepeatClickTimeoutShort; 819 IGNORE_REPEAT_CLICK_TIME value = RepeatClickTimeoutShortest; 820 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 821 instance.InitializeContext(); 822 instance.SetIgnoreRepeatClickTime(time); 823 instance.GetIgnoreRepeatClickTime(value); 824 EXPECT_EQ(1, static_cast<uint32_t>(value)); 825 GTEST_LOG_(INFO) << "SetIgnoreRepeatClickTime_001 end"; 826 } 827 828 /** 829 * @tc.number: ConfigNotify_001 830 * @tc.name: ConfigNotify_001 831 * @tc.desc: Test function OnConfigStateChanged 832 */ 833 HWTEST_F(AccessibilityConfigImplTest, ConfigNotify_001, TestSize.Level1) 834 { 835 GTEST_LOG_(INFO) << "ConfigNotify_001 start"; 836 float balance = -1.0; 837 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 838 std::shared_ptr<MockAccessibilityConfigObserverImpl> observer = 839 std::make_shared<MockAccessibilityConfigObserverImpl>(); 840 instance.InitializeContext(); 841 for (int32_t index = 0; index < static_cast<int32_t>(CONFIG_ID_MAX); index ++) { 842 instance.SubscribeConfigObserver(static_cast<CONFIG_ID>(index), observer, false); 843 } 844 instance.SetAudioBalance(balance); 845 sleep(1); 846 instance.SetAudioBalance(balance); 847 sleep(1); 848 for (int32_t index = 0; index < static_cast<int32_t>(CONFIG_ID_MAX); index ++) { 849 instance.UnsubscribeConfigObserver(static_cast<CONFIG_ID>(index), observer); 850 } 851 GTEST_LOG_(INFO) << "ConfigNotify_001 end"; 852 } 853 854 /** 855 * @tc.number: ConfigNotify_002 856 * @tc.name: ConfigNotify_002 857 * @tc.desc: Test function OnConfigStateChanged 858 */ 859 HWTEST_F(AccessibilityConfigImplTest, ConfigNotify_002, TestSize.Level1) 860 { 861 GTEST_LOG_(INFO) << "ConfigNotify_002 start"; 862 float balance = 0; 863 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 864 std::shared_ptr<MockAccessibilityConfigObserverImpl> observer = 865 std::make_shared<MockAccessibilityConfigObserverImpl>(); 866 instance.InitializeContext(); 867 for (int32_t index = 0; index < static_cast<int32_t>(CONFIG_ID_MAX); index ++) { 868 instance.SubscribeConfigObserver(static_cast<CONFIG_ID>(index), observer); 869 } 870 instance.SetAudioBalance(balance); 871 sleep(1); 872 GTEST_LOG_(INFO) << "ConfigNotify_002 end"; 873 } 874 875 /** 876 * @tc.number: ConfigNotify_003 877 * @tc.name: ConfigNotify_003 878 * @tc.desc: Test function OnConfigStateChanged 879 */ 880 HWTEST_F(AccessibilityConfigImplTest, ConfigNotify_003, TestSize.Level1) 881 { 882 GTEST_LOG_(INFO) << "ConfigNotify_003 start"; 883 float balance = -1.0; 884 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 885 instance.InitializeContext(); 886 for (int32_t index = 0; index < static_cast<int32_t>(CONFIG_ID_MAX); index ++) { 887 instance.SubscribeConfigObserver(static_cast<CONFIG_ID>(index), nullptr); 888 } 889 instance.SetAudioBalance(balance); 890 sleep(1); 891 GTEST_LOG_(INFO) << "ConfigNotify_003 end"; 892 } 893 894 /** 895 * @tc.number: SubscribeConfigObserver_001 896 * @tc.name: SubscribeConfigObserver_001 897 * @tc.desc: Test function SubscribeConfigObserver 898 */ 899 HWTEST_F(AccessibilityConfigImplTest, SubscribeConfigObserver_001, TestSize.Level1) 900 { 901 GTEST_LOG_(INFO) << "SubscribeConfigObserver_001 start"; 902 903 std::shared_ptr<AccessibilityConfigObserver> observer = nullptr; 904 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 905 instance.InitializeContext(); 906 instance.SubscribeConfigObserver(CONFIG_HIGH_CONTRAST_TEXT, observer); 907 GTEST_LOG_(INFO) << "SubscribeConfigObserver_001 end"; 908 } 909 910 /** 911 * @tc.number: UnsubscribeConfigObserver_001 912 * @tc.name: UnsubscribeConfigObserver_001 913 * @tc.desc: Test function UnsubscribeConfigObserver 914 */ 915 HWTEST_F(AccessibilityConfigImplTest, UnsubscribeConfigObserver_001, TestSize.Level1) 916 { 917 GTEST_LOG_(INFO) << "UnsubscribeConfigObserver_001 start"; 918 919 std::shared_ptr<AccessibilityConfigObserver> observer = nullptr; 920 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 921 instance.InitializeContext(); 922 instance.UnsubscribeConfigObserver(CONFIG_HIGH_CONTRAST_TEXT, observer); 923 GTEST_LOG_(INFO) << "UnsubscribeConfigObserver_001 end"; 924 } 925 926 /** 927 * @tc.number: SubscribeEnableAbilityListsObserver_001 928 * @tc.name: SubscribeEnableAbilityListsObserver_001 929 * @tc.desc: Test function SubscribeEnableAbilityListsObserver 930 */ 931 HWTEST_F(AccessibilityConfigImplTest, SubscribeEnableAbilityListsObserver_001, TestSize.Level1) 932 { 933 GTEST_LOG_(INFO) << "SubscribeEnableAbilityListsObserver_001 start"; 934 935 std::shared_ptr<AccessibilityEnableAbilityListsObserver> observer = 936 std::make_shared<MockAccessibilityEnableAbilityListsObserverImpl>(); 937 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 938 instance.InitializeContext(); 939 instance.SubscribeEnableAbilityListsObserver(observer); 940 GTEST_LOG_(INFO) << "SubscribeEnableAbilityListsObserver_001 end"; 941 } 942 943 /** 944 * @tc.number: UnsubscribeEnableAbilityListsObserver_001 945 * @tc.name: UnsubscribeEnableAbilityListsObserver_001 946 * @tc.desc: Test function UnsubscribeEnableAbilityListsObserver 947 */ 948 HWTEST_F(AccessibilityConfigImplTest, UnsubscribeEnableAbilityListsObserver_001, TestSize.Level1) 949 { 950 GTEST_LOG_(INFO) << "UnsubscribeEnableAbilityListsObserver_001 start"; 951 952 std::shared_ptr<AccessibilityEnableAbilityListsObserver> observer = nullptr; 953 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 954 instance.InitializeContext(); 955 instance.SubscribeEnableAbilityListsObserver(observer); 956 instance.UnsubscribeEnableAbilityListsObserver(observer); 957 GTEST_LOG_(INFO) << "UnsubscribeEnableAbilityListsObserver_001 end"; 958 } 959 960 /** 961 * @tc.number: EnableAbility_001 962 * @tc.name: EnableAbility_001 963 * @tc.desc: Test function EnableAbility 964 */ 965 HWTEST_F(AccessibilityConfigImplTest, EnableAbility_001, TestSize.Level1) 966 { 967 GTEST_LOG_(INFO) << "EnableAbility_001 start"; 968 969 std::string name = "test"; 970 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 971 instance.InitializeContext(); 972 EXPECT_EQ(Accessibility::RET_OK, instance.EnableAbility(name, 0)); 973 sleep(1); 974 GTEST_LOG_(INFO) << "EnableAbility_001 end"; 975 } 976 977 /** 978 * @tc.number: DisableAbility_001 979 * @tc.name: DisableAbility_001 980 * @tc.desc: Test function DisableAbility 981 */ 982 HWTEST_F(AccessibilityConfigImplTest, DisableAbility_001, TestSize.Level1) 983 { 984 GTEST_LOG_(INFO) << "DisableAbility_001 start"; 985 986 std::string name = "test"; 987 auto &instance = OHOS::AccessibilityConfig::AccessibilityConfig::GetInstance(); 988 instance.InitializeContext(); 989 EXPECT_EQ(Accessibility::RET_OK, instance.DisableAbility(name)); 990 GTEST_LOG_(INFO) << "DisableAbility_001 end"; 991 } 992 } // namespace AccessibilityConfig 993 } // namespace OHOS