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