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