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