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_settings_config.h"
18 #include "mock_preferences.h"
19 #include "system_ability_definition.h"
20 #include "accesstoken_kit.h"
21 #include "nativetoken_kit.h"
22 #include "token_setproc.h"
23
24 using namespace testing;
25 using namespace testing::ext;
26
27 namespace OHOS {
28 namespace Accessibility {
29 namespace {
30 constexpr uint32_t CONTENT_TIMEOUT_VALUE = 10;
31 constexpr int32_t MOUSE_AUTO_CLICK_VALUE = 2;
32 constexpr int32_t MOUSE_AUTO_CLICK_DEFAULT_VALUE = -1;
33 constexpr int32_t SHORT_KEY_TIMEOUT = 3000;
34 constexpr float BRIGHTNESS_DISCOUNT_VALUE = 0.3f;
35 constexpr float AUDIO_BALANCE_VALUE = 0.2f;
36 const std::string CONFIG_ACCESSIBILITY = "accessible";
37 const std::string CONFIG_TOUCHGUIDE = "touchGuide";
38 const std::string CONFIG_GESTURE = "gesture";
39 const std::string CONFIG_CAPTION = "CaptionState";
40 const std::string CONFIG_KEYEVENT = "keyEventObserver";
41 const std::string CONFIG_SCREENMAGNIFIER = "ScreenMagnification";
42 const std::string CONFIG_SHORTKEY = "ShortKey";
43 const std::string CONFIG_MOUSEKEY = "MouseKey";
44 const std::string CONFIG_HIGHCONTRASTTEXT = "highContrastText";
45 const std::string CONFIG_DALTONIZATIONSTATE = "daltonizationState";
46 const std::string CONFIG_INVERTCOLOR = "invertColor";
47 const std::string CONFIG_ANIMATIONOFF = "animationOff";
48 const std::string CONFIG_AUDIOMONO = "audioMono";
49 const std::string CONFIG_IGNOREREPEATCLICKSTATE = "ignoreRepeatClickState";
50 const std::string CONFIG_SHORTCUT_ON_LOCK_SCREEN = "shortcutOnLockScreen";
51 const std::string CONFIG_SHORTCUT_TIMEOUT = "shortcutTimeout";
52 const std::string ENABLE_ABILITY_NAME = "HIGH_CONTRAST_TEXT";
53 } // namespace
54
55 class AccessibilitySettingsConfigTest : public testing::Test {
56 public:
AccessibilitySettingsConfigTest()57 AccessibilitySettingsConfigTest()
58 {}
~AccessibilitySettingsConfigTest()59 ~AccessibilitySettingsConfigTest()
60 {}
61
62 std::shared_ptr<AccessibilitySettingsConfig> settingConfig_ = nullptr;
63 std::shared_ptr<AccessibilityDatashareHelper> datashare_ = nullptr;
64
65 static void SetUpTestCase();
66 static void TearDownTestCase();
67 void SetUp() override;
68 void TearDown() override;
69 };
70
AddPermission()71 void AddPermission()
72 {
73 const char *perms[] = {
74 OHOS_PERMISSION_READ_ACCESSIBILITY_CONFIG.c_str(),
75 OHOS_PERMISSION_WRITE_ACCESSIBILITY_CONFIG.c_str(),
76 OHOS_PERMISSION_MANAGE_SECURE_SETTINGS.c_str(),
77 OHOS_PERMISSION_MANAGE_SETTINGS.c_str()
78 };
79 NativeTokenInfoParams infoInstance = {
80 .dcapsNum = 0,
81 .permsNum = 4,
82 .aclsNum = 0,
83 .dcaps = nullptr,
84 .perms = perms,
85 .acls = nullptr,
86 .processName = "com.accessibility.accessibilitySettingsConfigTest",
87 .aplStr = "normal",
88 };
89 uint64_t tokenId = GetAccessTokenId(&infoInstance);
90 auto ret = SetSelfTokenID(tokenId);
91 GTEST_LOG_(INFO) << "AccessibilitySettingsConfigTest AddPermission SetSelfTokenID ret: " << ret;
92 Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo();
93 }
94
SetUpTestCase()95 void AccessibilitySettingsConfigTest::SetUpTestCase()
96 {
97 GTEST_LOG_(INFO) << "AccessibilitySettingsConfigTest SetUpTestCase";
98 AddPermission();
99 }
100
TearDownTestCase()101 void AccessibilitySettingsConfigTest::TearDownTestCase()
102 {
103 GTEST_LOG_(INFO) << "AccessibilitySettingsConfigTest TearDownTestCase";
104 }
105
SetUp()106 void AccessibilitySettingsConfigTest::SetUp()
107 {
108 int32_t accountId = 100;
109 settingConfig_ = std::make_shared<AccessibilitySettingsConfig>(accountId);
110 GTEST_LOG_(INFO) << "AccessibilitySettingsConfigTest SetUp";
111 }
112
TearDown()113 void AccessibilitySettingsConfigTest::TearDown()
114 {
115 settingConfig_ = nullptr;
116 GTEST_LOG_(INFO) << "AccessibilitySettingsConfigTest TearDown";
117 }
118
119 /**
120 * @tc.number: AccessibilitySettingsConfig_Unittest_Init
121 * @tc.name: AccessibilitySettingsConfig_Unittest_Init
122 * @tc.desc: Test function Init
123 */
124 HWTEST_F(AccessibilitySettingsConfigTest, AccessibilitySettingsConfig_Unittest_Init, TestSize.Level1)
125 {
126 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_Init start";
127 settingConfig_->Init();
128 EXPECT_TRUE(settingConfig_->GetInitializeState());
129 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_Init end";
130 }
131
132 /**
133 * @tc.number: AccessibilitySettingsConfig_Unittest_SetEnabled_001
134 * @tc.name: SetEnabled
135 * @tc.desc: Test function SetEnabled GetEnabledState
136 */
137 HWTEST_F(AccessibilitySettingsConfigTest, AccessibilitySettingsConfig_Unittest_SetEnabled_001, TestSize.Level1)
138 {
139 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetEnabled_001 start";
140 bool state = true;
141 settingConfig_->Init();
142 settingConfig_->SetEnabled(state);
143 EXPECT_TRUE(settingConfig_->GetEnabledState());
144 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetEnabled_001 end";
145 }
146
147 /**
148 * @tc.number: AccessibilitySettingsConfig_Unittest_SetEnabled_002
149 * @tc.name: SetEnabled
150 * @tc.desc: Test function SetEnabled GetEnabledState
151 */
152 HWTEST_F(AccessibilitySettingsConfigTest, AccessibilitySettingsConfig_Unittest_SetEnabled_002, TestSize.Level1)
153 {
154 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetEnabled_002 start";
155 bool state = true;
156 settingConfig_->SetEnabled(state);
157 EXPECT_FALSE(settingConfig_->GetEnabledState());
158 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetEnabled_002 end";
159 }
160
161 /**
162 * @tc.number: AccessibilitySettingsConfig_Unittest_SetTouchGuideState_001
163 * @tc.name: SetTouchGuideState
164 * @tc.desc: Test function SetTouchGuideState GetTouchGuideState
165 */
166 HWTEST_F(AccessibilitySettingsConfigTest, AccessibilitySettingsConfig_Unittest_SetTouchGuideState_001, TestSize.Level1)
167 {
168 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetTouchGuideState_001 start";
169 bool state = true;
170 settingConfig_->Init();
171 settingConfig_->SetTouchGuideState(state);
172 EXPECT_TRUE(settingConfig_->GetTouchGuideState());
173 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetTouchGuideState_001 end";
174 }
175
176 /**
177 * @tc.number: AccessibilitySettingsConfig_Unittest_SetTouchGuideState_002
178 * @tc.name: SetTouchGuideState
179 * @tc.desc: Test function SetTouchGuideState GetTouchGuideState
180 */
181 HWTEST_F(AccessibilitySettingsConfigTest, AccessibilitySettingsConfig_Unittest_SetTouchGuideState_002, TestSize.Level1)
182 {
183 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetTouchGuideState_002 start";
184 bool state = true;
185 settingConfig_->SetTouchGuideState(state);
186 EXPECT_FALSE(settingConfig_->GetTouchGuideState());
187 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetTouchGuideState_002 end";
188 }
189
190 /**
191 * @tc.number: AccessibilitySettingsConfig_Unittest_SetGestureState_001
192 * @tc.name: SetGestureState
193 * @tc.desc: Test function SetGestureState GetGestureState
194 */
195 HWTEST_F(AccessibilitySettingsConfigTest, AccessibilitySettingsConfig_Unittest_SetGestureState_001, TestSize.Level1)
196 {
197 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetGestureState_001 start";
198 bool state = true;
199 settingConfig_->Init();
200 settingConfig_->SetGestureState(state);
201 EXPECT_TRUE(settingConfig_->GetGestureState());
202 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetGestureState_001 end";
203 }
204
205 /**
206 * @tc.number: AccessibilitySettingsConfig_Unittest_SetGestureState_002
207 * @tc.name: SetGestureState
208 * @tc.desc: Test function SetGestureState GetGestureState
209 */
210 HWTEST_F(AccessibilitySettingsConfigTest, AccessibilitySettingsConfig_Unittest_SetGestureState_002, TestSize.Level1)
211 {
212 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetGestureState_002 start";
213 bool state = true;
214 settingConfig_->SetGestureState(state);
215 EXPECT_FALSE(settingConfig_->GetGestureState());
216 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetGestureState_002 end";
217 }
218
219 /**
220 * @tc.number: AccessibilitySettingsConfig_Unittest_SetKeyEventObserverState_001
221 * @tc.name: SetKeyEventObserverState
222 * @tc.desc: Test function SetKeyEventObserverState GetKeyEventObserverState
223 */
224 HWTEST_F(AccessibilitySettingsConfigTest, AccessibilitySettingsConfig_Unittest_SetKeyEventObserverState_001,
225 TestSize.Level1)
226 {
227 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetKeyEventObserverState_001 start";
228 bool state = true;
229 settingConfig_->Init();
230 settingConfig_->SetKeyEventObserverState(state);
231 EXPECT_TRUE(settingConfig_->GetKeyEventObserverState());
232 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetKeyEventObserverState_001 end";
233 }
234
235 /**
236 * @tc.number: AccessibilitySettingsConfig_Unittest_SetKeyEventObserverState_002
237 * @tc.name: SetKeyEventObserverState
238 * @tc.desc: Test function SetKeyEventObserverState GetKeyEventObserverState
239 */
240 HWTEST_F(AccessibilitySettingsConfigTest, AccessibilitySettingsConfig_Unittest_SetKeyEventObserverState_002,
241 TestSize.Level1)
242 {
243 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetKeyEventObserverState_002 start";
244 bool state = true;
245 settingConfig_->SetKeyEventObserverState(state);
246 EXPECT_FALSE(settingConfig_->GetKeyEventObserverState());
247 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetKeyEventObserverState_002 end";
248 }
249
250 /**
251 * @tc.number: AccessibilitySettingsConfig_Unittest_SetCaptionProperty_001
252 * @tc.name: SetCaptionProperty
253 * @tc.desc: Test function SetCaptionProperty GetCaptionProperty
254 */
255 HWTEST_F(AccessibilitySettingsConfigTest, AccessibilitySettingsConfig_Unittest_SetCaptionProperty_001, TestSize.Level1)
256 {
257 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetCaptionProperty_001 start";
258 AccessibilityConfig::CaptionProperty caption;
259 settingConfig_->Init();
260 settingConfig_->SetCaptionProperty(caption);
261 settingConfig_->GetCaptionProperty();
262 EXPECT_NE(settingConfig_.get(), nullptr);
263 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetCaptionProperty_001 end";
264 }
265
266 /**
267 * @tc.number: AccessibilitySettingsConfig_Unittest_SetCaptionProperty_002
268 * @tc.name: SetCaptionProperty
269 * @tc.desc: Test function SetCaptionProperty GetCaptionProperty
270 */
271 HWTEST_F(AccessibilitySettingsConfigTest, AccessibilitySettingsConfig_Unittest_SetCaptionProperty_002, TestSize.Level1)
272 {
273 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetCaptionProperty_002 start";
274 AccessibilityConfig::CaptionProperty caption;
275 settingConfig_->SetCaptionProperty(caption);
276 settingConfig_->GetCaptionProperty();
277 EXPECT_NE(settingConfig_.get(), nullptr);
278 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetCaptionProperty_002 end";
279 }
280
281 /**
282 * @tc.number: AccessibilitySettingsConfig_Unittest_SetCaptionState_001
283 * @tc.name: SetCaptionState
284 * @tc.desc: Test function SetCaptionState GetCaptionState
285 */
286 HWTEST_F(AccessibilitySettingsConfigTest, AccessibilitySettingsConfig_Unittest_SetCaptionState_001, TestSize.Level1)
287 {
288 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetCaptionState_001 start";
289 bool state = true;
290 settingConfig_->Init();
291 settingConfig_->SetCaptionState(state);
292 EXPECT_TRUE(settingConfig_->GetCaptionState());
293 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetCaptionState_001 end";
294 }
295
296 /**
297 * @tc.number: AccessibilitySettingsConfig_Unittest_SetCaptionState_002
298 * @tc.name: SetCaptionState
299 * @tc.desc: Test function SetCaptionState GetCaptionState
300 */
301 HWTEST_F(AccessibilitySettingsConfigTest, AccessibilitySettingsConfig_Unittest_SetCaptionState_002, TestSize.Level1)
302 {
303 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetCaptionState_002 start";
304 bool state = true;
305 settingConfig_->SetCaptionState(state);
306 EXPECT_FALSE(settingConfig_->GetCaptionState());
307 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetCaptionState_002 end";
308 }
309
310 /**
311 * @tc.number: AccessibilitySettingsConfig_Unittest_SetScreenMagnificationState_001
312 * @tc.name: SetScreenMagnificationState
313 * @tc.desc: Test function SetScreenMagnificationState GetScreenMagnificationState
314 */
315 HWTEST_F(AccessibilitySettingsConfigTest, AccessibilitySettingsConfig_Unittest_SetScreenMagnificationState_001,
316 TestSize.Level1)
317 {
318 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetScreenMagnificationState_001 start";
319 bool state = true;
320 settingConfig_->Init();
321 settingConfig_->SetScreenMagnificationState(state);
322 EXPECT_TRUE(settingConfig_->GetScreenMagnificationState());
323 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetScreenMagnificationState_001 end";
324 }
325
326 /**
327 * @tc.number: AccessibilitySettingsConfig_Unittest_SetScreenMagnificationState_002
328 * @tc.name: SetScreenMagnificationState
329 * @tc.desc: Test function SetScreenMagnificationState GetScreenMagnificationState
330 */
331 HWTEST_F(AccessibilitySettingsConfigTest, AccessibilitySettingsConfig_Unittest_SetScreenMagnificationState_002,
332 TestSize.Level1)
333 {
334 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetScreenMagnificationState_002 start";
335 bool state = true;
336 settingConfig_->Init();
337 settingConfig_->SetScreenMagnificationState(state);
338 EXPECT_TRUE(settingConfig_->GetScreenMagnificationState());
339 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetScreenMagnificationState_002 end";
340 }
341
342 /**
343 * @tc.number: AccessibilitySettingsConfig_Unittest_SetShortKeyState_001
344 * @tc.name: SetShortKeyState
345 * @tc.desc: Test function SetShortKeyState GetShortKeyState
346 * @tc.require: issueI5NTXH
347 */
348 HWTEST_F(AccessibilitySettingsConfigTest, AccessibilitySettingsConfig_Unittest_SetShortKeyState_001, TestSize.Level1)
349 {
350 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetShortKeyState_001 start";
351 bool state = true;
352 settingConfig_->Init();
353 settingConfig_->SetShortKeyState(state);
354 EXPECT_TRUE(settingConfig_->GetShortKeyState());
355 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetShortKeyState_001 end";
356 }
357
358 /**
359 * @tc.number: AccessibilitySettingsConfig_Unittest_SetShortKeyState_002
360 * @tc.name: SetShortKeyState
361 * @tc.desc: Test function SetShortKeyState GetShortKeyState
362 * @tc.require: issueI5NTXH
363 */
364 HWTEST_F(AccessibilitySettingsConfigTest, AccessibilitySettingsConfig_Unittest_SetShortKeyState_002, TestSize.Level1)
365 {
366 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetShortKeyState_002 start";
367 bool state = true;
368 settingConfig_->SetShortKeyState(state);
369 EXPECT_FALSE(settingConfig_->GetShortKeyState());
370 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetShortKeyState_002 end";
371 }
372
373 /**
374 * @tc.number: AccessibilitySettingsConfig_Unittest_SetShortKeyOnLockScreenState_001
375 * @tc.name: SetShortKeyOnLockScreenState
376 * @tc.desc: Test function SetShortKeyOnLockScreenState GetShortKeyOnLockScreenState
377 * @tc.require: issueI5NTXH
378 */
379 HWTEST_F(AccessibilitySettingsConfigTest, AccessibilitySettingsConfig_Unittest_SetShortKeyOnLockScreenState_001,
380 TestSize.Level1)
381 {
382 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetShortKeyOnLockScreenState_001 start";
383 bool state = true;
384 settingConfig_->Init();
385 settingConfig_->SetShortKeyOnLockScreenState(state);
386 EXPECT_TRUE(settingConfig_->GetShortKeyOnLockScreenState());
387 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetShortKeyOnLockScreenState_001 end";
388 }
389
390 /**
391 * @tc.number: AccessibilitySettingsConfig_Unittest_SetShortKeyOnLockScreenState_002
392 * @tc.name: SetShortKeyOnLockScreenState
393 * @tc.desc: Test function SetShortKeyOnLockScreenState GetShortKeyOnLockScreenState
394 * @tc.require: issueI5NTXH
395 */
396 HWTEST_F(AccessibilitySettingsConfigTest, AccessibilitySettingsConfig_Unittest_SetShortKeyOnLockScreenState_002,
397 TestSize.Level1)
398 {
399 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetShortKeyOnLockScreenState_002 start";
400 bool state = true;
401 settingConfig_->SetShortKeyOnLockScreenState(state);
402 EXPECT_FALSE(settingConfig_->GetShortKeyOnLockScreenState());
403 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetShortKeyOnLockScreenState_002 end";
404 }
405
406 /**
407 * @tc.number: AccessibilitySettingsConfig_Unittest_SetShortKeyTimeout_001
408 * @tc.name: SetShortKeyTimeout
409 * @tc.desc: Test function SetShortKeyTimeout GetShortKeyTimeout
410 * @tc.require: issueI5NTXH
411 */
412 HWTEST_F(AccessibilitySettingsConfigTest, AccessibilitySettingsConfig_Unittest_SetShortKeyTimeout_001,
413 TestSize.Level1)
414 {
415 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetShortKeyTimeout_001 start";
416 settingConfig_->Init();
417 settingConfig_->SetShortKeyTimeout(SHORT_KEY_TIMEOUT);
418 EXPECT_TRUE(settingConfig_->GetShortKeyTimeout() == SHORT_KEY_TIMEOUT);
419 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetShortKeyTimeout_001 end";
420 }
421
422 /**
423 * @tc.number: AccessibilitySettingsConfig_Unittest_SetShortKeyTimeout_002
424 * @tc.name: SetShortKeyTimeout
425 * @tc.desc: Test function SetShortKeyTimeout GetShortKeyTimeout
426 * @tc.require: issueI5NTXH
427 */
428 HWTEST_F(AccessibilitySettingsConfigTest, AccessibilitySettingsConfig_Unittest_SetShortKeyTimeout_002,
429 TestSize.Level1)
430 {
431 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetShortKeyTimeout_002 start";
432 settingConfig_->SetShortKeyTimeout(SHORT_KEY_TIMEOUT);
433 EXPECT_FALSE(settingConfig_->GetShortKeyTimeout() == SHORT_KEY_TIMEOUT);
434 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetShortKeyTimeout_002 end";
435 }
436
437 /**
438 * @tc.number: AccessibilitySettingsConfig_Unittest_SetMouseKeyState_001
439 * @tc.name: SetMouseKeyState
440 * @tc.desc: Test function SetMouseKeyState GetMouseKeyState
441 * @tc.require: issueI5NTXA
442 */
443 HWTEST_F(AccessibilitySettingsConfigTest, AccessibilitySettingsConfig_Unittest_SetMouseKeyState_001, TestSize.Level1)
444 {
445 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetMouseKeyState_001 start";
446 bool state = true;
447 settingConfig_->Init();
448 settingConfig_->SetMouseKeyState(state);
449 EXPECT_TRUE(settingConfig_->GetMouseKeyState());
450 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetMouseKeyState_001 end";
451 }
452
453 /**
454 * @tc.number: AccessibilitySettingsConfig_Unittest_SetMouseKeyState_002
455 * @tc.name: SetMouseKeyState
456 * @tc.desc: Test function SetMouseKeyState GetMouseKeyState
457 * @tc.require: issueI5NTXA
458 */
459 HWTEST_F(AccessibilitySettingsConfigTest, AccessibilitySettingsConfig_Unittest_SetMouseKeyState_002, TestSize.Level1)
460 {
461 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetMouseKeyState_002 start";
462 bool state = true;
463 settingConfig_->SetMouseKeyState(state);
464 EXPECT_FALSE(settingConfig_->GetMouseKeyState());
465 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetMouseKeyState_002 end";
466 }
467
468 /**
469 * @tc.number: AccessibilitySettingsConfig_Unittest_SetMouseAutoClick_001
470 * @tc.name: SetMouseAutoClick
471 * @tc.desc: Test function SetMouseAutoClick GetMouseAutoClick
472 * @tc.require: issueI5NTXC
473 */
474 HWTEST_F(AccessibilitySettingsConfigTest, AccessibilitySettingsConfig_Unittest_SetMouseAutoClick_001, TestSize.Level1)
475 {
476 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetMouseAutoClick_001 start";
477 settingConfig_->Init();
478 settingConfig_->SetMouseAutoClick(MOUSE_AUTO_CLICK_VALUE);
479 EXPECT_EQ(MOUSE_AUTO_CLICK_VALUE, settingConfig_->GetMouseAutoClick());
480 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetMouseAutoClick_001 end";
481 }
482
483 /**
484 * @tc.number: AccessibilitySettingsConfig_Unittest_SetMouseAutoClick_002
485 * @tc.name: SetMouseAutoClick
486 * @tc.desc: Test function SetMouseAutoClick GetMouseAutoClick
487 * @tc.require: issueI5NTXC
488 */
489 HWTEST_F(AccessibilitySettingsConfigTest, AccessibilitySettingsConfig_Unittest_SetMouseAutoClick_002, TestSize.Level1)
490 {
491 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetMouseAutoClick_002 start";
492 settingConfig_->Init();
493 settingConfig_->SetMouseAutoClick(MOUSE_AUTO_CLICK_DEFAULT_VALUE);
494 EXPECT_EQ(MOUSE_AUTO_CLICK_DEFAULT_VALUE, settingConfig_->GetMouseAutoClick());
495 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetMouseAutoClick_002 end";
496 }
497
498 /**
499 * @tc.number: AccessibilitySettingsConfig_Unittest_SetShortkeyTarget_001
500 * @tc.name: SetShortkeyTarget
501 * @tc.desc: Test function SetShortkeyTarget GetShortkeyTarget
502 * @tc.require: issueI5NTXH
503 */
504 HWTEST_F(AccessibilitySettingsConfigTest, AccessibilitySettingsConfig_Unittest_SetShortkeyTarget_001, TestSize.Level1)
505 {
506 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetShortkeyTarget_001 start";
507 std::string name = "TEST";
508 settingConfig_->Init();
509 settingConfig_->SetShortkeyTarget(name);
510 EXPECT_STREQ("TEST", settingConfig_->GetShortkeyTarget().c_str());
511 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetShortkeyTarget_001 end";
512 }
513
514 /**
515 * @tc.number: AccessibilitySettingsConfig_Unittest_SetShortkeyTarget_002
516 * @tc.name: SetShortkeyTarget
517 * @tc.desc: Test function SetShortkeyTarget GetShortkeyTarget
518 * @tc.require: issueI5NTXH
519 */
520 HWTEST_F(AccessibilitySettingsConfigTest, AccessibilitySettingsConfig_Unittest_SetShortkeyTarget_002, TestSize.Level1)
521 {
522 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetShortkeyTarget_002 start";
523 std::string name = "TEST";
524 settingConfig_->Init();
525 settingConfig_->SetShortkeyTarget(name);
526 EXPECT_NE("", settingConfig_->GetShortkeyTarget().c_str());
527 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetShortkeyTarget_002 end";
528 }
529
530 /**
531 * @tc.number: AccessibilitySettingsConfig_Unittest_SetHighContrastTextState_001
532 * @tc.name: SetHighContrastTextState
533 * @tc.desc: Test function SetHighContrastTextState GetHighContrastTextState
534 * @tc.require: issueI5NTX9
535 */
536 HWTEST_F(AccessibilitySettingsConfigTest, AccessibilitySettingsConfig_Unittest_SetHighContrastTextState_001,
537 TestSize.Level1)
538 {
539 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetHighContrastTextState_001 start";
540 bool state = true;
541 settingConfig_->Init();
542 settingConfig_->SetHighContrastTextState(state);
543 EXPECT_TRUE(settingConfig_->GetHighContrastTextState());
544 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetHighContrastTextState_001 end";
545 }
546
547 /**
548 * @tc.number: AccessibilitySettingsConfig_Unittest_SetHighContrastTextState_002
549 * @tc.name: SetHighContrastTextState
550 * @tc.desc: Test function SetHighContrastTextState GetHighContrastTextState
551 * @tc.require: issueI5NTX9
552 */
553 HWTEST_F(AccessibilitySettingsConfigTest, AccessibilitySettingsConfig_Unittest_SetHighContrastTextState_002,
554 TestSize.Level1)
555 {
556 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetHighContrastTextState_002 start";
557 bool state = true;
558 settingConfig_->SetHighContrastTextState(state);
559 EXPECT_FALSE(settingConfig_->GetHighContrastTextState());
560 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetHighContrastTextState_002 end";
561 }
562
563 /**
564 * @tc.number: AccessibilitySettingsConfig_Unittest_SetDaltonizationState_001
565 * @tc.name: SetDaltonizationState
566 * @tc.desc: Test function SetDaltonizationState GetDaltonizationState
567 */
568 HWTEST_F(AccessibilitySettingsConfigTest, AccessibilitySettingsConfig_Unittest_SetDaltonizationState_001,
569 TestSize.Level1)
570 {
571 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetDaltonizationState_001 start";
572 bool state = true;
573 settingConfig_->Init();
574 settingConfig_->SetDaltonizationState(state);
575 EXPECT_TRUE(settingConfig_->GetDaltonizationState());
576 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetDaltonizationState_001 end";
577 }
578
579 /**
580 * @tc.number: AccessibilitySettingsConfig_Unittest_SetDaltonizationState_002
581 * @tc.name: SetDaltonizationState
582 * @tc.desc: Test function SetDaltonizationState GetDaltonizationState
583 */
584 HWTEST_F(AccessibilitySettingsConfigTest, AccessibilitySettingsConfig_Unittest_SetDaltonizationState_002,
585 TestSize.Level1)
586 {
587 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetDaltonizationState_002 start";
588 bool state = true;
589 settingConfig_->SetDaltonizationState(state);
590 EXPECT_FALSE(settingConfig_->GetDaltonizationState());
591 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_DaltonizationState_002 end";
592 }
593
594 /**
595 * @tc.number: AccessibilitySettingsConfig_Unittest_SetInvertColorState_001
596 * @tc.name: SetInvertColorState
597 * @tc.desc: Test function SetInvertColorState GetInvertColorState
598 * @tc.require: issueI5NTX7
599 */
600 HWTEST_F(AccessibilitySettingsConfigTest,
601 AccessibilitySettingsConfig_Unittest_SetInvertColorState_001, TestSize.Level1)
602 {
603 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetInvertColorState_001 start";
604 bool state = true;
605 settingConfig_->Init();
606 settingConfig_->SetInvertColorState(state);
607 EXPECT_TRUE(settingConfig_->GetInvertColorState());
608 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetInvertColorState_001 end";
609 }
610
611 /**
612 * @tc.number: AccessibilitySettingsConfig_Unittest_SetInvertColorState_002
613 * @tc.name: SetInvertColorState
614 * @tc.desc: Test function SetInvertColorState GetInvertColorState
615 * @tc.require: issueI5NTX7
616 */
617 HWTEST_F(AccessibilitySettingsConfigTest,
618 AccessibilitySettingsConfig_Unittest_SetInvertColorState_002, TestSize.Level1)
619 {
620 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetInvertColorState_002 start";
621 bool state = true;
622 settingConfig_->SetInvertColorState(state);
623 EXPECT_FALSE(settingConfig_->GetInvertColorState());
624 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetInvertColorState_002 end";
625 }
626
627 /**
628 * @tc.number: AccessibilitySettingsConfig_Unittest_SetAnimationOffState_001
629 * @tc.name: SetAnimationOffState
630 * @tc.desc: Test function SetAnimationOffState GetAnimationOffState
631 * @tc.require: issueI5NTXG
632 */
633 HWTEST_F(AccessibilitySettingsConfigTest, AccessibilitySettingsConfig_Unittest_SetAnimationOffState_001,
634 TestSize.Level1)
635 {
636 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetAnimationOffState_001 start";
637 bool state = true;
638 settingConfig_->Init();
639 settingConfig_->SetAnimationOffState(state);
640 EXPECT_TRUE(settingConfig_->GetAnimationOffState());
641 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetAnimationOffState_001 end";
642 }
643
644 /**
645 * @tc.number: AccessibilitySettingsConfig_Unittest_SetAnimationOffState_002
646 * @tc.name: SetAnimationOffState
647 * @tc.desc: Test function SetAnimationOffState GetAnimationOffState
648 * @tc.require: issueI5NTXG
649 */
650 HWTEST_F(AccessibilitySettingsConfigTest, AccessibilitySettingsConfig_Unittest_SetAnimationOffState_002,
651 TestSize.Level1)
652 {
653 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetAnimationOffState_002 start";
654 bool state = true;
655 settingConfig_->SetAnimationOffState(state);
656 EXPECT_FALSE(settingConfig_->GetAnimationOffState());
657 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetAnimationOffState_002 end";
658 }
659
660 /**
661 * @tc.number: AccessibilitySettingsConfig_Unittest_SetAudioMonoState_001
662 * @tc.name: SetAudioMonoState
663 * @tc.desc: Test function SetAudioMonoState GetAudioMonoState
664 */
665 HWTEST_F(AccessibilitySettingsConfigTest, AccessibilitySettingsConfig_Unittest_SetAudioMonoState_001, TestSize.Level1)
666 {
667 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetAudioMonoState_001 start";
668 bool state = true;
669 settingConfig_->Init();
670 settingConfig_->SetAudioMonoState(state);
671 EXPECT_TRUE(settingConfig_->GetAudioMonoState());
672 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetAudioMonoState_001 end";
673 }
674
675 /**
676 * @tc.number: AccessibilitySettingsConfig_Unittest_SetAudioMonoState_002
677 * @tc.name: SetAudioMonoState
678 * @tc.desc: Test function SetAudioMonoState GetAudioMonoState
679 */
680 HWTEST_F(AccessibilitySettingsConfigTest, AccessibilitySettingsConfig_Unittest_SetAudioMonoState_002, TestSize.Level1)
681 {
682 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetAudioMonoState_002 start";
683 bool state = true;
684 settingConfig_->SetAudioMonoState(state);
685 EXPECT_FALSE(settingConfig_->GetAudioMonoState());
686 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetAudioMonoState_002 end";
687 }
688
689 /**
690 * @tc.number: AccessibilitySettingsConfig_Unittest_SetDaltonizationColorFilter_001
691 * @tc.name: SetDaltonizationColorFilter
692 * @tc.desc: Test function SetDaltonizationColorFilter GetDaltonizationColorFilter
693 * @tc.require: issueI5NTX8
694 */
695 HWTEST_F(AccessibilitySettingsConfigTest, AccessibilitySettingsConfig_Unittest_SetDaltonizationColorFilter_001,
696 TestSize.Level1)
697 {
698 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetDaltonizationColorFilter_001 start";
699 uint32_t filter = 1;
700 settingConfig_->Init();
701 settingConfig_->SetDaltonizationColorFilter(filter);
702 EXPECT_TRUE(settingConfig_->GetDaltonizationColorFilter());
703 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetDaltonizationColorFilter_001 end";
704 }
705
706 /**
707 * @tc.number: AccessibilitySettingsConfig_Unittest_SetDaltonizationColorFilter_002
708 * @tc.name: SetDaltonizationColorFilter
709 * @tc.desc: Test function SetDaltonizationColorFilter GetDaltonizationColorFilter
710 * @tc.require: issueI5NTX8
711 */
712 HWTEST_F(AccessibilitySettingsConfigTest, AccessibilitySettingsConfig_Unittest_SetDaltonizationColorFilter_002,
713 TestSize.Level1)
714 {
715 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetDaltonizationColorFilter_002 start";
716 uint32_t filter = 1;
717 settingConfig_->SetDaltonizationColorFilter(filter);
718 EXPECT_FALSE(settingConfig_->GetDaltonizationColorFilter());
719 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetDaltonizationColorFilter_002 end";
720 }
721
722 /**
723 * @tc.number: AccessibilitySettingsConfig_Unittest_SetContentTimeout_001
724 * @tc.name: SetContentTimeout
725 * @tc.desc: Test function SetContentTimeout GetContentTimeout
726 * @tc.require: issueI5NTXF
727 */
728 HWTEST_F(AccessibilitySettingsConfigTest, AccessibilitySettingsConfig_Unittest_SetContentTimeout_001, TestSize.Level1)
729 {
730 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetContentTimeout_001 start";
731 settingConfig_->Init();
732 settingConfig_->SetContentTimeout(CONTENT_TIMEOUT_VALUE);
733 EXPECT_EQ(CONTENT_TIMEOUT_VALUE, settingConfig_->GetContentTimeout());
734 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetContentTimeout_001 end";
735 }
736
737 /**
738 * @tc.number: AccessibilitySettingsConfig_Unittest_SetContentTimeout_002
739 * @tc.name: SetContentTimeout
740 * @tc.desc: Test function SetContentTimeout GetContentTimeout
741 * @tc.require: issueI5NTXF
742 */
743 HWTEST_F(AccessibilitySettingsConfigTest, AccessibilitySettingsConfig_Unittest_SetContentTimeout_002, TestSize.Level1)
744 {
745 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetContentTimeout_002 start";
746 settingConfig_->SetContentTimeout(CONTENT_TIMEOUT_VALUE);
747 EXPECT_NE(CONTENT_TIMEOUT_VALUE, settingConfig_->GetContentTimeout());
748 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetContentTimeout_002 end";
749 }
750
751 /**
752 * @tc.number: AccessibilitySettingsConfig_Unittest_SetBrightnessDiscount_001
753 * @tc.name: SetBrightnessDiscount
754 * @tc.desc: Test function SetBrightnessDiscount GetBrightnessDiscount
755 * @tc.require: issueI5NTXE
756 */
757 HWTEST_F(AccessibilitySettingsConfigTest,
758 AccessibilitySettingsConfig_Unittest_SetBrightnessDiscount_001, TestSize.Level1)
759 {
760 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetBrightnessDiscount_001 start";
761 settingConfig_->Init();
762 settingConfig_->SetBrightnessDiscount(BRIGHTNESS_DISCOUNT_VALUE);
763 EXPECT_EQ(BRIGHTNESS_DISCOUNT_VALUE, settingConfig_->GetBrightnessDiscount());
764 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetBrightnessDiscount_001 end";
765 }
766
767 /**
768 * @tc.number: AccessibilitySettingsConfig_Unittest_SetBrightnessDiscount_002
769 * @tc.name: SetBrightnessDiscount
770 * @tc.desc: Test function SetBrightnessDiscount GetBrightnessDiscount
771 * @tc.require: issueI5NTXE
772 */
773 HWTEST_F(AccessibilitySettingsConfigTest,
774 AccessibilitySettingsConfig_Unittest_SetBrightnessDiscount_002, TestSize.Level1)
775 {
776 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetBrightnessDiscount_002 start";
777 settingConfig_->SetBrightnessDiscount(BRIGHTNESS_DISCOUNT_VALUE);
778 EXPECT_NE(BRIGHTNESS_DISCOUNT_VALUE, settingConfig_->GetBrightnessDiscount());
779 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetBrightnessDiscount_002 end";
780 }
781
782 /**
783 * @tc.number: AccessibilitySettingsConfig_Unittest_SetAudioBalance_001
784 * @tc.name: SetAudioBalance
785 * @tc.desc: Test function SetAudioBalance GetAudioBalance
786 */
787 HWTEST_F(AccessibilitySettingsConfigTest, AccessibilitySettingsConfig_Unittest_SetAudioBalance_001, TestSize.Level1)
788 {
789 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetAudioBalance_001 start";
790 settingConfig_->Init();
791 settingConfig_->SetAudioBalance(AUDIO_BALANCE_VALUE);
792 EXPECT_EQ(AUDIO_BALANCE_VALUE, settingConfig_->GetAudioBalance());
793 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetAudioBalance_001 end";
794 }
795
796 /**
797 * @tc.number: AccessibilitySettingsConfig_Unittest_SetAudioBalance_002
798 * @tc.name: SetAudioBalance
799 * @tc.desc: Test function SetAudioBalance GetAudioBalance
800 */
801 HWTEST_F(AccessibilitySettingsConfigTest, AccessibilitySettingsConfig_Unittest_SetAudioBalance_002, TestSize.Level1)
802 {
803 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetAudioBalance_002 start";
804 settingConfig_->SetAudioBalance(AUDIO_BALANCE_VALUE);
805 EXPECT_NE(AUDIO_BALANCE_VALUE, settingConfig_->GetAudioBalance());
806 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetAudioBalance_002 end";
807 }
808
809 /**
810 * @tc.number: AccessibilitySettingsConfig_Unittest_SetClickResponseTime_001
811 * @tc.name: SetClickResponseTime
812 * @tc.desc: Test function SetClickResponseTime GetClickResponseTime
813 */
814 HWTEST_F(AccessibilitySettingsConfigTest,
815 AccessibilitySettingsConfig_Unittest_SetClickResponseTime_001, TestSize.Level1)
816 {
817 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetClickResponseTime_001 start";
818 settingConfig_->Init();
819 settingConfig_->SetClickResponseTime(1);
820 EXPECT_EQ(1, settingConfig_->GetClickResponseTime());
821 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetClickResponseTime_001 end";
822 }
823
824 /**
825 * @tc.number: AccessibilitySettingsConfig_Unittest_SetClickResponseTime_002
826 * @tc.name: SetClickResponseTime
827 * @tc.desc: Test function SetClickResponseTime GetClickResponseTime
828 */
829 HWTEST_F(AccessibilitySettingsConfigTest,
830 AccessibilitySettingsConfig_Unittest_SetClickResponseTime_002, TestSize.Level1)
831 {
832 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetClickResponseTime_002 start";
833 settingConfig_->SetClickResponseTime(1);
834 EXPECT_NE(1, settingConfig_->GetClickResponseTime());
835 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetClickResponseTime_002 end";
836 }
837
838 /**
839 * @tc.number: AccessibilitySettingsConfig_Unittest_SetIgnoreRepeatClickState_001
840 * @tc.name: SetIgnoreRepeatClickState
841 * @tc.desc: Test function SetIgnoreRepeatClickState GetIgnoreRepeatClickState
842 */
843 HWTEST_F(AccessibilitySettingsConfigTest,
844 AccessibilitySettingsConfig_Unittest_SetIgnoreRepeatClickState_001, TestSize.Level1)
845 {
846 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetIgnoreRepeatClickState_001 start";
847 settingConfig_->Init();
848 settingConfig_->SetIgnoreRepeatClickState(true);
849 EXPECT_EQ(true, settingConfig_->GetIgnoreRepeatClickState());
850 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetIgnoreRepeatClickState_001 end";
851 }
852
853 /**
854 * @tc.number: AccessibilitySettingsConfig_Unittest_SetIgnoreRepeatClickState_002
855 * @tc.name: SetIgnoreRepeatClickState
856 * @tc.desc: Test function SetIgnoreRepeatClickState GetIgnoreRepeatClickState
857 */
858 HWTEST_F(AccessibilitySettingsConfigTest,
859 AccessibilitySettingsConfig_Unittest_SetIgnoreRepeatClickState_002, TestSize.Level1)
860 {
861 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetIgnoreRepeatClickState_002 start";
862 settingConfig_->SetIgnoreRepeatClickState(true);
863 EXPECT_NE(true, settingConfig_->GetIgnoreRepeatClickState());
864 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetIgnoreRepeatClickState_002 end";
865 }
866
867 /**
868 * @tc.number: AccessibilitySettingsConfig_Unittest_SetIgnoreRepeatClickTime_001
869 * @tc.name: SetIgnoreRepeatClickTime
870 * @tc.desc: Test function SetIgnoreRepeatClickTime GetIgnoreRepeatClickTime
871 */
872 HWTEST_F(AccessibilitySettingsConfigTest,
873 AccessibilitySettingsConfig_Unittest_SetIgnoreRepeatClickTime_001, TestSize.Level1)
874 {
875 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetIgnoreRepeatClickTime_001 start";
876 settingConfig_->Init();
877 settingConfig_->SetIgnoreRepeatClickTime(1);
878 EXPECT_EQ(1, settingConfig_->GetIgnoreRepeatClickTime());
879 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetIgnoreRepeatClickTime_001 end";
880 }
881
882 /**
883 * @tc.number: AccessibilitySettingsConfig_Unittest_SetIgnoreRepeatClickTime_002
884 * @tc.name: SetIgnoreRepeatClickTime
885 * @tc.desc: Test function SetIgnoreRepeatClickTime GetIgnoreRepeatClickTime
886 */
887 HWTEST_F(AccessibilitySettingsConfigTest,
888 AccessibilitySettingsConfig_Unittest_SetIgnoreRepeatClickTime_002, TestSize.Level1)
889 {
890 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetIgnoreRepeatClickTime_002 start";
891 settingConfig_->SetIgnoreRepeatClickTime(1);
892 EXPECT_NE(1, settingConfig_->GetIgnoreRepeatClickTime());
893 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetIgnoreRepeatClickTime_002 end";
894 }
895
896 /**
897 * @tc.number: AccessibilitySettingsConfig_Unittest_GetConfigState_001
898 * @tc.name: GetConfigState
899 * @tc.desc: Test function GetConfigState
900 */
901 HWTEST_F(AccessibilitySettingsConfigTest, AccessibilitySettingsConfig_Unittest_GetConfigState_001, TestSize.Level1)
902 {
903 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_GetConfigState_001 start";
904 uint32_t state = 0x00000000;
905 EXPECT_EQ(state, settingConfig_->GetConfigState());
906 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_GetConfigState_001 end";
907 }
908
909 /**
910 * @tc.number: AccessibilitySettingsConfig_Unittest_ClearData_001
911 * @tc.name: ClearData
912 * @tc.desc: Test function ClearData
913 */
914 HWTEST_F(AccessibilitySettingsConfigTest, AccessibilitySettingsConfig_Unittest_ClearData_001, TestSize.Level1)
915 {
916 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_ClearData_001 start";
917 settingConfig_->Init();
918 EXPECT_TRUE(settingConfig_->GetInitializeState());
919 settingConfig_->ClearData();
920 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_ClearData_001 end";
921 }
922
923 /**
924 * @tc.number: AccessibilitySettingsConfig_Unittest_SetShortkeyMultiTargetInPkgRemove_001
925 * @tc.name: SetShortkeyMultiTargetInPkgRemove
926 * @tc.desc: Test function SetShortkeyMultiTargetInPkgRemove
927 */
928 HWTEST_F(AccessibilitySettingsConfigTest, Unittest_SetShortkeyMultiTargetInPkgRemove_001, TestSize.Level1)
929 {
930 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetShortkeyMultiTargetInPkgRemove_001 start";
931 settingConfig_->Init();
932 std::string name = "TEST";
933 settingConfig_->SetShortkeyMultiTargetInPkgRemove(name);
934 EXPECT_NE(settingConfig_->GetShortkeyMultiTarget().size(), 0);
935 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetShortkeyMultiTargetInPkgRemove_001 end";
936 }
937
938 /**
939 * @tc.number: AccessibilitySettingsConfig_Unittest_SetStartToHosState_001
940 * @tc.name: SetStartToHosState
941 * @tc.desc: Test function SetScreenMagnificationState GetScreenMagnificationState
942 */
943 HWTEST_F(AccessibilitySettingsConfigTest,
944 AccessibilitySettingsConfig_Unittest_SetStartToHosState_001, TestSize.Level1)
945 {
946 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetStartToHosState_001 start";
947 bool state = true;
948 int32_t ret = settingConfig_->SetStartToHosState(state);
949 EXPECT_EQ(ret, RET_ERR_NULLPTR);
950 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetStartToHosState_001 end";
951 }
952
953 /**
954 * @tc.number: AccessibilitySettingsConfig_Unittest_SetShortkeyMultiTarget_001
955 * @tc.name: SetShortkeyMultiTarget
956 * @tc.desc: Test function SetShortkeyMultiTarget
957 * @tc.require: issueI5NTXH
958 */
959 HWTEST_F(AccessibilitySettingsConfigTest,
960 AccessibilitySettingsConfig_Unittest_SetShortkeyMultiTarget_001, TestSize.Level1)
961 {
962 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetShortkeyMultiTarget_001 start";
963 const std::vector<std::string> name;
964 int32_t ret = settingConfig_->SetShortkeyMultiTarget(name);
965 EXPECT_EQ(ret, RET_ERR_NULLPTR);
966 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetShortkeyMultiTarget_001 end";
967 }
968
969 /**
970 * @tc.number: AccessibilitySettingsConfig_Unittest_SetShortkeyMultiTarget_002
971 * @tc.name: SetShortkeyMultiTarget
972 * @tc.desc: Test function SetShortkeyMultiTarget
973 * @tc.require: issueI5NTXH
974 */
975 HWTEST_F(AccessibilitySettingsConfigTest,
976 AccessibilitySettingsConfig_Unittest_SetShortkeyMultiTarget_002, TestSize.Level1)
977 {
978 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetShortkeyMultiTarget_002 start";
979 const std::vector<std::string> name = {"test"};
980 int32_t ret = settingConfig_->SetShortkeyMultiTarget(name);
981 EXPECT_EQ(ret, RET_ERR_NULLPTR);
982 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetShortkeyMultiTarget_002 end";
983 }
984
985 /**
986 * @tc.number: AccessibilitySettingsConfig_Unittest_SetShortkeyMultiTargetInPkgRemove_001
987 * @tc.name: SetShortkeyMultiTargetInPkgRemove
988 * @tc.desc: Test function SetShortkeyMultiTargetInPkgRemove
989 * @tc.require: issueI5NTXH
990 */
991 HWTEST_F(AccessibilitySettingsConfigTest,
992 AccessibilitySettingsConfig_Unittest_SetShortkeyMultiTargetInPkgRemove_001, TestSize.Level1)
993 {
994 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetShortkeyMultiTargetInPkgRemove_001 start";
995 const std::string name = "test";
996 int32_t ret = settingConfig_->SetShortkeyMultiTargetInPkgRemove(name);
997 EXPECT_EQ(ret, RET_ERR_NULLPTR);
998 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetShortkeyMultiTargetInPkgRemove_001 end";
999 }
1000
1001 /**
1002 * @tc.number: AccessibilitySettingsConfig_Unittest_SetScreenMagnificationType_001
1003 * @tc.name: SetScreenMagnificationType
1004 * @tc.desc: Test function SetScreenMagnificationType GetScreenMagnificationType
1005 */
1006 HWTEST_F(AccessibilitySettingsConfigTest, AccessibilitySettingsConfig_Unittest_SetScreenMagnificationType_001,
1007 TestSize.Level1)
1008 {
1009 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetScreenMagnificationType_001 start";
1010 settingConfig_->Init();
1011 uint32_t screenMagnificationType = 0;
1012 settingConfig_->SetScreenMagnificationType(screenMagnificationType);
1013
1014 EXPECT_EQ(settingConfig_->GetScreenMagnificationType(), 0);
1015 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetScreenMagnificationType_001 end";
1016 }
1017
1018 /**
1019 * @tc.number: AccessibilitySettingsConfig_Unittest_RemoveEnabledAccessibilityService_001
1020 * @tc.name: RemoveEnabledAccessibilityService
1021 * @tc.desc: Test function AddEnabledAccessibilityService RemoveEnabledAccessibilityService
1022 */
1023 HWTEST_F(AccessibilitySettingsConfigTest, AccessibilitySettingsConfig_Unittest_RemoveEnabledAccessibilityService_001,
1024 TestSize.Level1)
1025 {
1026 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_RemoveEnabledAccessibilityService_001 start";
1027 settingConfig_->Init();
1028 settingConfig_->RemoveEnabledAccessibilityService(ENABLE_ABILITY_NAME);
1029 settingConfig_->AddEnabledAccessibilityService(ENABLE_ABILITY_NAME);
1030 RetError rtn = settingConfig_->RemoveEnabledAccessibilityService(ENABLE_ABILITY_NAME);
1031
1032 EXPECT_EQ(rtn, RET_OK);
1033 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_RemoveEnabledAccessibilityService_001 end";
1034 }
1035
1036 /**
1037 * @tc.number: AccessibilitySettingsConfig_Unittest_OnDataClone_001
1038 * @tc.name: OnDataClone
1039 * @tc.desc: Test function OnDataClone
1040 */
1041 HWTEST_F(AccessibilitySettingsConfigTest, AccessibilitySettingsConfig_Unittest_OnDataClone_001,
1042 TestSize.Level1)
1043 {
1044 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_OnDataClone start";
1045 settingConfig_->Init();
1046 settingConfig_->OnDataClone();
1047 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_OnDataClone end";
1048 }
1049
1050 /**
1051 * @tc.number: AccessibilitySettingsConfig_Unittest_SetInitializeState_001
1052 * @tc.name: SetInitializeState
1053 * @tc.desc: Test function SetInitializeState GetInitializeState
1054 */
1055 HWTEST_F(AccessibilitySettingsConfigTest, AccessibilitySettingsConfig_Unittest_SetInitializeState_001,
1056 TestSize.Level1)
1057 {
1058 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetInitializeState_001 start";
1059 settingConfig_->Init();
1060 settingConfig_->SetInitializeState(false);
1061
1062 EXPECT_EQ(settingConfig_->GetInitializeState(), 0);
1063 GTEST_LOG_(INFO) << "AccessibilitySettingsConfig_Unittest_SetInitializeState_001 end";
1064 }
1065 } // namespace Accessibility
1066 } // namespace OHOS