1 /*
2 * Copyright (C) 2022-2023 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 <optional>
18 #include "accessibility_ability_info.h"
19 #include "accessibility_common_helper.h"
20 #include "accessibility_display_manager.h"
21 #include "accessibility_ut_helper.h"
22 #include "accessibility_window_manager.h"
23 #include "accessible_ability_manager_service.h"
24 #include "iservice_registry.h"
25 #include "mock_accessible_ability_client_stub_impl.h"
26 #include "mock_accessible_ability_manager_service_config_observer_proxy.h"
27 #include "mock_accessible_ability_manager_service_config_observer_stub.h"
28 #include "mock_accessible_ability_manager_service_state_observer_proxy.h"
29 #include "mock_accessible_ability_manager_service_state_observer_stub.h"
30 #include "mock_bundle_manager.h"
31 #include "system_ability_definition.h"
32
33 using namespace testing;
34 using namespace testing::ext;
35
36 namespace OHOS {
37 namespace Accessibility {
38 namespace {
39 constexpr uint32_t SLEEP_TIME_1 = 1;
40 constexpr uint32_t CONTENT_TIMEOUT_VALUE = 10;
41 constexpr int32_t MOUSE_AUTO_CLICK_VALUE = 3;
42 constexpr float BRIGHTNESS_DISCOUNT_VALUE = 0.1f;
43 constexpr float AUDIO_BALANCE_VALUE = 0.1f;
44 constexpr int32_t ACTIVE_WINDOW_VALUE = 2;
45 } // namespace
46
47 class AccessibleAbilityManagerServiceUnitTest : public ::testing::Test {
48 public:
AccessibleAbilityManagerServiceUnitTest()49 AccessibleAbilityManagerServiceUnitTest()
50 {}
~AccessibleAbilityManagerServiceUnitTest()51 ~AccessibleAbilityManagerServiceUnitTest()
52 {}
53
54 static void SetUpTestCase();
55 static void TearDownTestCase();
56 void SetUp() override;
57 void TearDown() override;
58
59 sptr<AccessibleAbilityClientStub> stub_ = nullptr;
60 void RegisterAbilityConnectionClient(const sptr<IRemoteObject>& obj);
61 };
62
SetUpTestCase()63 void AccessibleAbilityManagerServiceUnitTest::SetUpTestCase()
64 {
65 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest SetUpTestCase";
66 Singleton<AccessibleAbilityManagerService>::GetInstance().OnStart();
67 AccessibilityCommonHelper::GetInstance().WaitForServicePublish();
68 }
69
TearDownTestCase()70 void AccessibleAbilityManagerServiceUnitTest::TearDownTestCase()
71 {
72 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest TearDownTestCase";
73 Singleton<AccessibleAbilityManagerService>::GetInstance().OnStop();
74 AccessibilityCommonHelper::GetInstance().SetIsServicePublished(false);
75 }
76
SetUp()77 void AccessibleAbilityManagerServiceUnitTest::SetUp()
78 {
79 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest SetUp";
80 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(AccessibilityAbilityHelper::accountId_);
81 stub_ = new MockAccessibleAbilityClientStubImpl();
82 }
83
TearDown()84 void AccessibleAbilityManagerServiceUnitTest::TearDown()
85 {
86 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest TearDown";
87 stub_ = nullptr;
88 }
89
RegisterAbilityConnectionClient(const sptr<IRemoteObject> & obj)90 void AccessibleAbilityManagerServiceUnitTest::RegisterAbilityConnectionClient(const sptr<IRemoteObject>& obj)
91 {
92 // add an ability connection client
93 AccessibilityAbilityInitParams initParams;
94 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
95 AppExecFwk::ElementName elementName("deviceId", "bundleName", "name");
96 auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
97 if (!accountData) {
98 GTEST_LOG_(INFO) << "current account data is null";
99 return;
100 }
101 accountData->AddInstalledAbility(*abilityInfo);
102 sptr<AccessibleAbilityConnection> connection =
103 new AccessibleAbilityConnection(accountData->GetAccountId(), 0, *abilityInfo);
104 connection->OnAbilityConnectDoneSync(elementName, obj);
105 sleep(SLEEP_TIME_1);
106 }
107
108 /**
109 * @tc.number: AccessibleAbilityManagerServiceUnitTest_GetInstance_001
110 * @tc.name: GetInstance
111 * @tc.desc: Test function GetInstance
112 */
113 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetInstance_001, TestSize.Level1)
114 {
115 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_GetInstance_001 start";
116
117 auto ins = &Singleton<AccessibleAbilityManagerService>::GetInstance();
118 EXPECT_TRUE(ins);
119
120 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_GetInstance_001 end";
121 }
122
123 /**
124 * @tc.number: AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterStateCallback_001
125 * @tc.name: RegisterStateCallback
126 * @tc.desc: Test function RegisterStateCallback
127 */
128 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, RegisterStateCallback_001, TestSize.Level1)
129 {
130 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterStateCallback_001 start";
131
132 sptr<AccessibleAbilityManagerStateObserverStub> stub = new MockAccessibleAbilityManagerStateObserverStub();
133 sptr<IAccessibleAbilityManagerStateObserver> state = new MockAccessibleAbilityManagerStateObserverProxy(stub);
134
135 uint32_t ret = Singleton<AccessibleAbilityManagerService>::GetInstance().RegisterStateObserver(state);
136 EXPECT_EQ(ret, 0);
137
138 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterStateCallback_001 end";
139 }
140
141 /**
142 * @tc.number: AccessibleAbility_ManagerService_UnitTest_GetAbilityList_001
143 * @tc.name: GetAbilityList
144 * @tc.desc: Test function GetAbilityList
145 */
146 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetAbilityList_001, TestSize.Level1)
147 {
148 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetAbilityList_001 start";
149 std::vector<OHOS::Accessibility::AccessibilityAbilityInfo> infos;
150 Singleton<AccessibleAbilityManagerService>::GetInstance().GetAbilityList(
151 ACCESSIBILITY_ABILITY_TYPE_ALL, ABILITY_STATE_ENABLE, infos);
152 EXPECT_EQ(infos.size(), 0);
153
154 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_GetAbilityList_001 end";
155 }
156
157 /**
158 * @tc.number: Accessible_Ability_ManagerService_UnitTest_RegisterElementOperator_001
159 * @tc.name: RegisterElementOperator
160 * @tc.desc: Test function RegisterElementOperator
161 */
162 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, RegisterElementOperator_001, TestSize.Level1)
163 {
164 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterElementOperator_001 start";
165 auto &aams = Singleton<AccessibleAbilityManagerService>::GetInstance();
166 auto accountData = aams.GetCurrentAccountData();
167 ASSERT_TRUE(accountData);
168 auto map = accountData->GetAsacConnections();
169 EXPECT_EQ(int(map.size()), 0);
170 EXPECT_EQ(RET_OK, aams.RegisterElementOperator(0, nullptr));
171 sleep(SLEEP_TIME_1);
172 GTEST_LOG_(INFO) << "RegisterElementOperator OK";
173 map = accountData->GetAsacConnections();
174 EXPECT_EQ(int(map.size()), 1);
175
176 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterElementOperator_001 end";
177 }
178
179 /**
180 * @tc.number: AccessibleAbility_ManagerService_UnitTest_DeregisterElementOperator_001
181 * @tc.name: DeregisterElementOperator
182 * @tc.desc: Test function DeregisterElementOperator
183 */
184 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, DeregisterElementOperator_001, TestSize.Level1)
185 {
186 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_DeregisterElementOperator_001 start";
187 auto &aams = Singleton<AccessibleAbilityManagerService>::GetInstance();
188 auto accountData = aams.GetCurrentAccountData();
189 ASSERT_TRUE(accountData);
190 EXPECT_EQ(RET_OK, aams.DeregisterElementOperator(0));
191 sleep(SLEEP_TIME_1);
192 auto map = accountData->GetAsacConnections();
193 EXPECT_EQ(int(map.size()), 0);
194
195 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_DeregisterElementOperator_001 end";
196 }
197
198 /**
199 * @tc.number: AccessibleAbility_ManagerService_UnitTest_SetTouchEventInjector_001
200 * @tc.name: SetTouchEventInjector
201 * @tc.desc: Test function SetTouchEventInjector
202 */
203 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetTouchEventInjector_001, TestSize.Level1)
204 {
205 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTouchEventInjector_001 start";
206 sptr<TouchEventInjector> touchEventInjector = new TouchEventInjector();
207 sleep(SLEEP_TIME_1);
208 Singleton<AccessibleAbilityManagerService>::GetInstance().SetTouchEventInjector(touchEventInjector);
209 auto ret = Singleton<AccessibleAbilityManagerService>::GetInstance().GetTouchEventInjector();
210 EXPECT_TRUE(ret);
211 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTouchEventInjector_001 end";
212 }
213
214 /**
215 * @tc.number: AccessibleAbility_ManagerService_UnitTest_SetKeyEventFilter_001
216 * @tc.name: SetKeyEventFilter
217 * @tc.desc: Test function SetKeyEventFilter
218 */
219 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetKeyEventFilter_001, TestSize.Level1)
220 {
221 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetKeyEventFilter_001 start";
222 sptr<KeyEventFilter> keyEventFilter = new KeyEventFilter();
223 Singleton<AccessibleAbilityManagerService>::GetInstance().SetKeyEventFilter(keyEventFilter);
224 auto ret = Singleton<AccessibleAbilityManagerService>::GetInstance().GetKeyEventFilter();
225 EXPECT_TRUE(ret);
226 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetKeyEventFilter_001 end";
227 }
228
229 /**
230 * @tc.number: AccessibleAbility_ManagerService_UnitTest_RemovedUser_001
231 * @tc.name: RemovedUser
232 * @tc.desc: Test function RemovedUser
233 */
234 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, RemovedUser_001, TestSize.Level1)
235 {
236 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_RemovedUser_001 start";
237 RegisterAbilityConnectionClient(stub_);
238 auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
239 ASSERT_TRUE(accountData);
240 EXPECT_EQ(int(accountData->GetConnectedA11yAbilities().size()), 1);
241 Singleton<AccessibleAbilityManagerService>::GetInstance().RemovedUser(1);
242 // can't to check a11yAccountsData_ because it is private,and don't provite api.
243 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_RemovedUser_001 end";
244 }
245
246 /**
247 * @tc.number: AccessibleAbility_ManagerService_UnitTest_GetBundleMgrProxy_001
248 * @tc.name: GetBundleMgrProxy
249 * @tc.desc: Test function GetBundleMgrProxy
250 */
251 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetBundleMgrProxy_001, TestSize.Level1)
252 {
253 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_GetBundleMgrProxy_001 start";
254 auto ret = Singleton<AccessibleAbilityManagerService>::GetInstance().GetBundleMgrProxy();
255 EXPECT_TRUE(ret);
256 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_GetBundleMgrProxyr_001 end";
257 }
258
259 /**
260 * @tc.number: AccessibleAbility_ManagerService_UnitTest_PackageChanged_001
261 * @tc.name: PackageChanged
262 * @tc.desc: Test function PackageChanged
263 */
264 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, PackageChanged_001, TestSize.Level1)
265 {
266 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_PackageChanged_001 start";
267 auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
268 ASSERT_TRUE(accountData);
269 accountData->ClearInstalledAbility();
270 /* install ability is null */
271 GTEST_LOG_(INFO) << "GetInstalledAbilities start";
272 EXPECT_EQ(0, int(accountData->GetInstalledAbilities().size()));
273 GTEST_LOG_(INFO) << "PackageChanged start";
274 std::string bundleName = "bundleName1";
275 Singleton<AccessibleAbilityManagerService>::GetInstance().PackageChanged(bundleName);
276 GTEST_LOG_(INFO) << "PackageChanged end";
277 EXPECT_EQ(0, int(accountData->GetInstalledAbilities().size()));
278 GTEST_LOG_(INFO) << "GetInstalledAbilities end";
279 /* add install ability */
280 sleep(SLEEP_TIME_1);
281 RegisterAbilityConnectionClient(stub_);
282 sleep(SLEEP_TIME_1);
283 EXPECT_EQ(1, int(accountData->GetInstalledAbilities().size()));
284 bundleName = "bundleName2";
285 Singleton<AccessibleAbilityManagerService>::GetInstance().PackageChanged(bundleName);
286 sleep(SLEEP_TIME_1);
287 EXPECT_EQ(1, int(accountData->GetInstalledAbilities().size()));
288 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_PackageChanged_001 end";
289 }
290
291 /**
292 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetScreenMagnificationState_001
293 * @tc.name: SetScreenMagnificationState
294 * @tc.desc: Test function SetScreenMagnificationState GetScreenMagnificationState
295 */
296 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetScreenMagnificationState_001, TestSize.Level1)
297 {
298 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetScreenMagnificationState_001 start";
299 bool state = true;
300 Singleton<AccessibleAbilityManagerService>::GetInstance().SetScreenMagnificationState(state);
301 bool ret = false;
302 Singleton<AccessibleAbilityManagerService>::GetInstance().GetScreenMagnificationState(ret);
303 EXPECT_TRUE(ret);
304 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetScreenMagnificationState_001 end";
305 }
306
307 /**
308 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetShortKeyState_001
309 * @tc.name: SetShortKeyState
310 * @tc.desc: Test function SetShortKeyState GetShortKeyState
311 * @tc.require: issueI5NTXH
312 */
313 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetShortKeyState_001, TestSize.Level1)
314 {
315 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetShortKeyState_001 start";
316 bool state = true;
317 Singleton<AccessibleAbilityManagerService>::GetInstance().SetShortKeyState(state);
318 bool ret = false;
319 Singleton<AccessibleAbilityManagerService>::GetInstance().GetShortKeyState(ret);
320 EXPECT_TRUE(ret);
321 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetShortKeyState_001 end";
322 }
323
324 /**
325 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetMouseKeyState_001
326 * @tc.name: SetMouseKeyState
327 * @tc.desc: Test function SetMouseKeyState GetMouseKeyState
328 * @tc.require: issueI5NTXA
329 */
330 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetMouseKeyState_001, TestSize.Level1)
331 {
332 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetMouseKeyState_001 start";
333 bool state = true;
334 Singleton<AccessibleAbilityManagerService>::GetInstance().SetMouseKeyState(state);
335 bool ret = false;
336 Singleton<AccessibleAbilityManagerService>::GetInstance().GetMouseKeyState(ret);
337 EXPECT_TRUE(ret);
338 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetMouseKeyState_001 end";
339 }
340
341 /**
342 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetMouseAutoClick_001
343 * @tc.name: SetMouseAutoClick
344 * @tc.desc: Test function SetMouseAutoClick GetMouseAutoClick
345 * @tc.require: issueI5NTXC
346 */
347 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetMouseAutoClick_001, TestSize.Level1)
348 {
349 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetMouseAutoClick_001 start";
350 Singleton<AccessibleAbilityManagerService>::GetInstance().SetMouseAutoClick(MOUSE_AUTO_CLICK_VALUE);
351 int32_t ret = 0;
352 Singleton<AccessibleAbilityManagerService>::GetInstance().GetMouseAutoClick(ret);
353 EXPECT_EQ(MOUSE_AUTO_CLICK_VALUE, ret);
354 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetMouseAutoClick_001 end";
355 }
356
357 /**
358 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetShortkeyTarget_001
359 * @tc.name: SetShortkeyTarget
360 * @tc.desc: Test function SetShortkeyTarget GetShortkeyTarget
361 * @tc.require: issueI5NTXH
362 */
363 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetShortkeyTarget_001, TestSize.Level1)
364 {
365 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetShortkeyTarget_001 start";
366 std::string name = "test";
367 Singleton<AccessibleAbilityManagerService>::GetInstance().SetShortkeyTarget(name);
368 std::string ret = "";
369 Singleton<AccessibleAbilityManagerService>::GetInstance().GetShortkeyTarget(ret);
370 EXPECT_STREQ("test", ret.c_str());
371 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetShortkeyTarget_001 end";
372 }
373
374 /**
375 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetHighContrastTextState_001
376 * @tc.name: SetHighContrastTextState
377 * @tc.desc: Test function SetHighContrastTextState GetHighContrastTextState
378 * @tc.require: issueI5NTX9
379 */
380 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetHighContrastTextState_001, TestSize.Level1)
381 {
382 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetHighContrastTextState_001 start";
383 bool state = true;
384 Singleton<AccessibleAbilityManagerService>::GetInstance().SetHighContrastTextState(state);
385 bool ret = false;
386 Singleton<AccessibleAbilityManagerService>::GetInstance().GetHighContrastTextState(ret);
387 EXPECT_TRUE(ret);
388 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetHighContrastTextState_001 end";
389 }
390
391 /**
392 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetInvertColorState_001
393 * @tc.name: SetInvertColorState
394 * @tc.desc: Test function SetInvertColorState GetInvertColorState
395 * @tc.require: issueI5NTX7
396 */
397 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetInvertColorState_001, TestSize.Level1)
398 {
399 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetInvertColorState_001 start";
400 bool state = true;
401 Singleton<AccessibleAbilityManagerService>::GetInstance().SetInvertColorState(state);
402 bool ret = false;
403 Singleton<AccessibleAbilityManagerService>::GetInstance().GetInvertColorState(ret);
404 EXPECT_TRUE(ret);
405 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetInvertColorState_001 end";
406 }
407
408 /**
409 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetAnimationOffState_001
410 * @tc.name: SetAnimationOffState
411 * @tc.desc: Test function SetAnimationOffState GetAnimationOffState
412 * @tc.require: issueI5NTXG
413 */
414 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetAnimationOffState_001, TestSize.Level1)
415 {
416 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetAnimationOffState_001 start";
417 bool state = true;
418 Singleton<AccessibleAbilityManagerService>::GetInstance().SetAnimationOffState(state);
419 bool ret = false;
420 Singleton<AccessibleAbilityManagerService>::GetInstance().GetAnimationOffState(ret);
421 EXPECT_TRUE(ret);
422 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetAnimationOffState_001 end";
423 }
424
425 /**
426 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetAudioMonoState_001
427 * @tc.name: SetAudioMonoState
428 * @tc.desc: Test function SetAudioMonoState GetAudioMonoState
429 */
430 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetAudioMonoState_001, TestSize.Level1)
431 {
432 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetAudioMonoState_001 start";
433 bool state = true;
434 Singleton<AccessibleAbilityManagerService>::GetInstance().SetAudioMonoState(state);
435 bool ret = false;
436 Singleton<AccessibleAbilityManagerService>::GetInstance().GetAudioMonoState(ret);
437 EXPECT_TRUE(ret);
438 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetAudioMonoState_001 end";
439 }
440
441 /**
442 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetDaltonizationColorFilter_001
443 * @tc.name: SetDaltonizationColorFilter
444 * @tc.desc: Test function SetDaltonizationColorFilter GetDaltonizationColorFilter
445 * @tc.require: issueI5NTX8
446 */
447 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetDaltonizationColorFilter_001, TestSize.Level1)
448 {
449 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetDaltonizationColorFilter_001 start";
450 uint32_t filter = 1;
451 Singleton<AccessibleAbilityManagerService>::GetInstance().SetDaltonizationColorFilter(filter);
452 uint32_t ret = 0;
453 Singleton<AccessibleAbilityManagerService>::GetInstance().GetDaltonizationColorFilter(ret);
454 EXPECT_EQ(filter, ret);
455 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetDaltonizationColorFilter_001 end";
456 }
457
458 /**
459 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetContentTimeout_001
460 * @tc.name: SetContentTimeout
461 * @tc.desc: Test function SetContentTimeout GetContentTimeout
462 * @tc.require: issueI5NTXF
463 */
464 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetContentTimeout_001, TestSize.Level1)
465 {
466 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetContentTimeout_001 start";
467 Singleton<AccessibleAbilityManagerService>::GetInstance().SetContentTimeout(CONTENT_TIMEOUT_VALUE);
468 uint32_t ret = 0;
469 Singleton<AccessibleAbilityManagerService>::GetInstance().GetContentTimeout(ret);
470 EXPECT_EQ(CONTENT_TIMEOUT_VALUE, ret);
471 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetContentTimeout_001 end";
472 }
473
474 /**
475 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetBrightnessDiscount_001
476 * @tc.name: SetBrightnessDiscount
477 * @tc.desc: Test function SetBrightnessDiscount GetBrightnessDiscount
478 * @tc.require: issueI5NTXE
479 */
480 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetBrightnessDiscount_001, TestSize.Level1)
481 {
482 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetBrightnessDiscount_001 start";
483 Singleton<AccessibleAbilityManagerService>::GetInstance().SetBrightnessDiscount(BRIGHTNESS_DISCOUNT_VALUE);
484 float ret = 0;
485 Singleton<AccessibleAbilityManagerService>::GetInstance().GetBrightnessDiscount(ret);
486 EXPECT_EQ(BRIGHTNESS_DISCOUNT_VALUE, ret);
487 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetBrightnessDiscount_001 end";
488 }
489
490 /**
491 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetAudioBalance_001
492 * @tc.name: SetAudioBalance
493 * @tc.desc: Test function SetAudioBalance GetAudioBalance
494 */
495 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetAudioBalance_001, TestSize.Level1)
496 {
497 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetAudioBalance_001 start";
498 Singleton<AccessibleAbilityManagerService>::GetInstance().SetAudioBalance(AUDIO_BALANCE_VALUE);
499 float ret = 0;
500 Singleton<AccessibleAbilityManagerService>::GetInstance().GetAudioBalance(ret);
501 EXPECT_EQ(AUDIO_BALANCE_VALUE, ret);
502 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetAudioBalance_001 end";
503 }
504
505 /**
506 * @tc.number: AccessibleAbilityManagerServiceUnitTest_GetAllConfigs_001
507 * @tc.name: GetAllConfigs
508 * @tc.desc: Test function GetAllConfigs
509 */
510 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetAllConfigs_001, TestSize.Level1)
511 {
512 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetAllConfigs_001 start";
513 AccessibilityConfigData data;
514 Singleton<AccessibleAbilityManagerService>::GetInstance().GetAllConfigs(data);
515 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetAllConfigs_001 end";
516 }
517
518 /**
519 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetCaptionState_001
520 * @tc.name: SetCaptionState
521 * @tc.desc: Test function SetCaptionState GetCaptionState
522 */
523 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetCaptionState_001, TestSize.Level1)
524 {
525 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetCaptionState_001 start";
526 bool state = true;
527 Singleton<AccessibleAbilityManagerService>::GetInstance().SetCaptionState(state);
528 bool ret = false;
529 Singleton<AccessibleAbilityManagerService>::GetInstance().GetCaptionState(ret);
530 EXPECT_TRUE(ret);
531 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetCaptionState_001 end";
532 }
533
534 /**
535 * @tc.number: AccessibleAbilityManagerServiceUnitTest_GetEnabledState_001
536 * @tc.name: GetEnabledState
537 * @tc.desc: Test function GetEnabledState
538 */
539 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetEnabledState_001, TestSize.Level1)
540 {
541 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetEnabledState_001 start";
542 EXPECT_TRUE(Singleton<AccessibleAbilityManagerService>::GetInstance().GetEnabledState());
543 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetEnabledState_001 end";
544 }
545
546 /**
547 * @tc.number: AccessibleAbilityManagerServiceUnitTest_GetTouchGuideState_001
548 * @tc.name: GetTouchGuideState
549 * @tc.desc: Test function GetTouchGuideState
550 */
551 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetTouchGuideState_001, TestSize.Level1)
552 {
553 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetTouchGuideState_001 start";
554 EXPECT_FALSE(Singleton<AccessibleAbilityManagerService>::GetInstance().GetTouchGuideState());
555 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetTouchGuideState_001 end";
556 }
557
558 /**
559 * @tc.number: AccessibleAbilityManagerServiceUnitTest_GetGestureState_001
560 * @tc.name: GetGestureState
561 * @tc.desc: Test function GetGestureState
562 */
563 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetGestureState_001, TestSize.Level1)
564 {
565 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetGestureState_001 start";
566 EXPECT_FALSE(Singleton<AccessibleAbilityManagerService>::GetInstance().GetGestureState());
567 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetGestureState_001 end";
568 }
569
570 /**
571 * @tc.number: AccessibleAbilityManagerServiceUnitTest_GetKeyEventObserverState_001
572 * @tc.name: GetKeyEventObserverState
573 * @tc.desc: Test function GetKeyEventObserverState
574 */
575 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetKeyEventObserverState_001, TestSize.Level1)
576 {
577 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetKeyEventObserverState_001 start";
578 EXPECT_FALSE(Singleton<AccessibleAbilityManagerService>::GetInstance().GetKeyEventObserverState());
579 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetKeyEventObserverState_001 end";
580 }
581
582 /**
583 * @tc.number: AccessibleAbilityManagerServiceUnitTest_GetActiveWindow_001
584 * @tc.name: GetActiveWindow
585 * @tc.desc: Test function GetActiveWindow
586 */
587 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetActiveWindow_001, TestSize.Level1)
588 {
589 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetActiveWindow_001 start";
590 Singleton<AccessibilityWindowManager>::GetInstance().SetActiveWindow(ACTIVE_WINDOW_VALUE);
591 EXPECT_EQ(ACTIVE_WINDOW_VALUE, Singleton<AccessibleAbilityManagerService>::GetInstance().GetActiveWindow());
592 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetActiveWindow_001 end";
593 }
594
595 /**
596 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetCaptionProperty_001
597 * @tc.name: SetCaptionProperty
598 * @tc.desc: Test function SetCaptionProperty GetCaptionProperty
599 */
600 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetCaptionProperty_001, TestSize.Level1)
601 {
602 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetCaptionProperty_001 start";
603 AccessibilityConfig::CaptionProperty caption;
604 int scale = 1;
605 caption.SetFontScale(scale);
606 Singleton<AccessibleAbilityManagerService>::GetInstance().SetCaptionProperty(caption);
607
608 AccessibilityConfig::CaptionProperty res;
609 Singleton<AccessibleAbilityManagerService>::GetInstance().GetCaptionProperty(res);
610 EXPECT_EQ(1, res.GetFontScale());
611 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetCaptionProperty_001 end";
612 }
613
614 /**
615 * @tc.number: AccessibleAbility_ManagerService_UnitTest_PackageAdd_001
616 * @tc.name: PackageAdd
617 * @tc.desc: Test function PackageAdd
618 */
619 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, PackageAdd_001, TestSize.Level1)
620 {
621 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_PackageAdd_001 start";
622
623 std::string bundleName = "bundleName1";
624 Singleton<AccessibleAbilityManagerService>::GetInstance().PackageAdd(bundleName);
625 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_PackageAdd_001 end";
626 }
627
628 /**
629 * @tc.number: AccessibleAbility_ManagerService_UnitTest_PackageRemoved_001
630 * @tc.name: PackageRemoved
631 * @tc.desc: Test function PackageRemoved
632 */
633 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, PackageRemoved_001, TestSize.Level1)
634 {
635 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_PackageRemoved_001 start";
636 std::string bundleName = "bundleName1";
637 Singleton<AccessibleAbilityManagerService>::GetInstance().PackageRemoved(bundleName);
638 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_PackageRemoved_001 end";
639 }
640
641 /**
642 * @tc.number: AccessibleAbility_ManagerService_UnitTest_AddedUser_001
643 * @tc.name: AddedUser
644 * @tc.desc: Test function AddedUser
645 */
646 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, AddedUser_001, TestSize.Level1)
647 {
648 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_AddedUser_001 start";
649 int32_t accountId = 1;
650 Singleton<AccessibleAbilityManagerService>::GetInstance().AddedUser(accountId);
651 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_AddedUser_001 end";
652 }
653
654 /**
655 * @tc.number: AccessibleAbility_ManagerService_UnitTest_EnableShortKeyTargetAbility_001
656 * @tc.name: EnableShortKeyTargetAbility
657 * @tc.desc: Test function EnableShortKeyTargetAbility
658 */
659 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, EnableShortKeyTargetAbility_001, TestSize.Level1)
660 {
661 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_EnableShortKeyTargetAbility_001 start";
662 EXPECT_FALSE(Singleton<AccessibleAbilityManagerService>::GetInstance().EnableShortKeyTargetAbility());
663 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_EnableShortKeyTargetAbility_001 end";
664 }
665
666 /**
667 * @tc.number: AccessibleAbility_ManagerService_UnitTest_DisableShortKeyTargetAbility_001
668 * @tc.name: DisableShortKeyTargetAbility
669 * @tc.desc: Test function DisableShortKeyTargetAbility
670 */
671 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, DisableShortKeyTargetAbility_001, TestSize.Level1)
672 {
673 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_DisableShortKeyTargetAbility_001 start";
674 EXPECT_FALSE(Singleton<AccessibleAbilityManagerService>::GetInstance().DisableShortKeyTargetAbility());
675 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_DisableShortKeyTargetAbility_001 end";
676 }
677
678 /**
679 * @tc.number: AccessibleAbility_ManagerService_UnitTest_EnableAbility_001
680 * @tc.name: EnableAbility
681 * @tc.desc: Test function EnableAbility
682 */
683 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, EnableAbility_001, TestSize.Level1)
684 {
685 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_EnableAbility_001 start";
686 std::string name = "test";
687 uint32_t capabilities = 1;
688 EXPECT_EQ(RET_ERR_NOT_INSTALLED,
689 Singleton<AccessibleAbilityManagerService>::GetInstance().EnableAbility(name, capabilities));
690 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_EnableAbility_001 end";
691 }
692
693 /*
694 * @tc.number: AccessibleAbility_ManagerService_UnitTest_DisableAbility_001
695 * @tc.name: DisableAbility
696 * @tc.desc: Test function DisableAbility
697 */
698 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, DisableAbility_001, TestSize.Level1)
699 {
700 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_DisableAbility_001 start";
701 std::string name = "test";
702 EXPECT_EQ(RET_ERR_NOT_ENABLED, Singleton<AccessibleAbilityManagerService>::GetInstance().DisableAbility(name));
703 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_DisableAbility_001 end";
704 }
705
706 /*
707 * @tc.number: AccessibleAbility_ManagerService_UnitTest_GetEnabledAbilities_001
708 * @tc.name: GetEnabledAbilities
709 * @tc.desc: Test function GetEnabledAbilities
710 */
711 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetEnabledAbilities_001, TestSize.Level1)
712 {
713 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_GetEnabledAbilities_001 start";
714 std::vector<std::string> enabledAbilities;
715 EXPECT_EQ(RET_OK,
716 Singleton<AccessibleAbilityManagerService>::GetInstance().GetEnabledAbilities(enabledAbilities));
717 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_GetEnabledAbilities_001 end";
718 }
719
720 /*
721 * @tc.number: AccessibleAbility_ManagerService_UnitTest_EnableUITestAbility_001
722 * @tc.name: EnableUITestAbility
723 * @tc.desc: Test function EnableUITestAbility
724 */
725 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, EnableUITestAbility_001, TestSize.Level1)
726 {
727 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_EnableUITestAbility_001 start";
728 sptr<IRemoteObject> obj;
729 EXPECT_EQ(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().EnableUITestAbility(obj));
730 GTEST_LOG_(INFO) << "Accessib le_Ability_Manager_ServiceUnittest_EnableUITestAbility_001 end";
731 }
732
733 /*
734 * @tc.number: AccessibleAbility_ManagerService_UnitTest_DisableUITestAbility_001
735 * @tc.name: DisableUITestAbility
736 * @tc.desc: Test function DisableUITestAbility
737 */
738 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, DisableUITestAbility_001, TestSize.Level1)
739 {
740 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_DisableUITestAbility_001 start";
741 EXPECT_EQ(RET_ERR_NO_CONNECTION, Singleton<AccessibleAbilityManagerService>::GetInstance().DisableUITestAbility());
742 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_DisableUITestAbility_001 end";
743 }
744
745 /**
746 * @tc.number: AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterCaptionObserver_001
747 * @tc.name: RegisterCaptionObserver
748 * @tc.desc: Test function RegisterCaptionObserver
749 */
750 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, RegisterCaptionObserver_001, TestSize.Level1)
751 {
752 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterCaptionObserver_001 start";
753
754 sptr<MockAccessibleAbilityManagerCaptionObserverStub> stub = new MockAccessibleAbilityManagerCaptionObserverStub();
755 sptr<IAccessibleAbilityManagerCaptionObserver> state = new MockAccessibleAbilityManagerCaptionObserverProxy(stub);
756
757 uint32_t ret = Singleton<AccessibleAbilityManagerService>::GetInstance().RegisterCaptionObserver(state);
758 EXPECT_EQ(ret, 0);
759
760 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterCaptionObserver_001 end";
761 }
762
763 /*
764 * @tc.number: AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterConfigObserver_001
765 * @tc.name: RegisterConfigObserver
766 * @tc.desc: Test function RegisterConfigObserver
767 */
768 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, RegisterConfigObserver_001, TestSize.Level1)
769 {
770 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterConfigObserver_001 start";
771
772 sptr<MockAccessibleAbilityManagerConfigObserverStub> stub = new MockAccessibleAbilityManagerConfigObserverStub();
773 sptr<IAccessibleAbilityManagerConfigObserver> state = new MockAccessibleAbilityManagerConfigObserverProxy(stub);
774
775 uint32_t ret = Singleton<AccessibleAbilityManagerService>::GetInstance().RegisterConfigObserver(state);
776 EXPECT_EQ(ret, 0);
777
778 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterConfigObserver_001 end";
779 }
780
781 /*
782 * @tc.number: AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterEnableAbilityListsObserver_001
783 * @tc.name: RegisterEnableAbilityListsObserver
784 * @tc.desc: Test function RegisterEnableAbilityListsObserver
785 */
786 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, RegisterEnableAbilityListsObserver_001, TestSize.Level1)
787 {
788 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterEnableAbilityListsObserver_001 start";
789
790 sptr<MockAccessibilityEnableAbilityListsObserverStub> stub = new MockAccessibilityEnableAbilityListsObserverStub();
791 sptr<IAccessibilityEnableAbilityListsObserver> state = new MockAccessibilityEnableAbilityListsObserverProxy(stub);
792
793 Singleton<AccessibleAbilityManagerService>::GetInstance().RegisterEnableAbilityListsObserver(state);
794
795 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterEnableAbilityListsObserver_001 end";
796 }
797
798 /**
799 * @tc.number: AccessibleAbility_ManagerService_UnitTest_SwitchedUser_001
800 * @tc.name: SwitchedUser
801 * @tc.desc: Test function SwitchedUser
802 */
803 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SwitchedUser_001, TestSize.Level1)
804 {
805 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_SwitchedUser_001 start";
806 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(2);
807
808 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_SwitchedUser_001 end";
809 }
810
811 /**
812 * @tc.number: AccessibleAbility_ManagerService_UnitTest_GetAbilityList_002
813 * @tc.name: GetAbilityList
814 * @tc.desc: Test function GetAbilityList
815 */
816 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetAbilityList_002, TestSize.Level1)
817 {
818 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetAbilityList_002 start";
819 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
820 std::vector<OHOS::Accessibility::AccessibilityAbilityInfo> infos;
821 Singleton<AccessibleAbilityManagerService>::GetInstance().GetAbilityList(0xFFFFFFFF, 3, infos);
822
823 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_GetAbilityList_002 end";
824 }
825
826 /**
827 * @tc.number: Accessible_Ability_ManagerService_UnitTest_RegisterElementOperator_002
828 * @tc.name: RegisterElementOperator
829 * @tc.desc: Test function RegisterElementOperator
830 */
831 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, RegisterElementOperator_002, TestSize.Level1)
832 {
833 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterElementOperator_002 start";
834 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
835 Singleton<AccessibleAbilityManagerService>::GetInstance().RegisterElementOperator(0, nullptr);
836 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterElementOperator_002 end";
837 }
838
839 /**
840 * @tc.number: AccessibleAbility_ManagerService_UnitTest_UpdateAccessibilityManagerService_001
841 * @tc.name: UpdateAccessibilityManagerService
842 * @tc.desc: Test function UpdateAccessibilityManagerService
843 */
844 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, UpdateAccessibilityManagerService_001, TestSize.Level1)
845 {
846 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_UpdateAccessibilityManagerService_001 start";
847 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
848 Singleton<AccessibleAbilityManagerService>::GetInstance().UpdateAccessibilityManagerService();
849 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_UpdateAccessibilityManagerService_001 end";
850 }
851
852 /**
853 * @tc.number: AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterStateCallback_002
854 * @tc.name: RegisterStateCallback
855 * @tc.desc: Test function RegisterStateCallback
856 */
857 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, RegisterStateCallback_002, TestSize.Level1)
858 {
859 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterStateCallback_00 start";
860 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
861 sptr<AccessibleAbilityManagerStateObserverStub> stub = new MockAccessibleAbilityManagerStateObserverStub();
862 sptr<IAccessibleAbilityManagerStateObserver> state = new MockAccessibleAbilityManagerStateObserverProxy(stub);
863
864 uint32_t ret = Singleton<AccessibleAbilityManagerService>::GetInstance().RegisterStateObserver(state);
865 EXPECT_EQ(ret, 0);
866
867 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterStateCallback_002 end";
868 }
869
870 /**
871 * @tc.number: AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterCaptionObserver_002
872 * @tc.name: RegisterCaptionObserver
873 * @tc.desc: Test function RegisterCaptionObserver
874 */
875 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, RegisterCaptionObserver_002, TestSize.Level1)
876 {
877 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterCaptionObserver_002 start";
878 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
879 sptr<MockAccessibleAbilityManagerCaptionObserverStub> stub = new MockAccessibleAbilityManagerCaptionObserverStub();
880 sptr<IAccessibleAbilityManagerCaptionObserver> state = new MockAccessibleAbilityManagerCaptionObserverProxy(stub);
881
882 uint32_t ret = Singleton<AccessibleAbilityManagerService>::GetInstance().RegisterCaptionObserver(state);
883 EXPECT_EQ(ret, ERR_INVALID_VALUE);
884
885 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterCaptionObserver_002 end";
886 }
887
888 /*
889 * @tc.number: AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterEnableAbilityListsObserver_002
890 * @tc.name: RegisterEnableAbilityListsObserver
891 * @tc.desc: Test function RegisterEnableAbilityListsObserver
892 */
893 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, RegisterEnableAbilityListsObserver_002, TestSize.Level1)
894 {
895 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterEnableAbilityListsObserver_002 start";
896 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
897 sptr<MockAccessibilityEnableAbilityListsObserverStub> stub = new MockAccessibilityEnableAbilityListsObserverStub();
898 sptr<IAccessibilityEnableAbilityListsObserver> state = new MockAccessibilityEnableAbilityListsObserverProxy(stub);
899
900 Singleton<AccessibleAbilityManagerService>::GetInstance().RegisterEnableAbilityListsObserver(state);
901
902 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterEnableAbilityListsObserver_002 end";
903 }
904
905
906 /**
907 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetCaptionProperty_002
908 * @tc.name: SetCaptionProperty
909 * @tc.desc: Test function SetCaptionProperty GetCaptionProperty
910 */
911 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetCaptionProperty_002, TestSize.Level1)
912 {
913 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetCaptionProperty_002 start";
914 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
915 AccessibilityConfig::CaptionProperty caption;
916 int scale = 1;
917 caption.SetFontScale(scale);
918 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetCaptionProperty(caption));
919 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetCaptionProperty(caption));
920 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetCaptionProperty_002 end";
921 }
922
923 /**
924 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetCaptionState_002
925 * @tc.name: SetCaptionState
926 * @tc.desc: Test function SetCaptionState GetCaptionState
927 */
928 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetCaptionState_002, TestSize.Level1)
929 {
930 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetCaptionState_002 start";
931 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
932 bool state = true;
933 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetCaptionState(state));
934 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetCaptionState(state));
935 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetCaptionState_002 end";
936 }
937
938 /**
939 * @tc.number: AccessibleAbilityManagerServiceUnitTest_GetTouchGuideState_002
940 * @tc.name: GetTouchGuideState
941 * @tc.desc: Test function GetTouchGuideState
942 */
943 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetTouchGuideState_002, TestSize.Level1)
944 {
945 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetTouchGuideState_002 start";
946 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
947 EXPECT_FALSE(Singleton<AccessibleAbilityManagerService>::GetInstance().GetTouchGuideState());
948 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetTouchGuideState_002 end";
949 }
950
951 /**
952 * @tc.number: AccessibleAbilityManagerServiceUnitTest_GetGestureState_002
953 * @tc.name: GetGestureState
954 * @tc.desc: Test function GetGestureState
955 */
956 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetGestureState_002, TestSize.Level1)
957 {
958 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetGestureState_002 start";
959 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
960 EXPECT_FALSE(Singleton<AccessibleAbilityManagerService>::GetInstance().GetGestureState());
961 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetGestureState_002 end";
962 }
963
964 /**
965 * @tc.number: AccessibleAbilityManagerServiceUnitTest_GetKeyEventObserverState_002
966 * @tc.name: GetKeyEventObserverState
967 * @tc.desc: Test function GetKeyEventObserverState
968 */
969 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetKeyEventObserverState_002, TestSize.Level1)
970 {
971 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetKeyEventObserverState_002 start";
972 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
973 EXPECT_FALSE(Singleton<AccessibleAbilityManagerService>::GetInstance().GetKeyEventObserverState());
974 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetKeyEventObserverState_002 end";
975 }
976
977 /**
978 * @tc.number: AccessibleAbility_ManagerService_UnitTest_EnableAbility_002
979 * @tc.name: EnableAbility
980 * @tc.desc: Test function EnableAbility
981 */
982 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, EnableAbility_002, TestSize.Level1)
983 {
984 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_EnableAbility_002 start";
985 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
986 std::string name = "test";
987 uint32_t capabilities = 1;
988 EXPECT_EQ(RET_ERR_NULLPTR,
989 Singleton<AccessibleAbilityManagerService>::GetInstance().EnableAbility(name, capabilities));
990 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_EnableAbility_002 end";
991 }
992
993 /*
994 * @tc.number: AccessibleAbility_ManagerService_UnitTest_GetEnabledAbilities_002
995 * @tc.name: GetEnabledAbilities
996 * @tc.desc: Test function GetEnabledAbilities
997 */
998 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetEnabledAbilities_002, TestSize.Level1)
999 {
1000 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_GetEnabledAbilities_002 start";
1001 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1002 std::vector<std::string> enabledAbilities;
1003 EXPECT_EQ(RET_ERR_NULLPTR,
1004 Singleton<AccessibleAbilityManagerService>::GetInstance().GetEnabledAbilities(enabledAbilities));
1005 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_GetEnabledAbilities_002 end";
1006 }
1007
1008 /*
1009 * @tc.number: AccessibleAbility_ManagerService_UnitTest_DisableAbility_002
1010 * @tc.name: DisableAbility
1011 * @tc.desc: Test function DisableAbility
1012 */
1013 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, DisableAbility_002, TestSize.Level1)
1014 {
1015 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_DisableAbility_002 start";
1016 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1017 std::string name = "test";
1018 EXPECT_EQ(RET_ERR_NULLPTR, Singleton<AccessibleAbilityManagerService>::GetInstance().DisableAbility(name));
1019 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_DisableAbility_002 end";
1020 }
1021
1022 /*
1023 * @tc.number: AccessibleAbility_ManagerService_UnitTest_EnableUITestAbility_002
1024 * @tc.name: EnableUITestAbility
1025 * @tc.desc: Test function EnableUITestAbility
1026 */
1027 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, EnableUITestAbility_002, TestSize.Level1)
1028 {
1029 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_EnableUITestAbility_002 start";
1030 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1031 sptr<IRemoteObject> obj;
1032 EXPECT_EQ(RET_ERR_NULLPTR, Singleton<AccessibleAbilityManagerService>::GetInstance().EnableUITestAbility(obj));
1033 GTEST_LOG_(INFO) << "Accessib le_Ability_Manager_ServiceUnittest_EnableUITestAbility_002 end";
1034 }
1035
1036 /*
1037 * @tc.number: AccessibleAbility_ManagerService_UnitTest_DisableUITestAbility_002
1038 * @tc.name: DisableUITestAbility
1039 * @tc.desc: Test function DisableUITestAbility
1040 */
1041 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, DisableUITestAbility_002, TestSize.Level1)
1042 {
1043 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_DisableUITestAbility_002 start";
1044 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1045 EXPECT_EQ(Singleton<AccessibleAbilityManagerService>::GetInstance().DisableUITestAbility(), RET_ERR_NULLPTR);
1046 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_DisableUITestAbility_002 end";
1047 }
1048
1049 /**
1050 * @tc.number: AccessibleAbility_ManagerService_UnitTest_EnableShortKeyTargetAbility_002
1051 * @tc.name: EnableShortKeyTargetAbility
1052 * @tc.desc: Test function EnableShortKeyTargetAbility
1053 */
1054 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, EnableShortKeyTargetAbility_002, TestSize.Level1)
1055 {
1056 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_EnableShortKeyTargetAbility_002 start";
1057 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1058 EXPECT_FALSE(Singleton<AccessibleAbilityManagerService>::GetInstance().EnableShortKeyTargetAbility());
1059 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_EnableShortKeyTargetAbility_002 end";
1060 }
1061
1062 /**
1063 * @tc.number: AccessibleAbility_ManagerService_UnitTest_DisableShortKeyTargetAbility_002
1064 * @tc.name: DisableShortKeyTargetAbility
1065 * @tc.desc: Test function DisableShortKeyTargetAbility
1066 */
1067 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, DisableShortKeyTargetAbility_002, TestSize.Level1)
1068 {
1069 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_DisableShortKeyTargetAbility_002 start";
1070 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1071 EXPECT_FALSE(Singleton<AccessibleAbilityManagerService>::GetInstance().DisableShortKeyTargetAbility());
1072 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_DisableShortKeyTargetAbility_002 end";
1073 }
1074
1075 /**
1076 * @tc.number: AccessibleAbility_ManagerService_UnitTest_PackageRemoved_002
1077 * @tc.name: PackageRemoved
1078 * @tc.desc: Test function PackageRemoved
1079 */
1080 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, PackageRemoved_002, TestSize.Level1)
1081 {
1082 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_PackageRemoved_002 start";
1083 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1084 std::string bundleName = "bundleName1";
1085 Singleton<AccessibleAbilityManagerService>::GetInstance().PackageRemoved(bundleName);
1086 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_PackageRemoved_002 end";
1087 }
1088
1089 /**
1090 * @tc.number: AccessibleAbility_ManagerService_UnitTest_PackageAdd_002
1091 * @tc.name: PackageAdd
1092 * @tc.desc: Test function PackageAdd
1093 */
1094 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, PackageAdd_002, TestSize.Level1)
1095 {
1096 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_PackageAdd_002 start";
1097 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1098 std::string bundleName = "bundleName1";
1099 Singleton<AccessibleAbilityManagerService>::GetInstance().PackageAdd(bundleName);
1100 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_PackageAdd_002 end";
1101 }
1102
1103 /*
1104 * @tc.number: AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterConfigObserver_002
1105 * @tc.name: RegisterConfigObserver
1106 * @tc.desc: Test function RegisterConfigObserver
1107 */
1108 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, RegisterConfigObserver_002, TestSize.Level1)
1109 {
1110 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterConfigObserver_002 start";
1111
1112 sptr<MockAccessibleAbilityManagerConfigObserverStub> stub = new MockAccessibleAbilityManagerConfigObserverStub();
1113 sptr<IAccessibleAbilityManagerConfigObserver> state = new MockAccessibleAbilityManagerConfigObserverProxy(stub);
1114 Singleton<AccessibleAbilityManagerService>::GetInstance().RegisterConfigObserver(state);
1115 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterConfigObserver_002 end";
1116 }
1117
1118 /**
1119 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetScreenMagnificationState_002
1120 * @tc.name: SetScreenMagnificationState
1121 * @tc.desc: Test function SetScreenMagnificationState GetScreenMagnificationState
1122 */
1123
1124 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetScreenMagnificationState_002, TestSize.Level1)
1125 {
1126 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetScreenMagnificationState_000 start";
1127 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1128 bool state = true;
1129 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetScreenMagnificationState(state));
1130 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetScreenMagnificationState(state));
1131 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetScreenMagnificationState_002 end";
1132 }
1133
1134 /**
1135 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetShortKeyState_002
1136 * @tc.name: SetShortKeyState
1137 * @tc.desc: Test function SetShortKeyState GetShortKeyState
1138 * @tc.require: issueI5NTXH
1139 */
1140 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetShortKeyState_002, TestSize.Level1)
1141 {
1142 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetShortKeyState_002 start";
1143 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1144 bool state = true;
1145 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetShortKeyState(state));
1146 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetShortKeyState(state));
1147 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetShortKeyState_002 end";
1148 }
1149
1150 /**
1151 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetMouseKeyState_002
1152 * @tc.name: SetMouseKeyState
1153 * @tc.desc: Test function SetMouseKeyState GetMouseKeyState
1154 * @tc.require: issueI5NTXA
1155 */
1156 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetMouseKeyState_002, TestSize.Level1)
1157 {
1158 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetMouseKeyState_002 start";
1159 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1160 bool state = true;
1161 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetMouseKeyState(state));
1162 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetMouseKeyState(state));
1163 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetMouseKeyState_002 end";
1164 }
1165
1166 /**
1167 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetMouseAutoClick_002
1168 * @tc.name: SetMouseAutoClick
1169 * @tc.desc: Test function SetMouseAutoClick GetMouseAutoClick
1170 * @tc.require: issueI5NTXC
1171 */
1172 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetMouseAutoClick_002, TestSize.Level1)
1173 {
1174 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetMouseAutoClick_002 start";
1175 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1176 int32_t value = MOUSE_AUTO_CLICK_VALUE;
1177 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetMouseAutoClick(value));
1178 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetMouseAutoClick(value));
1179 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetMouseAutoClick_002 end";
1180 }
1181
1182 /**
1183 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetShortkeyTarget_002
1184 * @tc.name: SetShortkeyTarget
1185 * @tc.desc: Test function SetShortkeyTarget GetShortkeyTarget
1186 * @tc.require: issueI5NTXH
1187 */
1188 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetShortkeyTarget_002, TestSize.Level1)
1189 {
1190 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetShortkeyTarget_002 start";
1191 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1192 std::string name = "test";
1193 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetShortkeyTarget(name));
1194 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetShortkeyTarget(name));
1195 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetShortkeyTarget_002 end";
1196 }
1197
1198 /**
1199 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetHighContrastTextState_002
1200 * @tc.name: SetHighContrastTextState
1201 * @tc.desc: Test function SetHighContrastTextState GetHighContrastTextState
1202 * @tc.require: issueI5NTX9
1203 */
1204 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetHighContrastTextState_002, TestSize.Level1)
1205 {
1206 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetHighContrastTextState_002 start";
1207 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1208 bool state = true;
1209 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetHighContrastTextState(state));
1210 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetHighContrastTextState(state));
1211 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetHighContrastTextState_002 end";
1212 }
1213
1214 /**
1215 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetInvertColorState_002
1216 * @tc.name: SetInvertColorState
1217 * @tc.desc: Test function SetInvertColorState GetInvertColorState
1218 * @tc.require: issueI5NTX7
1219 */
1220 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetInvertColorState_002, TestSize.Level1)
1221 {
1222 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetInvertColorState_002 start";
1223 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1224 bool state = true;
1225 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetInvertColorState(state));
1226 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetInvertColorState(state));
1227 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetInvertColorState_002 end";
1228 }
1229
1230 /**
1231 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetAnimationOffState_002
1232 * @tc.name: SetAnimationOffState
1233 * @tc.desc: Test function SetAnimationOffState GetAnimationOffState
1234 * @tc.require: issueI5NTXG
1235 */
1236 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetAnimationOffState_002, TestSize.Level1)
1237 {
1238 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetAnimationOffState_002 start";
1239 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1240 bool state = true;
1241 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetAnimationOffState(state));
1242 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetAnimationOffState(state));
1243 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetAnimationOffState_002 end";
1244 }
1245
1246 /**
1247 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetAudioMonoState_002
1248 * @tc.name: SetAudioMonoState
1249 * @tc.desc: Test function SetAudioMonoState GetAudioMonoState
1250 */
1251 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetAudioMonoState_002, TestSize.Level1)
1252 {
1253 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetAudioMonoState_002 start";
1254 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1255 bool state = true;
1256 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetAudioMonoState(state));
1257 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetAudioMonoState(state));
1258 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetAudioMonoState_002 end";
1259 }
1260
1261 /**
1262 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetDaltonizationColorFilter_002
1263 * @tc.name: SetDaltonizationColorFilter
1264 * @tc.desc: Test function SetDaltonizationColorFilter GetDaltonizationColorFilter
1265 * @tc.require: issueI5NTX8
1266 */
1267 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetDaltonizationColorFilter_002, TestSize.Level1)
1268 {
1269 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetDaltonizationColorFilter_002 start";
1270 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1271 uint32_t filter = 1;
1272 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetDaltonizationColorFilter(filter));
1273 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetDaltonizationColorFilter(filter));
1274 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetDaltonizationColorFilter_002 end";
1275 }
1276
1277 /**
1278 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetContentTimeout_002
1279 * @tc.name: SetContentTimeout
1280 * @tc.desc: Test function SetContentTimeout GetContentTimeout
1281 * @tc.require: issueI5NTXF
1282 */
1283 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetContentTimeout_002, TestSize.Level1)
1284 {
1285 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetContentTimeout_002 start";
1286 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1287 uint32_t time = CONTENT_TIMEOUT_VALUE;
1288 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetContentTimeout(time));
1289 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetContentTimeout(time));
1290 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetContentTimeout_002 end";
1291 }
1292
1293 /**
1294 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetBrightnessDiscount_002
1295 * @tc.name: SetBrightnessDiscount
1296 * @tc.desc: Test function SetBrightnessDiscount GetBrightnessDiscount
1297 * @tc.require: issueI5NTXE
1298 */
1299 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetBrightnessDiscount_002, TestSize.Level1)
1300 {
1301 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetBrightnessDiscount_002 start";
1302 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1303 float value = BRIGHTNESS_DISCOUNT_VALUE;
1304 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetBrightnessDiscount(value));
1305 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetBrightnessDiscount(value));
1306 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetBrightnessDiscount_002 end";
1307 }
1308
1309 /**
1310 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetAudioBalance_002
1311 * @tc.name: SetAudioBalance
1312 * @tc.desc: Test function SetAudioBalance GetAudioBalance
1313 */
1314 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetAudioBalance_002, TestSize.Level1)
1315 {
1316 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetAudioBalance_002 start";
1317 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1318 float value = AUDIO_BALANCE_VALUE;
1319 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetAudioBalance(value));
1320 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetAudioBalance(value));
1321 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetAudioBalance_002 end";
1322 }
1323
1324 /**
1325 * @tc.number: AccessibleAbilityManagerServiceUnitTest_GetAllConfigs_002
1326 * @tc.name: GetAllConfigs
1327 * @tc.desc: Test function GetAllConfigs
1328 */
1329 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetAllConfigs_002, TestSize.Level1)
1330 {
1331 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetAllConfigs_002 start";
1332 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1333 AccessibilityConfigData data;
1334 Singleton<AccessibleAbilityManagerService>::GetInstance().GetAllConfigs(data);
1335 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetAllConfigs_002 end";
1336 }
1337
1338 /**
1339 * @tc.number: AccessibleAbilityManagerServiceUnitTest_OnRemoveSystemAbility_001
1340 * @tc.name: OnRemoveSystemAbility
1341 * @tc.desc: Test function OnRemoveSystemAbility
1342 */
1343 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, OnRemoveSystemAbility_001, TestSize.Level1)
1344 {
1345 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_OnRemoveSystemAbility_001 start";
1346 int32_t systemAbilityId = 1;
1347 std::string deviceId = "test";
1348 auto &ins = Singleton<AccessibleAbilityManagerService>::GetInstance();
1349 ins.OnRemoveSystemAbility(systemAbilityId, deviceId);
1350 EXPECT_TRUE(ins.IsServiceReady());
1351 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_OnRemoveSystemAbility_001 end";
1352 }
1353
1354 /**
1355 * @tc.number: AccessibleAbilityManagerServiceUnitTest_OnRemoveSystemAbility_002
1356 * @tc.name: OnRemoveSystemAbility
1357 * @tc.desc: Test function OnRemoveSystemAbility
1358 */
1359 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, OnRemoveSystemAbility_002, TestSize.Level1)
1360 {
1361 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_OnRemoveSystemAbility_002 start";
1362 auto &ins = Singleton<AccessibleAbilityManagerService>::GetInstance();
1363 EXPECT_TRUE(ins.IsServiceReady());
1364 int32_t systemAbilityId = SUBSYS_ACCOUNT_SYS_ABILITY_ID_BEGIN;
1365 std::string deviceId = "test";
1366 ins.OnRemoveSystemAbility(systemAbilityId, deviceId);
__anon5483eb950202() 1367 AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([]() -> bool {
1368 if (Singleton<AccessibleAbilityManagerService>::GetInstance().IsServiceReady() == false) {
1369 return true;
1370 } else {
1371 return false;
1372 }
1373 }), SLEEP_TIME_1);
1374 EXPECT_FALSE(ins.IsServiceReady());
1375 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_OnRemoveSystemAbility_002 end";
1376 }
1377 } // namespace Accessibility
1378 } // namespace OHOS