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_event_info.h"
20 #include "accessibility_common_helper.h"
21 #include "accessibility_display_manager.h"
22 #include "accessibility_ut_helper.h"
23 #include "accessibility_window_manager.h"
24 #include "accessible_ability_manager_service.h"
25 #include "iservice_registry.h"
26 #include "mock_accessible_ability_client_stub_impl.h"
27 #include "mock_accessible_ability_manager_service_config_observer_proxy.h"
28 #include "mock_accessible_ability_manager_service_config_observer_stub.h"
29 #include "mock_accessible_ability_manager_service_state_observer_proxy.h"
30 #include "mock_accessible_ability_manager_service_state_observer_stub.h"
31 #include "mock_bundle_manager.h"
32 #include "system_ability_definition.h"
33
34 using namespace testing;
35 using namespace testing::ext;
36
37 namespace OHOS {
38 namespace Accessibility {
39 namespace {
40 constexpr uint32_t SLEEP_TIME_1 = 1;
41 constexpr uint32_t CONTENT_TIMEOUT_VALUE = 10;
42 constexpr int32_t MOUSE_AUTO_CLICK_VALUE = 3;
43 constexpr float BRIGHTNESS_DISCOUNT_VALUE = 0.1f;
44 constexpr float AUDIO_BALANCE_VALUE = 0.1f;
45 constexpr int32_t ACTIVE_WINDOW_VALUE = 2;
46 } // namespace
47
48 class AccessibleAbilityManagerServiceUnitTest : public ::testing::Test {
49 public:
AccessibleAbilityManagerServiceUnitTest()50 AccessibleAbilityManagerServiceUnitTest()
51 {}
~AccessibleAbilityManagerServiceUnitTest()52 ~AccessibleAbilityManagerServiceUnitTest()
53 {}
54
55 static void SetUpTestCase();
56 static void TearDownTestCase();
57 void SetUp() override;
58 void TearDown() override;
59
60 sptr<AccessibleAbilityClientStub> stub_ = nullptr;
61 void RegisterAbilityConnectionClient(const sptr<IRemoteObject>& obj);
62 };
63
SetUpTestCase()64 void AccessibleAbilityManagerServiceUnitTest::SetUpTestCase()
65 {
66 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest SetUpTestCase";
67 Singleton<AccessibleAbilityManagerService>::GetInstance().OnStart();
68 AccessibilityCommonHelper::GetInstance().WaitForServicePublish();
69 }
70
TearDownTestCase()71 void AccessibleAbilityManagerServiceUnitTest::TearDownTestCase()
72 {
73 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest TearDownTestCase";
74 Singleton<AccessibleAbilityManagerService>::GetInstance().OnStop();
75 AccessibilityCommonHelper::GetInstance().SetIsServicePublished(false);
76 }
77
SetUp()78 void AccessibleAbilityManagerServiceUnitTest::SetUp()
79 {
80 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest SetUp";
81 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(AccessibilityAbilityHelper::accountId_);
82 stub_ = new MockAccessibleAbilityClientStubImpl();
83 }
84
TearDown()85 void AccessibleAbilityManagerServiceUnitTest::TearDown()
86 {
87 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest TearDown";
88 stub_ = nullptr;
89 }
90
RegisterAbilityConnectionClient(const sptr<IRemoteObject> & obj)91 void AccessibleAbilityManagerServiceUnitTest::RegisterAbilityConnectionClient(const sptr<IRemoteObject>& obj)
92 {
93 // add an ability connection client
94 AccessibilityAbilityInitParams initParams;
95 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
96 AppExecFwk::ElementName elementName("deviceId", "bundleName", "name");
97 auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
98 if (!accountData) {
99 GTEST_LOG_(INFO) << "current account data is null";
100 return;
101 }
102 accountData->AddInstalledAbility(*abilityInfo);
103 sptr<AccessibleAbilityConnection> connection =
104 new AccessibleAbilityConnection(accountData->GetAccountId(), 0, *abilityInfo);
105 connection->OnAbilityConnectDoneSync(elementName, obj);
106 sleep(SLEEP_TIME_1);
107 EXPECT_NE(abilityInfo.get(), nullptr);
108 }
109
110 /**
111 * @tc.number: AccessibleAbilityManagerServiceUnitTest_GetInstance_001
112 * @tc.name: GetInstance
113 * @tc.desc: Test function GetInstance
114 */
115 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetInstance_001, TestSize.Level1)
116 {
117 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_GetInstance_001 start";
118
119 auto ins = &Singleton<AccessibleAbilityManagerService>::GetInstance();
120 EXPECT_TRUE(ins);
121
122 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_GetInstance_001 end";
123 }
124
125 /**
126 * @tc.number: AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterStateCallback_001
127 * @tc.name: RegisterStateCallback
128 * @tc.desc: Test function RegisterStateCallback
129 */
130 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, RegisterStateCallback_001, TestSize.Level1)
131 {
132 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterStateCallback_001 start";
133
134 sptr<AccessibleAbilityManagerStateObserverStub> stub = new MockAccessibleAbilityManagerStateObserverStub();
135 sptr<IAccessibleAbilityManagerStateObserver> state = new MockAccessibleAbilityManagerStateObserverProxy(stub);
136
137 uint32_t ret = Singleton<AccessibleAbilityManagerService>::GetInstance().RegisterStateObserver(state);
138 EXPECT_EQ(ret, 0);
139
140 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterStateCallback_001 end";
141 }
142
143 /**
144 * @tc.number: AccessibleAbility_ManagerService_UnitTest_GetAbilityList_001
145 * @tc.name: GetAbilityList
146 * @tc.desc: Test function GetAbilityList
147 */
148 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetAbilityList_001, TestSize.Level1)
149 {
150 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetAbilityList_001 start";
151 std::vector<OHOS::Accessibility::AccessibilityAbilityInfo> infos;
152 Singleton<AccessibleAbilityManagerService>::GetInstance().GetAbilityList(
153 ACCESSIBILITY_ABILITY_TYPE_ALL, ABILITY_STATE_ENABLE, infos);
154 EXPECT_EQ(infos.size(), 0);
155
156 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_GetAbilityList_001 end";
157 }
158
159 /**
160 * @tc.number: Accessible_Ability_ManagerService_UnitTest_RegisterElementOperator_001
161 * @tc.name: RegisterElementOperator
162 * @tc.desc: Test function RegisterElementOperator
163 */
164 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, RegisterElementOperator_001, TestSize.Level1)
165 {
166 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterElementOperator_001 start";
167 auto &aams = Singleton<AccessibleAbilityManagerService>::GetInstance();
168 auto accountData = aams.GetCurrentAccountData();
169 ASSERT_TRUE(accountData);
170 auto map = accountData->GetAsacConnections();
171 EXPECT_EQ(int(map.size()), 0);
172 EXPECT_EQ(RET_OK, aams.RegisterElementOperator(0, nullptr));
173 sleep(SLEEP_TIME_1);
174 GTEST_LOG_(INFO) << "RegisterElementOperator OK";
175 map = accountData->GetAsacConnections();
176 EXPECT_EQ(int(map.size()), 1);
177
178 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterElementOperator_001 end";
179 }
180
181 /**
182 * @tc.number: AccessibleAbility_ManagerService_UnitTest_DeregisterElementOperator_001
183 * @tc.name: DeregisterElementOperator
184 * @tc.desc: Test function DeregisterElementOperator
185 */
186 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, DeregisterElementOperator_001, TestSize.Level1)
187 {
188 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_DeregisterElementOperator_001 start";
189 auto &aams = Singleton<AccessibleAbilityManagerService>::GetInstance();
190 auto accountData = aams.GetCurrentAccountData();
191 ASSERT_TRUE(accountData);
192 EXPECT_EQ(RET_OK, aams.DeregisterElementOperator(0));
193 sleep(SLEEP_TIME_1);
194 auto map = accountData->GetAsacConnections();
195 EXPECT_EQ(int(map.size()), 0);
196
197 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_DeregisterElementOperator_001 end";
198 }
199
200 /**
201 * @tc.number: AccessibleAbility_ManagerService_UnitTest_DeregisterElementOperator_002
202 * @tc.name: DeregisterElementOperator
203 * @tc.desc: Test function DeregisterElementOperator
204 */
205 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, DeregisterElementOperator_002, TestSize.Level1)
206 {
207 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_DeregisterElementOperator_002 start";
208 auto &aams = Singleton<AccessibleAbilityManagerService>::GetInstance();
209 auto accountData = aams.GetCurrentAccountData();
210 ASSERT_TRUE(accountData);
211 EXPECT_EQ(RET_OK, aams.RegisterElementOperator(0, nullptr));
212 sleep(SLEEP_TIME_1);
213 EXPECT_EQ(RET_OK, aams.DeregisterElementOperator(0));
214 sleep(SLEEP_TIME_1);
215 auto map = accountData->GetAsacConnections();
216 EXPECT_EQ(int(map.size()), 0);
217
218 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_DeregisterElementOperator_002 end";
219 }
220
221
222 /**
223 * @tc.number: AccessibleAbility_ManagerService_UnitTest_SetTouchEventInjector_001
224 * @tc.name: SetTouchEventInjector
225 * @tc.desc: Test function SetTouchEventInjector
226 */
227 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetTouchEventInjector_001, TestSize.Level1)
228 {
229 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTouchEventInjector_001 start";
230 sptr<TouchEventInjector> touchEventInjector = new TouchEventInjector();
231 sleep(SLEEP_TIME_1);
232 Singleton<AccessibleAbilityManagerService>::GetInstance().SetTouchEventInjector(touchEventInjector);
233 auto ret = Singleton<AccessibleAbilityManagerService>::GetInstance().GetTouchEventInjector();
234 EXPECT_TRUE(ret);
235 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTouchEventInjector_001 end";
236 }
237
238 /**
239 * @tc.number: AccessibleAbility_ManagerService_UnitTest_SetKeyEventFilter_001
240 * @tc.name: SetKeyEventFilter
241 * @tc.desc: Test function SetKeyEventFilter
242 */
243 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetKeyEventFilter_001, TestSize.Level1)
244 {
245 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetKeyEventFilter_001 start";
246 sptr<KeyEventFilter> keyEventFilter = new KeyEventFilter();
247 Singleton<AccessibleAbilityManagerService>::GetInstance().SetKeyEventFilter(keyEventFilter);
248 auto ret = Singleton<AccessibleAbilityManagerService>::GetInstance().GetKeyEventFilter();
249 EXPECT_TRUE(ret);
250 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetKeyEventFilter_001 end";
251 }
252
253 /**
254 * @tc.number: AccessibleAbility_ManagerService_UnitTest_RemovedUser_001
255 * @tc.name: RemovedUser
256 * @tc.desc: Test function RemovedUser
257 */
258 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, RemovedUser_001, TestSize.Level1)
259 {
260 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_RemovedUser_001 start";
261 RegisterAbilityConnectionClient(stub_);
262 auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
263 ASSERT_TRUE(accountData);
264 EXPECT_EQ(int(accountData->GetConnectedA11yAbilities().size()), 1);
265 Singleton<AccessibleAbilityManagerService>::GetInstance().RemovedUser(1);
266 // can't to check a11yAccountsData_ because it is private,and don't provite api.
267 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_RemovedUser_001 end";
268 }
269
270 /**
271 * @tc.number: AccessibleAbility_ManagerService_UnitTest_RemovedUser_002
272 * @tc.name: RemovedUser
273 * @tc.desc: Test function RemovedUser
274 */
275 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, RemovedUser_002, TestSize.Level1)
276 {
277 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_RemovedUser_002 start";
278 Singleton<AccessibleAbilityManagerService>::GetInstance().AddedUser(1);
279 sleep(SLEEP_TIME_1);
280 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(1);
281 sleep(SLEEP_TIME_1);
282 auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
283 ASSERT_EQ(accountData->GetAccountId(), 1);
284 Singleton<AccessibleAbilityManagerService>::GetInstance().RemovedUser(1);
285 // can't to check a11yAccountsData_ because it is private,and don't provite api.
286 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_RemovedUser_002 end";
287 }
288
289 /**
290 * @tc.number: AccessibleAbility_ManagerService_UnitTest_GetBundleMgrProxy_001
291 * @tc.name: GetBundleMgrProxy
292 * @tc.desc: Test function GetBundleMgrProxy
293 */
294 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetBundleMgrProxy_001, TestSize.Level1)
295 {
296 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_GetBundleMgrProxy_001 start";
297 auto ret = Singleton<AccessibleAbilityManagerService>::GetInstance().GetBundleMgrProxy();
298 EXPECT_TRUE(ret);
299 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_GetBundleMgrProxyr_001 end";
300 }
301
302 /**
303 * @tc.number: AccessibleAbility_ManagerService_UnitTest_PackageChanged_001
304 * @tc.name: PackageChanged
305 * @tc.desc: Test function PackageChanged
306 */
307 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, PackageChanged_001, TestSize.Level1)
308 {
309 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_PackageChanged_001 start";
310 auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
311 ASSERT_TRUE(accountData);
312 accountData->ClearInstalledAbility();
313 /* install ability is null */
314 GTEST_LOG_(INFO) << "GetInstalledAbilities start";
315 EXPECT_EQ(0, int(accountData->GetInstalledAbilities().size()));
316 GTEST_LOG_(INFO) << "PackageChanged start";
317 std::string bundleName = "bundleName1";
318 Singleton<AccessibleAbilityManagerService>::GetInstance().PackageChanged(bundleName);
319 GTEST_LOG_(INFO) << "PackageChanged end";
320 EXPECT_EQ(0, int(accountData->GetInstalledAbilities().size()));
321 GTEST_LOG_(INFO) << "GetInstalledAbilities end";
322 /* add install ability */
323 sleep(SLEEP_TIME_1);
324 RegisterAbilityConnectionClient(stub_);
325 sleep(SLEEP_TIME_1);
326 EXPECT_EQ(1, int(accountData->GetInstalledAbilities().size()));
327 bundleName = "bundleName2";
328 Singleton<AccessibleAbilityManagerService>::GetInstance().PackageChanged(bundleName);
329 sleep(SLEEP_TIME_1);
330 EXPECT_EQ(1, int(accountData->GetInstalledAbilities().size()));
331 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_PackageChanged_001 end";
332 }
333
334 /**
335 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetScreenMagnificationState_001
336 * @tc.name: SetScreenMagnificationState
337 * @tc.desc: Test function SetScreenMagnificationState GetScreenMagnificationState
338 */
339 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetScreenMagnificationState_001, TestSize.Level1)
340 {
341 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetScreenMagnificationState_001 start";
342 bool state = true;
343 bool ret = false;
344 EXPECT_EQ(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetScreenMagnificationState(state));
345 EXPECT_EQ(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetScreenMagnificationState(ret));
346 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetScreenMagnificationState_001 end";
347 }
348
349 /**
350 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetShortKeyState_001
351 * @tc.name: SetShortKeyState
352 * @tc.desc: Test function SetShortKeyState GetShortKeyState
353 * @tc.require: issueI5NTXH
354 */
355 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetShortKeyState_001, TestSize.Level1)
356 {
357 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetShortKeyState_001 start";
358 bool state = true;
359 bool ret = false;
360 EXPECT_EQ(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetShortKeyState(state));
361 EXPECT_EQ(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetShortKeyState(ret));
362 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetShortKeyState_001 end";
363 }
364
365 /**
366 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetMouseKeyState_001
367 * @tc.name: SetMouseKeyState
368 * @tc.desc: Test function SetMouseKeyState GetMouseKeyState
369 * @tc.require: issueI5NTXA
370 */
371 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetMouseKeyState_001, TestSize.Level1)
372 {
373 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetMouseKeyState_001 start";
374 bool state = true;
375 bool ret = false;
376 EXPECT_EQ(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetMouseKeyState(state));
377 EXPECT_EQ(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetMouseKeyState(ret));
378 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetMouseKeyState_001 end";
379 }
380
381 /**
382 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetMouseAutoClick_001
383 * @tc.name: SetMouseAutoClick
384 * @tc.desc: Test function SetMouseAutoClick GetMouseAutoClick
385 * @tc.require: issueI5NTXC
386 */
387 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetMouseAutoClick_001, TestSize.Level1)
388 {
389 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetMouseAutoClick_001 start";
390 int32_t ret = 0;
391 int32_t value = MOUSE_AUTO_CLICK_VALUE;
392 EXPECT_EQ(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetMouseAutoClick(value));
393 EXPECT_EQ(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetMouseAutoClick(ret));
394 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetMouseAutoClick_001 end";
395 }
396
397 /**
398 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetShortkeyTarget_001
399 * @tc.name: SetShortkeyTarget
400 * @tc.desc: Test function SetShortkeyTarget GetShortkeyTarget
401 * @tc.require: issueI5NTXH
402 */
403 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetShortkeyTarget_001, TestSize.Level1)
404 {
405 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetShortkeyTarget_001 start";
406 std::string name = "test";
407 std::string ret = "";
408 EXPECT_EQ(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetShortkeyTarget(name));
409 EXPECT_EQ(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetShortkeyTarget(ret));
410 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetShortkeyTarget_001 end";
411 }
412
413 /**
414 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetHighContrastTextState_001
415 * @tc.name: SetHighContrastTextState
416 * @tc.desc: Test function SetHighContrastTextState GetHighContrastTextState
417 * @tc.require: issueI5NTX9
418 */
419 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetHighContrastTextState_001, TestSize.Level1)
420 {
421 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetHighContrastTextState_001 start";
422 bool state = true;
423 bool ret = false;
424 EXPECT_EQ(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetHighContrastTextState(state));
425 EXPECT_EQ(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetHighContrastTextState(ret));
426 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetHighContrastTextState_001 end";
427 }
428
429 /**
430 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetInvertColorState_001
431 * @tc.name: SetInvertColorState
432 * @tc.desc: Test function SetInvertColorState GetInvertColorState
433 * @tc.require: issueI5NTX7
434 */
435 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetInvertColorState_001, TestSize.Level1)
436 {
437 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetInvertColorState_001 start";
438 bool state = true;
439 bool ret = false;
440 EXPECT_EQ(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetInvertColorState(state));
441 EXPECT_EQ(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetInvertColorState(ret));
442 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetInvertColorState_001 end";
443 }
444
445 /**
446 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetAnimationOffState_001
447 * @tc.name: SetAnimationOffState
448 * @tc.desc: Test function SetAnimationOffState GetAnimationOffState
449 * @tc.require: issueI5NTXG
450 */
451 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetAnimationOffState_001, TestSize.Level1)
452 {
453 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetAnimationOffState_001 start";
454 bool state = true;
455 bool ret = false;
456 EXPECT_EQ(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetAnimationOffState(state));
457 EXPECT_EQ(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetAnimationOffState(ret));
458 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetAnimationOffState_001 end";
459 }
460
461 /**
462 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetAudioMonoState_001
463 * @tc.name: SetAudioMonoState
464 * @tc.desc: Test function SetAudioMonoState GetAudioMonoState
465 */
466 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetAudioMonoState_001, TestSize.Level1)
467 {
468 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetAudioMonoState_001 start";
469 bool state = true;
470 bool ret = false;
471 EXPECT_EQ(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetAudioMonoState(state));
472 EXPECT_EQ(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetAudioMonoState(ret));
473 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetAudioMonoState_001 end";
474 }
475
476 /**
477 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetDaltonizationColorFilter_001
478 * @tc.name: SetDaltonizationColorFilter
479 * @tc.desc: Test function SetDaltonizationColorFilter GetDaltonizationColorFilter
480 * @tc.require: issueI5NTX8
481 */
482 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetDaltonizationColorFilter_001, TestSize.Level1)
483 {
484 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetDaltonizationColorFilter_001 start";
485 uint32_t filter = 1;
486 EXPECT_EQ(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetDaltonizationColorFilter(filter));
487 uint32_t ret = 0;
488 EXPECT_EQ(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetDaltonizationColorFilter(ret));
489 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetDaltonizationColorFilter_001 end";
490 }
491
492 /**
493 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetContentTimeout_001
494 * @tc.name: SetContentTimeout
495 * @tc.desc: Test function SetContentTimeout GetContentTimeout
496 * @tc.require: issueI5NTXF
497 */
498 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetContentTimeout_001, TestSize.Level1)
499 {
500 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetContentTimeout_001 start";
501 uint32_t value = CONTENT_TIMEOUT_VALUE;
502 EXPECT_EQ(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetContentTimeout(value));
503 uint32_t ret = 0;
504 EXPECT_EQ(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetContentTimeout(ret));
505 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetContentTimeout_001 end";
506 }
507
508 /**
509 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetBrightnessDiscount_001
510 * @tc.name: SetBrightnessDiscount
511 * @tc.desc: Test function SetBrightnessDiscount GetBrightnessDiscount
512 * @tc.require: issueI5NTXE
513 */
514 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetBrightnessDiscount_001, TestSize.Level1)
515 {
516 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetBrightnessDiscount_001 start";
517 float value = BRIGHTNESS_DISCOUNT_VALUE;
518 RetError result = Singleton<AccessibleAbilityManagerService>::GetInstance().SetBrightnessDiscount(value);
519 EXPECT_EQ(RET_OK, result);
520 float ret = 0;
521 EXPECT_EQ(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetBrightnessDiscount(ret));
522 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetBrightnessDiscount_001 end";
523 }
524
525 /**
526 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetAudioBalance_001
527 * @tc.name: SetAudioBalance
528 * @tc.desc: Test function SetAudioBalance GetAudioBalance
529 */
530 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetAudioBalance_001, TestSize.Level1)
531 {
532 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetAudioBalance_001 start";
533 EXPECT_EQ(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetAudioBalance(AUDIO_BALANCE_VALUE));
534 float ret = 0;
535 EXPECT_EQ(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetAudioBalance(ret));
536 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetAudioBalance_001 end";
537 }
538
539 /**
540 * @tc.number: AccessibleAbilityManagerServiceUnitTest_GetAllConfigs_001
541 * @tc.name: GetAllConfigs
542 * @tc.desc: Test function GetAllConfigs
543 */
544 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetAllConfigs_001, TestSize.Level1)
545 {
546 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetAllConfigs_001 start";
547 AccessibilityConfigData data;
548 Singleton<AccessibleAbilityManagerService>::GetInstance().GetAllConfigs(data);
549 EXPECT_NE(stub_.GetRefPtr(), nullptr);
550 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetAllConfigs_001 end";
551 }
552
553 /**
554 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetCaptionState_001
555 * @tc.name: SetCaptionState
556 * @tc.desc: Test function SetCaptionState GetCaptionState
557 */
558 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetCaptionState_001, TestSize.Level1)
559 {
560 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetCaptionState_001 start";
561 bool state = true;
562 EXPECT_EQ(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetCaptionState(state));
563 bool ret = false;
564 EXPECT_EQ(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetCaptionState(ret));
565 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetCaptionState_001 end";
566 }
567
568 /**
569 * @tc.number: AccessibleAbilityManagerServiceUnitTest_GetEnabledState_001
570 * @tc.name: GetEnabledState
571 * @tc.desc: Test function GetEnabledState
572 */
573 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetEnabledState_001, TestSize.Level1)
574 {
575 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetEnabledState_001 start";
576 EXPECT_TRUE(Singleton<AccessibleAbilityManagerService>::GetInstance().GetEnabledState());
577 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetEnabledState_001 end";
578 }
579
580 /**
581 * @tc.number: AccessibleAbilityManagerServiceUnitTest_GetTouchGuideState_001
582 * @tc.name: GetTouchGuideState
583 * @tc.desc: Test function GetTouchGuideState
584 */
585 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetTouchGuideState_001, TestSize.Level1)
586 {
587 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetTouchGuideState_001 start";
588 EXPECT_FALSE(Singleton<AccessibleAbilityManagerService>::GetInstance().GetTouchGuideState());
589 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetTouchGuideState_001 end";
590 }
591
592 /**
593 * @tc.number: AccessibleAbilityManagerServiceUnitTest_GetGestureState_001
594 * @tc.name: GetGestureState
595 * @tc.desc: Test function GetGestureState
596 */
597 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetGestureState_001, TestSize.Level1)
598 {
599 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetGestureState_001 start";
600 EXPECT_FALSE(Singleton<AccessibleAbilityManagerService>::GetInstance().GetGestureState());
601 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetGestureState_001 end";
602 }
603
604 /**
605 * @tc.number: AccessibleAbilityManagerServiceUnitTest_GetKeyEventObserverState_001
606 * @tc.name: GetKeyEventObserverState
607 * @tc.desc: Test function GetKeyEventObserverState
608 */
609 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetKeyEventObserverState_001, TestSize.Level1)
610 {
611 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetKeyEventObserverState_001 start";
612 EXPECT_FALSE(Singleton<AccessibleAbilityManagerService>::GetInstance().GetKeyEventObserverState());
613 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetKeyEventObserverState_001 end";
614 }
615
616 /**
617 * @tc.number: AccessibleAbilityManagerServiceUnitTest_GetActiveWindow_001
618 * @tc.name: GetActiveWindow
619 * @tc.desc: Test function GetActiveWindow
620 */
621 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetActiveWindow_001, TestSize.Level1)
622 {
623 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetActiveWindow_001 start";
624 Singleton<AccessibilityWindowManager>::GetInstance().SetActiveWindow(ACTIVE_WINDOW_VALUE);
625 EXPECT_EQ(ACTIVE_WINDOW_VALUE, Singleton<AccessibleAbilityManagerService>::GetInstance().GetActiveWindow());
626 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetActiveWindow_001 end";
627 }
628
629 /**
630 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetCaptionProperty_001
631 * @tc.name: SetCaptionProperty
632 * @tc.desc: Test function SetCaptionProperty GetCaptionProperty
633 */
634 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetCaptionProperty_001, TestSize.Level1)
635 {
636 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetCaptionProperty_001 start";
637 AccessibilityConfig::CaptionProperty caption;
638 int scale = 1;
639 caption.SetFontScale(scale);
640 EXPECT_EQ(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetCaptionProperty(caption));
641
642 AccessibilityConfig::CaptionProperty res;
643 EXPECT_EQ(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetCaptionProperty(res));
644 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetCaptionProperty_001 end";
645 }
646
647 /**
648 * @tc.number: AccessibleAbility_ManagerService_UnitTest_PackageAdd_001
649 * @tc.name: PackageAdd
650 * @tc.desc: Test function PackageAdd
651 */
652 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, PackageAdd_001, TestSize.Level1)
653 {
654 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_PackageAdd_001 start";
655
656 std::string bundleName = "bundleName1";
657 Singleton<AccessibleAbilityManagerService>::GetInstance().PackageAdd(bundleName);
658 EXPECT_NE(stub_.GetRefPtr(), nullptr);
659 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_PackageAdd_001 end";
660 }
661
662 /**
663 * @tc.number: AccessibleAbility_ManagerService_UnitTest_PackageRemoved_001
664 * @tc.name: PackageRemoved
665 * @tc.desc: Test function PackageRemoved
666 */
667 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, PackageRemoved_001, TestSize.Level1)
668 {
669 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_PackageRemoved_001 start";
670 std::string bundleName = "bundleName1";
671 Singleton<AccessibleAbilityManagerService>::GetInstance().PackageRemoved(bundleName);
672 EXPECT_NE(stub_.GetRefPtr(), nullptr);
673 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_PackageRemoved_001 end";
674 }
675
676 /**
677 * @tc.number: AccessibleAbility_ManagerService_UnitTest_AddedUser_001
678 * @tc.name: AddedUser
679 * @tc.desc: Test function AddedUser
680 */
681 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, AddedUser_001, TestSize.Level1)
682 {
683 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_AddedUser_001 start";
684 int32_t accountId = 1;
685 Singleton<AccessibleAbilityManagerService>::GetInstance().AddedUser(accountId);
686 EXPECT_NE(stub_.GetRefPtr(), nullptr);
687 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_AddedUser_001 end";
688 }
689
690 /**
691 * @tc.number: AccessibleAbility_ManagerService_UnitTest_EnableShortKeyTargetAbility_001
692 * @tc.name: EnableShortKeyTargetAbility
693 * @tc.desc: Test function EnableShortKeyTargetAbility
694 */
695 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, EnableShortKeyTargetAbility_001, TestSize.Level1)
696 {
697 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_EnableShortKeyTargetAbility_001 start";
698 EXPECT_FALSE(Singleton<AccessibleAbilityManagerService>::GetInstance().EnableShortKeyTargetAbility());
699 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_EnableShortKeyTargetAbility_001 end";
700 }
701
702 /**
703 * @tc.number: AccessibleAbility_ManagerService_UnitTest_DisableShortKeyTargetAbility_001
704 * @tc.name: DisableShortKeyTargetAbility
705 * @tc.desc: Test function DisableShortKeyTargetAbility
706 */
707 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, DisableShortKeyTargetAbility_001, TestSize.Level1)
708 {
709 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_DisableShortKeyTargetAbility_001 start";
710 EXPECT_FALSE(Singleton<AccessibleAbilityManagerService>::GetInstance().DisableShortKeyTargetAbility());
711 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_DisableShortKeyTargetAbility_001 end";
712 }
713
714 /**
715 * @tc.number: AccessibleAbility_ManagerService_UnitTest_EnableAbility_001
716 * @tc.name: EnableAbility
717 * @tc.desc: Test function EnableAbility
718 */
719 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, EnableAbility_001, TestSize.Level1)
720 {
721 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_EnableAbility_001 start";
722 std::string name = "test";
723 uint32_t capabilities = 1;
724 EXPECT_EQ(RET_ERR_NOT_INSTALLED,
725 Singleton<AccessibleAbilityManagerService>::GetInstance().EnableAbility(name, capabilities));
726 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_EnableAbility_001 end";
727 }
728
729 /*
730 * @tc.number: AccessibleAbility_ManagerService_UnitTest_DisableAbility_001
731 * @tc.name: DisableAbility
732 * @tc.desc: Test function DisableAbility
733 */
734 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, DisableAbility_001, TestSize.Level1)
735 {
736 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_DisableAbility_001 start";
737 std::string name = "test";
738 EXPECT_EQ(RET_ERR_NOT_ENABLED, Singleton<AccessibleAbilityManagerService>::GetInstance().DisableAbility(name));
739 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_DisableAbility_001 end";
740 }
741
742 /*
743 * @tc.number: AccessibleAbility_ManagerService_UnitTest_GetEnabledAbilities_001
744 * @tc.name: GetEnabledAbilities
745 * @tc.desc: Test function GetEnabledAbilities
746 */
747 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetEnabledAbilities_001, TestSize.Level1)
748 {
749 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_GetEnabledAbilities_001 start";
750 std::vector<std::string> enabledAbilities;
751 EXPECT_EQ(RET_OK,
752 Singleton<AccessibleAbilityManagerService>::GetInstance().GetEnabledAbilities(enabledAbilities));
753 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_GetEnabledAbilities_001 end";
754 }
755
756 /*
757 * @tc.number: AccessibleAbility_ManagerService_UnitTest_EnableUITestAbility_001
758 * @tc.name: EnableUITestAbility
759 * @tc.desc: Test function EnableUITestAbility
760 */
761 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, EnableUITestAbility_001, TestSize.Level1)
762 {
763 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_EnableUITestAbility_001 start";
764 sptr<IRemoteObject> obj;
765 EXPECT_EQ(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().EnableUITestAbility(obj));
766 GTEST_LOG_(INFO) << "Accessib le_Ability_Manager_ServiceUnittest_EnableUITestAbility_001 end";
767 }
768
769 /*
770 * @tc.number: AccessibleAbility_ManagerService_UnitTest_DisableUITestAbility_001
771 * @tc.name: DisableUITestAbility
772 * @tc.desc: Test function DisableUITestAbility
773 */
774 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, DisableUITestAbility_001, TestSize.Level1)
775 {
776 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_DisableUITestAbility_001 start";
777 EXPECT_EQ(RET_ERR_NO_CONNECTION, Singleton<AccessibleAbilityManagerService>::GetInstance().DisableUITestAbility());
778 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_DisableUITestAbility_001 end";
779 }
780
781 /**
782 * @tc.number: AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterCaptionObserver_001
783 * @tc.name: RegisterCaptionObserver
784 * @tc.desc: Test function RegisterCaptionObserver
785 */
786 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, RegisterCaptionObserver_001, TestSize.Level1)
787 {
788 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterCaptionObserver_001 start";
789
790 sptr<MockAccessibleAbilityManagerCaptionObserverStub> stub = new MockAccessibleAbilityManagerCaptionObserverStub();
791 sptr<IAccessibleAbilityManagerCaptionObserver> state = new MockAccessibleAbilityManagerCaptionObserverProxy(stub);
792
793 uint32_t ret = Singleton<AccessibleAbilityManagerService>::GetInstance().RegisterCaptionObserver(state);
794 EXPECT_EQ(ret, 0);
795
796 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterCaptionObserver_001 end";
797 }
798
799 /*
800 * @tc.number: AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterConfigObserver_001
801 * @tc.name: RegisterConfigObserver
802 * @tc.desc: Test function RegisterConfigObserver
803 */
804 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, RegisterConfigObserver_001, TestSize.Level1)
805 {
806 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterConfigObserver_001 start";
807
808 sptr<MockAccessibleAbilityManagerConfigObserverStub> stub = new MockAccessibleAbilityManagerConfigObserverStub();
809 sptr<IAccessibleAbilityManagerConfigObserver> state = new MockAccessibleAbilityManagerConfigObserverProxy(stub);
810
811 uint32_t ret = Singleton<AccessibleAbilityManagerService>::GetInstance().RegisterConfigObserver(state);
812 EXPECT_EQ(ret, 0);
813
814 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterConfigObserver_001 end";
815 }
816
817 /*
818 * @tc.number: AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterEnableAbilityListsObserver_001
819 * @tc.name: RegisterEnableAbilityListsObserver
820 * @tc.desc: Test function RegisterEnableAbilityListsObserver
821 */
822 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, RegisterEnableAbilityListsObserver_001, TestSize.Level1)
823 {
824 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterEnableAbilityListsObserver_001 start";
825
826 sptr<MockAccessibilityEnableAbilityListsObserverStub> stub = new MockAccessibilityEnableAbilityListsObserverStub();
827 sptr<IAccessibilityEnableAbilityListsObserver> state = new MockAccessibilityEnableAbilityListsObserverProxy(stub);
828
829 Singleton<AccessibleAbilityManagerService>::GetInstance().RegisterEnableAbilityListsObserver(state);
830 EXPECT_NE(stub.GetRefPtr(), nullptr);
831 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterEnableAbilityListsObserver_001 end";
832 }
833
834 /**
835 * @tc.number: AccessibleAbility_ManagerService_UnitTest_SwitchedUser_001
836 * @tc.name: SwitchedUser
837 * @tc.desc: Test function SwitchedUser
838 */
839 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SwitchedUser_001, TestSize.Level1)
840 {
841 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_SwitchedUser_001 start";
842 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(100);
843 sleep(SLEEP_TIME_1);
844 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(2);
845 EXPECT_NE(stub_.GetRefPtr(), nullptr);
846 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_SwitchedUser_001 end";
847 }
848
849 /**
850 * @tc.number: AccessibleAbility_ManagerService_UnitTest_GetAbilityList_002
851 * @tc.name: GetAbilityList
852 * @tc.desc: Test function GetAbilityList
853 */
854 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetAbilityList_002, TestSize.Level1)
855 {
856 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetAbilityList_002 start";
857 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
858 std::vector<OHOS::Accessibility::AccessibilityAbilityInfo> infos;
859 Singleton<AccessibleAbilityManagerService>::GetInstance().GetAbilityList(0xFFFFFFFF, 3, infos);
860 EXPECT_NE(stub_.GetRefPtr(), nullptr);
861 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_GetAbilityList_002 end";
862 }
863
864 /**
865 * @tc.number: Accessible_Ability_ManagerService_UnitTest_RegisterElementOperator_002
866 * @tc.name: RegisterElementOperator
867 * @tc.desc: Test function RegisterElementOperator
868 */
869 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, RegisterElementOperator_002, TestSize.Level1)
870 {
871 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterElementOperator_002 start";
872 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
873 Singleton<AccessibleAbilityManagerService>::GetInstance().RegisterElementOperator(0, nullptr);
874 EXPECT_NE(stub_.GetRefPtr(), nullptr);
875 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterElementOperator_002 end";
876 }
877
878 /**
879 * @tc.number: Accessible_Ability_ManagerService_UnitTest_RegisterElementOperator_003
880 * @tc.name: RegisterElementOperator
881 * @tc.desc: Test function RegisterElementOperator
882 */
883 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, RegisterElementOperator_003, TestSize.Level1)
884 {
885 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterElementOperator_003 start";
886 RegisterAbilityConnectionClient(stub_);
887 auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
888 ASSERT_TRUE(accountData);
889 sptr<IAccessibilityElementOperator> operation;
890 Singleton<AccessibleAbilityManagerService>::GetInstance().RegisterElementOperator(0, operation);
891 sleep(SLEEP_TIME_1);
892 Singleton<AccessibleAbilityManagerService>::GetInstance().RegisterElementOperator(0, operation);
893 auto map = accountData->GetAsacConnections();
894 EXPECT_EQ(int(map.size()), 1);
895 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterElementOperator_003 end";
896 }
897
898 /**
899 * @tc.number: AccessibleAbility_ManagerService_UnitTest_UpdateAccessibilityManagerService_001
900 * @tc.name: UpdateAccessibilityManagerService
901 * @tc.desc: Test function UpdateAccessibilityManagerService
902 */
903 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, UpdateAccessibilityManagerService_001, TestSize.Level1)
904 {
905 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_UpdateAccessibilityManagerService_001 start";
906 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
907 Singleton<AccessibleAbilityManagerService>::GetInstance().UpdateAccessibilityManagerService();
908 EXPECT_NE(stub_.GetRefPtr(), nullptr);
909 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_UpdateAccessibilityManagerService_001 end";
910 }
911
912 /**
913 * @tc.number: AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterStateCallback_002
914 * @tc.name: RegisterStateCallback
915 * @tc.desc: Test function RegisterStateCallback
916 */
917 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, RegisterStateCallback_002, TestSize.Level1)
918 {
919 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterStateCallback_00 start";
920 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
921 sptr<AccessibleAbilityManagerStateObserverStub> stub = new MockAccessibleAbilityManagerStateObserverStub();
922 sptr<IAccessibleAbilityManagerStateObserver> state = new MockAccessibleAbilityManagerStateObserverProxy(stub);
923
924 uint32_t ret = Singleton<AccessibleAbilityManagerService>::GetInstance().RegisterStateObserver(state);
925 EXPECT_EQ(ret, 0);
926
927 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterStateCallback_002 end";
928 }
929
930 /**
931 * @tc.number: AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterCaptionObserver_002
932 * @tc.name: RegisterCaptionObserver
933 * @tc.desc: Test function RegisterCaptionObserver
934 */
935 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, RegisterCaptionObserver_002, TestSize.Level1)
936 {
937 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterCaptionObserver_002 start";
938 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
939 sptr<MockAccessibleAbilityManagerCaptionObserverStub> stub = new MockAccessibleAbilityManagerCaptionObserverStub();
940 sptr<IAccessibleAbilityManagerCaptionObserver> state = new MockAccessibleAbilityManagerCaptionObserverProxy(stub);
941
942 uint32_t ret = Singleton<AccessibleAbilityManagerService>::GetInstance().RegisterCaptionObserver(state);
943 EXPECT_EQ(ret, ERR_INVALID_VALUE);
944
945 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterCaptionObserver_002 end";
946 }
947
948 /**
949 * @tc.number: AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterCaptionObserver_003
950 * @tc.name: RegisterCaptionObserver
951 * @tc.desc: Test function RegisterCaptionObserver
952 */
953 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, RegisterCaptionObserver_003, TestSize.Level1)
954 {
955 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterCaptionObserver_003 start";
956 uint32_t ret = Singleton<AccessibleAbilityManagerService>::GetInstance().RegisterCaptionObserver(nullptr);
957 EXPECT_EQ(ret, ERR_INVALID_VALUE);
958
959 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterCaptionObserver_003 end";
960 }
961
962 /*
963 * @tc.number: AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterEnableAbilityListsObserver_002
964 * @tc.name: RegisterEnableAbilityListsObserver
965 * @tc.desc: Test function RegisterEnableAbilityListsObserver
966 */
967 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, RegisterEnableAbilityListsObserver_002, TestSize.Level1)
968 {
969 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterEnableAbilityListsObserver_002 start";
970 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
971 sptr<MockAccessibilityEnableAbilityListsObserverStub> stub = new MockAccessibilityEnableAbilityListsObserverStub();
972 sptr<IAccessibilityEnableAbilityListsObserver> state = new MockAccessibilityEnableAbilityListsObserverProxy(stub);
973
974 Singleton<AccessibleAbilityManagerService>::GetInstance().RegisterEnableAbilityListsObserver(state);
975 EXPECT_NE(stub.GetRefPtr(), nullptr);
976 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterEnableAbilityListsObserver_002 end";
977 }
978
979 /*
980 * @tc.number: AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterEnableAbilityListsObserver_003
981 * @tc.name: RegisterEnableAbilityListsObserver
982 * @tc.desc: Test function RegisterEnableAbilityListsObserver
983 */
984 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, RegisterEnableAbilityListsObserver_003, TestSize.Level1)
985 {
986 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterEnableAbilityListsObserver_003 start";
987 Singleton<AccessibleAbilityManagerService>::GetInstance().RegisterEnableAbilityListsObserver(nullptr);
988 EXPECT_NE(stub_.GetRefPtr(), nullptr);
989 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterEnableAbilityListsObserver_003 end";
990 }
991
992 /**
993 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetCaptionProperty_002
994 * @tc.name: SetCaptionProperty
995 * @tc.desc: Test function SetCaptionProperty GetCaptionProperty
996 */
997 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetCaptionProperty_002, TestSize.Level1)
998 {
999 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetCaptionProperty_002 start";
1000 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1001 AccessibilityConfig::CaptionProperty caption;
1002 int scale = 1;
1003 caption.SetFontScale(scale);
1004 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetCaptionProperty(caption));
1005 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetCaptionProperty(caption));
1006 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetCaptionProperty_002 end";
1007 }
1008
1009 /**
1010 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetCaptionState_002
1011 * @tc.name: SetCaptionState
1012 * @tc.desc: Test function SetCaptionState GetCaptionState
1013 */
1014 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetCaptionState_002, TestSize.Level1)
1015 {
1016 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetCaptionState_002 start";
1017 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1018 bool state = true;
1019 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetCaptionState(state));
1020 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetCaptionState(state));
1021 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetCaptionState_002 end";
1022 }
1023
1024 /**
1025 * @tc.number: AccessibleAbilityManagerServiceUnitTest_GetTouchGuideState_002
1026 * @tc.name: GetTouchGuideState
1027 * @tc.desc: Test function GetTouchGuideState
1028 */
1029 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetTouchGuideState_002, TestSize.Level1)
1030 {
1031 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetTouchGuideState_002 start";
1032 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1033 EXPECT_FALSE(Singleton<AccessibleAbilityManagerService>::GetInstance().GetTouchGuideState());
1034 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetTouchGuideState_002 end";
1035 }
1036
1037 /**
1038 * @tc.number: AccessibleAbilityManagerServiceUnitTest_GetGestureState_002
1039 * @tc.name: GetGestureState
1040 * @tc.desc: Test function GetGestureState
1041 */
1042 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetGestureState_002, TestSize.Level1)
1043 {
1044 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetGestureState_002 start";
1045 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1046 EXPECT_FALSE(Singleton<AccessibleAbilityManagerService>::GetInstance().GetGestureState());
1047 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetGestureState_002 end";
1048 }
1049
1050 /**
1051 * @tc.number: AccessibleAbilityManagerServiceUnitTest_GetKeyEventObserverState_002
1052 * @tc.name: GetKeyEventObserverState
1053 * @tc.desc: Test function GetKeyEventObserverState
1054 */
1055 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetKeyEventObserverState_002, TestSize.Level1)
1056 {
1057 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetKeyEventObserverState_002 start";
1058 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1059 EXPECT_FALSE(Singleton<AccessibleAbilityManagerService>::GetInstance().GetKeyEventObserverState());
1060 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetKeyEventObserverState_002 end";
1061 }
1062
1063 /**
1064 * @tc.number: AccessibleAbility_ManagerService_UnitTest_EnableAbility_002
1065 * @tc.name: EnableAbility
1066 * @tc.desc: Test function EnableAbility
1067 */
1068 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, EnableAbility_002, TestSize.Level1)
1069 {
1070 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_EnableAbility_002 start";
1071 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1072 std::string name = "test";
1073 uint32_t capabilities = 1;
1074 EXPECT_EQ(RET_ERR_NULLPTR,
1075 Singleton<AccessibleAbilityManagerService>::GetInstance().EnableAbility(name, capabilities));
1076 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_EnableAbility_002 end";
1077 }
1078
1079 /*
1080 * @tc.number: AccessibleAbility_ManagerService_UnitTest_GetEnabledAbilities_002
1081 * @tc.name: GetEnabledAbilities
1082 * @tc.desc: Test function GetEnabledAbilities
1083 */
1084 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetEnabledAbilities_002, TestSize.Level1)
1085 {
1086 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_GetEnabledAbilities_002 start";
1087 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1088 std::vector<std::string> enabledAbilities;
1089 EXPECT_EQ(RET_ERR_NULLPTR,
1090 Singleton<AccessibleAbilityManagerService>::GetInstance().GetEnabledAbilities(enabledAbilities));
1091 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_GetEnabledAbilities_002 end";
1092 }
1093
1094 /*
1095 * @tc.number: AccessibleAbility_ManagerService_UnitTest_DisableAbility_002
1096 * @tc.name: DisableAbility
1097 * @tc.desc: Test function DisableAbility
1098 */
1099 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, DisableAbility_002, TestSize.Level1)
1100 {
1101 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_DisableAbility_002 start";
1102 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1103 std::string name = "test";
1104 EXPECT_EQ(RET_ERR_NULLPTR, Singleton<AccessibleAbilityManagerService>::GetInstance().DisableAbility(name));
1105 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_DisableAbility_002 end";
1106 }
1107
1108 /*
1109 * @tc.number: AccessibleAbility_ManagerService_UnitTest_EnableUITestAbility_002
1110 * @tc.name: EnableUITestAbility
1111 * @tc.desc: Test function EnableUITestAbility
1112 */
1113 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, EnableUITestAbility_002, TestSize.Level1)
1114 {
1115 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_EnableUITestAbility_002 start";
1116 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1117 sptr<IRemoteObject> obj;
1118 EXPECT_EQ(RET_ERR_NULLPTR, Singleton<AccessibleAbilityManagerService>::GetInstance().EnableUITestAbility(obj));
1119 GTEST_LOG_(INFO) << "Accessib le_Ability_Manager_ServiceUnittest_EnableUITestAbility_002 end";
1120 }
1121
1122 /*
1123 * @tc.number: AccessibleAbility_ManagerService_UnitTest_DisableUITestAbility_002
1124 * @tc.name: DisableUITestAbility
1125 * @tc.desc: Test function DisableUITestAbility
1126 */
1127 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, DisableUITestAbility_002, TestSize.Level1)
1128 {
1129 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_DisableUITestAbility_002 start";
1130 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1131 EXPECT_EQ(Singleton<AccessibleAbilityManagerService>::GetInstance().DisableUITestAbility(), RET_ERR_NULLPTR);
1132 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_DisableUITestAbility_002 end";
1133 }
1134
1135 /**
1136 * @tc.number: AccessibleAbility_ManagerService_UnitTest_EnableShortKeyTargetAbility_002
1137 * @tc.name: EnableShortKeyTargetAbility
1138 * @tc.desc: Test function EnableShortKeyTargetAbility
1139 */
1140 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, EnableShortKeyTargetAbility_002, TestSize.Level1)
1141 {
1142 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_EnableShortKeyTargetAbility_002 start";
1143 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1144 EXPECT_FALSE(Singleton<AccessibleAbilityManagerService>::GetInstance().EnableShortKeyTargetAbility());
1145 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_EnableShortKeyTargetAbility_002 end";
1146 }
1147
1148 /**
1149 * @tc.number: AccessibleAbility_ManagerService_UnitTest_DisableShortKeyTargetAbility_002
1150 * @tc.name: DisableShortKeyTargetAbility
1151 * @tc.desc: Test function DisableShortKeyTargetAbility
1152 */
1153 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, DisableShortKeyTargetAbility_002, TestSize.Level1)
1154 {
1155 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_DisableShortKeyTargetAbility_002 start";
1156 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1157 EXPECT_FALSE(Singleton<AccessibleAbilityManagerService>::GetInstance().DisableShortKeyTargetAbility());
1158 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_DisableShortKeyTargetAbility_002 end";
1159 }
1160
1161 /**
1162 * @tc.number: AccessibleAbility_ManagerService_UnitTest_PackageRemoved_002
1163 * @tc.name: PackageRemoved
1164 * @tc.desc: Test function PackageRemoved
1165 */
1166 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, PackageRemoved_002, TestSize.Level1)
1167 {
1168 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_PackageRemoved_002 start";
1169 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1170 std::string bundleName = "bundleName1";
1171 Singleton<AccessibleAbilityManagerService>::GetInstance().PackageRemoved(bundleName);
1172 EXPECT_NE(stub_.GetRefPtr(), nullptr);
1173 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_PackageRemoved_002 end";
1174 }
1175
1176 /**
1177 * @tc.number: AccessibleAbility_ManagerService_UnitTest_PackageAdd_002
1178 * @tc.name: PackageAdd
1179 * @tc.desc: Test function PackageAdd
1180 */
1181 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, PackageAdd_002, TestSize.Level1)
1182 {
1183 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_PackageAdd_002 start";
1184 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1185 std::string bundleName = "bundleName1";
1186 Singleton<AccessibleAbilityManagerService>::GetInstance().PackageAdd(bundleName);
1187 EXPECT_NE(stub_.GetRefPtr(), nullptr);
1188 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_PackageAdd_002 end";
1189 }
1190
1191 /*
1192 * @tc.number: AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterConfigObserver_002
1193 * @tc.name: RegisterConfigObserver
1194 * @tc.desc: Test function RegisterConfigObserver
1195 */
1196 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, RegisterConfigObserver_002, TestSize.Level1)
1197 {
1198 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterConfigObserver_002 start";
1199 uint32_t ret = Singleton<AccessibleAbilityManagerService>::GetInstance().RegisterConfigObserver(nullptr);
1200 EXPECT_EQ(ret, ERR_INVALID_VALUE);
1201 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterConfigObserver_002 end";
1202 }
1203
1204 /**
1205 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetScreenMagnificationState_002
1206 * @tc.name: SetScreenMagnificationState
1207 * @tc.desc: Test function SetScreenMagnificationState GetScreenMagnificationState
1208 */
1209
1210 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetScreenMagnificationState_002, TestSize.Level1)
1211 {
1212 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetScreenMagnificationState_000 start";
1213 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1214 bool state = true;
1215 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetScreenMagnificationState(state));
1216 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetScreenMagnificationState(state));
1217 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetScreenMagnificationState_002 end";
1218 }
1219
1220 /**
1221 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetShortKeyState_002
1222 * @tc.name: SetShortKeyState
1223 * @tc.desc: Test function SetShortKeyState GetShortKeyState
1224 * @tc.require: issueI5NTXH
1225 */
1226 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetShortKeyState_002, TestSize.Level1)
1227 {
1228 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetShortKeyState_002 start";
1229 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1230 bool state = true;
1231 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetShortKeyState(state));
1232 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetShortKeyState(state));
1233 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetShortKeyState_002 end";
1234 }
1235
1236 /**
1237 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetMouseKeyState_002
1238 * @tc.name: SetMouseKeyState
1239 * @tc.desc: Test function SetMouseKeyState GetMouseKeyState
1240 * @tc.require: issueI5NTXA
1241 */
1242 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetMouseKeyState_002, TestSize.Level1)
1243 {
1244 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetMouseKeyState_002 start";
1245 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1246 bool state = true;
1247 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetMouseKeyState(state));
1248 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetMouseKeyState(state));
1249 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetMouseKeyState_002 end";
1250 }
1251
1252 /**
1253 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetMouseAutoClick_002
1254 * @tc.name: SetMouseAutoClick
1255 * @tc.desc: Test function SetMouseAutoClick GetMouseAutoClick
1256 * @tc.require: issueI5NTXC
1257 */
1258 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetMouseAutoClick_002, TestSize.Level1)
1259 {
1260 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetMouseAutoClick_002 start";
1261 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1262 int32_t value = MOUSE_AUTO_CLICK_VALUE;
1263 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetMouseAutoClick(value));
1264 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetMouseAutoClick(value));
1265 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetMouseAutoClick_002 end";
1266 }
1267
1268 /**
1269 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetShortkeyTarget_002
1270 * @tc.name: SetShortkeyTarget
1271 * @tc.desc: Test function SetShortkeyTarget GetShortkeyTarget
1272 * @tc.require: issueI5NTXH
1273 */
1274 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetShortkeyTarget_002, TestSize.Level1)
1275 {
1276 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetShortkeyTarget_002 start";
1277 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1278 std::string name = "test";
1279 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetShortkeyTarget(name));
1280 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetShortkeyTarget(name));
1281 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetShortkeyTarget_002 end";
1282 }
1283
1284 /**
1285 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetHighContrastTextState_002
1286 * @tc.name: SetHighContrastTextState
1287 * @tc.desc: Test function SetHighContrastTextState GetHighContrastTextState
1288 * @tc.require: issueI5NTX9
1289 */
1290 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetHighContrastTextState_002, TestSize.Level1)
1291 {
1292 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetHighContrastTextState_002 start";
1293 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1294 bool state = true;
1295 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetHighContrastTextState(state));
1296 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetHighContrastTextState(state));
1297 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetHighContrastTextState_002 end";
1298 }
1299
1300 /**
1301 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetInvertColorState_002
1302 * @tc.name: SetInvertColorState
1303 * @tc.desc: Test function SetInvertColorState GetInvertColorState
1304 * @tc.require: issueI5NTX7
1305 */
1306 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetInvertColorState_002, TestSize.Level1)
1307 {
1308 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetInvertColorState_002 start";
1309 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1310 bool state = true;
1311 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetInvertColorState(state));
1312 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetInvertColorState(state));
1313 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetInvertColorState_002 end";
1314 }
1315
1316 /**
1317 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetAnimationOffState_002
1318 * @tc.name: SetAnimationOffState
1319 * @tc.desc: Test function SetAnimationOffState GetAnimationOffState
1320 * @tc.require: issueI5NTXG
1321 */
1322 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetAnimationOffState_002, TestSize.Level1)
1323 {
1324 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetAnimationOffState_002 start";
1325 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1326 bool state = true;
1327 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetAnimationOffState(state));
1328 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetAnimationOffState(state));
1329 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetAnimationOffState_002 end";
1330 }
1331
1332 /**
1333 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetAudioMonoState_002
1334 * @tc.name: SetAudioMonoState
1335 * @tc.desc: Test function SetAudioMonoState GetAudioMonoState
1336 */
1337 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetAudioMonoState_002, TestSize.Level1)
1338 {
1339 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetAudioMonoState_002 start";
1340 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1341 bool state = true;
1342 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetAudioMonoState(state));
1343 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetAudioMonoState(state));
1344 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetAudioMonoState_002 end";
1345 }
1346
1347 /**
1348 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetDaltonizationColorFilter_002
1349 * @tc.name: SetDaltonizationColorFilter
1350 * @tc.desc: Test function SetDaltonizationColorFilter GetDaltonizationColorFilter
1351 * @tc.require: issueI5NTX8
1352 */
1353 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetDaltonizationColorFilter_002, TestSize.Level1)
1354 {
1355 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetDaltonizationColorFilter_002 start";
1356 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1357 uint32_t filter = 1;
1358 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetDaltonizationColorFilter(filter));
1359 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetDaltonizationColorFilter(filter));
1360 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetDaltonizationColorFilter_002 end";
1361 }
1362
1363 /**
1364 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetContentTimeout_002
1365 * @tc.name: SetContentTimeout
1366 * @tc.desc: Test function SetContentTimeout GetContentTimeout
1367 * @tc.require: issueI5NTXF
1368 */
1369 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetContentTimeout_002, TestSize.Level1)
1370 {
1371 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetContentTimeout_002 start";
1372 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1373 uint32_t time = CONTENT_TIMEOUT_VALUE;
1374 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetContentTimeout(time));
1375 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetContentTimeout(time));
1376 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetContentTimeout_002 end";
1377 }
1378
1379 /**
1380 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetBrightnessDiscount_002
1381 * @tc.name: SetBrightnessDiscount
1382 * @tc.desc: Test function SetBrightnessDiscount GetBrightnessDiscount
1383 * @tc.require: issueI5NTXE
1384 */
1385 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetBrightnessDiscount_002, TestSize.Level1)
1386 {
1387 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetBrightnessDiscount_002 start";
1388 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1389 float value = BRIGHTNESS_DISCOUNT_VALUE;
1390 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetBrightnessDiscount(value));
1391 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetBrightnessDiscount(value));
1392 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetBrightnessDiscount_002 end";
1393 }
1394
1395 /**
1396 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetAudioBalance_002
1397 * @tc.name: SetAudioBalance
1398 * @tc.desc: Test function SetAudioBalance GetAudioBalance
1399 */
1400 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetAudioBalance_002, TestSize.Level1)
1401 {
1402 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetAudioBalance_002 start";
1403 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1404 float value = AUDIO_BALANCE_VALUE;
1405 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetAudioBalance(value));
1406 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetAudioBalance(value));
1407 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetAudioBalance_002 end";
1408 }
1409
1410 /**
1411 * @tc.number: AccessibleAbilityManagerServiceUnitTest_GetAllConfigs_002
1412 * @tc.name: GetAllConfigs
1413 * @tc.desc: Test function GetAllConfigs
1414 */
1415 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetAllConfigs_002, TestSize.Level1)
1416 {
1417 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetAllConfigs_002 start";
1418 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1419 std::shared_ptr<AccessibilityConfigData> data = std::make_shared<AccessibilityConfigData>();
1420 Singleton<AccessibleAbilityManagerService>::GetInstance().GetAllConfigs(*data);
1421 EXPECT_NE(data.get(), nullptr);
1422 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetAllConfigs_002 end";
1423 }
1424
1425 /**
1426 * @tc.number: AccessibleAbilityManagerServiceUnitTest_OnRemoveSystemAbility_001
1427 * @tc.name: OnRemoveSystemAbility
1428 * @tc.desc: Test function OnRemoveSystemAbility
1429 */
1430 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, OnRemoveSystemAbility_001, TestSize.Level1)
1431 {
1432 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_OnRemoveSystemAbility_001 start";
1433 int32_t systemAbilityId = 1;
1434 std::string deviceId = "test";
1435 auto &ins = Singleton<AccessibleAbilityManagerService>::GetInstance();
1436 ins.OnRemoveSystemAbility(systemAbilityId, deviceId);
1437 EXPECT_TRUE(ins.IsServiceReady());
1438 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_OnRemoveSystemAbility_001 end";
1439 }
1440
1441 /**
1442 * @tc.number: AccessibleAbilityManagerServiceUnitTest_OnRemoveSystemAbility_002
1443 * @tc.name: OnRemoveSystemAbility
1444 * @tc.desc: Test function OnRemoveSystemAbility
1445 */
1446 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, OnRemoveSystemAbility_002, TestSize.Level1)
1447 {
1448 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_OnRemoveSystemAbility_002 start";
1449 auto &ins = Singleton<AccessibleAbilityManagerService>::GetInstance();
1450 EXPECT_TRUE(ins.IsServiceReady());
1451 int32_t systemAbilityId = SUBSYS_ACCOUNT_SYS_ABILITY_ID_BEGIN;
1452 std::string deviceId = "test";
1453 ins.OnRemoveSystemAbility(systemAbilityId, deviceId);
__anon5a34e4f40202() 1454 AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([]() -> bool {
1455 if (Singleton<AccessibleAbilityManagerService>::GetInstance().IsServiceReady() == false) {
1456 return true;
1457 } else {
1458 return false;
1459 }
1460 }), SLEEP_TIME_1);
1461 EXPECT_FALSE(ins.IsServiceReady());
1462 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_OnRemoveSystemAbility_002 end";
1463 }
1464
1465 /**
1466 * @tc.number: AccessibleAbility_ManagerService_UnitTest_UpdateConfigState_001
1467 * @tc.name: UpdateConfigState
1468 * @tc.desc: Test function UpdateConfigState
1469 */
1470 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, UpdateConfigState_001, TestSize.Level1)
1471 {
1472 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_UpdateConfigState_001 start";
1473 sptr<MockAccessibleAbilityManagerConfigObserverStub> stub = new MockAccessibleAbilityManagerConfigObserverStub();
1474 sptr<IAccessibleAbilityManagerConfigObserver> state = new MockAccessibleAbilityManagerConfigObserverProxy(stub);
1475
1476 uint32_t ret = Singleton<AccessibleAbilityManagerService>::GetInstance().RegisterConfigObserver(state);
1477 EXPECT_EQ(ret, 0);
1478 Singleton<AccessibleAbilityManagerService>::GetInstance().UpdateConfigState();
1479 EXPECT_NE(stub_.GetRefPtr(), nullptr);
1480 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_UpdateConfigState_001 end";
1481 }
1482
1483 /**
1484 * @tc.number: AccessibleAbility_ManagerService_UnitTest_UpdateAudioBalance_001
1485 * @tc.name: UpdateAudioBalance
1486 * @tc.desc: Test function UpdateAudioBalance
1487 */
1488 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, UpdateAudioBalance_001, TestSize.Level1)
1489 {
1490 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_UpdateAudioBalance_001 start";
1491 sptr<MockAccessibleAbilityManagerConfigObserverStub> stub = new MockAccessibleAbilityManagerConfigObserverStub();
1492 sptr<IAccessibleAbilityManagerConfigObserver> state = new MockAccessibleAbilityManagerConfigObserverProxy(stub);
1493
1494 uint32_t ret = Singleton<AccessibleAbilityManagerService>::GetInstance().RegisterConfigObserver(state);
1495 EXPECT_EQ(ret, 0);
1496 Singleton<AccessibleAbilityManagerService>::GetInstance().UpdateAudioBalance();
1497 EXPECT_NE(stub_.GetRefPtr(), nullptr);
1498 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_UpdateAudioBalance_001 end";
1499 }
1500
1501 /**
1502 * @tc.number: AccessibleAbility_ManagerService_UnitTest_UpdateBrightnessDiscount_001
1503 * @tc.name: UpdateBrightnessDiscount
1504 * @tc.desc: Test function UpdateBrightnessDiscount
1505 */
1506 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, UpdateBrightnessDiscount_001, TestSize.Level1)
1507 {
1508 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_UpdateBrightnessDiscount_001 start";
1509 sptr<MockAccessibleAbilityManagerConfigObserverStub> stub = new MockAccessibleAbilityManagerConfigObserverStub();
1510 sptr<IAccessibleAbilityManagerConfigObserver> state = new MockAccessibleAbilityManagerConfigObserverProxy(stub);
1511
1512 uint32_t ret = Singleton<AccessibleAbilityManagerService>::GetInstance().RegisterConfigObserver(state);
1513 EXPECT_EQ(ret, 0);
1514 Singleton<AccessibleAbilityManagerService>::GetInstance().UpdateBrightnessDiscount();
1515 EXPECT_NE(stub_.GetRefPtr(), nullptr);
1516 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_UpdateBrightnessDiscount_001 end";
1517 }
1518
1519 /**
1520 * @tc.number: AccessibleAbility_ManagerService_UnitTest_UpdateContentTimeout_001
1521 * @tc.name: UpdateContentTimeout
1522 * @tc.desc: Test function UpdateContentTimeout
1523 */
1524 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, UpdateContentTimeout_001, TestSize.Level1)
1525 {
1526 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_UpdateContentTimeout_001 start";
1527 sptr<MockAccessibleAbilityManagerConfigObserverStub> stub = new MockAccessibleAbilityManagerConfigObserverStub();
1528 sptr<IAccessibleAbilityManagerConfigObserver> state = new MockAccessibleAbilityManagerConfigObserverProxy(stub);
1529
1530 uint32_t ret = Singleton<AccessibleAbilityManagerService>::GetInstance().RegisterConfigObserver(state);
1531 EXPECT_EQ(ret, 0);
1532 Singleton<AccessibleAbilityManagerService>::GetInstance().UpdateContentTimeout();
1533 EXPECT_NE(stub_.GetRefPtr(), nullptr);
1534 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_UpdateContentTimeout_001 end";
1535 }
1536
1537 /**
1538 * @tc.number: AccessibleAbility_ManagerService_UnitTest_UpdateDaltonizationColorFilter_001
1539 * @tc.name: UpdateDaltonizationColorFilter
1540 * @tc.desc: Test function UpdateDaltonizationColorFilter
1541 */
1542 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, UpdateDaltonizationColorFilter_001, TestSize.Level1)
1543 {
1544 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_UpdateDaltonizationColorFilter_001 start";
1545 sptr<MockAccessibleAbilityManagerConfigObserverStub> stub = new MockAccessibleAbilityManagerConfigObserverStub();
1546 sptr<IAccessibleAbilityManagerConfigObserver> state = new MockAccessibleAbilityManagerConfigObserverProxy(stub);
1547
1548 uint32_t ret = Singleton<AccessibleAbilityManagerService>::GetInstance().RegisterConfigObserver(state);
1549 EXPECT_EQ(ret, 0);
1550 Singleton<AccessibleAbilityManagerService>::GetInstance().UpdateDaltonizationColorFilter();
1551 EXPECT_NE(stub_.GetRefPtr(), nullptr);
1552 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_UpdateDaltonizationColorFilter_001 end";
1553 }
1554
1555 /**
1556 * @tc.number: AccessibleAbility_ManagerService_UnitTest_UpdateMouseAutoClick_001
1557 * @tc.name: UpdateMouseAutoClick
1558 * @tc.desc: Test function UpdateMouseAutoClick
1559 */
1560 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, UpdateMouseAutoClick_001, TestSize.Level1)
1561 {
1562 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_UpdateMouseAutoClick_001 start";
1563 sptr<MockAccessibleAbilityManagerConfigObserverStub> stub = new MockAccessibleAbilityManagerConfigObserverStub();
1564 sptr<IAccessibleAbilityManagerConfigObserver> state = new MockAccessibleAbilityManagerConfigObserverProxy(stub);
1565
1566 uint32_t ret = Singleton<AccessibleAbilityManagerService>::GetInstance().RegisterConfigObserver(state);
1567 EXPECT_EQ(ret, 0);
1568 Singleton<AccessibleAbilityManagerService>::GetInstance().UpdateMouseAutoClick();
1569 EXPECT_NE(stub_.GetRefPtr(), nullptr);
1570 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_UpdateMouseAutoClick_001 end";
1571 }
1572
1573 /**
1574 * @tc.number: AccessibleAbility_ManagerService_UnitTest_UpdateShortkeyTarget_001
1575 * @tc.name: UpdateShortkeyTarget
1576 * @tc.desc: Test function UpdateShortkeyTarget
1577 */
1578 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, UpdateShortkeyTarget_001, TestSize.Level1)
1579 {
1580 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_UpdateShortkeyTarget_001 start";
1581 sptr<MockAccessibleAbilityManagerConfigObserverStub> stub = new MockAccessibleAbilityManagerConfigObserverStub();
1582 sptr<IAccessibleAbilityManagerConfigObserver> state = new MockAccessibleAbilityManagerConfigObserverProxy(stub);
1583
1584 uint32_t ret = Singleton<AccessibleAbilityManagerService>::GetInstance().RegisterConfigObserver(state);
1585 EXPECT_EQ(ret, 0);
1586 Singleton<AccessibleAbilityManagerService>::GetInstance().UpdateShortkeyTarget();
1587 EXPECT_NE(stub_.GetRefPtr(), nullptr);
1588 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_UpdateShortkeyTarget_001 end";
1589 }
1590
1591 /**
1592 * @tc.number: AccessibleAbility_ManagerService_UnitTest_PackageRemoved_003
1593 * @tc.name: PackageRemoved
1594 * @tc.desc: Test function PackageRemoved
1595 */
1596 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, PackageRemoved_003, TestSize.Level1)
1597 {
1598 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_PackageRemoved_003 start";
1599 std::string bundleName = "bundleName1";
1600 Singleton<AccessibleAbilityManagerService>::GetInstance().PackageAdd(bundleName);
1601 sleep(SLEEP_TIME_1);
1602 Singleton<AccessibleAbilityManagerService>::GetInstance().PackageRemoved(bundleName);
1603 EXPECT_NE(stub_.GetRefPtr(), nullptr);
1604 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_PackageRemoved_003 end";
1605 }
1606
1607 /**
1608 * @tc.number: AccessibleAbility_ManagerService_UnitTest_GetAbilityList_003
1609 * @tc.name: GetAbilityList
1610 * @tc.desc: Test function GetAbilityList
1611 */
1612 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetAbilityList_003, TestSize.Level1)
1613 {
1614 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetAbilityList_003 start";
1615 std::vector<OHOS::Accessibility::AccessibilityAbilityInfo> infos;
1616 uint32_t type = 0xFFFFFFFF;
1617 Singleton<AccessibleAbilityManagerService>::GetInstance().GetAbilityList(type, -1, infos);
1618 EXPECT_EQ(infos.size(), 0);
1619 Singleton<AccessibleAbilityManagerService>::GetInstance().GetAbilityList(type, 5, infos);
1620 EXPECT_EQ(infos.size(), 0);
1621 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_GetAbilityList_003 end";
1622 }
1623
1624 /**
1625 * @tc.number: AccessibleAbility_ManagerService_UnitTest_SetTargetAbility_001
1626 * @tc.name: SetTargetAbility
1627 * @tc.desc: Test function HIGH_CONTRAST_TEXT
1628 */
1629 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetTargetAbility_001, TestSize.Level1)
1630 {
1631 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTargetAbility_001 start";
1632 auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
1633 if (!accountData) {
1634 GTEST_LOG_(INFO) << "current account data is null";
1635 return;
1636 }
1637 accountData->GetConfig()->SetShortkeyTarget("HIGH_CONTRAST_TEXT");
1638 bool ret = Singleton<AccessibleAbilityManagerService>::GetInstance().EnableShortKeyTargetAbility();
1639 EXPECT_TRUE(ret);
1640 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTargetAbility_001 end";
1641 }
1642
1643 /**
1644 * @tc.number: AccessibleAbility_ManagerService_UnitTest_SetTargetAbility_002
1645 * @tc.name: SetTargetAbility
1646 * @tc.desc: Test function INVERT_COLOR
1647 */
1648 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetTargetAbility_002, TestSize.Level1)
1649 {
1650 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTargetAbility_002 start";
1651 auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
1652 if (!accountData) {
1653 GTEST_LOG_(INFO) << "current account data is null";
1654 return;
1655 }
1656 accountData->GetConfig()->SetShortkeyTarget("INVERT_COLOR");
1657 bool ret = Singleton<AccessibleAbilityManagerService>::GetInstance().EnableShortKeyTargetAbility();
1658 EXPECT_TRUE(ret);
1659 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTargetAbility_002 end";
1660 }
1661
1662 /**
1663 * @tc.number: AccessibleAbility_ManagerService_UnitTest_SetTargetAbility_003
1664 * @tc.name: SetTargetAbility
1665 * @tc.desc: Test function ANIMATION_OFF
1666 */
1667 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetTargetAbility_003, TestSize.Level1)
1668 {
1669 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTargetAbility_003 start";
1670 auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
1671 if (!accountData) {
1672 GTEST_LOG_(INFO) << "current account data is null";
1673 return;
1674 }
1675 accountData->GetConfig()->SetShortkeyTarget("ANIMATION_OFF");
1676 bool ret = Singleton<AccessibleAbilityManagerService>::GetInstance().EnableShortKeyTargetAbility();
1677 EXPECT_TRUE(ret);
1678 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTargetAbility_003 end";
1679 }
1680
1681 /**
1682 * @tc.number: AccessibleAbility_ManagerService_UnitTest_SetTargetAbility_004
1683 * @tc.name: SetTargetAbility
1684 * @tc.desc: Test function SCREEN_MAGNIFICATION
1685 */
1686 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetTargetAbility_004, TestSize.Level1)
1687 {
1688 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTargetAbility_004 start";
1689 auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
1690 if (!accountData) {
1691 GTEST_LOG_(INFO) << "current account data is null";
1692 return;
1693 }
1694 accountData->GetConfig()->SetShortkeyTarget("SCREEN_MAGNIFICATION");
1695 bool ret = Singleton<AccessibleAbilityManagerService>::GetInstance().EnableShortKeyTargetAbility();
1696 EXPECT_TRUE(ret);
1697 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTargetAbility_004 end";
1698 }
1699
1700 /**
1701 * @tc.number: AccessibleAbility_ManagerService_UnitTest_SetTargetAbility_005
1702 * @tc.name: SetTargetAbility
1703 * @tc.desc: Test function AUDIO_MONO
1704 */
1705 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetTargetAbility_005, TestSize.Level1)
1706 {
1707 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTargetAbility_005 start";
1708 auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
1709 if (!accountData) {
1710 GTEST_LOG_(INFO) << "current account data is null";
1711 return;
1712 }
1713 accountData->GetConfig()->SetShortkeyTarget("AUDIO_MONO");
1714 bool ret = Singleton<AccessibleAbilityManagerService>::GetInstance().EnableShortKeyTargetAbility();
1715 EXPECT_TRUE(ret);
1716 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTargetAbility_005 end";
1717 }
1718
1719 /**
1720 * @tc.number: AccessibleAbility_ManagerService_UnitTest_SetTargetAbility_006
1721 * @tc.name: SetTargetAbility
1722 * @tc.desc: Test function MOUSE_KEY
1723 */
1724 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetTargetAbility_006, TestSize.Level1)
1725 {
1726 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTargetAbility_006 start";
1727 auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
1728 if (!accountData) {
1729 GTEST_LOG_(INFO) << "current account data is null";
1730 return;
1731 }
1732 accountData->GetConfig()->SetShortkeyTarget("MOUSE_KEY");
1733 bool ret = Singleton<AccessibleAbilityManagerService>::GetInstance().EnableShortKeyTargetAbility();
1734 EXPECT_TRUE(ret);
1735 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTargetAbility_006 end";
1736 }
1737
1738 /**
1739 * @tc.number: AccessibleAbility_ManagerService_UnitTest_SetTargetAbility_007
1740 * @tc.name: SetTargetAbility
1741 * @tc.desc: Test function CAPTION_STATE
1742 */
1743 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetTargetAbility_007, TestSize.Level1)
1744 {
1745 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTargetAbility_007 start";
1746 auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
1747 if (!accountData) {
1748 GTEST_LOG_(INFO) << "current account data is null";
1749 return;
1750 }
1751 accountData->GetConfig()->SetShortkeyTarget("CAPTION_STATE");
1752 bool ret = Singleton<AccessibleAbilityManagerService>::GetInstance().EnableShortKeyTargetAbility();
1753 EXPECT_TRUE(ret);
1754 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTargetAbility_007 end";
1755 }
1756
1757 /**
1758 * @tc.number: AccessibleAbility_ManagerService_UnitTest_SetTargetAbility_008
1759 * @tc.name: SetTargetAbility
1760 * @tc.desc: Test function OTHERS
1761 */
1762 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetTargetAbility_008, TestSize.Level1)
1763 {
1764 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTargetAbility_008 start";
1765 auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
1766 if (!accountData) {
1767 GTEST_LOG_(INFO) << "current account data is null";
1768 return;
1769 }
1770 accountData->GetConfig()->SetShortkeyTarget("CONTENT_TIMEOUT");
1771 bool ret = Singleton<AccessibleAbilityManagerService>::GetInstance().EnableShortKeyTargetAbility();
1772 EXPECT_FALSE(ret);
1773 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTargetAbility_008 end";
1774 }
1775
1776 /**
1777 * @tc.number: AccessibleAbility_ManagerService_UnitTest_SetTargetAbility_009
1778 * @tc.name: SetTargetAbility
1779 * @tc.desc: Test function ""
1780 */
1781 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetTargetAbility_009, TestSize.Level1)
1782 {
1783 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTargetAbility_009 start";
1784 auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
1785 if (!accountData) {
1786 GTEST_LOG_(INFO) << "current account data is null";
1787 return;
1788 }
1789 accountData->GetConfig()->SetShortkeyTarget("");
1790 bool ret = Singleton<AccessibleAbilityManagerService>::GetInstance().EnableShortKeyTargetAbility();
1791 EXPECT_FALSE(ret);
1792 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTargetAbility_009 end";
1793 }
1794
1795 /**
1796 * @tc.number: AccessibleAbility_ManagerService_UnitTest_SetTargetAbility_010
1797 * @tc.name: SetTargetAbility
1798 * @tc.desc: Test function other account
1799 */
1800 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetTargetAbility_010, TestSize.Level1)
1801 {
1802 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTargetAbility_010 start";
1803 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1804 auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
1805 if (!accountData) {
1806 GTEST_LOG_(INFO) << "current account data is null";
1807 return;
1808 }
1809 accountData->GetConfig()->SetShortkeyTarget("MOUSE_KEY");
1810 bool ret = Singleton<AccessibleAbilityManagerService>::GetInstance().EnableShortKeyTargetAbility();
1811 EXPECT_FALSE(ret);
1812 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTargetAbility_010 end";
1813 }
1814 } // namespace Accessibility
1815 } // namespace OHOS