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 AccessibleAbilityManagerServiceUnitTest : public ::testing::Test {
51 public:
AccessibleAbilityManagerServiceUnitTest()52 AccessibleAbilityManagerServiceUnitTest()
53 {}
~AccessibleAbilityManagerServiceUnitTest()54 ~AccessibleAbilityManagerServiceUnitTest()
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 AccessibleAbilityManagerServiceUnitTest::SetUpTestCase()
67 {
68 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest SetUpTestCase";
69 Singleton<AccessibleAbilityManagerService>::GetInstance().OnStart();
70 AccessibilityCommonHelper::GetInstance().WaitForServicePublish();
71 }
72
TearDownTestCase()73 void AccessibleAbilityManagerServiceUnitTest::TearDownTestCase()
74 {
75 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest TearDownTestCase";
76 Singleton<AccessibleAbilityManagerService>::GetInstance().OnStop();
77 AccessibilityCommonHelper::GetInstance().SetIsServicePublished(false);
78 }
79
SetUp()80 void AccessibleAbilityManagerServiceUnitTest::SetUp()
81 {
82 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest SetUp";
83 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(AccessibilityAbilityHelper::accountId_);
84 stub_ = new MockAccessibleAbilityClientStubImpl();
85 }
86
TearDown()87 void AccessibleAbilityManagerServiceUnitTest::TearDown()
88 {
89 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest TearDown";
90 stub_ = nullptr;
91 }
92
RegisterAbilityConnectionClient(const sptr<IRemoteObject>& obj)93 void AccessibleAbilityManagerServiceUnitTest::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: AccessibleAbilityManagerServiceUnitTest_GetInstance_001
114 * @tc.name: GetInstance
115 * @tc.desc: Test function GetInstance
116 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetInstance_001, TestSize.Level1)117 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetInstance_001, TestSize.Level1)
118 {
119 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_GetInstance_001 start";
120
121 auto ins = &Singleton<AccessibleAbilityManagerService>::GetInstance();
122 EXPECT_TRUE(ins);
123
124 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_GetInstance_001 end";
125 }
126
127 /**
128 * @tc.number: AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterStateCallback_001
129 * @tc.name: RegisterStateCallback
130 * @tc.desc: Test function RegisterStateCallback
131 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, RegisterStateCallback_001, TestSize.Level1)132 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, RegisterStateCallback_001, TestSize.Level1)
133 {
134 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_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) << "AccessibleAbilityManagerServiceUnitTest_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(AccessibleAbilityManagerServiceUnitTest, GetAbilityList_001, TestSize.Level1)150 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetAbilityList_001, TestSize.Level1)
151 {
152 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_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) << "AccessibleAbilityManagerServiceUnitTest_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(AccessibleAbilityManagerServiceUnitTest, RegisterElementOperator_001, TestSize.Level1)166 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, RegisterElementOperator_001, TestSize.Level1)
167 {
168 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_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) << "AccessibleAbilityManagerServiceUnitTest_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(AccessibleAbilityManagerServiceUnitTest, DeregisterElementOperator_001, TestSize.Level1)188 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, 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(AccessibleAbilityManagerServiceUnitTest, DeregisterElementOperator_002, TestSize.Level1)207 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, 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(AccessibleAbilityManagerServiceUnitTest, SetTouchEventInjector_001, TestSize.Level1)229 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, 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(AccessibleAbilityManagerServiceUnitTest, SetKeyEventFilter_001, TestSize.Level1)245 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, 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(AccessibleAbilityManagerServiceUnitTest, RemovedUser_001, TestSize.Level1)260 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, 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(AccessibleAbilityManagerServiceUnitTest, RemovedUser_002, TestSize.Level1)277 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, 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(AccessibleAbilityManagerServiceUnitTest, GetBundleMgrProxy_001, TestSize.Level1)296 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, 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(AccessibleAbilityManagerServiceUnitTest, PackageChanged_001, TestSize.Level1)309 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, 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: AccessibleAbilityManagerServiceUnitTest_SetScreenMagnificationState_001
338 * @tc.name: SetScreenMagnificationState
339 * @tc.desc: Test function SetScreenMagnificationState GetScreenMagnificationState
340 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetScreenMagnificationState_001, TestSize.Level1)341 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetScreenMagnificationState_001, TestSize.Level1)
342 {
343 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_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) << "AccessibleAbilityManagerServiceUnitTest_SetScreenMagnificationState_001 end";
350 }
351
352 /**
353 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetShortKeyState_001
354 * @tc.name: SetShortKeyState
355 * @tc.desc: Test function SetShortKeyState GetShortKeyState
356 * @tc.require: issueI5NTXH
357 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetShortKeyState_001, TestSize.Level1)358 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetShortKeyState_001, TestSize.Level1)
359 {
360 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_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) << "AccessibleAbilityManagerServiceUnitTest_SetShortKeyState_001 end";
366 }
367
368 /**
369 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetMouseKeyState_001
370 * @tc.name: SetMouseKeyState
371 * @tc.desc: Test function SetMouseKeyState GetMouseKeyState
372 * @tc.require: issueI5NTXA
373 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetMouseKeyState_001, TestSize.Level1)374 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetMouseKeyState_001, TestSize.Level1)
375 {
376 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_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) << "AccessibleAbilityManagerServiceUnitTest_SetMouseKeyState_001 end";
382 }
383
384 /**
385 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetMouseAutoClick_001
386 * @tc.name: SetMouseAutoClick
387 * @tc.desc: Test function SetMouseAutoClick GetMouseAutoClick
388 * @tc.require: issueI5NTXC
389 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetMouseAutoClick_001, TestSize.Level1)390 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetMouseAutoClick_001, TestSize.Level1)
391 {
392 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_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) << "AccessibleAbilityManagerServiceUnitTest_SetMouseAutoClick_001 end";
398 }
399
400 /**
401 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetShortkeyTarget_001
402 * @tc.name: SetShortkeyTarget
403 * @tc.desc: Test function SetShortkeyTarget GetShortkeyTarget
404 * @tc.require: issueI5NTXH
405 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetShortkeyTarget_001, TestSize.Level1)406 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetShortkeyTarget_001, TestSize.Level1)
407 {
408 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_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) << "AccessibleAbilityManagerServiceUnitTest_SetShortkeyTarget_001 end";
414 }
415
416 /**
417 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetHighContrastTextState_001
418 * @tc.name: SetHighContrastTextState
419 * @tc.desc: Test function SetHighContrastTextState GetHighContrastTextState
420 * @tc.require: issueI5NTX9
421 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetHighContrastTextState_001, TestSize.Level1)422 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetHighContrastTextState_001, TestSize.Level1)
423 {
424 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_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) << "AccessibleAbilityManagerServiceUnitTest_SetHighContrastTextState_001 end";
431 }
432
433 /**
434 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetDaltonizationState_001
435 * @tc.name: SetDaltonizationState
436 * @tc.desc: Test function SetDaltonizationState GetDaltonizationState
437 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetDaltonizationState_001, TestSize.Level1)438 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetDaltonizationState_001, TestSize.Level1)
439 {
440 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_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) << "AccessibleAbilityManagerServiceUnitTest_SetDaltonizationState_001 end";
447 }
448
449 /**
450 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetInvertColorState_001
451 * @tc.name: SetInvertColorState
452 * @tc.desc: Test function SetInvertColorState GetInvertColorState
453 * @tc.require: issueI5NTX7
454 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetInvertColorState_001, TestSize.Level1)455 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetInvertColorState_001, TestSize.Level1)
456 {
457 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_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) << "AccessibleAbilityManagerServiceUnitTest_SetInvertColorState_001 end";
463 }
464
465 /**
466 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetAnimationOffState_001
467 * @tc.name: SetAnimationOffState
468 * @tc.desc: Test function SetAnimationOffState GetAnimationOffState
469 * @tc.require: issueI5NTXG
470 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetAnimationOffState_001, TestSize.Level1)471 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetAnimationOffState_001, TestSize.Level1)
472 {
473 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_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) << "AccessibleAbilityManagerServiceUnitTest_SetAnimationOffState_001 end";
479 }
480
481 /**
482 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetAudioMonoState_001
483 * @tc.name: SetAudioMonoState
484 * @tc.desc: Test function SetAudioMonoState GetAudioMonoState
485 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetAudioMonoState_001, TestSize.Level1)486 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetAudioMonoState_001, TestSize.Level1)
487 {
488 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_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) << "AccessibleAbilityManagerServiceUnitTest_SetAudioMonoState_001 end";
494 }
495
496 /**
497 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetDaltonizationColorFilter_001
498 * @tc.name: SetDaltonizationColorFilter
499 * @tc.desc: Test function SetDaltonizationColorFilter GetDaltonizationColorFilter
500 * @tc.require: issueI5NTX8
501 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetDaltonizationColorFilter_001, TestSize.Level1)502 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetDaltonizationColorFilter_001, TestSize.Level1)
503 {
504 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_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) << "AccessibleAbilityManagerServiceUnitTest_SetDaltonizationColorFilter_001 end";
511 }
512
513 /**
514 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetContentTimeout_001
515 * @tc.name: SetContentTimeout
516 * @tc.desc: Test function SetContentTimeout GetContentTimeout
517 * @tc.require: issueI5NTXF
518 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetContentTimeout_001, TestSize.Level1)519 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetContentTimeout_001, TestSize.Level1)
520 {
521 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_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) << "AccessibleAbilityManagerServiceUnitTest_SetContentTimeout_001 end";
527 }
528
529 /**
530 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetBrightnessDiscount_001
531 * @tc.name: SetBrightnessDiscount
532 * @tc.desc: Test function SetBrightnessDiscount GetBrightnessDiscount
533 * @tc.require: issueI5NTXE
534 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetBrightnessDiscount_001, TestSize.Level1)535 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetBrightnessDiscount_001, TestSize.Level1)
536 {
537 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_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) << "AccessibleAbilityManagerServiceUnitTest_SetBrightnessDiscount_001 end";
544 }
545
546 /**
547 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetAudioBalance_001
548 * @tc.name: SetAudioBalance
549 * @tc.desc: Test function SetAudioBalance GetAudioBalance
550 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetAudioBalance_001, TestSize.Level1)551 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetAudioBalance_001, TestSize.Level1)
552 {
553 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_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) << "AccessibleAbilityManagerServiceUnitTest_SetAudioBalance_001 end";
559 }
560
561 /**
562 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetClickResponseTime_001
563 * @tc.name: SetClickResponseTime
564 * @tc.desc: Test function SetClickResponseTime GetClickResponseTime
565 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetClickResponseTime_001, TestSize.Level1)566 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetClickResponseTime_001, TestSize.Level1)
567 {
568 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_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) << "AccessibleAbilityManagerServiceUnitTest_SetClickResponseTime_001 end";
573 }
574
575 /**
576 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetIgnoreRepeatClickState_001
577 * @tc.name: SetIgnoreRepeatClickState
578 * @tc.desc: Test function SetIgnoreRepeatClickState GetIgnoreRepeatClickState
579 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetIgnoreRepeatClickState_001, TestSize.Level1)580 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetIgnoreRepeatClickState_001, TestSize.Level1)
581 {
582 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_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) << "AccessibleAbilityManagerServiceUnitTest_SetIgnoreRepeatClickState_001 end";
588 }
589
590 /**
591 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetIgnoreRepeatClickTime_001
592 * @tc.name: SetIgnoreRepeatClickTime
593 * @tc.desc: Test function SetIgnoreRepeatClickTime GetIgnoreRepeatClickTime
594 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetIgnoreRepeatClickTime_001, TestSize.Level1)595 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetIgnoreRepeatClickTime_001, TestSize.Level1)
596 {
597 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_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) << "AccessibleAbilityManagerServiceUnitTest_SetIgnoreRepeatClickTime_001 end";
602 }
603
604 /**
605 * @tc.number: AccessibleAbilityManagerServiceUnitTest_GetAllConfigs_001
606 * @tc.name: GetAllConfigs
607 * @tc.desc: Test function GetAllConfigs
608 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetAllConfigs_001, TestSize.Level1)609 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetAllConfigs_001, TestSize.Level1)
610 {
611 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetAllConfigs_001 start";
612 AccessibilityConfigData data;
613 Singleton<AccessibleAbilityManagerService>::GetInstance().GetAllConfigs(data);
614 EXPECT_NE(stub_.GetRefPtr(), nullptr);
615 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetAllConfigs_001 end";
616 }
617
618 /**
619 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetCaptionState_001
620 * @tc.name: SetCaptionState
621 * @tc.desc: Test function SetCaptionState GetCaptionState
622 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetCaptionState_001, TestSize.Level1)623 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetCaptionState_001, TestSize.Level1)
624 {
625 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_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) << "AccessibleAbilityManagerServiceUnitTest_SetCaptionState_001 end";
631 }
632
633 /**
634 * @tc.number: AccessibleAbilityManagerServiceUnitTest_GetEnabledState_001
635 * @tc.name: GetEnabledState
636 * @tc.desc: Test function GetEnabledState
637 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetEnabledState_001, TestSize.Level1)638 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetEnabledState_001, TestSize.Level1)
639 {
640 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetEnabledState_001 start";
641 EXPECT_TRUE(Singleton<AccessibleAbilityManagerService>::GetInstance().GetEnabledState());
642 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetEnabledState_001 end";
643 }
644
645 /**
646 * @tc.number: AccessibleAbilityManagerServiceUnitTest_GetTouchGuideState_001
647 * @tc.name: GetTouchGuideState
648 * @tc.desc: Test function GetTouchGuideState
649 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetTouchGuideState_001, TestSize.Level1)650 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetTouchGuideState_001, TestSize.Level1)
651 {
652 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetTouchGuideState_001 start";
653 EXPECT_FALSE(Singleton<AccessibleAbilityManagerService>::GetInstance().GetTouchGuideState());
654 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetTouchGuideState_001 end";
655 }
656
657 /**
658 * @tc.number: AccessibleAbilityManagerServiceUnitTest_GetGestureState_001
659 * @tc.name: GetGestureState
660 * @tc.desc: Test function GetGestureState
661 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetGestureState_001, TestSize.Level1)662 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetGestureState_001, TestSize.Level1)
663 {
664 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetGestureState_001 start";
665 EXPECT_FALSE(Singleton<AccessibleAbilityManagerService>::GetInstance().GetGestureState());
666 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetGestureState_001 end";
667 }
668
669 /**
670 * @tc.number: AccessibleAbilityManagerServiceUnitTest_GetKeyEventObserverState_001
671 * @tc.name: GetKeyEventObserverState
672 * @tc.desc: Test function GetKeyEventObserverState
673 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetKeyEventObserverState_001, TestSize.Level1)674 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetKeyEventObserverState_001, TestSize.Level1)
675 {
676 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetKeyEventObserverState_001 start";
677 EXPECT_FALSE(Singleton<AccessibleAbilityManagerService>::GetInstance().GetKeyEventObserverState());
678 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetKeyEventObserverState_001 end";
679 }
680
681 /**
682 * @tc.number: AccessibleAbilityManagerServiceUnitTest_GetActiveWindow_001
683 * @tc.name: GetActiveWindow
684 * @tc.desc: Test function GetActiveWindow
685 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetActiveWindow_001, TestSize.Level1)686 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetActiveWindow_001, TestSize.Level1)
687 {
688 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_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) << "AccessibleAbilityManagerServiceUnitTest_GetActiveWindow_001 end";
692 }
693
694 /**
695 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetCaptionProperty_001
696 * @tc.name: SetCaptionProperty
697 * @tc.desc: Test function SetCaptionProperty GetCaptionProperty
698 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetCaptionProperty_001, TestSize.Level1)699 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetCaptionProperty_001, TestSize.Level1)
700 {
701 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_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) << "AccessibleAbilityManagerServiceUnitTest_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(AccessibleAbilityManagerServiceUnitTest, PackageAdd_001, TestSize.Level1)717 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, 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(AccessibleAbilityManagerServiceUnitTest, PackageRemoved_001, TestSize.Level1)732 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, 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(AccessibleAbilityManagerServiceUnitTest, AddedUser_001, TestSize.Level1)746 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, 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(AccessibleAbilityManagerServiceUnitTest, EnableShortKeyTargetAbility_001, TestSize.Level1)760 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, 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(AccessibleAbilityManagerServiceUnitTest, DisableShortKeyTargetAbility_001, TestSize.Level1)772 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, 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(AccessibleAbilityManagerServiceUnitTest, EnableAbility_001, TestSize.Level1)784 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, 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(AccessibleAbilityManagerServiceUnitTest, DisableAbility_001, TestSize.Level1)799 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, 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(AccessibleAbilityManagerServiceUnitTest, GetEnabledAbilities_001, TestSize.Level1)812 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, 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(AccessibleAbilityManagerServiceUnitTest, EnableUITestAbility_001, TestSize.Level1)826 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, 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(AccessibleAbilityManagerServiceUnitTest, DisableUITestAbility_001, TestSize.Level1)839 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, 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: AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterCaptionObserver_001
848 * @tc.name: RegisterCaptionObserver
849 * @tc.desc: Test function RegisterCaptionObserver
850 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, RegisterCaptionObserver_001, TestSize.Level1)851 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, RegisterCaptionObserver_001, TestSize.Level1)
852 {
853 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_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) << "AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterCaptionObserver_001 end";
862 }
863
864 /*
865 * @tc.number: AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterConfigObserver_001
866 * @tc.name: RegisterConfigObserver
867 * @tc.desc: Test function RegisterConfigObserver
868 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, RegisterConfigObserver_001, TestSize.Level1)869 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, RegisterConfigObserver_001, TestSize.Level1)
870 {
871 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_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) << "AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterConfigObserver_001 end";
880 }
881
882 /*
883 * @tc.number: AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterEnableAbilityListsObserver_001
884 * @tc.name: RegisterEnableAbilityListsObserver
885 * @tc.desc: Test function RegisterEnableAbilityListsObserver
886 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, RegisterEnableAbilityListsObserver_001, TestSize.Level1)887 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, RegisterEnableAbilityListsObserver_001, TestSize.Level1)
888 {
889 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_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) << "AccessibleAbilityManagerServiceUnitTest_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(AccessibleAbilityManagerServiceUnitTest, SwitchedUser_001, TestSize.Level1)904 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, 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(AccessibleAbilityManagerServiceUnitTest, GetAbilityList_002, TestSize.Level1)919 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetAbilityList_002, TestSize.Level1)
920 {
921 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_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) << "AccessibleAbilityManagerServiceUnitTest_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(AccessibleAbilityManagerServiceUnitTest, RegisterElementOperator_002, TestSize.Level1)935 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, RegisterElementOperator_002, TestSize.Level1)
936 {
937 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_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) << "AccessibleAbilityManagerServiceUnitTest_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(AccessibleAbilityManagerServiceUnitTest, RegisterElementOperator_003, TestSize.Level1)950 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, RegisterElementOperator_003, TestSize.Level1)
951 {
952 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_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) << "AccessibleAbilityManagerServiceUnitTest_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(AccessibleAbilityManagerServiceUnitTest, UpdateAccessibilityManagerService_001, TestSize.Level1)969 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, 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: AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterStateCallback_002
981 * @tc.name: RegisterStateCallback
982 * @tc.desc: Test function RegisterStateCallback
983 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, RegisterStateCallback_002, TestSize.Level1)984 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, RegisterStateCallback_002, TestSize.Level1)
985 {
986 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_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) << "AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterStateCallback_002 end";
996 }
997
998 /**
999 * @tc.number: AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterCaptionObserver_002
1000 * @tc.name: RegisterCaptionObserver
1001 * @tc.desc: Test function RegisterCaptionObserver
1002 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, RegisterCaptionObserver_002, TestSize.Level1)1003 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, RegisterCaptionObserver_002, TestSize.Level1)
1004 {
1005 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_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) << "AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterCaptionObserver_002 end";
1015 }
1016
1017 /**
1018 * @tc.number: AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterCaptionObserver_003
1019 * @tc.name: RegisterCaptionObserver
1020 * @tc.desc: Test function RegisterCaptionObserver
1021 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, RegisterCaptionObserver_003, TestSize.Level1)1022 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, RegisterCaptionObserver_003, TestSize.Level1)
1023 {
1024 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_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) << "AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterCaptionObserver_003 end";
1029 }
1030
1031 /*
1032 * @tc.number: AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterEnableAbilityListsObserver_002
1033 * @tc.name: RegisterEnableAbilityListsObserver
1034 * @tc.desc: Test function RegisterEnableAbilityListsObserver
1035 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, RegisterEnableAbilityListsObserver_002, TestSize.Level1)1036 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, RegisterEnableAbilityListsObserver_002, TestSize.Level1)
1037 {
1038 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_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) << "AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterEnableAbilityListsObserver_002 end";
1047 }
1048
1049 /*
1050 * @tc.number: AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterEnableAbilityListsObserver_003
1051 * @tc.name: RegisterEnableAbilityListsObserver
1052 * @tc.desc: Test function RegisterEnableAbilityListsObserver
1053 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, RegisterEnableAbilityListsObserver_003, TestSize.Level1)1054 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, RegisterEnableAbilityListsObserver_003, TestSize.Level1)
1055 {
1056 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterEnableAbilityListsObserver_003 start";
1057 Singleton<AccessibleAbilityManagerService>::GetInstance().RegisterEnableAbilityListsObserver(nullptr);
1058 EXPECT_NE(stub_.GetRefPtr(), nullptr);
1059 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterEnableAbilityListsObserver_003 end";
1060 }
1061
1062 /**
1063 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetCaptionProperty_002
1064 * @tc.name: SetCaptionProperty
1065 * @tc.desc: Test function SetCaptionProperty GetCaptionProperty
1066 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetCaptionProperty_002, TestSize.Level1)1067 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetCaptionProperty_002, TestSize.Level1)
1068 {
1069 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_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) << "AccessibleAbilityManagerServiceUnitTest_SetCaptionProperty_002 end";
1078 }
1079
1080 /**
1081 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetCaptionState_002
1082 * @tc.name: SetCaptionState
1083 * @tc.desc: Test function SetCaptionState GetCaptionState
1084 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetCaptionState_002, TestSize.Level1)1085 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetCaptionState_002, TestSize.Level1)
1086 {
1087 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_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) << "AccessibleAbilityManagerServiceUnitTest_SetCaptionState_002 end";
1094 }
1095
1096 /**
1097 * @tc.number: AccessibleAbilityManagerServiceUnitTest_GetTouchGuideState_002
1098 * @tc.name: GetTouchGuideState
1099 * @tc.desc: Test function GetTouchGuideState
1100 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetTouchGuideState_002, TestSize.Level1)1101 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetTouchGuideState_002, TestSize.Level1)
1102 {
1103 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_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) << "AccessibleAbilityManagerServiceUnitTest_GetTouchGuideState_002 end";
1108 }
1109
1110 /**
1111 * @tc.number: AccessibleAbilityManagerServiceUnitTest_GetGestureState_002
1112 * @tc.name: GetGestureState
1113 * @tc.desc: Test function GetGestureState
1114 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetGestureState_002, TestSize.Level1)1115 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetGestureState_002, TestSize.Level1)
1116 {
1117 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_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) << "AccessibleAbilityManagerServiceUnitTest_GetGestureState_002 end";
1122 }
1123
1124 /**
1125 * @tc.number: AccessibleAbilityManagerServiceUnitTest_GetKeyEventObserverState_002
1126 * @tc.name: GetKeyEventObserverState
1127 * @tc.desc: Test function GetKeyEventObserverState
1128 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetKeyEventObserverState_002, TestSize.Level1)1129 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetKeyEventObserverState_002, TestSize.Level1)
1130 {
1131 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_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) << "AccessibleAbilityManagerServiceUnitTest_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(AccessibleAbilityManagerServiceUnitTest, EnableAbility_002, TestSize.Level1)1143 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, 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(AccessibleAbilityManagerServiceUnitTest, GetEnabledAbilities_002, TestSize.Level1)1160 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, 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(AccessibleAbilityManagerServiceUnitTest, DisableAbility_002, TestSize.Level1)1176 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, 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(AccessibleAbilityManagerServiceUnitTest, EnableUITestAbility_002, TestSize.Level1)1191 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, 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(AccessibleAbilityManagerServiceUnitTest, DisableUITestAbility_002, TestSize.Level1)1206 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, 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(AccessibleAbilityManagerServiceUnitTest, EnableShortKeyTargetAbility_002, TestSize.Level1)1220 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, 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(AccessibleAbilityManagerServiceUnitTest, DisableShortKeyTargetAbility_002, TestSize.Level1)1234 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, 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(AccessibleAbilityManagerServiceUnitTest, PackageRemoved_002, TestSize.Level1)1248 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, 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(AccessibleAbilityManagerServiceUnitTest, PackageAdd_002, TestSize.Level1)1264 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, 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: AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterConfigObserver_002
1277 * @tc.name: RegisterConfigObserver
1278 * @tc.desc: Test function RegisterConfigObserver
1279 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, RegisterConfigObserver_002, TestSize.Level1)1280 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, RegisterConfigObserver_002, TestSize.Level1)
1281 {
1282 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterConfigObserver_002 start";
1283 uint32_t ret = Singleton<AccessibleAbilityManagerService>::GetInstance().RegisterConfigObserver(nullptr);
1284 EXPECT_EQ(ret, ERR_INVALID_VALUE);
1285 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterConfigObserver_002 end";
1286 }
1287
1288 /**
1289 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetScreenMagnificationState_002
1290 * @tc.name: SetScreenMagnificationState
1291 * @tc.desc: Test function SetScreenMagnificationState GetScreenMagnificationState
1292 */
1293
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetScreenMagnificationState_002, TestSize.Level1)1294 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetScreenMagnificationState_002, TestSize.Level1)
1295 {
1296 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_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) << "AccessibleAbilityManagerServiceUnitTest_SetScreenMagnificationState_002 end";
1303 }
1304
1305 /**
1306 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetShortKeyState_002
1307 * @tc.name: SetShortKeyState
1308 * @tc.desc: Test function SetShortKeyState GetShortKeyState
1309 * @tc.require: issueI5NTXH
1310 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetShortKeyState_002, TestSize.Level1)1311 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetShortKeyState_002, TestSize.Level1)
1312 {
1313 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_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) << "AccessibleAbilityManagerServiceUnitTest_SetShortKeyState_002 end";
1320 }
1321
1322 /**
1323 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetMouseKeyState_002
1324 * @tc.name: SetMouseKeyState
1325 * @tc.desc: Test function SetMouseKeyState GetMouseKeyState
1326 * @tc.require: issueI5NTXA
1327 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetMouseKeyState_002, TestSize.Level1)1328 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetMouseKeyState_002, TestSize.Level1)
1329 {
1330 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_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) << "AccessibleAbilityManagerServiceUnitTest_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(AccessibleAbilityManagerServiceUnitTest, SetSearchElementInfoByAccessibilityIdResult_001, TestSize.Level1)1344 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, 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(AccessibleAbilityManagerServiceUnitTest, SetSearchElementInfoByTextResult_001, TestSize.Level1)1361 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, 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(AccessibleAbilityManagerServiceUnitTest, SetFindFocusedElementInfoResult_001, TestSize.Level1)1378 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, 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(AccessibleAbilityManagerServiceUnitTest, SetFocusMoveSearchResult_001, TestSize.Level1)1395 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, 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(AccessibleAbilityManagerServiceUnitTest, SetExecuteActionResult_001, TestSize.Level1)1412 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, 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(AccessibleAbilityManagerServiceUnitTest, SetCursorPositionResult_001, TestSize.Level1)1430 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, 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(AccessibleAbilityManagerServiceUnitTest, SetShortkeyMultiTarget_001, TestSize.Level1)1449 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, 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(AccessibleAbilityManagerServiceUnitTest, GetShortkeyMultiTarget_001, TestSize.Level1)1462 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, 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(AccessibleAbilityManagerServiceUnitTest, OnShortKeyProcess_001, TestSize.Level1)1475 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, 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(AccessibleAbilityManagerServiceUnitTest, OnShortKeyProcess_002, TestSize.Level1)1490 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, 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(AccessibleAbilityManagerServiceUnitTest, OnShortKeyProcess_003, TestSize.Level1)1517 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, 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(AccessibleAbilityManagerServiceUnitTest, OnShortKeyProcess_004, TestSize.Level1)1544 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, 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(AccessibleAbilityManagerServiceUnitTest, OnShortKeyProcess_005, TestSize.Level1)1576 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, 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(AccessibleAbilityManagerServiceUnitTest, OnShortKeyProcess_006, TestSize.Level1)1609 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, 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: AccessibleAbilityManagerServiceUnitTest_SetMouseAutoClick_002
1640 * @tc.name: SetMouseAutoClick
1641 * @tc.desc: Test function SetMouseAutoClick GetMouseAutoClick
1642 * @tc.require: issueI5NTXC
1643 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetMouseAutoClick_002, TestSize.Level1)1644 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetMouseAutoClick_002, TestSize.Level1)
1645 {
1646 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_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) << "AccessibleAbilityManagerServiceUnitTest_SetMouseAutoClick_002 end";
1653 }
1654
1655 /**
1656 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetShortkeyTarget_002
1657 * @tc.name: SetShortkeyTarget
1658 * @tc.desc: Test function SetShortkeyTarget GetShortkeyTarget
1659 * @tc.require: issueI5NTXH
1660 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetShortkeyTarget_002, TestSize.Level1)1661 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetShortkeyTarget_002, TestSize.Level1)
1662 {
1663 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_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) << "AccessibleAbilityManagerServiceUnitTest_SetShortkeyTarget_002 end";
1670 }
1671
1672 /**
1673 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetHighContrastTextState_002
1674 * @tc.name: SetHighContrastTextState
1675 * @tc.desc: Test function SetHighContrastTextState GetHighContrastTextState
1676 * @tc.require: issueI5NTX9
1677 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetHighContrastTextState_002, TestSize.Level1)1678 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetHighContrastTextState_002, TestSize.Level1)
1679 {
1680 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_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) << "AccessibleAbilityManagerServiceUnitTest_SetHighContrastTextState_002 end";
1687 }
1688
1689 /**
1690 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetDaltonizationState_002
1691 * @tc.name: SetDaltonizationState
1692 * @tc.desc: Test function SetDaltonizationState GetDaltonizationState
1693 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetDaltonizationState_002, TestSize.Level1)1694 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetDaltonizationState_002, TestSize.Level1)
1695 {
1696 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_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) << "AccessibleAbilityManagerServiceUnitTest_SetDaltonizationState_002 end";
1705 }
1706
1707 /**
1708 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetInvertColorState_002
1709 * @tc.name: SetInvertColorState
1710 * @tc.desc: Test function SetInvertColorState GetInvertColorState
1711 * @tc.require: issueI5NTX7
1712 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetInvertColorState_002, TestSize.Level1)1713 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetInvertColorState_002, TestSize.Level1)
1714 {
1715 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_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) << "AccessibleAbilityManagerServiceUnitTest_SetInvertColorState_002 end";
1722 }
1723
1724 /**
1725 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetAnimationOffState_002
1726 * @tc.name: SetAnimationOffState
1727 * @tc.desc: Test function SetAnimationOffState GetAnimationOffState
1728 * @tc.require: issueI5NTXG
1729 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetAnimationOffState_002, TestSize.Level1)1730 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetAnimationOffState_002, TestSize.Level1)
1731 {
1732 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_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) << "AccessibleAbilityManagerServiceUnitTest_SetAnimationOffState_002 end";
1739 }
1740
1741 /**
1742 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetAudioMonoState_002
1743 * @tc.name: SetAudioMonoState
1744 * @tc.desc: Test function SetAudioMonoState GetAudioMonoState
1745 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetAudioMonoState_002, TestSize.Level1)1746 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetAudioMonoState_002, TestSize.Level1)
1747 {
1748 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_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) << "AccessibleAbilityManagerServiceUnitTest_SetAudioMonoState_002 end";
1755 }
1756
1757 /**
1758 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetDaltonizationColorFilter_002
1759 * @tc.name: SetDaltonizationColorFilter
1760 * @tc.desc: Test function SetDaltonizationColorFilter GetDaltonizationColorFilter
1761 * @tc.require: issueI5NTX8
1762 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetDaltonizationColorFilter_002, TestSize.Level1)1763 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetDaltonizationColorFilter_002, TestSize.Level1)
1764 {
1765 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_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) << "AccessibleAbilityManagerServiceUnitTest_SetDaltonizationColorFilter_002 end";
1772 }
1773
1774 /**
1775 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetContentTimeout_002
1776 * @tc.name: SetContentTimeout
1777 * @tc.desc: Test function SetContentTimeout GetContentTimeout
1778 * @tc.require: issueI5NTXF
1779 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetContentTimeout_002, TestSize.Level1)1780 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetContentTimeout_002, TestSize.Level1)
1781 {
1782 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_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) << "AccessibleAbilityManagerServiceUnitTest_SetContentTimeout_002 end";
1789 }
1790
1791 /**
1792 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetBrightnessDiscount_002
1793 * @tc.name: SetBrightnessDiscount
1794 * @tc.desc: Test function SetBrightnessDiscount GetBrightnessDiscount
1795 * @tc.require: issueI5NTXE
1796 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetBrightnessDiscount_002, TestSize.Level1)1797 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetBrightnessDiscount_002, TestSize.Level1)
1798 {
1799 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_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) << "AccessibleAbilityManagerServiceUnitTest_SetBrightnessDiscount_002 end";
1806 }
1807
1808 /**
1809 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SetAudioBalance_002
1810 * @tc.name: SetAudioBalance
1811 * @tc.desc: Test function SetAudioBalance GetAudioBalance
1812 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetAudioBalance_002, TestSize.Level1)1813 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetAudioBalance_002, TestSize.Level1)
1814 {
1815 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_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) << "AccessibleAbilityManagerServiceUnitTest_SetAudioBalance_002 end";
1822 }
1823
1824 /**
1825 * @tc.number: AccessibleAbilityManagerServiceUnitTest_GetAllConfigs_002
1826 * @tc.name: GetAllConfigs
1827 * @tc.desc: Test function GetAllConfigs
1828 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetAllConfigs_002, TestSize.Level1)1829 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetAllConfigs_002, TestSize.Level1)
1830 {
1831 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_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) << "AccessibleAbilityManagerServiceUnitTest_GetAllConfigs_002 end";
1838 }
1839
1840 /**
1841 * @tc.number: AccessibleAbilityManagerServiceUnitTest_OnRemoveSystemAbility_001
1842 * @tc.name: OnRemoveSystemAbility
1843 * @tc.desc: Test function OnRemoveSystemAbility
1844 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, OnRemoveSystemAbility_001, TestSize.Level1)1845 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, OnRemoveSystemAbility_001, TestSize.Level1)
1846 {
1847 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_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) << "AccessibleAbilityManagerServiceUnitTest_OnRemoveSystemAbility_001 end";
1854 }
1855
1856 /**
1857 * @tc.number: AccessibleAbilityManagerServiceUnitTest_OnRemoveSystemAbility_002
1858 * @tc.name: OnRemoveSystemAbility
1859 * @tc.desc: Test function OnRemoveSystemAbility
1860 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, OnRemoveSystemAbility_002, TestSize.Level1)1861 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, OnRemoveSystemAbility_002, TestSize.Level1)
1862 {
1863 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_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) << "AccessibleAbilityManagerServiceUnitTest_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(AccessibleAbilityManagerServiceUnitTest, UpdateConfigState_001, TestSize.Level1)1885 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, 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(AccessibleAbilityManagerServiceUnitTest, UpdateAudioBalance_001, TestSize.Level1)1903 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, 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(AccessibleAbilityManagerServiceUnitTest, UpdateBrightnessDiscount_001, TestSize.Level1)1921 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, 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(AccessibleAbilityManagerServiceUnitTest, UpdateContentTimeout_001, TestSize.Level1)1939 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, 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(AccessibleAbilityManagerServiceUnitTest, UpdateDaltonizationColorFilter_001, TestSize.Level1)1957 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, 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(AccessibleAbilityManagerServiceUnitTest, UpdateMouseAutoClick_001, TestSize.Level1)1975 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, 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
1988 /**
1989 * @tc.number: AccessibleAbility_ManagerService_UnitTest_UpdateShortkeyTarget_001
1990 * @tc.name: UpdateShortkeyTarget
1991 * @tc.desc: Test function UpdateShortkeyTarget
1992 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, UpdateShortkeyTarget_001, TestSize.Level1)1993 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, UpdateShortkeyTarget_001, TestSize.Level1)
1994 {
1995 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_UpdateShortkeyTarget_001 start";
1996 sptr<MockAccessibleAbilityManagerConfigObserverStub> stub = new MockAccessibleAbilityManagerConfigObserverStub();
1997 sptr<IAccessibleAbilityManagerConfigObserver> state = new MockAccessibleAbilityManagerConfigObserverProxy(stub);
1998
1999 uint32_t ret = Singleton<AccessibleAbilityManagerService>::GetInstance().RegisterConfigObserver(state);
2000 EXPECT_EQ(ret, 0);
2001 Singleton<AccessibleAbilityManagerService>::GetInstance().UpdateShortkeyTarget();
2002 EXPECT_NE(stub_.GetRefPtr(), nullptr);
2003 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_UpdateShortkeyTarget_001 end";
2004 }
2005
2006 /**
2007 * @tc.number: AccessibleAbility_ManagerService_UnitTest_UpdateClickResponseTime_001
2008 * @tc.name: UpdateClickResponseTime
2009 * @tc.desc: Test function UpdateClickResponseTime
2010 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, UpdateClickResponseTime_001, TestSize.Level1)2011 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, UpdateClickResponseTime_001, TestSize.Level1)
2012 {
2013 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_UpdateClickResponseTime_001 start";
2014 sptr<MockAccessibleAbilityManagerConfigObserverStub> stub = new MockAccessibleAbilityManagerConfigObserverStub();
2015 sptr<IAccessibleAbilityManagerConfigObserver> state = new MockAccessibleAbilityManagerConfigObserverProxy(stub);
2016
2017 uint32_t ret = Singleton<AccessibleAbilityManagerService>::GetInstance().RegisterConfigObserver(state);
2018 EXPECT_EQ(ret, 0);
2019 Singleton<AccessibleAbilityManagerService>::GetInstance().UpdateClickResponseTime();
2020 EXPECT_NE(stub_.GetRefPtr(), nullptr);
2021 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_UpdateClickResponseTime_001 end";
2022 }
2023
2024 /**
2025 * @tc.number: AccessibleAbility_ManagerService_UnitTest_UpdateIgnoreRepeatClickTime_001
2026 * @tc.name: UpdateIgnoreRepeatClickTime
2027 * @tc.desc: Test function UpdateIgnoreRepeatClickTime
2028 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, UpdateIgnoreRepeatClickTime_001, TestSize.Level1)2029 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, UpdateIgnoreRepeatClickTime_001, TestSize.Level1)
2030 {
2031 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_UpdateIgnoreRepeatClickTime_001 start";
2032 sptr<MockAccessibleAbilityManagerConfigObserverStub> stub = new MockAccessibleAbilityManagerConfigObserverStub();
2033 sptr<IAccessibleAbilityManagerConfigObserver> state = new MockAccessibleAbilityManagerConfigObserverProxy(stub);
2034
2035 uint32_t ret = Singleton<AccessibleAbilityManagerService>::GetInstance().RegisterConfigObserver(state);
2036 EXPECT_EQ(ret, 0);
2037 Singleton<AccessibleAbilityManagerService>::GetInstance().UpdateIgnoreRepeatClickTime();
2038 EXPECT_NE(stub_.GetRefPtr(), nullptr);
2039 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_UpdateIgnoreRepeatClickTime_001 end";
2040 }
2041
2042 /**
2043 * @tc.number: AccessibleAbility_ManagerService_UnitTest_PackageRemoved_003
2044 * @tc.name: PackageRemoved
2045 * @tc.desc: Test function PackageRemoved
2046 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, PackageRemoved_003, TestSize.Level1)2047 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, PackageRemoved_003, TestSize.Level1)
2048 {
2049 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_PackageRemoved_003 start";
2050 std::string bundleName = "bundleName1";
2051 Singleton<AccessibleAbilityManagerService>::GetInstance().PackageAdd(bundleName);
2052 sleep(SLEEP_TIME_1);
2053 Singleton<AccessibleAbilityManagerService>::GetInstance().PackageRemoved(bundleName);
2054 EXPECT_NE(stub_.GetRefPtr(), nullptr);
2055 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_PackageRemoved_003 end";
2056 }
2057
2058 /**
2059 * @tc.number: AccessibleAbility_ManagerService_UnitTest_GetAbilityList_003
2060 * @tc.name: GetAbilityList
2061 * @tc.desc: Test function GetAbilityList
2062 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetAbilityList_003, TestSize.Level1)2063 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetAbilityList_003, TestSize.Level1)
2064 {
2065 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetAbilityList_003 start";
2066 std::vector<OHOS::Accessibility::AccessibilityAbilityInfo> infos;
2067 uint32_t type = 0xFFFFFFFF;
2068 Singleton<AccessibleAbilityManagerService>::GetInstance().GetAbilityList(type, -1, infos);
2069 EXPECT_EQ(infos.size(), 0);
2070 Singleton<AccessibleAbilityManagerService>::GetInstance().GetAbilityList(type, 5, infos);
2071 EXPECT_EQ(infos.size(), 0);
2072 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_GetAbilityList_003 end";
2073 }
2074
2075 /**
2076 * @tc.number: AccessibleAbility_ManagerService_UnitTest_SetTargetAbility_001
2077 * @tc.name: SetTargetAbility
2078 * @tc.desc: Test function HIGH_CONTRAST_TEXT
2079 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetTargetAbility_001, TestSize.Level1)2080 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetTargetAbility_001, TestSize.Level1)
2081 {
2082 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTargetAbility_001 start";
2083 auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
2084 if (!accountData) {
2085 GTEST_LOG_(INFO) << "current account data is null";
2086 return;
2087 }
2088 accountData->GetConfig()->SetShortkeyTarget("HIGH_CONTRAST_TEXT");
2089 bool ret = Singleton<AccessibleAbilityManagerService>::GetInstance().EnableShortKeyTargetAbility();
2090 EXPECT_FALSE(ret);
2091 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTargetAbility_001 end";
2092 }
2093
2094 /**
2095 * @tc.number: AccessibleAbility_ManagerService_UnitTest_SetTargetAbility_002
2096 * @tc.name: SetTargetAbility
2097 * @tc.desc: Test function INVERT_COLOR
2098 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetTargetAbility_002, TestSize.Level1)2099 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetTargetAbility_002, TestSize.Level1)
2100 {
2101 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTargetAbility_002 start";
2102 auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
2103 if (!accountData) {
2104 GTEST_LOG_(INFO) << "current account data is null";
2105 return;
2106 }
2107 accountData->GetConfig()->SetShortkeyTarget("INVERT_COLOR");
2108 bool ret = Singleton<AccessibleAbilityManagerService>::GetInstance().EnableShortKeyTargetAbility();
2109 EXPECT_FALSE(ret);
2110 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTargetAbility_002 end";
2111 }
2112
2113 /**
2114 * @tc.number: AccessibleAbility_ManagerService_UnitTest_SetTargetAbility_003
2115 * @tc.name: SetTargetAbility
2116 * @tc.desc: Test function ANIMATION_OFF
2117 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetTargetAbility_003, TestSize.Level1)2118 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetTargetAbility_003, TestSize.Level1)
2119 {
2120 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTargetAbility_003 start";
2121 auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
2122 if (!accountData) {
2123 GTEST_LOG_(INFO) << "current account data is null";
2124 return;
2125 }
2126 accountData->GetConfig()->SetShortkeyTarget("ANIMATION_OFF");
2127 bool ret = Singleton<AccessibleAbilityManagerService>::GetInstance().EnableShortKeyTargetAbility();
2128 EXPECT_FALSE(ret);
2129 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTargetAbility_003 end";
2130 }
2131
2132 /**
2133 * @tc.number: AccessibleAbility_ManagerService_UnitTest_SetTargetAbility_004
2134 * @tc.name: SetTargetAbility
2135 * @tc.desc: Test function SCREEN_MAGNIFICATION
2136 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetTargetAbility_004, TestSize.Level1)2137 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetTargetAbility_004, TestSize.Level1)
2138 {
2139 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTargetAbility_004 start";
2140 auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
2141 if (!accountData) {
2142 GTEST_LOG_(INFO) << "current account data is null";
2143 return;
2144 }
2145 accountData->GetConfig()->SetShortkeyTarget("SCREEN_MAGNIFICATION");
2146 bool ret = Singleton<AccessibleAbilityManagerService>::GetInstance().EnableShortKeyTargetAbility();
2147 EXPECT_FALSE(ret);
2148 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTargetAbility_004 end";
2149 }
2150
2151 /**
2152 * @tc.number: AccessibleAbility_ManagerService_UnitTest_SetTargetAbility_005
2153 * @tc.name: SetTargetAbility
2154 * @tc.desc: Test function AUDIO_MONO
2155 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetTargetAbility_005, TestSize.Level1)2156 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetTargetAbility_005, TestSize.Level1)
2157 {
2158 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTargetAbility_005 start";
2159 auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
2160 if (!accountData) {
2161 GTEST_LOG_(INFO) << "current account data is null";
2162 return;
2163 }
2164 accountData->GetConfig()->SetShortkeyTarget("AUDIO_MONO");
2165 bool ret = Singleton<AccessibleAbilityManagerService>::GetInstance().EnableShortKeyTargetAbility();
2166 EXPECT_FALSE(ret);
2167 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTargetAbility_005 end";
2168 }
2169
2170 /**
2171 * @tc.number: AccessibleAbility_ManagerService_UnitTest_SetTargetAbility_006
2172 * @tc.name: SetTargetAbility
2173 * @tc.desc: Test function MOUSE_KEY
2174 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetTargetAbility_006, TestSize.Level1)2175 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetTargetAbility_006, TestSize.Level1)
2176 {
2177 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTargetAbility_006 start";
2178 auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
2179 if (!accountData) {
2180 GTEST_LOG_(INFO) << "current account data is null";
2181 return;
2182 }
2183 accountData->GetConfig()->SetShortkeyTarget("MOUSE_KEY");
2184 bool ret = Singleton<AccessibleAbilityManagerService>::GetInstance().EnableShortKeyTargetAbility();
2185 EXPECT_FALSE(ret);
2186 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTargetAbility_006 end";
2187 }
2188
2189 /**
2190 * @tc.number: AccessibleAbility_ManagerService_UnitTest_SetTargetAbility_007
2191 * @tc.name: SetTargetAbility
2192 * @tc.desc: Test function CAPTION_STATE
2193 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetTargetAbility_007, TestSize.Level1)2194 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetTargetAbility_007, TestSize.Level1)
2195 {
2196 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTargetAbility_007 start";
2197 auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
2198 if (!accountData) {
2199 GTEST_LOG_(INFO) << "current account data is null";
2200 return;
2201 }
2202 accountData->GetConfig()->SetShortkeyTarget("CAPTION_STATE");
2203 bool ret = Singleton<AccessibleAbilityManagerService>::GetInstance().EnableShortKeyTargetAbility();
2204 EXPECT_FALSE(ret);
2205 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTargetAbility_007 end";
2206 }
2207
2208 /**
2209 * @tc.number: AccessibleAbility_ManagerService_UnitTest_SetTargetAbility_008
2210 * @tc.name: SetTargetAbility
2211 * @tc.desc: Test function OTHERS
2212 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetTargetAbility_008, TestSize.Level1)2213 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetTargetAbility_008, TestSize.Level1)
2214 {
2215 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTargetAbility_008 start";
2216 auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
2217 if (!accountData) {
2218 GTEST_LOG_(INFO) << "current account data is null";
2219 return;
2220 }
2221 accountData->GetConfig()->SetShortkeyTarget("CONTENT_TIMEOUT");
2222 bool ret = Singleton<AccessibleAbilityManagerService>::GetInstance().EnableShortKeyTargetAbility();
2223 EXPECT_FALSE(ret);
2224 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTargetAbility_008 end";
2225 }
2226
2227 /**
2228 * @tc.number: AccessibleAbility_ManagerService_UnitTest_SetTargetAbility_009
2229 * @tc.name: SetTargetAbility
2230 * @tc.desc: Test function ""
2231 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetTargetAbility_009, TestSize.Level1)2232 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetTargetAbility_009, TestSize.Level1)
2233 {
2234 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTargetAbility_009 start";
2235 auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
2236 if (!accountData) {
2237 GTEST_LOG_(INFO) << "current account data is null";
2238 return;
2239 }
2240 // set
2241 accountData->GetConfig()->SetShortkeyTarget("");
2242 bool ret = Singleton<AccessibleAbilityManagerService>::GetInstance().EnableShortKeyTargetAbility();
2243 EXPECT_FALSE(ret);
2244 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTargetAbility_009 end";
2245 }
2246
2247 /**
2248 * @tc.number: AccessibleAbility_ManagerService_UnitTest_SetTargetAbility_010
2249 * @tc.name: SetTargetAbility
2250 * @tc.desc: Test function other account
2251 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetTargetAbility_010, TestSize.Level1)2252 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetTargetAbility_010, TestSize.Level1)
2253 {
2254 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTargetAbility_010 start";
2255 sleep(SLEEP_TIME_1);
2256 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
2257 auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
2258 if (!accountData) {
2259 GTEST_LOG_(INFO) << "current account data is null";
2260 return;
2261 }
2262 accountData->GetConfig()->SetShortkeyTarget("MOUSE_KEY");
2263 bool ret = Singleton<AccessibleAbilityManagerService>::GetInstance().EnableShortKeyTargetAbility();
2264 EXPECT_FALSE(ret);
2265 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTargetAbility_010 end";
2266 }
2267
2268 /**
2269 * @tc.number: Accessible_Ability_Manager_ServiceUnittest_AddAccountData_001
2270 * @tc.name: AddAccountData
2271 * @tc.desc: Test function add account
2272 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, AddAccountData_001, TestSize.Level1)2273 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, AddAccountData_001, TestSize.Level1)
2274 {
2275 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_AddAccountData_001 start";
2276 Singleton<AccessibleAbilityManagerService>::GetInstance().AddedUser(1);
2277 auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetAccountData(1);
2278 EXPECT_NE(accountData.GetRefPtr(), nullptr);
2279
2280 Singleton<AccessibleAbilityManagerService>::GetInstance().RemovedUser(1);
2281 accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetAccountData(1);
2282 EXPECT_EQ(accountData.GetRefPtr(), nullptr);
2283 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_AddAccountData_001 end";
2284 }
2285
2286 /**
2287 * @tc.number: Accessible_Ability_Manager_ServiceUnittest_FindInnerWindowId_001
2288 * @tc.name: FindInnerWindowId
2289 * @tc.desc: Test function find inner windowId
2290 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, FindInnerWindowId_001, TestSize.Level1)2291 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, FindInnerWindowId_001, TestSize.Level1)
2292 {
2293 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_FindInnerWindowId_001 start";
2294 AccessibilityEventInfo event;
2295 event.SetWindowId(1);
2296 event.SetSource(1);
2297 int32_t windowId = 1;
2298 Singleton<AccessibleAbilityManagerService>::GetInstance().FindInnerWindowId(event, windowId);
2299 EXPECT_EQ(windowId, 1);
2300 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_FindInnerWindowId_001 end";
2301 }
2302
2303 /**
2304 * @tc.number: Accessible_Ability_Manager_ServiceUnittest_GetFocusedWindowId_001
2305 * @tc.name: GetFocusedWindowId
2306 * @tc.desc: Test function find focused windowId
2307 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetFocusedWindowId_001, TestSize.Level1)2308 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetFocusedWindowId_001, TestSize.Level1)
2309 {
2310 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_GetFocusedWindowId_001 start";
2311 int32_t windowId = 1;
2312 RetError ret = Singleton<AccessibleAbilityManagerService>::GetInstance().GetFocusedWindowId(windowId);
2313 EXPECT_EQ(ret, RET_OK);
2314 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_GetFocusedWindowId_001 end";
2315 }
2316
2317 /**
2318 * @tc.number: Accessible_Ability_Manager_ServiceUnittest_InsertWindowIdEventPair_001
2319 * @tc.name: InsertWindowIdEventPair
2320 * @tc.desc: Test insert foucus window event.
2321 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, InsertWindowIdEventPair_001, TestSize.Level1)2322 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, InsertWindowIdEventPair_001, TestSize.Level1)
2323 {
2324 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_InsertWindowIdEventPair_001 start";
2325 AccessibilityEventInfo event;
2326 event.SetWindowId(1);
2327 event.SetSource(1);
2328 int32_t windowId = 1;
2329 Singleton<AccessibleAbilityManagerService>::GetInstance().InsertWindowIdEventPair(windowId, event);
2330 bool ret = Singleton<AccessibleAbilityManagerService>::GetInstance().CheckWindowIdEventExist(windowId);
2331 EXPECT_TRUE(ret);
2332 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_InsertWindowIdEventPair_001 end";
2333 }
2334
2335 /**
2336 * @tc.number: Accessible_Ability_Manager_ServiceUnittest_OnAddSystemAbility_001
2337 * @tc.name: OnAddSystemAbility
2338 * @tc.desc: Test insert foucus window event.
2339 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, OnAddSystemAbility_001, TestSize.Level1)2340 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, OnAddSystemAbility_001, TestSize.Level1)
2341 {
2342 GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_OnAddSystemAbility_001 start";
2343 TearDownTestCase();
2344 std::string deviceId = "test";
2345 Singleton<AccessibleAbilityManagerService>::GetInstance().OnAddSystemAbility(0, deviceId);
2346 SetUpTestCase();
2347 GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_OnAddSystemAbility_001 end";
2348 }
2349
2350 /**
2351 * @tc.number: Accessible_Ability_Manager_ServiceUnittest_OnAddSystemAbility_002
2352 * @tc.name: OnAddSystemAbility
2353 * @tc.desc: Test insert foucus window event. (SystemAbilityId not found)
2354 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, OnAddSystemAbility_002, TestSize.Level1)2355 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, OnAddSystemAbility_002, TestSize.Level1)
2356 {
2357 GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_OnAddSystemAbility_002 start";
2358 std::string deviceId = "test";
2359 Singleton<AccessibleAbilityManagerService>::GetInstance().OnAddSystemAbility(7, deviceId);
2360 GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_OnAddSystemAbility_002 end";
2361 }
2362
2363 /**
2364 * @tc.number: AccessibleAbilityManagerServiceUnitTest_OnRemoveSystemAbility_003
2365 * @tc.name: OnRemoveSystemAbility
2366 * @tc.desc: Test function OnRemoveSystemAbility
2367 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, OnRemoveSystemAbility_003, TestSize.Level1)2368 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, OnRemoveSystemAbility_003, TestSize.Level1)
2369 {
2370 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_OnRemoveSystemAbility_003 start";
2371 TearDownTestCase();
2372 std::string deviceId = "test";
2373 Singleton<AccessibleAbilityManagerService>::GetInstance().OnRemoveSystemAbility(0, deviceId);
2374 SetUpTestCase();
2375 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_OnRemoveSystemAbility_003 end";
2376 }
2377
2378 /**
2379 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SendEvent_001
2380 * @tc.name: SendEvent
2381 * @tc.desc: Test function SendEvent
2382 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SendEvent_001, TestSize.Level1)2383 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SendEvent_001, TestSize.Level1)
2384 {
2385 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SendEvent_001 start";
2386 TearDownTestCase();
2387 AccessibilityEventInfo event;
2388 Singleton<AccessibleAbilityManagerService>::GetInstance().SendEvent(event);
2389 SetUpTestCase();
2390 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SendEvent_001 end";
2391 }
2392
2393 /**
2394 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SendEvent_002
2395 * @tc.name: SendEvent
2396 * @tc.desc: Test function SendEvent
2397 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SendEvent_002, TestSize.Level1)2398 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SendEvent_002, TestSize.Level1)
2399 {
2400 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SendEvent_002 start";
2401 AccessibilityEventInfo event;
2402 sleep(SLEEP_TIME_1);
2403 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
2404 RetError ret = Singleton<AccessibleAbilityManagerService>::GetInstance().SendEvent(event);
2405 EXPECT_EQ(ret, RET_OK);
2406 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SendEvent_002 end";
2407 }
2408
2409
2410 /**
2411 * @tc.number: AccessibleAbility_ManagerService_UnitTest_DeregisterElementOperator_003
2412 * @tc.name: DeregisterElementOperator
2413 * @tc.desc: Test function DeregisterElementOperator
2414 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, DeregisterElementOperator_003, TestSize.Level1)2415 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, DeregisterElementOperator_003, TestSize.Level1)
2416 {
2417 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_DeregisterElementOperator_003 start";
2418 TearDownTestCase();
2419 Singleton<AccessibleAbilityManagerService>::GetInstance().DeregisterElementOperator(0);
2420 SetUpTestCase();
2421 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_DeregisterElementOperator_003 end";
2422 }
2423
2424 /**
2425 * @tc.number: AccessibleAbilityManagerServiceUnitTest_GetEnabledState_002
2426 * @tc.name: GetEnabledState
2427 * @tc.desc: Test function GetEnabledState
2428 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetEnabledState_002, TestSize.Level1)2429 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetEnabledState_002, TestSize.Level1)
2430 {
2431 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetEnabledState_002 start";
2432 TearDownTestCase();
2433 bool ret = true;
2434 ret = Singleton<AccessibleAbilityManagerService>::GetInstance().GetEnabledState();
2435 EXPECT_EQ(ret, false);
2436 SetUpTestCase();
2437 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetEnabledState_002 end";
2438 }
2439
2440 /**
2441 * @tc.number: AccessibleAbilityManagerServiceUnitTest_GetTouchGuideState_003
2442 * @tc.name: GetTouchGuideState
2443 * @tc.desc: Test function GetTouchGuideState
2444 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetTouchGuideState_003, TestSize.Level1)2445 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetTouchGuideState_003, TestSize.Level1)
2446 {
2447 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetTouchGuideState_003 start";
2448 TearDownTestCase();
2449 bool ret = true;
2450 ret = Singleton<AccessibleAbilityManagerService>::GetInstance().GetTouchGuideState();
2451 EXPECT_EQ(ret, false);
2452 SetUpTestCase();
2453 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetTouchGuideState_003 end";
2454 }
2455
2456 /**
2457 * @tc.number: AccessibleAbilityManagerServiceUnitTest_GetGestureState_003
2458 * @tc.name: GetGestureState
2459 * @tc.desc: Test function GetGestureState
2460 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetGestureState_003, TestSize.Level1)2461 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetGestureState_003, TestSize.Level1)
2462 {
2463 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetGestureState_003 start";
2464 TearDownTestCase();
2465 bool ret = true;
2466 ret = Singleton<AccessibleAbilityManagerService>::GetInstance().GetGestureState();
2467 EXPECT_EQ(ret, false);
2468 SetUpTestCase();
2469 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetGestureState_003 end";
2470 }
2471
2472 /**
2473 * @tc.number: AccessibleAbilityManagerServiceUnitTest_GetKeyEventObserverState_003
2474 * @tc.name: GetKeyEventObserverState
2475 * @tc.desc: Test function GetKeyEventObserverState
2476 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetKeyEventObserverState_003, TestSize.Level1)2477 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetKeyEventObserverState_003, TestSize.Level1)
2478 {
2479 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetKeyEventObserverState_003 start";
2480 TearDownTestCase();
2481 bool ret = true;
2482 ret = Singleton<AccessibleAbilityManagerService>::GetInstance().GetKeyEventObserverState();
2483 EXPECT_EQ(ret, false);
2484 SetUpTestCase();
2485 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetKeyEventObserverState_003 end";
2486 }
2487
2488 /*
2489 * @tc.number: AccessibleAbility_ManagerService_UnitTest_GetEnabledAbilities_003
2490 * @tc.name: GetEnabledAbilities
2491 * @tc.desc: Test function GetEnabledAbilities
2492 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetEnabledAbilities_003, TestSize.Level1)2493 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetEnabledAbilities_003, TestSize.Level1)
2494 {
2495 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_GetEnabledAbilities_003 start";
2496 TearDownTestCase();
2497 std::vector<std::string> enabledAbilities;
2498 RetError ret = Singleton<AccessibleAbilityManagerService>::GetInstance().GetEnabledAbilities(enabledAbilities);
2499 EXPECT_EQ(ret, RET_ERR_NULLPTR);
2500 SetUpTestCase();
2501 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_GetEnabledAbilities_003 end";
2502 }
2503
2504 /*
2505 * @tc.number: AccessibleAbility_ManagerService_UnitTest_Dump_001
2506 * @tc.name: Dump
2507 * @tc.desc: Test function Dump
2508 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, Dump_001, TestSize.Level1)2509 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, Dump_001, TestSize.Level1)
2510 {
2511 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_Dump_001 start";
2512 TearDownTestCase();
2513 std::vector<std::u16string> args;
2514 Singleton<AccessibleAbilityManagerService>::GetInstance().Dump(0, args);
2515 SetUpTestCase();
2516 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_Dump_001 end";
2517 }
2518
2519 /*
2520 * @tc.number: AccessibleAbility_ManagerService_UnitTest_Dump_002
2521 * @tc.name: Dump
2522 * @tc.desc: Test function Dump
2523 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, Dump_002, TestSize.Level1)2524 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, Dump_002, TestSize.Level1)
2525 {
2526 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_Dump_002 start";
2527 std::vector<std::u16string> args;
2528 Singleton<AccessibleAbilityManagerService>::GetInstance().Dump(0, args);
2529 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_Dump_002 end";
2530 }
2531
2532 /*
2533 * @tc.number: AccessibleAbility_ManagerService_UnitTest_EnableUITestAbility_003
2534 * @tc.name: EnableUITestAbility
2535 * @tc.desc: Test function EnableUITestAbility
2536 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, EnableUITestAbility_003, TestSize.Level1)2537 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, EnableUITestAbility_003, TestSize.Level1)
2538 {
2539 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_EnableUITestAbility_003 start";
2540 TearDownTestCase();
2541 sptr<IRemoteObject> obj = nullptr;
2542 RetError ret = Singleton<AccessibleAbilityManagerService>::GetInstance().EnableUITestAbility(obj);
2543 EXPECT_EQ(ret, RET_ERR_NULLPTR);
2544 SetUpTestCase();
2545 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_EnableUITestAbility_003 end";
2546 }
2547
2548 /*
2549 * @tc.number: AccessibleAbility_ManagerService_UnitTest_EnableUITestAbility_004
2550 * @tc.name: EnableUITestAbility
2551 * @tc.desc: Test function EnableUITestAbility
2552 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, EnableUITestAbility_004, TestSize.Level1)2553 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, EnableUITestAbility_004, TestSize.Level1)
2554 {
2555 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_EnableUITestAbility_004 start";
2556 sptr<IRemoteObject> obj = nullptr;
2557 RetError ret = Singleton<AccessibleAbilityManagerService>::GetInstance().EnableUITestAbility(obj);
2558 EXPECT_EQ(ret, RET_ERR_NULLPTR);
2559 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_EnableUITestAbility_004 end";
2560 }
2561
2562 /*
2563 * @tc.number: AccessibleAbility_ManagerService_UnitTest_DisableAbility_003
2564 * @tc.name: DisableAbility
2565 * @tc.desc: Test function DisableAbility
2566 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, DisableAbility_003, TestSize.Level1)2567 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, DisableAbility_003, TestSize.Level1)
2568 {
2569 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_DisableAbility_003 start";
2570 TearDownTestCase();
2571 std::string name = "test";
2572 RetError ret = Singleton<AccessibleAbilityManagerService>::GetInstance().DisableAbility(name);
2573 EXPECT_EQ(ret, RET_ERR_NULLPTR);
2574 SetUpTestCase();
2575 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_DisableAbility_003 end";
2576 }
2577
2578 /*
2579 * @tc.number: AccessibleAbility_ManagerService_UnitTest_DisableUITestAbility_003
2580 * @tc.name: DisableUITestAbility
2581 * @tc.desc: Test function DisableUITestAbility
2582 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, DisableUITestAbility_003, TestSize.Level1)2583 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, DisableUITestAbility_003, TestSize.Level1)
2584 {
2585 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_DisableUITestAbility_003 start";
2586 TearDownTestCase();
2587 RetError ret = Singleton<AccessibleAbilityManagerService>::GetInstance().DisableUITestAbility();
2588 EXPECT_EQ(ret, RET_ERR_NULLPTR);
2589 SetUpTestCase();
2590 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_DisableUITestAbility_003 end";
2591 }
2592
2593 /**
2594 * @tc.number: AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterStateObserver_001
2595 * @tc.name: RegisterStateObserver
2596 * @tc.desc: Test function RegisterStateObserver
2597 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, RegisterStateObserver_001, TestSize.Level1)2598 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, RegisterStateObserver_001, TestSize.Level1)
2599 {
2600 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterStateObserver_001 start";
2601 TearDownTestCase();
2602 sptr<AccessibleAbilityManagerStateObserverStub> stub = new MockAccessibleAbilityManagerStateObserverStub();
2603 sptr<IAccessibleAbilityManagerStateObserver> state = new MockAccessibleAbilityManagerStateObserverProxy(stub);
2604 uint32_t ret = Singleton<AccessibleAbilityManagerService>::GetInstance().RegisterStateObserver(state);
2605 EXPECT_EQ(ret, 0);
2606 SetUpTestCase();
2607 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterStateObserver_001 end";
2608 }
2609
2610 /*
2611 * @tc.number: AccessibleAbility_ManagerService_UnitTest_GetRealWindowAndElementId_001
2612 * @tc.name: GetRealWindowAndElementId
2613 * @tc.desc: Test function GetRealWindowAndElementId
2614 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetRealWindowAndElementId_001, TestSize.Level1)2615 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetRealWindowAndElementId_001, TestSize.Level1)
2616 {
2617 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_GetRealWindowAndElementId_001 start";
2618 TearDownTestCase();
2619 int32_t windowId = 0;
2620 int64_t elementId = 0;
2621 Singleton<AccessibleAbilityManagerService>::GetInstance().GetRealWindowAndElementId(windowId, elementId);
2622 SetUpTestCase();
2623 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_GetRealWindowAndElementId_001 end";
2624 }
2625
2626 /*
2627 * @tc.number: AccessibleAbility_ManagerService_UnitTest_GetRealWindowAndElementId_002
2628 * @tc.name: GetRealWindowAndElementId
2629 * @tc.desc: Test function GetRealWindowAndElementId
2630 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetRealWindowAndElementId_002, TestSize.Level1)2631 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetRealWindowAndElementId_002, TestSize.Level1)
2632 {
2633 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_GetRealWindowAndElementId_002 start";
2634 int32_t windowId = 0;
2635 int64_t elementId = 0;
2636 Singleton<AccessibleAbilityManagerService>::GetInstance().GetRealWindowAndElementId(windowId, elementId);
2637 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_GetRealWindowAndElementId_002 end";
2638 }
2639
2640 /*
2641 * @tc.number: AccessibleAbility_ManagerService_UnitTest_GetSceneBoardInnerWinId_001
2642 * @tc.name: GetSceneBoardInnerWinId
2643 * @tc.desc: Test function GetSceneBoardInnerWinId
2644 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetSceneBoardInnerWinId_001, TestSize.Level1)2645 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetSceneBoardInnerWinId_001, TestSize.Level1)
2646 {
2647 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_GetSceneBoardInnerWinId_001 start";
2648 TearDownTestCase();
2649 int32_t windowId = 0;
2650 int64_t elementId = 0;
2651 int32_t innerWid = 0;
2652 Singleton<AccessibleAbilityManagerService>::GetInstance().GetSceneBoardInnerWinId(windowId, elementId, innerWid);
2653 SetUpTestCase();
2654 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_GetSceneBoardInnerWinId_001 end";
2655 }
2656
2657 /*
2658 * @tc.number: AccessibleAbility_ManagerService_UnitTest_GetSceneBoardInnerWinId_002
2659 * @tc.name: GetSceneBoardInnerWinId
2660 * @tc.desc: Test function GetSceneBoardInnerWinId
2661 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetSceneBoardInnerWinId_002, TestSize.Level1)2662 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetSceneBoardInnerWinId_002, TestSize.Level1)
2663 {
2664 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_GetSceneBoardInnerWinId_002 start";
2665 TearDownTestCase();
2666 int32_t windowId = 0;
2667 int64_t elementId = 0;
2668 int32_t innerWid = 0;
2669 Singleton<AccessibleAbilityManagerService>::GetInstance().GetSceneBoardInnerWinId(windowId, elementId, innerWid);
2670 SetUpTestCase();
2671 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_GetSceneBoardInnerWinId_002 end";
2672 }
2673
2674 /**
2675 * @tc.number: Accessible_Ability_ManagerService_UnitTest_UpdateShortkeyMultiTarget_001
2676 * @tc.name: UpdateShortkeyMultiTarget
2677 * @tc.desc: Test function UpdateShortkeyMultiTarget
2678 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, UpdateShortkeyMultiTarget_001, TestSize.Level1)2679 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, UpdateShortkeyMultiTarget_001, TestSize.Level1)
2680 {
2681 GTEST_LOG_(INFO) << "Accessible_Ability_ManagerService_UnitTest_UpdateShortkeyMultiTarget_001 start";
2682 Singleton<AccessibleAbilityManagerService>::GetInstance().UpdateShortkeyMultiTarget();
2683 GTEST_LOG_(INFO) << "Accessible_Ability_ManagerService_UnitTest_UpdateShortkeyMultiTarget_001 end";
2684 }
2685
2686 /**
2687 * @tc.number: Accessible_Ability_ManagerService_UnitTest_OnDeviceProvisioned_001
2688 * @tc.name: OnDeviceProvisioned
2689 * @tc.desc: Test function OnDeviceProvisioned
2690 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, OnDeviceProvisioned_001, TestSize.Level1)2691 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, OnDeviceProvisioned_001, TestSize.Level1)
2692 {
2693 GTEST_LOG_(INFO) << "Accessible_Ability_ManagerService_UnitTest_OnDeviceProvisioned_001 start";
2694 auto &aams = Singleton<AccessibleAbilityManagerService>::GetInstance();
2695 auto accountData = aams.GetCurrentAccountData();
2696 ASSERT_TRUE(accountData);
2697 std::string deviceId = "false";
2698 aams.OnAddSystemAbility(WINDOW_MANAGER_SERVICE_ID, deviceId);
2699 GTEST_LOG_(INFO) << "Accessible_Ability_ManagerService_UnitTest_OnDeviceProvisioned_001 end";
2700 }
2701
2702 /**
2703 * @tc.number: Accessible_Ability_ManagerService_UnitTest_OnDeviceProvisioned_002
2704 * @tc.name: OnDeviceProvisioned
2705 * @tc.desc: Test function OnDeviceProvisioned
2706 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, OnDeviceProvisioned_002, TestSize.Level1)2707 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, OnDeviceProvisioned_002, TestSize.Level1)
2708 {
2709 GTEST_LOG_(INFO) << "Accessible_Ability_ManagerService_UnitTest_OnDeviceProvisioned_002 start";
2710 auto &aams = Singleton<AccessibleAbilityManagerService>::GetInstance();
2711 aams.OnStop();
2712 auto accountData = aams.GetCurrentAccountData();
2713 if (!accountData) {
2714 GTEST_LOG_(INFO) << "current account data is null";
2715 }
2716 std::string deviceId = "false";
2717 aams.OnAddSystemAbility(WINDOW_MANAGER_SERVICE_ID, deviceId);
2718 aams.OnStart();
2719 GTEST_LOG_(INFO) << "Accessible_Ability_ManagerService_UnitTest_OnDeviceProvisioned_002 end";
2720 }
2721
2722 /**
2723 * @tc.number: Accessible_Ability_ManagerService_UnitTest_RegisterShortKeyEvent_001
2724 * @tc.name: RegisterShortKeyEvent
2725 * @tc.desc: Test function RegisterShortKeyEvent
2726 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, RegisterShortKeyEvent_001, TestSize.Level1)2727 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, RegisterShortKeyEvent_001, TestSize.Level1)
2728 {
2729 GTEST_LOG_(INFO) << "Accessible_Ability_ManagerService_UnitTest_RegisterShortKeyEvent_001 start";
2730 auto &aams = Singleton<AccessibleAbilityManagerService>::GetInstance();
2731 aams.OnStop();
2732 auto accountData = aams.GetCurrentAccountData();
2733 if (!accountData) {
2734 GTEST_LOG_(INFO) << "current account data is null";
2735 }
2736 std::string deviceId = "false";
2737 aams.OnAddSystemAbility(WINDOW_MANAGER_SERVICE_ID, deviceId);
2738 aams.OnStart();
2739 GTEST_LOG_(INFO) << "Accessible_Ability_ManagerService_UnitTest_RegisterShortKeyEvent_001 end";
2740 }
2741
2742 /**
2743 * @tc.number: Accessible_Ability_ManagerService_UnitTest_RegisterShortKeyEvent_002
2744 * @tc.name: RegisterShortKeyEvent
2745 * @tc.desc: Test function RegisterShortKeyEvent
2746 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, RegisterShortKeyEvent_002, TestSize.Level1)2747 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, RegisterShortKeyEvent_002, TestSize.Level1)
2748 {
2749 GTEST_LOG_(INFO) << "Accessible_Ability_ManagerService_UnitTest_RegisterShortKeyEvent_002 start";
2750 auto &aams = Singleton<AccessibleAbilityManagerService>::GetInstance();
2751 auto accountData = aams.GetCurrentAccountData();
2752 ASSERT_TRUE(accountData);
2753 std::string deviceId = "false";
2754 aams.OnAddSystemAbility(WINDOW_MANAGER_SERVICE_ID, deviceId);
2755 GTEST_LOG_(INFO) << "Accessible_Ability_ManagerService_UnitTest_RegisterShortKeyEvent_002 end";
2756 }
2757
2758 /**
2759 * @tc.number: AccessibleAbility_ManagerService_UnitTest_RemoveRequestId_001
2760 * @tc.name: RemoveRequestId
2761 * @tc.desc: Test function AddRequestId RemoveRequestId
2762 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, RemoveRequestId_001, TestSize.Level1)2763 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, RemoveRequestId_001, TestSize.Level1)
2764 {
2765 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_RemoveRequestId_001 start";
2766 int32_t windowId = 1;
2767 int32_t treeId = 2;
2768 int32_t requestId = 3;
2769 Singleton<AccessibleAbilityManagerService>::GetInstance().AddRequestId(windowId, treeId, requestId, nullptr);
2770 Singleton<AccessibleAbilityManagerService>::GetInstance().RemoveRequestId(requestId);
2771 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_RemoveRequestId_001 end";
2772 }
2773 } // namespace Accessibility
2774 } // namespace OHOS