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 // add parameter whehter an application
173 EXPECT_EQ(RET_OK, aams.RegisterElementOperator(0, nullptr, true));
174 sleep(SLEEP_TIME_1);
175 GTEST_LOG_(INFO) << "RegisterElementOperator OK";
176 map = accountData->GetAsacConnections();
177 EXPECT_EQ(int(map.size()), 1);
178
179 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterElementOperator_001 end";
180 }
181
182 /**
183 * @tc.number: AccessibleAbility_ManagerService_UnitTest_DeregisterElementOperator_001
184 * @tc.name: DeregisterElementOperator
185 * @tc.desc: Test function DeregisterElementOperator
186 */
187 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, DeregisterElementOperator_001, TestSize.Level1)
188 {
189 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_DeregisterElementOperator_001 start";
190 auto &aams = Singleton<AccessibleAbilityManagerService>::GetInstance();
191 auto accountData = aams.GetCurrentAccountData();
192 ASSERT_TRUE(accountData);
193 EXPECT_EQ(RET_OK, aams.DeregisterElementOperator(0));
194 sleep(SLEEP_TIME_1);
195 auto map = accountData->GetAsacConnections();
196 EXPECT_EQ(int(map.size()), 0);
197
198 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_DeregisterElementOperator_001 end";
199 }
200
201 /**
202 * @tc.number: AccessibleAbility_ManagerService_UnitTest_DeregisterElementOperator_002
203 * @tc.name: DeregisterElementOperator
204 * @tc.desc: Test function DeregisterElementOperator
205 */
206 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, DeregisterElementOperator_002, TestSize.Level1)
207 {
208 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_DeregisterElementOperator_002 start";
209 auto &aams = Singleton<AccessibleAbilityManagerService>::GetInstance();
210 auto accountData = aams.GetCurrentAccountData();
211 ASSERT_TRUE(accountData);
212 EXPECT_EQ(RET_OK, aams.RegisterElementOperator(0, nullptr, true));
213 sleep(SLEEP_TIME_1);
214 EXPECT_EQ(RET_OK, aams.DeregisterElementOperator(0));
215 sleep(SLEEP_TIME_1);
216 auto map = accountData->GetAsacConnections();
217 EXPECT_EQ(int(map.size()), 0);
218
219 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_DeregisterElementOperator_002 end";
220 }
221
222
223 /**
224 * @tc.number: AccessibleAbility_ManagerService_UnitTest_SetTouchEventInjector_001
225 * @tc.name: SetTouchEventInjector
226 * @tc.desc: Test function SetTouchEventInjector
227 */
228 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetTouchEventInjector_001, TestSize.Level1)
229 {
230 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTouchEventInjector_001 start";
231 sptr<TouchEventInjector> touchEventInjector = new TouchEventInjector();
232 sleep(SLEEP_TIME_1);
233 Singleton<AccessibleAbilityManagerService>::GetInstance().SetTouchEventInjector(touchEventInjector);
234 auto ret = Singleton<AccessibleAbilityManagerService>::GetInstance().GetTouchEventInjector();
235 EXPECT_TRUE(ret);
236 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTouchEventInjector_001 end";
237 }
238
239 /**
240 * @tc.number: AccessibleAbility_ManagerService_UnitTest_SetKeyEventFilter_001
241 * @tc.name: SetKeyEventFilter
242 * @tc.desc: Test function SetKeyEventFilter
243 */
244 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetKeyEventFilter_001, TestSize.Level1)
245 {
246 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetKeyEventFilter_001 start";
247 sptr<KeyEventFilter> keyEventFilter = new KeyEventFilter();
248 Singleton<AccessibleAbilityManagerService>::GetInstance().SetKeyEventFilter(keyEventFilter);
249 auto ret = Singleton<AccessibleAbilityManagerService>::GetInstance().GetKeyEventFilter();
250 EXPECT_TRUE(ret);
251 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetKeyEventFilter_001 end";
252 }
253
254 /**
255 * @tc.number: AccessibleAbility_ManagerService_UnitTest_RemovedUser_001
256 * @tc.name: RemovedUser
257 * @tc.desc: Test function RemovedUser
258 */
259 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, RemovedUser_001, TestSize.Level1)
260 {
261 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_RemovedUser_001 start";
262 RegisterAbilityConnectionClient(stub_);
263 auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
264 ASSERT_TRUE(accountData);
265 EXPECT_EQ(int(accountData->GetConnectedA11yAbilities().size()), 1);
266 Singleton<AccessibleAbilityManagerService>::GetInstance().RemovedUser(1);
267 // can't to check a11yAccountsData_ because it is private,and don't provite api.
268 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_RemovedUser_001 end";
269 }
270
271 /**
272 * @tc.number: AccessibleAbility_ManagerService_UnitTest_RemovedUser_002
273 * @tc.name: RemovedUser
274 * @tc.desc: Test function RemovedUser
275 */
276 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, RemovedUser_002, TestSize.Level1)
277 {
278 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_RemovedUser_002 start";
279 Singleton<AccessibleAbilityManagerService>::GetInstance().AddedUser(1);
280 sleep(SLEEP_TIME_1);
281 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(1);
282 sleep(SLEEP_TIME_1);
283 auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
284 ASSERT_EQ(accountData->GetAccountId(), 1);
285 Singleton<AccessibleAbilityManagerService>::GetInstance().RemovedUser(1);
286 // can't to check a11yAccountsData_ because it is private,and don't provite api.
287 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_RemovedUser_002 end";
288 }
289
290 /**
291 * @tc.number: AccessibleAbility_ManagerService_UnitTest_GetBundleMgrProxy_001
292 * @tc.name: GetBundleMgrProxy
293 * @tc.desc: Test function GetBundleMgrProxy
294 */
295 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetBundleMgrProxy_001, TestSize.Level1)
296 {
297 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_GetBundleMgrProxy_001 start";
298 auto ret = Singleton<AccessibleAbilityManagerService>::GetInstance().GetBundleMgrProxy();
299 EXPECT_TRUE(ret);
300 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_GetBundleMgrProxyr_001 end";
301 }
302
303 /**
304 * @tc.number: AccessibleAbility_ManagerService_UnitTest_PackageChanged_001
305 * @tc.name: PackageChanged
306 * @tc.desc: Test function PackageChanged
307 */
308 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, PackageChanged_001, TestSize.Level1)
309 {
310 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_PackageChanged_001 start";
311 auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
312 ASSERT_TRUE(accountData);
313 accountData->ClearInstalledAbility();
314 /* install ability is null */
315 GTEST_LOG_(INFO) << "GetInstalledAbilities start";
316 EXPECT_EQ(0, int(accountData->GetInstalledAbilities().size()));
317 GTEST_LOG_(INFO) << "PackageChanged start";
318 std::string bundleName = "bundleName1";
319 Singleton<AccessibleAbilityManagerService>::GetInstance().PackageChanged(bundleName);
320 GTEST_LOG_(INFO) << "PackageChanged end";
321 EXPECT_EQ(0, int(accountData->GetInstalledAbilities().size()));
322 GTEST_LOG_(INFO) << "GetInstalledAbilities end";
323 /* add install ability */
324 sleep(SLEEP_TIME_1);
325 RegisterAbilityConnectionClient(stub_);
326 sleep(SLEEP_TIME_1);
327 EXPECT_EQ(1, int(accountData->GetInstalledAbilities().size()));
328 bundleName = "bundleName2";
329 Singleton<AccessibleAbilityManagerService>::GetInstance().PackageChanged(bundleName);
330 sleep(SLEEP_TIME_1);
331 EXPECT_EQ(1, int(accountData->GetInstalledAbilities().size()));
332 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_PackageChanged_001 end";
333 }
334
335 /**
336 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetScreenMagnificationState_001
337 * @tc.name: SetScreenMagnificationState
338 * @tc.desc: Test function SetScreenMagnificationState GetScreenMagnificationState
339 */
340 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetScreenMagnificationState_001, TestSize.Level1)
341 {
342 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetScreenMagnificationState_001 start";
343 bool state = true;
344 bool ret = false;
345 EXPECT_EQ(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetScreenMagnificationState(state));
346 EXPECT_EQ(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetScreenMagnificationState(ret));
347 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetScreenMagnificationState_001 end";
348 }
349
350 /**
351 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetShortKeyState_001
352 * @tc.name: SetShortKeyState
353 * @tc.desc: Test function SetShortKeyState GetShortKeyState
354 * @tc.require: issueI5NTXH
355 */
356 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetShortKeyState_001, TestSize.Level1)
357 {
358 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetShortKeyState_001 start";
359 bool state = true;
360 bool ret = false;
361 EXPECT_EQ(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetShortKeyState(state));
362 EXPECT_EQ(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetShortKeyState(ret));
363 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetShortKeyState_001 end";
364 }
365
366 /**
367 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetMouseKeyState_001
368 * @tc.name: SetMouseKeyState
369 * @tc.desc: Test function SetMouseKeyState GetMouseKeyState
370 * @tc.require: issueI5NTXA
371 */
372 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetMouseKeyState_001, TestSize.Level1)
373 {
374 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetMouseKeyState_001 start";
375 bool state = true;
376 bool ret = false;
377 EXPECT_EQ(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetMouseKeyState(state));
378 EXPECT_EQ(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetMouseKeyState(ret));
379 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetMouseKeyState_001 end";
380 }
381
382 /**
383 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetMouseAutoClick_001
384 * @tc.name: SetMouseAutoClick
385 * @tc.desc: Test function SetMouseAutoClick GetMouseAutoClick
386 * @tc.require: issueI5NTXC
387 */
388 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetMouseAutoClick_001, TestSize.Level1)
389 {
390 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetMouseAutoClick_001 start";
391 int32_t ret = 0;
392 int32_t value = MOUSE_AUTO_CLICK_VALUE;
393 EXPECT_EQ(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetMouseAutoClick(value));
394 EXPECT_EQ(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetMouseAutoClick(ret));
395 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetMouseAutoClick_001 end";
396 }
397
398 /**
399 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetShortkeyTarget_001
400 * @tc.name: SetShortkeyTarget
401 * @tc.desc: Test function SetShortkeyTarget GetShortkeyTarget
402 * @tc.require: issueI5NTXH
403 */
404 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetShortkeyTarget_001, TestSize.Level1)
405 {
406 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetShortkeyTarget_001 start";
407 std::string name = "test";
408 std::string ret = "";
409 EXPECT_EQ(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetShortkeyTarget(name));
410 EXPECT_EQ(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetShortkeyTarget(ret));
411 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetShortkeyTarget_001 end";
412 }
413
414 /**
415 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetHighContrastTextState_001
416 * @tc.name: SetHighContrastTextState
417 * @tc.desc: Test function SetHighContrastTextState GetHighContrastTextState
418 * @tc.require: issueI5NTX9
419 */
420 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetHighContrastTextState_001, TestSize.Level1)
421 {
422 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetHighContrastTextState_001 start";
423 bool state = true;
424 bool ret = false;
425 EXPECT_EQ(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetHighContrastTextState(state));
426 EXPECT_EQ(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetHighContrastTextState(ret));
427 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetHighContrastTextState_001 end";
428 }
429
430 /**
431 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetDaltonizationState_001
432 * @tc.name: SetDaltonizationState
433 * @tc.desc: Test function SetDaltonizationState GetDaltonizationState
434 */
435 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetDaltonizationState_001, TestSize.Level1)
436 {
437 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetDaltonizationState_001 start";
438 bool state = true;
439 bool ret = false;
440 EXPECT_EQ(RET_OK,
441 Singleton<AccessibleAbilityManagerService>::GetInstance().SetDaltonizationState(state));
442 EXPECT_EQ(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetDaltonizationState(ret));
443 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetDaltonizationState_001 end";
444 }
445
446 /**
447 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetInvertColorState_001
448 * @tc.name: SetInvertColorState
449 * @tc.desc: Test function SetInvertColorState GetInvertColorState
450 * @tc.require: issueI5NTX7
451 */
452 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetInvertColorState_001, TestSize.Level1)
453 {
454 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetInvertColorState_001 start";
455 bool state = true;
456 bool ret = false;
457 EXPECT_EQ(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetInvertColorState(state));
458 EXPECT_EQ(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetInvertColorState(ret));
459 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetInvertColorState_001 end";
460 }
461
462 /**
463 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetAnimationOffState_001
464 * @tc.name: SetAnimationOffState
465 * @tc.desc: Test function SetAnimationOffState GetAnimationOffState
466 * @tc.require: issueI5NTXG
467 */
468 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetAnimationOffState_001, TestSize.Level1)
469 {
470 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetAnimationOffState_001 start";
471 bool state = true;
472 bool ret = false;
473 EXPECT_EQ(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetAnimationOffState(state));
474 EXPECT_EQ(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetAnimationOffState(ret));
475 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetAnimationOffState_001 end";
476 }
477
478 /**
479 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetAudioMonoState_001
480 * @tc.name: SetAudioMonoState
481 * @tc.desc: Test function SetAudioMonoState GetAudioMonoState
482 */
483 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetAudioMonoState_001, TestSize.Level1)
484 {
485 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetAudioMonoState_001 start";
486 bool state = true;
487 bool ret = false;
488 EXPECT_EQ(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetAudioMonoState(state));
489 EXPECT_EQ(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetAudioMonoState(ret));
490 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetAudioMonoState_001 end";
491 }
492
493 /**
494 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetDaltonizationColorFilter_001
495 * @tc.name: SetDaltonizationColorFilter
496 * @tc.desc: Test function SetDaltonizationColorFilter GetDaltonizationColorFilter
497 * @tc.require: issueI5NTX8
498 */
499 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetDaltonizationColorFilter_001, TestSize.Level1)
500 {
501 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetDaltonizationColorFilter_001 start";
502 uint32_t filter = 1;
503 EXPECT_EQ(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetDaltonizationColorFilter(filter));
504 uint32_t ret = 0;
505 EXPECT_EQ(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetDaltonizationColorFilter(ret));
506 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetDaltonizationColorFilter_001 end";
507 }
508
509 /**
510 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetContentTimeout_001
511 * @tc.name: SetContentTimeout
512 * @tc.desc: Test function SetContentTimeout GetContentTimeout
513 * @tc.require: issueI5NTXF
514 */
515 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetContentTimeout_001, TestSize.Level1)
516 {
517 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetContentTimeout_001 start";
518 uint32_t value = CONTENT_TIMEOUT_VALUE;
519 EXPECT_EQ(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetContentTimeout(value));
520 uint32_t ret = 0;
521 EXPECT_EQ(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetContentTimeout(ret));
522 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetContentTimeout_001 end";
523 }
524
525 /**
526 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetBrightnessDiscount_001
527 * @tc.name: SetBrightnessDiscount
528 * @tc.desc: Test function SetBrightnessDiscount GetBrightnessDiscount
529 * @tc.require: issueI5NTXE
530 */
531 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetBrightnessDiscount_001, TestSize.Level1)
532 {
533 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetBrightnessDiscount_001 start";
534 float value = BRIGHTNESS_DISCOUNT_VALUE;
535 RetError result = Singleton<AccessibleAbilityManagerService>::GetInstance().SetBrightnessDiscount(value);
536 EXPECT_EQ(RET_OK, result);
537 float ret = 0;
538 EXPECT_EQ(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetBrightnessDiscount(ret));
539 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetBrightnessDiscount_001 end";
540 }
541
542 /**
543 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetAudioBalance_001
544 * @tc.name: SetAudioBalance
545 * @tc.desc: Test function SetAudioBalance GetAudioBalance
546 */
547 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetAudioBalance_001, TestSize.Level1)
548 {
549 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetAudioBalance_001 start";
550 EXPECT_EQ(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetAudioBalance(AUDIO_BALANCE_VALUE));
551 float ret = 0;
552 EXPECT_EQ(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetAudioBalance(ret));
553 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetAudioBalance_001 end";
554 }
555
556 /**
557 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetClickResponseTime_001
558 * @tc.name: SetClickResponseTime
559 * @tc.desc: Test function SetClickResponseTime GetClickResponseTime
560 */
561 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetClickResponseTime_001, TestSize.Level1)
562 {
563 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetClickResponseTime_001 start";
564 EXPECT_EQ(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetClickResponseTime(1));
565 uint32_t ret = 0;
566 EXPECT_EQ(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetClickResponseTime(ret));
567 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetClickResponseTime_001 end";
568 }
569
570 /**
571 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetIgnoreRepeatClickState_001
572 * @tc.name: SetIgnoreRepeatClickState
573 * @tc.desc: Test function SetIgnoreRepeatClickState GetIgnoreRepeatClickState
574 */
575 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetIgnoreRepeatClickState_001, TestSize.Level1)
576 {
577 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetIgnoreRepeatClickState_001 start";
578 EXPECT_EQ(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetIgnoreRepeatClickState(true));
579 bool ret = false;
580 EXPECT_EQ(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetIgnoreRepeatClickState(ret));
581 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetIgnoreRepeatClickState_001 end";
582 }
583
584 /**
585 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetIgnoreRepeatClickTime_001
586 * @tc.name: SetIgnoreRepeatClickTime
587 * @tc.desc: Test function SetIgnoreRepeatClickTime GetIgnoreRepeatClickTime
588 */
589 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetIgnoreRepeatClickTime_001, TestSize.Level1)
590 {
591 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetIgnoreRepeatClickTime_001 start";
592 EXPECT_EQ(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetIgnoreRepeatClickTime(1));
593 uint32_t ret = 0;
594 EXPECT_EQ(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetIgnoreRepeatClickTime(ret));
595 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetIgnoreRepeatClickTime_001 end";
596 }
597
598 /**
599 * @tc.number: AccessibleAbilityManagerServiceUnitTest_GetAllConfigs_001
600 * @tc.name: GetAllConfigs
601 * @tc.desc: Test function GetAllConfigs
602 */
603 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetAllConfigs_001, TestSize.Level1)
604 {
605 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetAllConfigs_001 start";
606 AccessibilityConfigData data;
607 Singleton<AccessibleAbilityManagerService>::GetInstance().GetAllConfigs(data);
608 EXPECT_NE(stub_.GetRefPtr(), nullptr);
609 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetAllConfigs_001 end";
610 }
611
612 /**
613 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetCaptionState_001
614 * @tc.name: SetCaptionState
615 * @tc.desc: Test function SetCaptionState GetCaptionState
616 */
617 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetCaptionState_001, TestSize.Level1)
618 {
619 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetCaptionState_001 start";
620 bool state = true;
621 EXPECT_EQ(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetCaptionState(state));
622 bool ret = false;
623 EXPECT_EQ(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetCaptionState(ret));
624 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetCaptionState_001 end";
625 }
626
627 /**
628 * @tc.number: AccessibleAbilityManagerServiceUnitTest_GetEnabledState_001
629 * @tc.name: GetEnabledState
630 * @tc.desc: Test function GetEnabledState
631 */
632 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetEnabledState_001, TestSize.Level1)
633 {
634 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetEnabledState_001 start";
635 EXPECT_TRUE(Singleton<AccessibleAbilityManagerService>::GetInstance().GetEnabledState());
636 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetEnabledState_001 end";
637 }
638
639 /**
640 * @tc.number: AccessibleAbilityManagerServiceUnitTest_GetTouchGuideState_001
641 * @tc.name: GetTouchGuideState
642 * @tc.desc: Test function GetTouchGuideState
643 */
644 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetTouchGuideState_001, TestSize.Level1)
645 {
646 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetTouchGuideState_001 start";
647 EXPECT_FALSE(Singleton<AccessibleAbilityManagerService>::GetInstance().GetTouchGuideState());
648 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetTouchGuideState_001 end";
649 }
650
651 /**
652 * @tc.number: AccessibleAbilityManagerServiceUnitTest_GetGestureState_001
653 * @tc.name: GetGestureState
654 * @tc.desc: Test function GetGestureState
655 */
656 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetGestureState_001, TestSize.Level1)
657 {
658 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetGestureState_001 start";
659 EXPECT_FALSE(Singleton<AccessibleAbilityManagerService>::GetInstance().GetGestureState());
660 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetGestureState_001 end";
661 }
662
663 /**
664 * @tc.number: AccessibleAbilityManagerServiceUnitTest_GetKeyEventObserverState_001
665 * @tc.name: GetKeyEventObserverState
666 * @tc.desc: Test function GetKeyEventObserverState
667 */
668 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetKeyEventObserverState_001, TestSize.Level1)
669 {
670 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetKeyEventObserverState_001 start";
671 EXPECT_FALSE(Singleton<AccessibleAbilityManagerService>::GetInstance().GetKeyEventObserverState());
672 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetKeyEventObserverState_001 end";
673 }
674
675 /**
676 * @tc.number: AccessibleAbilityManagerServiceUnitTest_GetActiveWindow_001
677 * @tc.name: GetActiveWindow
678 * @tc.desc: Test function GetActiveWindow
679 */
680 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetActiveWindow_001, TestSize.Level1)
681 {
682 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetActiveWindow_001 start";
683 Singleton<AccessibilityWindowManager>::GetInstance().SetActiveWindow(ACTIVE_WINDOW_VALUE);
684 EXPECT_EQ(ACTIVE_WINDOW_VALUE, Singleton<AccessibleAbilityManagerService>::GetInstance().GetActiveWindow());
685 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetActiveWindow_001 end";
686 }
687
688 /**
689 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetCaptionProperty_001
690 * @tc.name: SetCaptionProperty
691 * @tc.desc: Test function SetCaptionProperty GetCaptionProperty
692 */
693 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetCaptionProperty_001, TestSize.Level1)
694 {
695 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetCaptionProperty_001 start";
696 AccessibilityConfig::CaptionProperty caption;
697 int scale = 1;
698 caption.SetFontScale(scale);
699 EXPECT_EQ(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetCaptionProperty(caption));
700
701 AccessibilityConfig::CaptionProperty res;
702 EXPECT_EQ(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetCaptionProperty(res));
703 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetCaptionProperty_001 end";
704 }
705
706 /**
707 * @tc.number: AccessibleAbility_ManagerService_UnitTest_PackageAdd_001
708 * @tc.name: PackageAdd
709 * @tc.desc: Test function PackageAdd
710 */
711 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, PackageAdd_001, TestSize.Level1)
712 {
713 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_PackageAdd_001 start";
714
715 std::string bundleName = "bundleName1";
716 Singleton<AccessibleAbilityManagerService>::GetInstance().PackageAdd(bundleName);
717 EXPECT_NE(stub_.GetRefPtr(), nullptr);
718 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_PackageAdd_001 end";
719 }
720
721 /**
722 * @tc.number: AccessibleAbility_ManagerService_UnitTest_PackageRemoved_001
723 * @tc.name: PackageRemoved
724 * @tc.desc: Test function PackageRemoved
725 */
726 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, PackageRemoved_001, TestSize.Level1)
727 {
728 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_PackageRemoved_001 start";
729 std::string bundleName = "bundleName1";
730 Singleton<AccessibleAbilityManagerService>::GetInstance().PackageRemoved(bundleName);
731 EXPECT_NE(stub_.GetRefPtr(), nullptr);
732 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_PackageRemoved_001 end";
733 }
734
735 /**
736 * @tc.number: AccessibleAbility_ManagerService_UnitTest_AddedUser_001
737 * @tc.name: AddedUser
738 * @tc.desc: Test function AddedUser
739 */
740 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, AddedUser_001, TestSize.Level1)
741 {
742 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_AddedUser_001 start";
743 int32_t accountId = 1;
744 Singleton<AccessibleAbilityManagerService>::GetInstance().AddedUser(accountId);
745 EXPECT_NE(stub_.GetRefPtr(), nullptr);
746 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_AddedUser_001 end";
747 }
748
749 /**
750 * @tc.number: AccessibleAbility_ManagerService_UnitTest_EnableShortKeyTargetAbility_001
751 * @tc.name: EnableShortKeyTargetAbility
752 * @tc.desc: Test function EnableShortKeyTargetAbility
753 */
754 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, EnableShortKeyTargetAbility_001, TestSize.Level1)
755 {
756 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_EnableShortKeyTargetAbility_001 start";
757 EXPECT_FALSE(Singleton<AccessibleAbilityManagerService>::GetInstance().EnableShortKeyTargetAbility());
758 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_EnableShortKeyTargetAbility_001 end";
759 }
760
761 /**
762 * @tc.number: AccessibleAbility_ManagerService_UnitTest_DisableShortKeyTargetAbility_001
763 * @tc.name: DisableShortKeyTargetAbility
764 * @tc.desc: Test function DisableShortKeyTargetAbility
765 */
766 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, DisableShortKeyTargetAbility_001, TestSize.Level1)
767 {
768 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_DisableShortKeyTargetAbility_001 start";
769 EXPECT_FALSE(Singleton<AccessibleAbilityManagerService>::GetInstance().DisableShortKeyTargetAbility());
770 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_DisableShortKeyTargetAbility_001 end";
771 }
772
773 /**
774 * @tc.number: AccessibleAbility_ManagerService_UnitTest_EnableAbility_001
775 * @tc.name: EnableAbility
776 * @tc.desc: Test function EnableAbility
777 */
778 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, EnableAbility_001, TestSize.Level1)
779 {
780 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_EnableAbility_001 start";
781 std::string name = "test";
782 uint32_t capabilities = 1;
783 EXPECT_EQ(RET_ERR_NOT_INSTALLED,
784 Singleton<AccessibleAbilityManagerService>::GetInstance().EnableAbility(name, capabilities));
785 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_EnableAbility_001 end";
786 }
787
788 /*
789 * @tc.number: AccessibleAbility_ManagerService_UnitTest_DisableAbility_001
790 * @tc.name: DisableAbility
791 * @tc.desc: Test function DisableAbility
792 */
793 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, DisableAbility_001, TestSize.Level1)
794 {
795 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_DisableAbility_001 start";
796 std::string name = "test";
797 EXPECT_EQ(RET_ERR_NOT_ENABLED, Singleton<AccessibleAbilityManagerService>::GetInstance().DisableAbility(name));
798 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_DisableAbility_001 end";
799 }
800
801 /*
802 * @tc.number: AccessibleAbility_ManagerService_UnitTest_GetEnabledAbilities_001
803 * @tc.name: GetEnabledAbilities
804 * @tc.desc: Test function GetEnabledAbilities
805 */
806 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetEnabledAbilities_001, TestSize.Level1)
807 {
808 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_GetEnabledAbilities_001 start";
809 std::vector<std::string> enabledAbilities;
810 EXPECT_EQ(RET_OK,
811 Singleton<AccessibleAbilityManagerService>::GetInstance().GetEnabledAbilities(enabledAbilities));
812 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_GetEnabledAbilities_001 end";
813 }
814
815 /*
816 * @tc.number: AccessibleAbility_ManagerService_UnitTest_EnableUITestAbility_001
817 * @tc.name: EnableUITestAbility
818 * @tc.desc: Test function EnableUITestAbility
819 */
820 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, EnableUITestAbility_001, TestSize.Level1)
821 {
822 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_EnableUITestAbility_001 start";
823 sptr<IRemoteObject> obj;
824 EXPECT_EQ(RET_ERR_NULLPTR, Singleton<AccessibleAbilityManagerService>::GetInstance().EnableUITestAbility(obj));
825 GTEST_LOG_(INFO) << "Accessib le_Ability_Manager_ServiceUnittest_EnableUITestAbility_001 end";
826 }
827
828 /*
829 * @tc.number: AccessibleAbility_ManagerService_UnitTest_DisableUITestAbility_001
830 * @tc.name: DisableUITestAbility
831 * @tc.desc: Test function DisableUITestAbility
832 */
833 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, DisableUITestAbility_001, TestSize.Level1)
834 {
835 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_DisableUITestAbility_001 start";
836 EXPECT_EQ(RET_ERR_NO_CONNECTION, Singleton<AccessibleAbilityManagerService>::GetInstance().DisableUITestAbility());
837 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_DisableUITestAbility_001 end";
838 }
839
840 /**
841 * @tc.number: AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterCaptionObserver_001
842 * @tc.name: RegisterCaptionObserver
843 * @tc.desc: Test function RegisterCaptionObserver
844 */
845 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, RegisterCaptionObserver_001, TestSize.Level1)
846 {
847 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterCaptionObserver_001 start";
848
849 sptr<MockAccessibleAbilityManagerCaptionObserverStub> stub = new MockAccessibleAbilityManagerCaptionObserverStub();
850 sptr<IAccessibleAbilityManagerCaptionObserver> state = new MockAccessibleAbilityManagerCaptionObserverProxy(stub);
851
852 uint32_t ret = Singleton<AccessibleAbilityManagerService>::GetInstance().RegisterCaptionObserver(state);
853 EXPECT_EQ(ret, 0);
854
855 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterCaptionObserver_001 end";
856 }
857
858 /*
859 * @tc.number: AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterConfigObserver_001
860 * @tc.name: RegisterConfigObserver
861 * @tc.desc: Test function RegisterConfigObserver
862 */
863 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, RegisterConfigObserver_001, TestSize.Level1)
864 {
865 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterConfigObserver_001 start";
866
867 sptr<MockAccessibleAbilityManagerConfigObserverStub> stub = new MockAccessibleAbilityManagerConfigObserverStub();
868 sptr<IAccessibleAbilityManagerConfigObserver> state = new MockAccessibleAbilityManagerConfigObserverProxy(stub);
869
870 uint32_t ret = Singleton<AccessibleAbilityManagerService>::GetInstance().RegisterConfigObserver(state);
871 EXPECT_EQ(ret, 0);
872
873 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterConfigObserver_001 end";
874 }
875
876 /*
877 * @tc.number: AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterEnableAbilityListsObserver_001
878 * @tc.name: RegisterEnableAbilityListsObserver
879 * @tc.desc: Test function RegisterEnableAbilityListsObserver
880 */
881 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, RegisterEnableAbilityListsObserver_001, TestSize.Level1)
882 {
883 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterEnableAbilityListsObserver_001 start";
884
885 sptr<MockAccessibilityEnableAbilityListsObserverStub> stub = new MockAccessibilityEnableAbilityListsObserverStub();
886 sptr<IAccessibilityEnableAbilityListsObserver> state = new MockAccessibilityEnableAbilityListsObserverProxy(stub);
887
888 Singleton<AccessibleAbilityManagerService>::GetInstance().RegisterEnableAbilityListsObserver(state);
889 EXPECT_NE(stub.GetRefPtr(), nullptr);
890 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterEnableAbilityListsObserver_001 end";
891 }
892
893 /**
894 * @tc.number: AccessibleAbility_ManagerService_UnitTest_SwitchedUser_001
895 * @tc.name: SwitchedUser
896 * @tc.desc: Test function SwitchedUser
897 */
898 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SwitchedUser_001, TestSize.Level1)
899 {
900 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_SwitchedUser_001 start";
901 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(100);
902 sleep(SLEEP_TIME_1);
903 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(2);
904 EXPECT_NE(stub_.GetRefPtr(), nullptr);
905 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_SwitchedUser_001 end";
906 }
907
908 /**
909 * @tc.number: AccessibleAbility_ManagerService_UnitTest_GetAbilityList_002
910 * @tc.name: GetAbilityList
911 * @tc.desc: Test function GetAbilityList
912 */
913 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetAbilityList_002, TestSize.Level1)
914 {
915 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetAbilityList_002 start";
916 sleep(SLEEP_TIME_1);
917 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
918 std::vector<OHOS::Accessibility::AccessibilityAbilityInfo> infos;
919 Singleton<AccessibleAbilityManagerService>::GetInstance().GetAbilityList(0xFFFFFFFF, 3, infos);
920 EXPECT_NE(stub_.GetRefPtr(), nullptr);
921 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_GetAbilityList_002 end";
922 }
923
924 /**
925 * @tc.number: Accessible_Ability_ManagerService_UnitTest_RegisterElementOperator_002
926 * @tc.name: RegisterElementOperator
927 * @tc.desc: Test function RegisterElementOperator
928 */
929 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, RegisterElementOperator_002, TestSize.Level1)
930 {
931 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterElementOperator_002 start";
932 sleep(SLEEP_TIME_1);
933 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
934 Singleton<AccessibleAbilityManagerService>::GetInstance().RegisterElementOperator(0, nullptr, true);
935 EXPECT_NE(stub_.GetRefPtr(), nullptr);
936 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterElementOperator_002 end";
937 }
938
939 /**
940 * @tc.number: Accessible_Ability_ManagerService_UnitTest_RegisterElementOperator_003
941 * @tc.name: RegisterElementOperator
942 * @tc.desc: Test function RegisterElementOperator
943 */
944 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, RegisterElementOperator_003, TestSize.Level1)
945 {
946 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterElementOperator_003 start";
947 auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
948 ASSERT_TRUE(accountData);
949 sptr<IAccessibilityElementOperator> operation;
950 Singleton<AccessibleAbilityManagerService>::GetInstance().RegisterElementOperator(0, operation, true);
951 sleep(SLEEP_TIME_1);
952 Singleton<AccessibleAbilityManagerService>::GetInstance().RegisterElementOperator(0, operation, true);
953 auto map = accountData->GetAsacConnections();
954 EXPECT_EQ(int(map.size()), 1);
955 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterElementOperator_003 end";
956 }
957
958 /**
959 * @tc.number: AccessibleAbility_ManagerService_UnitTest_UpdateAccessibilityManagerService_001
960 * @tc.name: UpdateAccessibilityManagerService
961 * @tc.desc: Test function UpdateAccessibilityManagerService
962 */
963 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, UpdateAccessibilityManagerService_001, TestSize.Level1)
964 {
965 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_UpdateAccessibilityManagerService_001 start";
966 sleep(SLEEP_TIME_1);
967 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
968 Singleton<AccessibleAbilityManagerService>::GetInstance().UpdateAccessibilityManagerService();
969 EXPECT_NE(stub_.GetRefPtr(), nullptr);
970 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_UpdateAccessibilityManagerService_001 end";
971 }
972
973 /**
974 * @tc.number: AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterStateCallback_002
975 * @tc.name: RegisterStateCallback
976 * @tc.desc: Test function RegisterStateCallback
977 */
978 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, RegisterStateCallback_002, TestSize.Level1)
979 {
980 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterStateCallback_00 start";
981 sleep(SLEEP_TIME_1);
982 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
983 sptr<AccessibleAbilityManagerStateObserverStub> stub = new MockAccessibleAbilityManagerStateObserverStub();
984 sptr<IAccessibleAbilityManagerStateObserver> state = new MockAccessibleAbilityManagerStateObserverProxy(stub);
985
986 uint32_t ret = Singleton<AccessibleAbilityManagerService>::GetInstance().RegisterStateObserver(state);
987 EXPECT_EQ(ret, 0);
988
989 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterStateCallback_002 end";
990 }
991
992 /**
993 * @tc.number: AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterCaptionObserver_002
994 * @tc.name: RegisterCaptionObserver
995 * @tc.desc: Test function RegisterCaptionObserver
996 */
997 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, RegisterCaptionObserver_002, TestSize.Level1)
998 {
999 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterCaptionObserver_002 start";
1000 sleep(SLEEP_TIME_1);
1001 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1002 sptr<MockAccessibleAbilityManagerCaptionObserverStub> stub = new MockAccessibleAbilityManagerCaptionObserverStub();
1003 sptr<IAccessibleAbilityManagerCaptionObserver> state = new MockAccessibleAbilityManagerCaptionObserverProxy(stub);
1004
1005 uint32_t ret = Singleton<AccessibleAbilityManagerService>::GetInstance().RegisterCaptionObserver(state);
1006 EXPECT_EQ(ret, ERR_INVALID_VALUE);
1007
1008 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterCaptionObserver_002 end";
1009 }
1010
1011 /**
1012 * @tc.number: AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterCaptionObserver_003
1013 * @tc.name: RegisterCaptionObserver
1014 * @tc.desc: Test function RegisterCaptionObserver
1015 */
1016 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, RegisterCaptionObserver_003, TestSize.Level1)
1017 {
1018 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterCaptionObserver_003 start";
1019 uint32_t ret = Singleton<AccessibleAbilityManagerService>::GetInstance().RegisterCaptionObserver(nullptr);
1020 EXPECT_EQ(ret, ERR_INVALID_VALUE);
1021
1022 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterCaptionObserver_003 end";
1023 }
1024
1025 /*
1026 * @tc.number: AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterEnableAbilityListsObserver_002
1027 * @tc.name: RegisterEnableAbilityListsObserver
1028 * @tc.desc: Test function RegisterEnableAbilityListsObserver
1029 */
1030 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, RegisterEnableAbilityListsObserver_002, TestSize.Level1)
1031 {
1032 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterEnableAbilityListsObserver_002 start";
1033 sleep(SLEEP_TIME_1);
1034 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1035 sptr<MockAccessibilityEnableAbilityListsObserverStub> stub = new MockAccessibilityEnableAbilityListsObserverStub();
1036 sptr<IAccessibilityEnableAbilityListsObserver> state = new MockAccessibilityEnableAbilityListsObserverProxy(stub);
1037
1038 Singleton<AccessibleAbilityManagerService>::GetInstance().RegisterEnableAbilityListsObserver(state);
1039 EXPECT_NE(stub.GetRefPtr(), nullptr);
1040 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterEnableAbilityListsObserver_002 end";
1041 }
1042
1043 /*
1044 * @tc.number: AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterEnableAbilityListsObserver_003
1045 * @tc.name: RegisterEnableAbilityListsObserver
1046 * @tc.desc: Test function RegisterEnableAbilityListsObserver
1047 */
1048 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, RegisterEnableAbilityListsObserver_003, TestSize.Level1)
1049 {
1050 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterEnableAbilityListsObserver_003 start";
1051 Singleton<AccessibleAbilityManagerService>::GetInstance().RegisterEnableAbilityListsObserver(nullptr);
1052 EXPECT_NE(stub_.GetRefPtr(), nullptr);
1053 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterEnableAbilityListsObserver_003 end";
1054 }
1055
1056 /**
1057 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetCaptionProperty_002
1058 * @tc.name: SetCaptionProperty
1059 * @tc.desc: Test function SetCaptionProperty GetCaptionProperty
1060 */
1061 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetCaptionProperty_002, TestSize.Level1)
1062 {
1063 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetCaptionProperty_002 start";
1064 sleep(SLEEP_TIME_1);
1065 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1066 AccessibilityConfig::CaptionProperty caption;
1067 int scale = 1;
1068 caption.SetFontScale(scale);
1069 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetCaptionProperty(caption));
1070 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetCaptionProperty(caption));
1071 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetCaptionProperty_002 end";
1072 }
1073
1074 /**
1075 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetCaptionState_002
1076 * @tc.name: SetCaptionState
1077 * @tc.desc: Test function SetCaptionState GetCaptionState
1078 */
1079 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetCaptionState_002, TestSize.Level1)
1080 {
1081 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetCaptionState_002 start";
1082 sleep(SLEEP_TIME_1);
1083 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1084 bool state = true;
1085 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetCaptionState(state));
1086 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetCaptionState(state));
1087 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetCaptionState_002 end";
1088 }
1089
1090 /**
1091 * @tc.number: AccessibleAbilityManagerServiceUnitTest_GetTouchGuideState_002
1092 * @tc.name: GetTouchGuideState
1093 * @tc.desc: Test function GetTouchGuideState
1094 */
1095 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetTouchGuideState_002, TestSize.Level1)
1096 {
1097 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetTouchGuideState_002 start";
1098 sleep(SLEEP_TIME_1);
1099 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1100 EXPECT_FALSE(Singleton<AccessibleAbilityManagerService>::GetInstance().GetTouchGuideState());
1101 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetTouchGuideState_002 end";
1102 }
1103
1104 /**
1105 * @tc.number: AccessibleAbilityManagerServiceUnitTest_GetGestureState_002
1106 * @tc.name: GetGestureState
1107 * @tc.desc: Test function GetGestureState
1108 */
1109 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetGestureState_002, TestSize.Level1)
1110 {
1111 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetGestureState_002 start";
1112 sleep(SLEEP_TIME_1);
1113 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1114 EXPECT_FALSE(Singleton<AccessibleAbilityManagerService>::GetInstance().GetGestureState());
1115 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetGestureState_002 end";
1116 }
1117
1118 /**
1119 * @tc.number: AccessibleAbilityManagerServiceUnitTest_GetKeyEventObserverState_002
1120 * @tc.name: GetKeyEventObserverState
1121 * @tc.desc: Test function GetKeyEventObserverState
1122 */
1123 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetKeyEventObserverState_002, TestSize.Level1)
1124 {
1125 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetKeyEventObserverState_002 start";
1126 sleep(SLEEP_TIME_1);
1127 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1128 EXPECT_FALSE(Singleton<AccessibleAbilityManagerService>::GetInstance().GetKeyEventObserverState());
1129 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetKeyEventObserverState_002 end";
1130 }
1131
1132 /**
1133 * @tc.number: AccessibleAbility_ManagerService_UnitTest_EnableAbility_002
1134 * @tc.name: EnableAbility
1135 * @tc.desc: Test function EnableAbility
1136 */
1137 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, EnableAbility_002, TestSize.Level1)
1138 {
1139 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_EnableAbility_002 start";
1140 sleep(SLEEP_TIME_1);
1141 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1142 std::string name = "test";
1143 uint32_t capabilities = 1;
1144 EXPECT_EQ(RET_ERR_NULLPTR,
1145 Singleton<AccessibleAbilityManagerService>::GetInstance().EnableAbility(name, capabilities));
1146 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_EnableAbility_002 end";
1147 }
1148
1149 /*
1150 * @tc.number: AccessibleAbility_ManagerService_UnitTest_GetEnabledAbilities_002
1151 * @tc.name: GetEnabledAbilities
1152 * @tc.desc: Test function GetEnabledAbilities
1153 */
1154 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetEnabledAbilities_002, TestSize.Level1)
1155 {
1156 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_GetEnabledAbilities_002 start";
1157 sleep(SLEEP_TIME_1);
1158 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1159 std::vector<std::string> enabledAbilities;
1160 EXPECT_EQ(RET_ERR_NULLPTR,
1161 Singleton<AccessibleAbilityManagerService>::GetInstance().GetEnabledAbilities(enabledAbilities));
1162 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_GetEnabledAbilities_002 end";
1163 }
1164
1165 /*
1166 * @tc.number: AccessibleAbility_ManagerService_UnitTest_DisableAbility_002
1167 * @tc.name: DisableAbility
1168 * @tc.desc: Test function DisableAbility
1169 */
1170 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, DisableAbility_002, TestSize.Level1)
1171 {
1172 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_DisableAbility_002 start";
1173 sleep(SLEEP_TIME_1);
1174 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1175 std::string name = "test";
1176 EXPECT_EQ(RET_ERR_NULLPTR, Singleton<AccessibleAbilityManagerService>::GetInstance().DisableAbility(name));
1177 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_DisableAbility_002 end";
1178 }
1179
1180 /*
1181 * @tc.number: AccessibleAbility_ManagerService_UnitTest_EnableUITestAbility_002
1182 * @tc.name: EnableUITestAbility
1183 * @tc.desc: Test function EnableUITestAbility
1184 */
1185 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, EnableUITestAbility_002, TestSize.Level1)
1186 {
1187 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_EnableUITestAbility_002 start";
1188 sleep(SLEEP_TIME_1);
1189 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1190 sptr<IRemoteObject> obj;
1191 EXPECT_EQ(RET_ERR_NULLPTR, Singleton<AccessibleAbilityManagerService>::GetInstance().EnableUITestAbility(obj));
1192 GTEST_LOG_(INFO) << "Accessib le_Ability_Manager_ServiceUnittest_EnableUITestAbility_002 end";
1193 }
1194
1195 /*
1196 * @tc.number: AccessibleAbility_ManagerService_UnitTest_DisableUITestAbility_002
1197 * @tc.name: DisableUITestAbility
1198 * @tc.desc: Test function DisableUITestAbility
1199 */
1200 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, DisableUITestAbility_002, TestSize.Level1)
1201 {
1202 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_DisableUITestAbility_002 start";
1203 sleep(SLEEP_TIME_1);
1204 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1205 EXPECT_EQ(Singleton<AccessibleAbilityManagerService>::GetInstance().DisableUITestAbility(), RET_ERR_NULLPTR);
1206 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_DisableUITestAbility_002 end";
1207 }
1208
1209 /**
1210 * @tc.number: AccessibleAbility_ManagerService_UnitTest_EnableShortKeyTargetAbility_002
1211 * @tc.name: EnableShortKeyTargetAbility
1212 * @tc.desc: Test function EnableShortKeyTargetAbility
1213 */
1214 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, EnableShortKeyTargetAbility_002, TestSize.Level1)
1215 {
1216 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_EnableShortKeyTargetAbility_002 start";
1217 sleep(SLEEP_TIME_1);
1218 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1219 EXPECT_FALSE(Singleton<AccessibleAbilityManagerService>::GetInstance().EnableShortKeyTargetAbility());
1220 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_EnableShortKeyTargetAbility_002 end";
1221 }
1222
1223 /**
1224 * @tc.number: AccessibleAbility_ManagerService_UnitTest_DisableShortKeyTargetAbility_002
1225 * @tc.name: DisableShortKeyTargetAbility
1226 * @tc.desc: Test function DisableShortKeyTargetAbility
1227 */
1228 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, DisableShortKeyTargetAbility_002, TestSize.Level1)
1229 {
1230 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_DisableShortKeyTargetAbility_002 start";
1231 sleep(SLEEP_TIME_1);
1232 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1233 EXPECT_FALSE(Singleton<AccessibleAbilityManagerService>::GetInstance().DisableShortKeyTargetAbility());
1234 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_DisableShortKeyTargetAbility_002 end";
1235 }
1236
1237 /**
1238 * @tc.number: AccessibleAbility_ManagerService_UnitTest_PackageRemoved_002
1239 * @tc.name: PackageRemoved
1240 * @tc.desc: Test function PackageRemoved
1241 */
1242 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, PackageRemoved_002, TestSize.Level1)
1243 {
1244 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_PackageRemoved_002 start";
1245 sleep(SLEEP_TIME_1);
1246 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1247 std::string bundleName = "bundleName1";
1248 Singleton<AccessibleAbilityManagerService>::GetInstance().PackageRemoved(bundleName);
1249 EXPECT_NE(stub_.GetRefPtr(), nullptr);
1250 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_PackageRemoved_002 end";
1251 }
1252
1253 /**
1254 * @tc.number: AccessibleAbility_ManagerService_UnitTest_PackageAdd_002
1255 * @tc.name: PackageAdd
1256 * @tc.desc: Test function PackageAdd
1257 */
1258 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, PackageAdd_002, TestSize.Level1)
1259 {
1260 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_PackageAdd_002 start";
1261 sleep(SLEEP_TIME_1);
1262 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1263 std::string bundleName = "bundleName1";
1264 Singleton<AccessibleAbilityManagerService>::GetInstance().PackageAdd(bundleName);
1265 EXPECT_NE(stub_.GetRefPtr(), nullptr);
1266 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_PackageAdd_002 end";
1267 }
1268
1269 /*
1270 * @tc.number: AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterConfigObserver_002
1271 * @tc.name: RegisterConfigObserver
1272 * @tc.desc: Test function RegisterConfigObserver
1273 */
1274 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, RegisterConfigObserver_002, TestSize.Level1)
1275 {
1276 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterConfigObserver_002 start";
1277 uint32_t ret = Singleton<AccessibleAbilityManagerService>::GetInstance().RegisterConfigObserver(nullptr);
1278 EXPECT_EQ(ret, ERR_INVALID_VALUE);
1279 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterConfigObserver_002 end";
1280 }
1281
1282 /**
1283 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetScreenMagnificationState_002
1284 * @tc.name: SetScreenMagnificationState
1285 * @tc.desc: Test function SetScreenMagnificationState GetScreenMagnificationState
1286 */
1287
1288 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetScreenMagnificationState_002, TestSize.Level1)
1289 {
1290 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetScreenMagnificationState_000 start";
1291 sleep(SLEEP_TIME_1);
1292 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1293 bool state = true;
1294 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetScreenMagnificationState(state));
1295 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetScreenMagnificationState(state));
1296 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetScreenMagnificationState_002 end";
1297 }
1298
1299 /**
1300 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetShortKeyState_002
1301 * @tc.name: SetShortKeyState
1302 * @tc.desc: Test function SetShortKeyState GetShortKeyState
1303 * @tc.require: issueI5NTXH
1304 */
1305 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetShortKeyState_002, TestSize.Level1)
1306 {
1307 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetShortKeyState_002 start";
1308 sleep(SLEEP_TIME_1);
1309 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1310 bool state = true;
1311 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetShortKeyState(state));
1312 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetShortKeyState(state));
1313 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetShortKeyState_002 end";
1314 }
1315
1316 /**
1317 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetMouseKeyState_002
1318 * @tc.name: SetMouseKeyState
1319 * @tc.desc: Test function SetMouseKeyState GetMouseKeyState
1320 * @tc.require: issueI5NTXA
1321 */
1322 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetMouseKeyState_002, TestSize.Level1)
1323 {
1324 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetMouseKeyState_002 start";
1325 sleep(SLEEP_TIME_1);
1326 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1327 bool state = true;
1328 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetMouseKeyState(state));
1329 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetMouseKeyState(state));
1330 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetMouseKeyState_002 end";
1331 }
1332
1333 /**
1334 * @tc.number: Accessible_Ability_ManagerService_UnitTest_SetSearchElementInfoByAccessibilityIdResult_001
1335 * @tc.name: SetSearchElementInfoByAccessibilityIdResult
1336 * @tc.desc: Test function SetSearchElementInfoByAccessibilityIdResult
1337 */
1338 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetSearchElementInfoByAccessibilityIdResult_001, TestSize.Level1)
1339 {
1340 GTEST_LOG_(INFO) << "ManagerService_UnitTest_SetSearchElementInfoByAccessibilityIdResult_001 start";
1341 std::vector<AccessibilityElementInfo> infos;
1342 int32_t requestId = 0;
1343 AccessibleAbilityManagerService::ElementOperatorCallbackImpl *obj = new
1344 AccessibleAbilityManagerService::ElementOperatorCallbackImpl();
1345 obj->SetSearchElementInfoByAccessibilityIdResult(infos, requestId);
1346 delete obj;
1347 GTEST_LOG_(INFO) << "ManagerService_UnitTest_SetSearchElementInfoByAccessibilityIdResult_001 end";
1348 }
1349
1350 /**
1351 * @tc.number: Accessible_Ability_ManagerService_UnitTest_SetSearchElementInfoByTextResult_001
1352 * @tc.name: SetSearchElementInfoByTextResult
1353 * @tc.desc: Test function SetSearchElementInfoByTextResult
1354 */
1355 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetSearchElementInfoByTextResult_001, TestSize.Level1)
1356 {
1357 GTEST_LOG_(INFO) << "Accessible_Ability_ManagerService_UnitTest_SetSearchElementInfoByTextResult_001 start";
1358 std::vector<AccessibilityElementInfo> infos;
1359 int32_t requestId = 0;
1360 AccessibleAbilityManagerService::ElementOperatorCallbackImpl *obj = new
1361 AccessibleAbilityManagerService::ElementOperatorCallbackImpl();
1362 obj->SetSearchElementInfoByTextResult(infos, requestId);
1363 delete obj;
1364 GTEST_LOG_(INFO) << "Accessible_Ability_ManagerService_UnitTest_SetSearchElementInfoByTextResult_001 end";
1365 }
1366
1367 /**
1368 * @tc.number: Accessible_Ability_ManagerService_UnitTest_SetFindFocusedElementInfoResult_001
1369 * @tc.name: SetFindFocusedElementInfoResult
1370 * @tc.desc: Test function SetFindFocusedElementInfoResult
1371 */
1372 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetFindFocusedElementInfoResult_001, TestSize.Level1)
1373 {
1374 GTEST_LOG_(INFO) << "Accessible_Ability_ManagerService_UnitTest_SetFindFocusedElementInfoResult_001 start";
1375 AccessibilityElementInfo info;
1376 int32_t requestId = 0;
1377 AccessibleAbilityManagerService::ElementOperatorCallbackImpl *obj = new
1378 AccessibleAbilityManagerService::ElementOperatorCallbackImpl();
1379 obj->SetFindFocusedElementInfoResult(info, requestId);
1380 delete obj;
1381 GTEST_LOG_(INFO) << "Accessible_Ability_ManagerService_UnitTest_SetFindFocusedElementInfoResult_001 end";
1382 }
1383
1384 /**
1385 * @tc.number: Accessible_Ability_ManagerService_UnitTest_SetFocusMoveSearchResult_001
1386 * @tc.name: SetFocusMoveSearchResult
1387 * @tc.desc: Test function SetFocusMoveSearchResult
1388 */
1389 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetFocusMoveSearchResult_001, TestSize.Level1)
1390 {
1391 GTEST_LOG_(INFO) << "Accessible_Ability_ManagerService_UnitTest_SetFocusMoveSearchResult_001 start";
1392 AccessibilityElementInfo info;
1393 int32_t requestId = 0;
1394 AccessibleAbilityManagerService::ElementOperatorCallbackImpl *obj = new
1395 AccessibleAbilityManagerService::ElementOperatorCallbackImpl();
1396 obj->SetFocusMoveSearchResult(info, requestId);
1397 delete obj;;
1398 GTEST_LOG_(INFO) << "Accessible_Ability_ManagerService_UnitTest_SetFocusMoveSearchResult_001 end";
1399 }
1400
1401 /**
1402 * @tc.number: Accessible_Ability_ManagerService_UnitTest_SetExecuteActionResult_001
1403 * @tc.name: SetExecuteActionResult
1404 * @tc.desc: Test function SetExecuteActionResult
1405 */
1406 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetExecuteActionResult_001, TestSize.Level1)
1407 {
1408 GTEST_LOG_(INFO) << "Accessible_Ability_ManagerService_UnitTest_SetExecuteActionResult_001 start";
1409 AccessibilityElementInfo info;
1410 int32_t requestId = 0;
1411 bool succeeded = true;
1412 AccessibleAbilityManagerService::ElementOperatorCallbackImpl *obj = new
1413 AccessibleAbilityManagerService::ElementOperatorCallbackImpl();
1414 obj->SetExecuteActionResult(succeeded, requestId);
1415 delete obj;;
1416 GTEST_LOG_(INFO) << "Accessible_Ability_ManagerService_UnitTest_SetExecuteActionResult_001 end";
1417 }
1418
1419 /**
1420 * @tc.number: Accessible_Ability_ManagerService_UnitTest_SetCursorPositionResult_001
1421 * @tc.name: SetCursorPositionResult
1422 * @tc.desc: Test function SetCursorPositionResult
1423 */
1424 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetCursorPositionResult_001, TestSize.Level1)
1425 {
1426 GTEST_LOG_(INFO) << "Accessible_Ability_ManagerService_UnitTest_SetCursorPositionResult_001 start";
1427 AccessibilityElementInfo info;
1428 int32_t requestId = 0;
1429 int32_t cursorPosition = 0;
1430 AccessibleAbilityManagerService::ElementOperatorCallbackImpl *obj = new
1431 AccessibleAbilityManagerService::ElementOperatorCallbackImpl();
1432 obj->SetCursorPositionResult(cursorPosition, requestId);
1433 delete obj;
1434
1435 GTEST_LOG_(INFO) << "Accessible_Ability_ManagerService_UnitTest_SetCursorPositionResult_001 end";
1436 }
1437
1438 /**
1439 * @tc.number: Accessible_Ability_ManagerService_UnitTest_SetShortkeyMultiTarget_001
1440 * @tc.name: SetShortkeyMultiTarget
1441 * @tc.desc: Test function SetShortkeyMultiTarget
1442 */
1443 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetShortkeyMultiTarget_001, TestSize.Level1)
1444 {
1445 GTEST_LOG_(INFO) << "Accessible_Ability_ManagerService_UnitTest_SetShortkeyMultiTarget_001 start";
1446 std::vector<std::string> name;
1447 Singleton<AccessibleAbilityManagerService>::GetInstance().SetShortkeyMultiTarget(name);
1448 GTEST_LOG_(INFO) << "Accessible_Ability_ManagerService_UnitTest_SetShortkeyMultiTarget_001 end";
1449 }
1450
1451 /**
1452 * @tc.number: Accessible_Ability_ManagerService_UnitTest_GetShortkeyMultiTarget_001
1453 * @tc.name: GetShortkeyMultiTarget
1454 * @tc.desc: Test function GetShortkeyMultiTarget
1455 */
1456 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetShortkeyMultiTarget_001, TestSize.Level1)
1457 {
1458 GTEST_LOG_(INFO) << "Accessible_Ability_ManagerService_UnitTest_GetShortkeyMultiTarget_001 start";
1459 std::vector<std::string> name;
1460 Singleton<AccessibleAbilityManagerService>::GetInstance().GetShortkeyMultiTarget(name);
1461 GTEST_LOG_(INFO) << "Accessible_Ability_ManagerService_UnitTest_GetShortkeyMultiTarget_001 end";
1462 }
1463
1464 /**OnShortKeyProcess
1465 * @tc.number: AccessibleAbility_ManagerService_UnitTest_OnShortKeyProcess_001
1466 * @tc.name: OnShortKeyProcess
1467 * @tc.desc: Test function OnShortKeyProcess
1468 */
1469 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, OnShortKeyProcess_001, TestSize.Level1)
1470 {
1471 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_OnShortKeyProcess_001 start";
1472 Singleton<AccessibleAbilityManagerService>::GetInstance().OnShortKeyProcess();
1473 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_OnShortKeyProcess_001 end";
1474 }
1475
1476 /**
1477 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetMouseAutoClick_002
1478 * @tc.name: SetMouseAutoClick
1479 * @tc.desc: Test function SetMouseAutoClick GetMouseAutoClick
1480 * @tc.require: issueI5NTXC
1481 */
1482 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetMouseAutoClick_002, TestSize.Level1)
1483 {
1484 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetMouseAutoClick_002 start";
1485 sleep(SLEEP_TIME_1);
1486 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1487 int32_t value = MOUSE_AUTO_CLICK_VALUE;
1488 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetMouseAutoClick(value));
1489 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetMouseAutoClick(value));
1490 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetMouseAutoClick_002 end";
1491 }
1492
1493 /**
1494 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetShortkeyTarget_002
1495 * @tc.name: SetShortkeyTarget
1496 * @tc.desc: Test function SetShortkeyTarget GetShortkeyTarget
1497 * @tc.require: issueI5NTXH
1498 */
1499 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetShortkeyTarget_002, TestSize.Level1)
1500 {
1501 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetShortkeyTarget_002 start";
1502 sleep(SLEEP_TIME_1);
1503 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1504 std::string name = "test";
1505 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetShortkeyTarget(name));
1506 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetShortkeyTarget(name));
1507 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetShortkeyTarget_002 end";
1508 }
1509
1510 /**
1511 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetHighContrastTextState_002
1512 * @tc.name: SetHighContrastTextState
1513 * @tc.desc: Test function SetHighContrastTextState GetHighContrastTextState
1514 * @tc.require: issueI5NTX9
1515 */
1516 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetHighContrastTextState_002, TestSize.Level1)
1517 {
1518 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetHighContrastTextState_002 start";
1519 sleep(SLEEP_TIME_1);
1520 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1521 bool state = true;
1522 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetHighContrastTextState(state));
1523 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetHighContrastTextState(state));
1524 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetHighContrastTextState_002 end";
1525 }
1526
1527 /**
1528 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetDaltonizationState_002
1529 * @tc.name: SetDaltonizationState
1530 * @tc.desc: Test function SetDaltonizationState GetDaltonizationState
1531 */
1532 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetDaltonizationState_002, TestSize.Level1)
1533 {
1534 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetDaltonizationState_002 start";
1535 sleep(SLEEP_TIME_1);
1536 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1537 bool state = true;
1538 EXPECT_NE(RET_OK,
1539 Singleton<AccessibleAbilityManagerService>::GetInstance().SetDaltonizationState(state));
1540 EXPECT_NE(RET_OK,
1541 Singleton<AccessibleAbilityManagerService>::GetInstance().GetDaltonizationState(state));
1542 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetDaltonizationState_002 end";
1543 }
1544
1545 /**
1546 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetInvertColorState_002
1547 * @tc.name: SetInvertColorState
1548 * @tc.desc: Test function SetInvertColorState GetInvertColorState
1549 * @tc.require: issueI5NTX7
1550 */
1551 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetInvertColorState_002, TestSize.Level1)
1552 {
1553 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetInvertColorState_002 start";
1554 sleep(SLEEP_TIME_1);
1555 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1556 bool state = true;
1557 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetInvertColorState(state));
1558 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetInvertColorState(state));
1559 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetInvertColorState_002 end";
1560 }
1561
1562 /**
1563 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetAnimationOffState_002
1564 * @tc.name: SetAnimationOffState
1565 * @tc.desc: Test function SetAnimationOffState GetAnimationOffState
1566 * @tc.require: issueI5NTXG
1567 */
1568 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetAnimationOffState_002, TestSize.Level1)
1569 {
1570 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetAnimationOffState_002 start";
1571 sleep(SLEEP_TIME_1);
1572 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1573 bool state = true;
1574 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetAnimationOffState(state));
1575 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetAnimationOffState(state));
1576 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetAnimationOffState_002 end";
1577 }
1578
1579 /**
1580 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetAudioMonoState_002
1581 * @tc.name: SetAudioMonoState
1582 * @tc.desc: Test function SetAudioMonoState GetAudioMonoState
1583 */
1584 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetAudioMonoState_002, TestSize.Level1)
1585 {
1586 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetAudioMonoState_002 start";
1587 sleep(SLEEP_TIME_1);
1588 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1589 bool state = true;
1590 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetAudioMonoState(state));
1591 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetAudioMonoState(state));
1592 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetAudioMonoState_002 end";
1593 }
1594
1595 /**
1596 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetDaltonizationColorFilter_002
1597 * @tc.name: SetDaltonizationColorFilter
1598 * @tc.desc: Test function SetDaltonizationColorFilter GetDaltonizationColorFilter
1599 * @tc.require: issueI5NTX8
1600 */
1601 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetDaltonizationColorFilter_002, TestSize.Level1)
1602 {
1603 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetDaltonizationColorFilter_002 start";
1604 sleep(SLEEP_TIME_1);
1605 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1606 uint32_t filter = 1;
1607 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetDaltonizationColorFilter(filter));
1608 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetDaltonizationColorFilter(filter));
1609 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetDaltonizationColorFilter_002 end";
1610 }
1611
1612 /**
1613 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetContentTimeout_002
1614 * @tc.name: SetContentTimeout
1615 * @tc.desc: Test function SetContentTimeout GetContentTimeout
1616 * @tc.require: issueI5NTXF
1617 */
1618 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetContentTimeout_002, TestSize.Level1)
1619 {
1620 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetContentTimeout_002 start";
1621 sleep(SLEEP_TIME_1);
1622 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1623 uint32_t time = CONTENT_TIMEOUT_VALUE;
1624 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetContentTimeout(time));
1625 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetContentTimeout(time));
1626 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetContentTimeout_002 end";
1627 }
1628
1629 /**
1630 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetBrightnessDiscount_002
1631 * @tc.name: SetBrightnessDiscount
1632 * @tc.desc: Test function SetBrightnessDiscount GetBrightnessDiscount
1633 * @tc.require: issueI5NTXE
1634 */
1635 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetBrightnessDiscount_002, TestSize.Level1)
1636 {
1637 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetBrightnessDiscount_002 start";
1638 sleep(SLEEP_TIME_1);
1639 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1640 float value = BRIGHTNESS_DISCOUNT_VALUE;
1641 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetBrightnessDiscount(value));
1642 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetBrightnessDiscount(value));
1643 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetBrightnessDiscount_002 end";
1644 }
1645
1646 /**
1647 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetAudioBalance_002
1648 * @tc.name: SetAudioBalance
1649 * @tc.desc: Test function SetAudioBalance GetAudioBalance
1650 */
1651 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetAudioBalance_002, TestSize.Level1)
1652 {
1653 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetAudioBalance_002 start";
1654 sleep(SLEEP_TIME_1);
1655 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1656 float value = AUDIO_BALANCE_VALUE;
1657 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetAudioBalance(value));
1658 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetAudioBalance(value));
1659 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SetAudioBalance_002 end";
1660 }
1661
1662 /**
1663 * @tc.number: AccessibleAbilityManagerServiceUnitTest_GetAllConfigs_002
1664 * @tc.name: GetAllConfigs
1665 * @tc.desc: Test function GetAllConfigs
1666 */
1667 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetAllConfigs_002, TestSize.Level1)
1668 {
1669 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetAllConfigs_002 start";
1670 sleep(SLEEP_TIME_1);
1671 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1672 std::shared_ptr<AccessibilityConfigData> data = std::make_shared<AccessibilityConfigData>();
1673 Singleton<AccessibleAbilityManagerService>::GetInstance().GetAllConfigs(*data);
1674 EXPECT_NE(data.get(), nullptr);
1675 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetAllConfigs_002 end";
1676 }
1677
1678 /**
1679 * @tc.number: AccessibleAbilityManagerServiceUnitTest_OnRemoveSystemAbility_001
1680 * @tc.name: OnRemoveSystemAbility
1681 * @tc.desc: Test function OnRemoveSystemAbility
1682 */
1683 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, OnRemoveSystemAbility_001, TestSize.Level1)
1684 {
1685 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_OnRemoveSystemAbility_001 start";
1686 int32_t systemAbilityId = 1;
1687 std::string deviceId = "test";
1688 auto &ins = Singleton<AccessibleAbilityManagerService>::GetInstance();
1689 ins.OnRemoveSystemAbility(systemAbilityId, deviceId);
1690 EXPECT_TRUE(ins.IsServiceReady());
1691 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_OnRemoveSystemAbility_001 end";
1692 }
1693
1694 /**
1695 * @tc.number: AccessibleAbilityManagerServiceUnitTest_OnRemoveSystemAbility_002
1696 * @tc.name: OnRemoveSystemAbility
1697 * @tc.desc: Test function OnRemoveSystemAbility
1698 */
1699 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, OnRemoveSystemAbility_002, TestSize.Level1)
1700 {
1701 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_OnRemoveSystemAbility_002 start";
1702 auto &ins = Singleton<AccessibleAbilityManagerService>::GetInstance();
1703 EXPECT_TRUE(ins.IsServiceReady());
1704 int32_t systemAbilityId = SUBSYS_ACCOUNT_SYS_ABILITY_ID_BEGIN;
1705 std::string deviceId = "test";
1706 ins.OnRemoveSystemAbility(systemAbilityId, deviceId);
__anona620984d0202() 1707 AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([]() -> bool {
1708 if (Singleton<AccessibleAbilityManagerService>::GetInstance().IsServiceReady() == false) {
1709 return true;
1710 } else {
1711 return false;
1712 }
1713 }), SLEEP_TIME_1);
1714 EXPECT_FALSE(ins.IsServiceReady());
1715 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_OnRemoveSystemAbility_002 end";
1716 }
1717
1718 /**
1719 * @tc.number: AccessibleAbility_ManagerService_UnitTest_UpdateConfigState_001
1720 * @tc.name: UpdateConfigState
1721 * @tc.desc: Test function UpdateConfigState
1722 */
1723 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, UpdateConfigState_001, TestSize.Level1)
1724 {
1725 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_UpdateConfigState_001 start";
1726 sptr<MockAccessibleAbilityManagerConfigObserverStub> stub = new MockAccessibleAbilityManagerConfigObserverStub();
1727 sptr<IAccessibleAbilityManagerConfigObserver> state = new MockAccessibleAbilityManagerConfigObserverProxy(stub);
1728
1729 uint32_t ret = Singleton<AccessibleAbilityManagerService>::GetInstance().RegisterConfigObserver(state);
1730 EXPECT_EQ(ret, 0);
1731 Singleton<AccessibleAbilityManagerService>::GetInstance().UpdateConfigState();
1732 EXPECT_NE(stub_.GetRefPtr(), nullptr);
1733 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_UpdateConfigState_001 end";
1734 }
1735
1736 /**
1737 * @tc.number: AccessibleAbility_ManagerService_UnitTest_UpdateAudioBalance_001
1738 * @tc.name: UpdateAudioBalance
1739 * @tc.desc: Test function UpdateAudioBalance
1740 */
1741 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, UpdateAudioBalance_001, TestSize.Level1)
1742 {
1743 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_UpdateAudioBalance_001 start";
1744 sptr<MockAccessibleAbilityManagerConfigObserverStub> stub = new MockAccessibleAbilityManagerConfigObserverStub();
1745 sptr<IAccessibleAbilityManagerConfigObserver> state = new MockAccessibleAbilityManagerConfigObserverProxy(stub);
1746
1747 uint32_t ret = Singleton<AccessibleAbilityManagerService>::GetInstance().RegisterConfigObserver(state);
1748 EXPECT_EQ(ret, 0);
1749 Singleton<AccessibleAbilityManagerService>::GetInstance().UpdateAudioBalance();
1750 EXPECT_NE(stub_.GetRefPtr(), nullptr);
1751 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_UpdateAudioBalance_001 end";
1752 }
1753
1754 /**
1755 * @tc.number: AccessibleAbility_ManagerService_UnitTest_UpdateBrightnessDiscount_001
1756 * @tc.name: UpdateBrightnessDiscount
1757 * @tc.desc: Test function UpdateBrightnessDiscount
1758 */
1759 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, UpdateBrightnessDiscount_001, TestSize.Level1)
1760 {
1761 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_UpdateBrightnessDiscount_001 start";
1762 sptr<MockAccessibleAbilityManagerConfigObserverStub> stub = new MockAccessibleAbilityManagerConfigObserverStub();
1763 sptr<IAccessibleAbilityManagerConfigObserver> state = new MockAccessibleAbilityManagerConfigObserverProxy(stub);
1764
1765 uint32_t ret = Singleton<AccessibleAbilityManagerService>::GetInstance().RegisterConfigObserver(state);
1766 EXPECT_EQ(ret, 0);
1767 Singleton<AccessibleAbilityManagerService>::GetInstance().UpdateBrightnessDiscount();
1768 EXPECT_NE(stub_.GetRefPtr(), nullptr);
1769 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_UpdateBrightnessDiscount_001 end";
1770 }
1771
1772 /**
1773 * @tc.number: AccessibleAbility_ManagerService_UnitTest_UpdateContentTimeout_001
1774 * @tc.name: UpdateContentTimeout
1775 * @tc.desc: Test function UpdateContentTimeout
1776 */
1777 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, UpdateContentTimeout_001, TestSize.Level1)
1778 {
1779 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_UpdateContentTimeout_001 start";
1780 sptr<MockAccessibleAbilityManagerConfigObserverStub> stub = new MockAccessibleAbilityManagerConfigObserverStub();
1781 sptr<IAccessibleAbilityManagerConfigObserver> state = new MockAccessibleAbilityManagerConfigObserverProxy(stub);
1782
1783 uint32_t ret = Singleton<AccessibleAbilityManagerService>::GetInstance().RegisterConfigObserver(state);
1784 EXPECT_EQ(ret, 0);
1785 Singleton<AccessibleAbilityManagerService>::GetInstance().UpdateContentTimeout();
1786 EXPECT_NE(stub_.GetRefPtr(), nullptr);
1787 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_UpdateContentTimeout_001 end";
1788 }
1789
1790 /**
1791 * @tc.number: AccessibleAbility_ManagerService_UnitTest_UpdateDaltonizationColorFilter_001
1792 * @tc.name: UpdateDaltonizationColorFilter
1793 * @tc.desc: Test function UpdateDaltonizationColorFilter
1794 */
1795 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, UpdateDaltonizationColorFilter_001, TestSize.Level1)
1796 {
1797 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_UpdateDaltonizationColorFilter_001 start";
1798 sptr<MockAccessibleAbilityManagerConfigObserverStub> stub = new MockAccessibleAbilityManagerConfigObserverStub();
1799 sptr<IAccessibleAbilityManagerConfigObserver> state = new MockAccessibleAbilityManagerConfigObserverProxy(stub);
1800
1801 uint32_t ret = Singleton<AccessibleAbilityManagerService>::GetInstance().RegisterConfigObserver(state);
1802 EXPECT_EQ(ret, 0);
1803 Singleton<AccessibleAbilityManagerService>::GetInstance().UpdateDaltonizationColorFilter();
1804 EXPECT_NE(stub_.GetRefPtr(), nullptr);
1805 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_UpdateDaltonizationColorFilter_001 end";
1806 }
1807
1808 /**
1809 * @tc.number: AccessibleAbility_ManagerService_UnitTest_UpdateMouseAutoClick_001
1810 * @tc.name: UpdateMouseAutoClick
1811 * @tc.desc: Test function UpdateMouseAutoClick
1812 */
1813 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, UpdateMouseAutoClick_001, TestSize.Level1)
1814 {
1815 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_UpdateMouseAutoClick_001 start";
1816 sptr<MockAccessibleAbilityManagerConfigObserverStub> stub = new MockAccessibleAbilityManagerConfigObserverStub();
1817 sptr<IAccessibleAbilityManagerConfigObserver> state = new MockAccessibleAbilityManagerConfigObserverProxy(stub);
1818
1819 uint32_t ret = Singleton<AccessibleAbilityManagerService>::GetInstance().RegisterConfigObserver(state);
1820 EXPECT_EQ(ret, 0);
1821 Singleton<AccessibleAbilityManagerService>::GetInstance().UpdateMouseAutoClick();
1822 EXPECT_NE(stub_.GetRefPtr(), nullptr);
1823 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_UpdateMouseAutoClick_001 end";
1824 }
1825
1826 /**
1827 * @tc.number: AccessibleAbility_ManagerService_UnitTest_UpdateShortkeyTarget_001
1828 * @tc.name: UpdateShortkeyTarget
1829 * @tc.desc: Test function UpdateShortkeyTarget
1830 */
1831 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, UpdateShortkeyTarget_001, TestSize.Level1)
1832 {
1833 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_UpdateShortkeyTarget_001 start";
1834 sptr<MockAccessibleAbilityManagerConfigObserverStub> stub = new MockAccessibleAbilityManagerConfigObserverStub();
1835 sptr<IAccessibleAbilityManagerConfigObserver> state = new MockAccessibleAbilityManagerConfigObserverProxy(stub);
1836
1837 uint32_t ret = Singleton<AccessibleAbilityManagerService>::GetInstance().RegisterConfigObserver(state);
1838 EXPECT_EQ(ret, 0);
1839 Singleton<AccessibleAbilityManagerService>::GetInstance().UpdateShortkeyTarget();
1840 EXPECT_NE(stub_.GetRefPtr(), nullptr);
1841 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_UpdateShortkeyTarget_001 end";
1842 }
1843
1844 /**
1845 * @tc.number: AccessibleAbility_ManagerService_UnitTest_UpdateClickResponseTime_001
1846 * @tc.name: UpdateClickResponseTime
1847 * @tc.desc: Test function UpdateClickResponseTime
1848 */
1849 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, UpdateClickResponseTime_001, TestSize.Level1)
1850 {
1851 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_UpdateClickResponseTime_001 start";
1852 sptr<MockAccessibleAbilityManagerConfigObserverStub> stub = new MockAccessibleAbilityManagerConfigObserverStub();
1853 sptr<IAccessibleAbilityManagerConfigObserver> state = new MockAccessibleAbilityManagerConfigObserverProxy(stub);
1854
1855 uint32_t ret = Singleton<AccessibleAbilityManagerService>::GetInstance().RegisterConfigObserver(state);
1856 EXPECT_EQ(ret, 0);
1857 Singleton<AccessibleAbilityManagerService>::GetInstance().UpdateClickResponseTime();
1858 EXPECT_NE(stub_.GetRefPtr(), nullptr);
1859 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_UpdateClickResponseTime_001 end";
1860 }
1861
1862 /**
1863 * @tc.number: AccessibleAbility_ManagerService_UnitTest_UpdateIgnoreRepeatClickTime_001
1864 * @tc.name: UpdateIgnoreRepeatClickTime
1865 * @tc.desc: Test function UpdateIgnoreRepeatClickTime
1866 */
1867 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, UpdateIgnoreRepeatClickTime_001, TestSize.Level1)
1868 {
1869 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_UpdateIgnoreRepeatClickTime_001 start";
1870 sptr<MockAccessibleAbilityManagerConfigObserverStub> stub = new MockAccessibleAbilityManagerConfigObserverStub();
1871 sptr<IAccessibleAbilityManagerConfigObserver> state = new MockAccessibleAbilityManagerConfigObserverProxy(stub);
1872
1873 uint32_t ret = Singleton<AccessibleAbilityManagerService>::GetInstance().RegisterConfigObserver(state);
1874 EXPECT_EQ(ret, 0);
1875 Singleton<AccessibleAbilityManagerService>::GetInstance().UpdateIgnoreRepeatClickTime();
1876 EXPECT_NE(stub_.GetRefPtr(), nullptr);
1877 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_UpdateIgnoreRepeatClickTime_001 end";
1878 }
1879
1880 /**
1881 * @tc.number: AccessibleAbility_ManagerService_UnitTest_PackageRemoved_003
1882 * @tc.name: PackageRemoved
1883 * @tc.desc: Test function PackageRemoved
1884 */
1885 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, PackageRemoved_003, TestSize.Level1)
1886 {
1887 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_PackageRemoved_003 start";
1888 std::string bundleName = "bundleName1";
1889 Singleton<AccessibleAbilityManagerService>::GetInstance().PackageAdd(bundleName);
1890 sleep(SLEEP_TIME_1);
1891 Singleton<AccessibleAbilityManagerService>::GetInstance().PackageRemoved(bundleName);
1892 EXPECT_NE(stub_.GetRefPtr(), nullptr);
1893 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_PackageRemoved_003 end";
1894 }
1895
1896 /**
1897 * @tc.number: AccessibleAbility_ManagerService_UnitTest_GetAbilityList_003
1898 * @tc.name: GetAbilityList
1899 * @tc.desc: Test function GetAbilityList
1900 */
1901 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetAbilityList_003, TestSize.Level1)
1902 {
1903 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetAbilityList_003 start";
1904 std::vector<OHOS::Accessibility::AccessibilityAbilityInfo> infos;
1905 uint32_t type = 0xFFFFFFFF;
1906 Singleton<AccessibleAbilityManagerService>::GetInstance().GetAbilityList(type, -1, infos);
1907 EXPECT_EQ(infos.size(), 0);
1908 Singleton<AccessibleAbilityManagerService>::GetInstance().GetAbilityList(type, 5, infos);
1909 EXPECT_EQ(infos.size(), 0);
1910 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_GetAbilityList_003 end";
1911 }
1912
1913 /**
1914 * @tc.number: AccessibleAbility_ManagerService_UnitTest_SetTargetAbility_001
1915 * @tc.name: SetTargetAbility
1916 * @tc.desc: Test function HIGH_CONTRAST_TEXT
1917 */
1918 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetTargetAbility_001, TestSize.Level1)
1919 {
1920 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTargetAbility_001 start";
1921 auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
1922 if (!accountData) {
1923 GTEST_LOG_(INFO) << "current account data is null";
1924 return;
1925 }
1926 accountData->GetConfig()->SetShortkeyTarget("HIGH_CONTRAST_TEXT");
1927 bool ret = Singleton<AccessibleAbilityManagerService>::GetInstance().EnableShortKeyTargetAbility();
1928 EXPECT_TRUE(ret);
1929 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTargetAbility_001 end";
1930 }
1931
1932 /**
1933 * @tc.number: AccessibleAbility_ManagerService_UnitTest_SetTargetAbility_002
1934 * @tc.name: SetTargetAbility
1935 * @tc.desc: Test function INVERT_COLOR
1936 */
1937 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetTargetAbility_002, TestSize.Level1)
1938 {
1939 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTargetAbility_002 start";
1940 auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
1941 if (!accountData) {
1942 GTEST_LOG_(INFO) << "current account data is null";
1943 return;
1944 }
1945 accountData->GetConfig()->SetShortkeyTarget("INVERT_COLOR");
1946 bool ret = Singleton<AccessibleAbilityManagerService>::GetInstance().EnableShortKeyTargetAbility();
1947 EXPECT_TRUE(ret);
1948 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTargetAbility_002 end";
1949 }
1950
1951 /**
1952 * @tc.number: AccessibleAbility_ManagerService_UnitTest_SetTargetAbility_003
1953 * @tc.name: SetTargetAbility
1954 * @tc.desc: Test function ANIMATION_OFF
1955 */
1956 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetTargetAbility_003, TestSize.Level1)
1957 {
1958 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTargetAbility_003 start";
1959 auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
1960 if (!accountData) {
1961 GTEST_LOG_(INFO) << "current account data is null";
1962 return;
1963 }
1964 accountData->GetConfig()->SetShortkeyTarget("ANIMATION_OFF");
1965 bool ret = Singleton<AccessibleAbilityManagerService>::GetInstance().EnableShortKeyTargetAbility();
1966 EXPECT_TRUE(ret);
1967 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTargetAbility_003 end";
1968 }
1969
1970 /**
1971 * @tc.number: AccessibleAbility_ManagerService_UnitTest_SetTargetAbility_004
1972 * @tc.name: SetTargetAbility
1973 * @tc.desc: Test function SCREEN_MAGNIFICATION
1974 */
1975 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetTargetAbility_004, TestSize.Level1)
1976 {
1977 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTargetAbility_004 start";
1978 auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
1979 if (!accountData) {
1980 GTEST_LOG_(INFO) << "current account data is null";
1981 return;
1982 }
1983 accountData->GetConfig()->SetShortkeyTarget("SCREEN_MAGNIFICATION");
1984 bool ret = Singleton<AccessibleAbilityManagerService>::GetInstance().EnableShortKeyTargetAbility();
1985 EXPECT_TRUE(ret);
1986 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTargetAbility_004 end";
1987 }
1988
1989 /**
1990 * @tc.number: AccessibleAbility_ManagerService_UnitTest_SetTargetAbility_005
1991 * @tc.name: SetTargetAbility
1992 * @tc.desc: Test function AUDIO_MONO
1993 */
1994 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetTargetAbility_005, TestSize.Level1)
1995 {
1996 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTargetAbility_005 start";
1997 auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
1998 if (!accountData) {
1999 GTEST_LOG_(INFO) << "current account data is null";
2000 return;
2001 }
2002 accountData->GetConfig()->SetShortkeyTarget("AUDIO_MONO");
2003 bool ret = Singleton<AccessibleAbilityManagerService>::GetInstance().EnableShortKeyTargetAbility();
2004 EXPECT_TRUE(ret);
2005 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTargetAbility_005 end";
2006 }
2007
2008 /**
2009 * @tc.number: AccessibleAbility_ManagerService_UnitTest_SetTargetAbility_006
2010 * @tc.name: SetTargetAbility
2011 * @tc.desc: Test function MOUSE_KEY
2012 */
2013 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetTargetAbility_006, TestSize.Level1)
2014 {
2015 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTargetAbility_006 start";
2016 auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
2017 if (!accountData) {
2018 GTEST_LOG_(INFO) << "current account data is null";
2019 return;
2020 }
2021 accountData->GetConfig()->SetShortkeyTarget("MOUSE_KEY");
2022 bool ret = Singleton<AccessibleAbilityManagerService>::GetInstance().EnableShortKeyTargetAbility();
2023 EXPECT_TRUE(ret);
2024 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTargetAbility_006 end";
2025 }
2026
2027 /**
2028 * @tc.number: AccessibleAbility_ManagerService_UnitTest_SetTargetAbility_007
2029 * @tc.name: SetTargetAbility
2030 * @tc.desc: Test function CAPTION_STATE
2031 */
2032 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetTargetAbility_007, TestSize.Level1)
2033 {
2034 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTargetAbility_007 start";
2035 auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
2036 if (!accountData) {
2037 GTEST_LOG_(INFO) << "current account data is null";
2038 return;
2039 }
2040 accountData->GetConfig()->SetShortkeyTarget("CAPTION_STATE");
2041 bool ret = Singleton<AccessibleAbilityManagerService>::GetInstance().EnableShortKeyTargetAbility();
2042 EXPECT_TRUE(ret);
2043 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTargetAbility_007 end";
2044 }
2045
2046 /**
2047 * @tc.number: AccessibleAbility_ManagerService_UnitTest_SetTargetAbility_008
2048 * @tc.name: SetTargetAbility
2049 * @tc.desc: Test function OTHERS
2050 */
2051 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetTargetAbility_008, TestSize.Level1)
2052 {
2053 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTargetAbility_008 start";
2054 auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
2055 if (!accountData) {
2056 GTEST_LOG_(INFO) << "current account data is null";
2057 return;
2058 }
2059 accountData->GetConfig()->SetShortkeyTarget("CONTENT_TIMEOUT");
2060 bool ret = Singleton<AccessibleAbilityManagerService>::GetInstance().EnableShortKeyTargetAbility();
2061 EXPECT_FALSE(ret);
2062 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTargetAbility_008 end";
2063 }
2064
2065 /**
2066 * @tc.number: AccessibleAbility_ManagerService_UnitTest_SetTargetAbility_009
2067 * @tc.name: SetTargetAbility
2068 * @tc.desc: Test function ""
2069 */
2070 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetTargetAbility_009, TestSize.Level1)
2071 {
2072 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTargetAbility_009 start";
2073 auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
2074 if (!accountData) {
2075 GTEST_LOG_(INFO) << "current account data is null";
2076 return;
2077 }
2078 // set
2079 accountData->GetConfig()->SetShortkeyTarget("");
2080 bool ret = Singleton<AccessibleAbilityManagerService>::GetInstance().EnableShortKeyTargetAbility();
2081 EXPECT_FALSE(ret);
2082 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTargetAbility_009 end";
2083 }
2084
2085 /**
2086 * @tc.number: AccessibleAbility_ManagerService_UnitTest_SetTargetAbility_010
2087 * @tc.name: SetTargetAbility
2088 * @tc.desc: Test function other account
2089 */
2090 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetTargetAbility_010, TestSize.Level1)
2091 {
2092 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTargetAbility_010 start";
2093 sleep(SLEEP_TIME_1);
2094 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
2095 auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
2096 if (!accountData) {
2097 GTEST_LOG_(INFO) << "current account data is null";
2098 return;
2099 }
2100 accountData->GetConfig()->SetShortkeyTarget("MOUSE_KEY");
2101 bool ret = Singleton<AccessibleAbilityManagerService>::GetInstance().EnableShortKeyTargetAbility();
2102 EXPECT_FALSE(ret);
2103 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTargetAbility_010 end";
2104 }
2105
2106 /**
2107 * @tc.number: Accessible_Ability_Manager_ServiceUnittest_AddAccountData_001
2108 * @tc.name: AddAccountData
2109 * @tc.desc: Test function add account
2110 */
2111 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, AddAccountData_001, TestSize.Level1)
2112 {
2113 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_AddAccountData_001 start";
2114 Singleton<AccessibleAbilityManagerService>::GetInstance().AddedUser(1);
2115 auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetAccountData(1);
2116 EXPECT_NE(accountData.GetRefPtr(), nullptr);
2117
2118 Singleton<AccessibleAbilityManagerService>::GetInstance().RemovedUser(1);
2119 accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetAccountData(1);
2120 EXPECT_EQ(accountData.GetRefPtr(), nullptr);
2121 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_AddAccountData_001 end";
2122 }
2123
2124 /**
2125 * @tc.number: Accessible_Ability_Manager_ServiceUnittest_FindInnerWindowId_001
2126 * @tc.name: FindInnerWindowId
2127 * @tc.desc: Test function find inner windowId
2128 */
2129 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, FindInnerWindowId_001, TestSize.Level1)
2130 {
2131 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_FindInnerWindowId_001 start";
2132 AccessibilityEventInfo event;
2133 int32_t windowId = 1;
2134 event.SetWindowId(windowId);
2135 event.SetSource(1);
2136 Singleton<AccessibleAbilityManagerService>::GetInstance().FindInnerWindowId(event, windowId);
2137 EXPECT_EQ(windowId, 1);
2138 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_FindInnerWindowId_001 end";
2139 }
2140
2141 /**
2142 * @tc.number: Accessible_Ability_Manager_ServiceUnittest_GetFocusedWindowId_001
2143 * @tc.name: GetFocusedWindowId
2144 * @tc.desc: Test function find focused windowId
2145 */
2146 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetFocusedWindowId_001, TestSize.Level1)
2147 {
2148 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_GetFocusedWindowId_001 start";
2149 int32_t windowId = 1;
2150 RetError ret = Singleton<AccessibleAbilityManagerService>::GetInstance().GetFocusedWindowId(windowId);
2151 EXPECT_EQ(ret, RET_OK);
2152 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_GetFocusedWindowId_001 end";
2153 }
2154
2155 /**
2156 * @tc.number: Accessible_Ability_Manager_ServiceUnittest_InsertWindowIdEventPair_001
2157 * @tc.name: InsertWindowIdEventPair
2158 * @tc.desc: Test insert foucus window event.
2159 */
2160 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, InsertWindowIdEventPair_001, TestSize.Level1)
2161 {
2162 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_InsertWindowIdEventPair_001 start";
2163 AccessibilityEventInfo event;
2164 event.SetWindowId(1);
2165 event.SetSource(1);
2166 int32_t windowId = 1;
2167 Singleton<AccessibleAbilityManagerService>::GetInstance().InsertWindowIdEventPair(windowId, event);
2168 bool ret = Singleton<AccessibleAbilityManagerService>::GetInstance().CheckWindowIdEventExist(windowId);
2169 EXPECT_TRUE(ret);
2170 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_InsertWindowIdEventPair_001 end";
2171 }
2172
2173 /**
2174 * @tc.number: Accessible_Ability_Manager_ServiceUnittest_OnAddSystemAbility_001
2175 * @tc.name: OnAddSystemAbility
2176 * @tc.desc: Test insert foucus window event.
2177 */
2178 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, OnAddSystemAbility_001, TestSize.Level1)
2179 {
2180 GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_OnAddSystemAbility_001 start";
2181 TearDownTestCase();
2182 std::string deviceId = "test";
2183 Singleton<AccessibleAbilityManagerService>::GetInstance().OnAddSystemAbility(0, deviceId);
2184 SetUpTestCase();
2185 GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_OnAddSystemAbility_001 end";
2186 }
2187
2188 /**
2189 * @tc.number: AccessibleAbilityManagerServiceUnitTest_OnRemoveSystemAbility_003
2190 * @tc.name: OnRemoveSystemAbility
2191 * @tc.desc: Test function OnRemoveSystemAbility
2192 */
2193 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, OnRemoveSystemAbility_003, TestSize.Level1)
2194 {
2195 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_OnRemoveSystemAbility_003 start";
2196 TearDownTestCase();
2197 std::string deviceId = "test";
2198 Singleton<AccessibleAbilityManagerService>::GetInstance().OnRemoveSystemAbility(0, deviceId);
2199 SetUpTestCase();
2200 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_OnRemoveSystemAbility_003 end";
2201 }
2202
2203 /**
2204 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SendEvent_001
2205 * @tc.name: SendEvent
2206 * @tc.desc: Test function SendEvent
2207 */
2208 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SendEvent_001, TestSize.Level1)
2209 {
2210 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SendEvent_001 start";
2211 TearDownTestCase();
2212 AccessibilityEventInfo event;
2213 Singleton<AccessibleAbilityManagerService>::GetInstance().SendEvent(event);
2214 SetUpTestCase();
2215 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SendEvent_001 end";
2216 }
2217
2218 /**
2219 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SendEvent_002
2220 * @tc.name: SendEvent
2221 * @tc.desc: Test function SendEvent
2222 */
2223 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SendEvent_002, TestSize.Level1)
2224 {
2225 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SendEvent_002 start";
2226 AccessibilityEventInfo event;
2227 sleep(SLEEP_TIME_1);
2228 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
2229 RetError ret = Singleton<AccessibleAbilityManagerService>::GetInstance().SendEvent(event);
2230 EXPECT_EQ(ret, RET_OK);
2231 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SendEvent_001 end";
2232 }
2233
2234
2235 /**
2236 * @tc.number: AccessibleAbility_ManagerService_UnitTest_DeregisterElementOperator_003
2237 * @tc.name: DeregisterElementOperator
2238 * @tc.desc: Test function DeregisterElementOperator
2239 */
2240 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, DeregisterElementOperator_003, TestSize.Level1)
2241 {
2242 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_DeregisterElementOperator_003 start";
2243 TearDownTestCase();
2244 RetError ret = Singleton<AccessibleAbilityManagerService>::GetInstance().DeregisterElementOperator(0);
2245 EXPECT_EQ(ret, RET_OK);
2246 SetUpTestCase();
2247 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_DeregisterElementOperator_003 end";
2248 }
2249
2250 /**
2251 * @tc.number: AccessibleAbilityManagerServiceUnitTest_GetEnabledState_002
2252 * @tc.name: GetEnabledState
2253 * @tc.desc: Test function GetEnabledState
2254 */
2255 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetEnabledState_002, TestSize.Level1)
2256 {
2257 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetEnabledState_002 start";
2258 TearDownTestCase();
2259 bool ret = true;
2260 ret = Singleton<AccessibleAbilityManagerService>::GetInstance().GetEnabledState();
2261 EXPECT_EQ(ret, false);
2262 SetUpTestCase();
2263 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetEnabledState_002 end";
2264 }
2265
2266 /**
2267 * @tc.number: AccessibleAbilityManagerServiceUnitTest_GetTouchGuideState_003
2268 * @tc.name: GetTouchGuideState
2269 * @tc.desc: Test function GetTouchGuideState
2270 */
2271 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetTouchGuideState_003, TestSize.Level1)
2272 {
2273 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetTouchGuideState_003 start";
2274 TearDownTestCase();
2275 bool ret = true;
2276 ret = Singleton<AccessibleAbilityManagerService>::GetInstance().GetTouchGuideState();
2277 EXPECT_EQ(ret, false);
2278 SetUpTestCase();
2279 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetTouchGuideState_003 end";
2280 }
2281
2282 /**
2283 * @tc.number: AccessibleAbilityManagerServiceUnitTest_GetGestureState_003
2284 * @tc.name: GetGestureState
2285 * @tc.desc: Test function GetGestureState
2286 */
2287 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetGestureState_003, TestSize.Level1)
2288 {
2289 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetGestureState_003 start";
2290 TearDownTestCase();
2291 bool ret = true;
2292 ret = Singleton<AccessibleAbilityManagerService>::GetInstance().GetGestureState();
2293 EXPECT_EQ(ret, false);
2294 SetUpTestCase();
2295 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetGestureState_003 end";
2296 }
2297
2298 /**
2299 * @tc.number: AccessibleAbilityManagerServiceUnitTest_GetKeyEventObserverState_003
2300 * @tc.name: GetKeyEventObserverState
2301 * @tc.desc: Test function GetKeyEventObserverState
2302 */
2303 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetKeyEventObserverState_003, TestSize.Level1)
2304 {
2305 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetKeyEventObserverState_003 start";
2306 TearDownTestCase();
2307 bool ret = true;
2308 ret = Singleton<AccessibleAbilityManagerService>::GetInstance().GetKeyEventObserverState();
2309 EXPECT_EQ(ret, false);
2310 SetUpTestCase();
2311 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetKeyEventObserverState_003 end";
2312 }
2313
2314 /*
2315 * @tc.number: AccessibleAbility_ManagerService_UnitTest_GetEnabledAbilities_003
2316 * @tc.name: GetEnabledAbilities
2317 * @tc.desc: Test function GetEnabledAbilities
2318 */
2319 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetEnabledAbilities_003, TestSize.Level1)
2320 {
2321 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_GetEnabledAbilities_003 start";
2322 TearDownTestCase();
2323 std::vector<std::string> enabledAbilities;
2324 RetError ret = Singleton<AccessibleAbilityManagerService>::GetInstance().GetEnabledAbilities(enabledAbilities);
2325 EXPECT_EQ(ret, RET_ERR_NULLPTR);
2326 SetUpTestCase();
2327 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_GetEnabledAbilities_003 end";
2328 }
2329
2330 /*
2331 * @tc.number: AccessibleAbility_ManagerService_UnitTest_Dump_001
2332 * @tc.name: Dump
2333 * @tc.desc: Test function Dump
2334 */
2335 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, Dump_001, TestSize.Level1)
2336 {
2337 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_Dump_001 start";
2338 TearDownTestCase();
2339 std::vector<std::u16string> args;
2340 int ret = Singleton<AccessibleAbilityManagerService>::GetInstance().Dump(0, args);
2341 EXPECT_EQ(ret, RET_ERR_FAILED);
2342 SetUpTestCase();
2343 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_Dump_001 end";
2344 }
2345
2346 /*
2347 * @tc.number: AccessibleAbility_ManagerService_UnitTest_EnableUITestAbility_003
2348 * @tc.name: EnableUITestAbility
2349 * @tc.desc: Test function EnableUITestAbility
2350 */
2351 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, EnableUITestAbility_003, TestSize.Level1)
2352 {
2353 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_EnableUITestAbility_003 start";
2354 TearDownTestCase();
2355 sptr<IRemoteObject> obj = nullptr;
2356 RetError ret = Singleton<AccessibleAbilityManagerService>::GetInstance().EnableUITestAbility(obj);
2357 EXPECT_EQ(ret, RET_ERR_NULLPTR);
2358 SetUpTestCase();
2359 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_EnableUITestAbility_003 end";
2360 }
2361
2362 /*
2363 * @tc.number: AccessibleAbility_ManagerService_UnitTest_EnableUITestAbility_004
2364 * @tc.name: EnableUITestAbility
2365 * @tc.desc: Test function EnableUITestAbility
2366 */
2367 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, EnableUITestAbility_004, TestSize.Level1)
2368 {
2369 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_EnableUITestAbility_004 start";
2370 sptr<IRemoteObject> obj = nullptr;
2371 RetError ret = Singleton<AccessibleAbilityManagerService>::GetInstance().EnableUITestAbility(obj);
2372 EXPECT_EQ(ret, RET_ERR_NULLPTR);
2373 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_EnableUITestAbility_004 end";
2374 }
2375
2376 /*
2377 * @tc.number: AccessibleAbility_ManagerService_UnitTest_DisableAbility_003
2378 * @tc.name: DisableAbility
2379 * @tc.desc: Test function DisableAbility
2380 */
2381 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, DisableAbility_003, TestSize.Level1)
2382 {
2383 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_DisableAbility_003 start";
2384 TearDownTestCase();
2385 std::string name = "test";
2386 RetError ret = Singleton<AccessibleAbilityManagerService>::GetInstance().DisableAbility(name);
2387 EXPECT_EQ(ret, RET_ERR_NULLPTR);
2388 SetUpTestCase();
2389 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_DisableAbility_003 end";
2390 }
2391
2392 /*
2393 * @tc.number: AccessibleAbility_ManagerService_UnitTest_DisableUITestAbility_003
2394 * @tc.name: DisableUITestAbility
2395 * @tc.desc: Test function DisableUITestAbility
2396 */
2397 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, DisableUITestAbility_003, TestSize.Level1)
2398 {
2399 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_DisableUITestAbility_003 start";
2400 TearDownTestCase();
2401 RetError ret = Singleton<AccessibleAbilityManagerService>::GetInstance().DisableUITestAbility();
2402 EXPECT_EQ(ret, RET_ERR_NULLPTR);
2403 SetUpTestCase();
2404 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_DisableUITestAbility_003 end";
2405 }
2406
2407 /**
2408 * @tc.number: AccessibleAbility_ManagerService_UnitTest_RemoveRequestId_001
2409 * @tc.name: RemoveRequestId
2410 * @tc.desc: Test function AddRequestId RemoveRequestId
2411 */
2412 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, RemoveRequestId_001, TestSize.Level1)
2413 {
2414 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_RemoveRequestId_001 start";
2415 int32_t windowId = 1;
2416 int32_t treeId = 2;
2417 int32_t requestId = 3;
2418 Singleton<AccessibleAbilityManagerService>::GetInstance().AddRequestId(windowId, treeId, requestId, nullptr);
2419 Singleton<AccessibleAbilityManagerService>::GetInstance().RemoveRequestId(requestId);
2420 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_RemoveRequestId_001 end";
2421 }
2422 } // namespace Accessibility
2423 } // namespace OHOS