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