1 /*
2 * Copyright (C) 2022 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 "accessibility_ability_info.h"
18 #include "accessibility_account_data.h"
19 #include "accessibility_common_helper.h"
20 #include "accessibility_constants.h"
21 #include "accessibility_element_operator_proxy.h"
22 #include "accessibility_element_operator_stub.h"
23 #include "accessibility_ut_helper.h"
24 #include "accessible_ability_manager_service.h"
25 #include "mock_accessibility_element_operator_proxy.h"
26 #include "mock_accessibility_element_operator_stub.h"
27 #include "mock_accessible_ability_client_stub_impl.h"
28 #include "mock_accessible_ability_connection.h"
29 #include "mock_accessible_ability_manager_service_config_observer_proxy.h"
30 #include "mock_accessible_ability_manager_service_config_observer_stub.h"
31 #include "mock_accessible_ability_manager_service_state_observer_proxy.h"
32 #include "mock_accessible_ability_manager_service_state_observer_stub.h"
33 #include "mock_accessibility_setting_provider.h"
34 #include "utils.h"
35
36 using namespace testing;
37 using namespace testing::ext;
38
39 namespace OHOS {
40 namespace Accessibility {
41 namespace {
42 constexpr uint32_t SLEEP_TIME_1 = 1;
43 constexpr size_t IMPORTANT_ABILITIES_SIZE = 0;
44 } // namespace
45
46 class AccessibilityAccountDataTest : public testing::Test {
47 public:
AccessibilityAccountDataTest()48 AccessibilityAccountDataTest()
49 {}
~AccessibilityAccountDataTest()50 ~AccessibilityAccountDataTest()
51 {}
52
53 static void SetUpTestCase();
54 static void TearDownTestCase();
55 void SetUp() override;
56 void TearDown() override;
57 };
58
SetUpTestCase()59 void AccessibilityAccountDataTest::SetUpTestCase()
60 {
61 GTEST_LOG_(INFO) << "AccessibilityAccountDataTest SetUpTestCase";
62 Singleton<AccessibleAbilityManagerService>::GetInstance().OnStart();
63 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(AccessibilityAbilityHelper::accountId_);
64 }
65
TearDownTestCase()66 void AccessibilityAccountDataTest::TearDownTestCase()
67 {
68 GTEST_LOG_(INFO) << "AccessibilityAccountDataTest TearDownTestCase";
69 Singleton<AccessibleAbilityManagerService>::GetInstance().OnStop();
70 }
71
SetUp()72 void AccessibilityAccountDataTest::SetUp()
73 {
74 GTEST_LOG_(INFO) << "AccessibilityAccountDataTest SetUp";
75 }
76
TearDown()77 void AccessibilityAccountDataTest::TearDown()
78 {
79 GTEST_LOG_(INFO) << "AccessibilityAccountDataTest TearDown";
80 }
81
82 /**
83 * @tc.number: AccessibilityAccountData_Unittest_GetAccessibilityState001
84 * @tc.name: GetAccessibilityState
85 * @tc.desc: Check the get accessibility state.
86 */
87 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_GetAccessibilityState001, TestSize.Level1)
88 {
89 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_GetAccessibilityState001 start";
90 int32_t accountId = 1;
91 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
92
93 /* Initial state */
94 accountData->Init();
95 accountData->GetConfig()->SetTouchGuideState(true);
96 uint32_t stateType = accountData->GetAccessibilityState();
97 uint32_t stateTypeTest = Accessibility::STATE_EXPLORATION_ENABLED;
98 EXPECT_EQ(stateTypeTest, stateType);
99 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_GetAccessibilityState001 end";
100 }
101
102 /**
103 * @tc.number: AccessibilityAccountData_Unittest_GetAccessibilityState002
104 * @tc.name: GetAccessibilityState
105 * @tc.desc: Check the get accessibility state.
106 */
107 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_GetAccessibilityState002, TestSize.Level1)
108 {
109 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_GetAccessibilityState_002 start";
110 const int32_t accountId = 1;
111 int32_t connectCounter = 0;
112 AccessibilityAbilityInitParams initParams;
113 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
114
115 sptr<AccessibleAbilityConnection> connection =
116 new MockAccessibleAbilityConnection(accountId, connectCounter++, *abilityInfo);
117 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
118 EXPECT_EQ(0, (int)accountData->GetConnectedA11yAbilities().size());
119
120 /* add connected ability */
121 accountData->AddConnectedAbility(connection);
122 const std::string elementName = Utils::GetUri(connection->GetElementName());
123 EXPECT_EQ(connection, accountData->GetAccessibleAbilityConnection(elementName));
124 EXPECT_EQ(1, (int)accountData->GetConnectedA11yAbilities().size());
125
126 // init
127 accountData->Init();
128 uint32_t stateType = accountData->GetAccessibilityState();
129 EXPECT_EQ(stateType, Accessibility::STATE_ACCESSIBILITY_ENABLED);
130 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_GetAccessibilityState_002 end";
131 }
132
133 /**
134 * @tc.number: AccessibilityAccountData_Unittest_GetAccessibilityState003
135 * @tc.name: GetAccessibilityState
136 * @tc.desc: Check the get accessibility state.
137 */
138 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_GetAccessibilityState003, TestSize.Level1)
139 {
140 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_GetAccessibilityState_003 start";
141 const int32_t accountId = 1;
142 int32_t connectCounter = 0;
143 AccessibilityAbilityInitParams initParams;
144 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
145 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
146 sptr<AccessibleAbilityConnection> connection =
147 new MockAccessibleAbilityConnection(accountId, connectCounter++, *abilityInfo);
148 const std::string bundleName = "bbb";
149 EXPECT_FALSE(accountData->GetConnectingA11yAbility(bundleName));
150 /* add connecting A11y ability */
151 accountData->AddConnectingA11yAbility(bundleName, connection);
152 EXPECT_TRUE(accountData->GetConnectingA11yAbility(bundleName));
153
154 accountData->Init();
155 accountData->GetConfig()->SetKeyEventObserverState(true);
156
157 uint32_t stateType = accountData->GetAccessibilityState();
158 EXPECT_EQ(stateType, Accessibility::STATE_ACCESSIBILITY_ENABLED | Accessibility::STATE_KEYEVENT_ENABLED);
159 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_GetAccessibilityState_003 end";
160 }
161
162 /**
163 * @tc.number: AccessibilityAccountData_Unittest_GetAccessibilityState004
164 * @tc.name: GetAccessibilityState
165 * @tc.desc: Check the get accessibility state.
166 */
167 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_GetAccessibilityState004, TestSize.Level1)
168 {
169 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_GetAccessibilityState_004 start";
170 const int32_t accountId = 1;
171 int32_t connectCounter = 0;
172 AccessibilityAbilityInitParams initParams;
173 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
174 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
175 sptr<AccessibleAbilityConnection> connection =
176 new MockAccessibleAbilityConnection(accountId, connectCounter++, *abilityInfo);
177 /* add connected ability */
178 accountData->AddConnectedAbility(connection);
179 /* add connecting A11y ability */
180 const std::string bundleName = "bbb";
181 accountData->AddConnectingA11yAbility(bundleName, connection);
182
183 accountData->Init();
184 accountData->GetConfig()->SetGestureState(true);
185
186 uint32_t stateType = accountData->GetAccessibilityState();
187 EXPECT_EQ(stateType, Accessibility::STATE_ACCESSIBILITY_ENABLED | Accessibility::STATE_GESTURE_ENABLED);
188
189 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_GetAccessibilityState_004 end";
190 }
191
192 /**
193 * @tc.number: AccessibilityAccountData_Unittest_AddConnectedAbility001
194 * @tc.name: AddConnectedAbility
195 * @tc.desc: Check the add connected ability.
196 */
197 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_AddConnectedAbility001, TestSize.Level1)
198 {
199 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_AddConnectedAbility_001 start";
200 const int32_t accountId = 1;
201 int32_t connectCounter = 0;
202 AccessibilityAbilityInitParams initParams;
203 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
204 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
205 sptr<AccessibleAbilityConnection> connection =
206 new MockAccessibleAbilityConnection(accountId, connectCounter++, *abilityInfo);
207 EXPECT_EQ(0, (int)accountData->GetConnectedA11yAbilities().size());
208 // add connected ability
209 accountData->AddConnectedAbility(connection);
210 const std::string elementName = Utils::GetUri(connection->GetElementName());
211 EXPECT_EQ(connection, accountData->GetAccessibleAbilityConnection(elementName));
212 EXPECT_EQ(1, (int)accountData->GetConnectedA11yAbilities().size());
213
214 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_AddConnectedAbility_001 end";
215 }
216
217 /**
218 * @tc.number: AccessibilityAccountData_Unittest_AddConnectedAbility002
219 * @tc.name: AddConnectedAbility
220 * @tc.desc: Check the add connected ability.
221 */
222 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_AddConnectedAbility002, TestSize.Level1)
223 {
224 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_AddConnectedAbility_002 start";
225 const int32_t accountId = 1;
226 sptr<AccessibleAbilityConnection> connection = nullptr;
227 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
228 /* add connected ability */
229 accountData->AddConnectedAbility(connection);
230 EXPECT_EQ(0, (int)accountData->GetConnectedA11yAbilities().size());
231
232 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_AddConnectedAbility_002 end";
233 }
234
235 /**
236 * @tc.number: AccessibilityAccountData_Unittest_RemoveConnectedAbility001
237 * @tc.name: RemoveConnectedAbility
238 * @tc.desc: Check the remove connected ability.
239 */
240 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_RemoveConnectedAbility001, TestSize.Level1)
241 {
242 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_RemoveConnectedAbility001 start";
243 const int32_t accountId = 1;
244 int32_t connectCounter = 0;
245 AccessibilityAbilityInitParams initParams;
246 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
247 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
248 sptr<AccessibleAbilityConnection> connection =
249 new MockAccessibleAbilityConnection(accountId, connectCounter++, *abilityInfo);
250 EXPECT_EQ(0, (int)accountData->GetConnectedA11yAbilities().size());
251
252 /* add */
253 accountData->AddConnectedAbility(connection);
254 EXPECT_EQ(1, (int)accountData->GetConnectedA11yAbilities().size());
255 const std::string elementName = Utils::GetUri(connection->GetElementName());
256 EXPECT_EQ(connection, accountData->GetAccessibleAbilityConnection(elementName));
257
258 /* remove */
259 accountData->RemoveConnectedAbility(connection->GetElementName());
260 EXPECT_EQ(0, (int)accountData->GetConnectedA11yAbilities().size());
261
262 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_RemoveConnectedAbility001 end";
263 }
264
265 /**
266 * @tc.number: AccessibilityAccountData_Unittest_DelAutoStartPrefKeyInRemovePkg001
267 * @tc.name: DelAutoStartPrefKeyInRemovePkg
268 * @tc.desc: Check DelAutoStartPrefKeyInRemovePkg.
269 */
270 HWTEST_F(AccessibilityAccountDataTest,
271 AccessibilityAccountData_Unittest_DelAutoStartPrefKeyInRemovePkg001, TestSize.Level1)
272 {
273 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_DelAutoStartPrefKeyInRemovePkg001 start";
274 const int32_t accountId = 1;
275 const std::string bundleName = "test";
276 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
277 accountData->DelAutoStartPrefKeyInRemovePkg(bundleName);
278 EXPECT_EQ(0, (int)accountData->GetInstalledAbilities().size());
279 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_DelAutoStartPrefKeyInRemovePkg001 end";
280 }
281
282 /**
283 * @tc.number: AccessibilityAccountData_Unittest_DelAutoStartPrefKeyInRemovePkg002
284 * @tc.name: DelAutoStartPrefKeyInRemovePkg
285 * @tc.desc: Check DelAutoStartPrefKeyInRemovePkg.
286 */
287 HWTEST_F(AccessibilityAccountDataTest,
288 AccessibilityAccountData_Unittest_DelAutoStartPrefKeyInRemovePkg002, TestSize.Level1)
289 {
290 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_DelAutoStartPrefKeyInRemovePkg002 start";
291 const int32_t accountId = 1;
292 const std::string name = "testName";
293 const std::string bundleName = "testBundleName";
294 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
295 /*add*/
296 AccessibilityAbilityInitParams initParams;
297 initParams.name = name;
298 initParams.bundleName = bundleName;
299 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
300 abilityInfo->SetCapabilityValues(1);
301 accountData->AddInstalledAbility(*abilityInfo);
302 accountData->DelAutoStartPrefKeyInRemovePkg(bundleName);
303 std::string abilityId = bundleName + "/" + name;
304 bool ret = accountData->GetAbilityAutoStartState(abilityId);
305 EXPECT_EQ(false, ret);
306 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_DelAutoStartPrefKeyInRemovePkg002 end";
307 }
308
309 /**
310 * @tc.number: AccessibilityAccountData_Unittest_AbilityDisconnected001
311 * @tc.name: AbilityDisconnected
312 * @tc.desc: Check the ability disconnected.
313 */
314 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_AbilityDisconnected001, TestSize.Level1)
315 {
316 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_AbilityDisconnected001 start";
317 const int32_t accountId = 1;
318 int32_t connectCounter = 0;
319 AccessibilityAbilityInitParams initParams;
320 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
321 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
322 sptr<AccessibleAbilityConnection> connection =
323 new MockAccessibleAbilityConnection(accountId, connectCounter++, *abilityInfo);
324 EXPECT_EQ(0, (int)accountData->GetConnectedA11yAbilities().size());
325 /* add */
326 accountData->AddConnectedAbility(connection);
327 const std::string elementNameURI = Utils::GetUri(connection->GetElementName());
328 EXPECT_EQ(1, (int)accountData->GetConnectedA11yAbilities().size());
329 EXPECT_EQ(connection, accountData->GetAccessibleAbilityConnection(elementNameURI));
330 EXPECT_FALSE(accountData->GetConnectingA11yAbility(elementNameURI));
331 /* disconnect */
332 accountData->RemoveConnectedAbility(connection->GetElementName());
333 EXPECT_EQ(0, (int)accountData->GetConnectedA11yAbilities().size());
334 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_AbilityDisconnected001 end";
335 }
336
337 /**
338 * @tc.number: AccessibilityAccountData_Unittest_RemoveConnectingA11yAbility001
339 * @tc.name: RemoveConnectingA11yAbility
340 * @tc.desc: Check the remove connecting A11y ability.GetAccessibilityWindows
341 */
342 HWTEST_F(
343 AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_RemoveConnectingA11yAbility001, TestSize.Level1)
344 {
345 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_RemoveConnectingA11yAbility001 start";
346 const int32_t accountId = 1;
347 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
348 const std::string bundleName = "bbb";
349 EXPECT_FALSE(accountData->GetConnectingA11yAbility(bundleName));
350 /* add connecting A11y ability */
351 AccessibilityAbilityInitParams initParams;
352 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
353 sptr<AccessibleAbilityConnection> connection =
354 new MockAccessibleAbilityConnection(accountId, 0, *abilityInfo);
355 /* add */
356 accountData->AddConnectingA11yAbility(bundleName, connection);
357 EXPECT_TRUE(accountData->GetConnectingA11yAbility(bundleName));
358 /* remove */
359 accountData->RemoveConnectingA11yAbility(bundleName);
360 EXPECT_FALSE(accountData->GetConnectingA11yAbility(bundleName));
361
362 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_RemoveConnectingA11yAbility001 end";
363 }
364
365 /**
366 * @tc.number: AccessibilityAccountData_Unittest_AddEnabledAbility001
367 * @tc.name: AddEnabledAbility
368 * @tc.desc: Check the add enable ability.
369 */
370 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_AddEnabledAbility001, TestSize.Level1)
371 {
372 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_AddEnabledAbility001 start";
373 const int32_t accountId = 1;
374 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
375 const std::string bundleName = "/bbb";
376 accountData->Init();
377 /* add */
378 AccessibilityAbilityInitParams initParams;
379 initParams.name = "bbb";
380 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
381 abilityInfo->SetCapabilityValues(1);
382 accountData->AddInstalledAbility(*abilityInfo);
383 accountData->AddEnabledAbility(bundleName);
384 accountData->AddEnabledAbility(bundleName);
385 EXPECT_EQ(1, (int)accountData->GetEnabledAbilities().size());
386 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_AddEnabledAbility001 end";
387 }
388
389 /**
390 * @tc.number: AccessibilityAccountData_Unittest_RemoveEnabledAbility001
391 * @tc.name: RemoveEnabledAbility
392 * @tc.desc: Check the remove enable ability.
393 */
394 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_RemoveEnabledAbility001, TestSize.Level1)
395 {
396 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_RemoveEnabledAbility001 start";
397 const int32_t accountId = 1;
398 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
399 const std::string bundleName = "/bbb";
400 accountData->Init();
401
402 /* remove */
403 accountData->RemoveEnabledAbility(bundleName);
404 EXPECT_EQ(0, (int)accountData->GetEnabledAbilities().size());
405
406 /* add */
407 AccessibilityAbilityInitParams initParams;
408 initParams.name = "bbb";
409 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
410 abilityInfo->SetCapabilityValues(1);
411 accountData->AddInstalledAbility(*abilityInfo);
412
413 accountData->AddEnabledAbility(bundleName);
414 EXPECT_EQ(1, (int)accountData->GetEnabledAbilities().size());
415
416 /* remove */
417 accountData->RemoveEnabledAbility(bundleName);
418 EXPECT_EQ(0, (int)accountData->GetEnabledAbilities().size());
419
420 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_RemoveEnabledAbility001 end";
421 }
422
423 /**
424 * @tc.number: AccessibilityAccountData_Unittest_AddInstalledAbility001
425 * @tc.name: AddInstalledAbility
426 * @tc.desc: Check the add install ability.
427 */
428 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_AddInstalledAbility001, TestSize.Level1)
429 {
430 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_AddInstalledAbility001 start";
431 const int32_t accountId = 1;
432 AccessibilityAbilityInitParams initParams;
433 initParams.bundleName = "TEST_BUNDLE_NAME";
434 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
435 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
436 EXPECT_EQ(0, (int)accountData->GetInstalledAbilities().size());
437
438 /* add */
439 accountData->AddInstalledAbility(*abilityInfo);
440 EXPECT_EQ(1, (int)accountData->GetInstalledAbilities().size());
441
442 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_AddInstalledAbility001 end";
443 }
444
445 /**
446 * @tc.number: AccessibilityAccountData_Unittest_RemoveInstalledAbility001
447 * @tc.name: RemoveInstalledAbility
448 * @tc.desc: Check the remove install ability.
449 */
450 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_RemoveInstalledAbility001, TestSize.Level1)
451 {
452 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_RemoveInstalledAbility001 start";
453 const int32_t accountId = 1;
454 AccessibilityAbilityInitParams initParams;
455 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
456 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
457 accountData->Init();
458 EXPECT_EQ(0, (int)accountData->GetInstalledAbilities().size());
459 /* add */
460 accountData->AddInstalledAbility(*abilityInfo);
461 EXPECT_EQ(1, (int)accountData->GetInstalledAbilities().size());
462 /* remove */
463 accountData->RemoveInstalledAbility(abilityInfo->GetPackageName());
464 EXPECT_EQ(0, (int)accountData->GetInstalledAbilities().size());
465
466 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_RemoveInstalledAbility001 end";
467 }
468
469 /**
470 * @tc.number: AccessibilityAccountData_Unittest_ClearInstalledAbility001
471 * @tc.name: ClearInstalledAbility
472 * @tc.desc: Check the clear install ability.
473 */
474 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_ClearInstalledAbility001, TestSize.Level1)
475 {
476 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_ClearInstalledAbility001 start";
477 const int32_t accountId = 1;
478 AccessibilityAbilityInitParams initParams;
479 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
480 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
481 EXPECT_EQ(0, (int)accountData->GetInstalledAbilities().size());
482 /* add */
483 accountData->AddInstalledAbility(*abilityInfo);
484 EXPECT_EQ(1, (int)accountData->GetInstalledAbilities().size());
485 /* clear */
486 accountData->ClearInstalledAbility();
487 EXPECT_EQ(0, (int)accountData->GetInstalledAbilities().size());
488
489 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_ClearInstalledAbility001 end";
490 }
491
492 /**
493 * @tc.number: AccessibilityAccountData_Unittest_GetAccessibleAbilityConnection001
494 * @tc.name: GetAccessibleAbilityConnection
495 * @tc.desc: Check the get accessibility connection.
496 */
497 HWTEST_F(
498 AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_GetAccessibleAbilityConnection001, TestSize.Level1)
499 {
500 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_GetAccessibleAbilityConnection001 start";
501 const int32_t accountId = 1;
502 int32_t connectCounter = 0;
503 AccessibilityAbilityInitParams initParams;
504 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
505 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
506 sptr<AccessibleAbilityConnection> connection =
507 new MockAccessibleAbilityConnection(accountId, connectCounter++, *abilityInfo);
508 EXPECT_EQ(0, (int)accountData->GetConnectedA11yAbilities().size());
509 std::string elementName = Utils::GetUri(connection->GetElementName());
510 EXPECT_FALSE(accountData->GetAccessibleAbilityConnection(elementName));
511 accountData->AddConnectedAbility(connection);
512 EXPECT_EQ(1, (int)accountData->GetConnectedA11yAbilities().size());
513 /* get */
514 EXPECT_EQ(connection, accountData->GetAccessibleAbilityConnection(elementName));
515 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_GetAccessibleAbilityConnection001 end";
516 }
517
518 /**
519 * @tc.number: AccessibilityAccountData_Unittest_GetAccessibleAbilityConnection002
520 * @tc.name: GetAccessibleAbilityConnection
521 * @tc.desc: Check the get accessibility connection.
522 */
523 HWTEST_F(
524 AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_GetAccessibleAbilityConnection002, TestSize.Level1)
525 {
526 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_GetAccessibleAbilityConnection002 start";
527 const int32_t accountId = 1;
528 int32_t connectCounter = 0;
529 AccessibilityAbilityInitParams initParams;
530 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
531 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
532 sptr<AccessibleAbilityConnection> connection =
533 new MockAccessibleAbilityConnection(accountId, connectCounter++, *abilityInfo);
534 accountData->AddConnectedAbility(connection);
535 const std::string elementName = "111name";
536 /* get */
537 EXPECT_EQ(nullptr, accountData->GetAccessibleAbilityConnection(elementName));
538 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_GetAccessibleAbilityConnection002 end";
539 }
540
541 /**
542 * @tc.number: AccessibilityAccountData_Unittest_GetConnectedA11yAbilities001
543 * @tc.name: GetConnectedA11yAbilities
544 * @tc.desc: Check the get connected abilities.
545 */
546 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_GetConnectedA11yAbilities001, TestSize.Level1)
547 {
548 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_GetConnectedA11yAbilities001 start";
549 const int32_t accountId = 1;
550 int32_t connectCounter = 0;
551 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
552 AccessibilityAbilityInitParams initParams;
553 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
554 sptr<AccessibleAbilityConnection> connection =
555 new MockAccessibleAbilityConnection(accountId, connectCounter++, *abilityInfo);
556 /* get */
557 size_t size = accountData->GetConnectedA11yAbilities().size();
558 EXPECT_EQ(0, size);
559 /* add */
560 accountData->AddConnectedAbility(connection);
561 /* get */
562 EXPECT_EQ(1, accountData->GetConnectedA11yAbilities().size());
563
564 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_GetConnectedA11yAbilities001 end";
565 }
566
567 /**
568 * @tc.number: AccessibilityAccountData_Unittest_GetAsacConnections001
569 * @tc.name: GetAsacConnections
570 * @tc.desc: Check the get asac connections.
571 */
572 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_GetAsacConnections001, TestSize.Level1)
573 {
574 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_GetAsacConnections001 start";
575 const int32_t accountId = 1;
576 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
577 /* get */
578 size_t size = accountData->GetAsacConnections().size();
579 EXPECT_EQ(0, size);
580
581 const int32_t windowId = 1;
582 sptr<AccessibilityElementOperatorStub> operationStub = new MockAccessibilityElementOperatorStub();
583 sptr<IAccessibilityElementOperator> operation = new MockAccessibilityElementOperatorProxy(operationStub);
584 sptr<AccessibilityWindowConnection> operationConnection =
585 new AccessibilityWindowConnection(windowId, operation, accountId);
586 /* add asacConnections */
587 accountData->AddAccessibilityWindowConnection(windowId, operationConnection);
588 /* get */
589 EXPECT_EQ(1, accountData->GetAsacConnections().size());
590
591 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_GetAsacConnections001 end";
592 }
593
594 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_SetEnabled, TestSize.Level1)
595 {
596 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_SetEnabled start";
597 const int32_t accountId = 1;
598 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
599
600 accountData->Init();
601 bool state = true;
602 RetError test = accountData->GetConfig()->SetEnabled(state);
603 EXPECT_EQ(test, RET_OK);
604
605 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_SetEnabled end";
606 }
607
608 /**
609 * @tc.number: AccessibilityAccountData_Unittest_GetAbilitiesByState001
610 * @tc.name: GetAbilitiesByState
611 * @tc.desc: Check the get ability state.
612 */
613 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_GetAbilitiesByState001, TestSize.Level1)
614 {
615 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_GetAbilitiesByState001 start";
616 const int32_t accountId = 1;
617 int32_t connectCounter = 0;
618 AccessibilityAbilityInitParams initParams;
619 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
620 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
621 sptr<AccessibleAbilityConnection> connection =
622 new MockAccessibleAbilityConnection(accountId, connectCounter++, *abilityInfo);
623 /* add connected ability */
624 EXPECT_EQ(0, (int)accountData->GetConnectedA11yAbilities().size());
625 accountData->AddConnectedAbility(connection);
626 EXPECT_EQ(1, (int)accountData->GetConnectedA11yAbilities().size());
627 /* ABILITY_STATE_ENABLE */
628 AbilityStateType state = AbilityStateType::ABILITY_STATE_ENABLE;;
629 /* get ability */
630 std::vector<AccessibilityAbilityInfo> enabledAbilities;
631 accountData->GetAbilitiesByState(state, enabledAbilities);
632 EXPECT_EQ(1, (int)enabledAbilities.size());
633 EXPECT_EQ(connection->GetAbilityInfo().GetPackageName(), enabledAbilities.begin()->GetPackageName());
634
635 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_GetAbilitiesByState001 end";
636 }
637
638 /**
639 * @tc.number: AccessibilityAccountData_Unittest_GetAbilitiesByState002
640 * @tc.name: GetAbilitiesByState
641 * @tc.desc: Check the get ability state.
642 */
643 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_GetAbilitiesByState002, TestSize.Level1)
644 {
645 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_GetAbilitiesByState002 start";
646 const int32_t accountId = 1;
647 int32_t connectCounter = 0;
648 AccessibilityAbilityInitParams initParams;
649 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
650 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
651 sptr<AccessibleAbilityConnection> connection =
652 new MockAccessibleAbilityConnection(accountId, connectCounter++, *abilityInfo);
653 /* add connected ability */
654 EXPECT_EQ(0, (int)accountData->GetConnectedA11yAbilities().size());
655 accountData->AddConnectedAbility(connection);
656 EXPECT_EQ(1, (int)accountData->GetConnectedA11yAbilities().size());
657 /* ABILITY_STATE_ENABLE */
658 AbilityStateType state = AbilityStateType::ABILITY_STATE_INSTALLED;;
659 /* get ability */
660 std::vector<AccessibilityAbilityInfo> enabledAbilities;
661 accountData->GetAbilitiesByState(state, enabledAbilities);
662 EXPECT_EQ(0, (int)enabledAbilities.size());
663 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_GetAbilitiesByState002 end";
664 }
665
666 /**
667 * @tc.number: AccessibilityAccountData_Unittest_GetAbilitiesByState003
668 * @tc.name: GetAbilitiesByState
669 * @tc.desc: Check the get ability state.
670 */
671 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_GetAbilitiesByState003, TestSize.Level1)
672 {
673 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_GetAbilitiesByState003 start";
674 const int32_t accountId = 1;
675 int32_t connectCounter = 0;
676
677 AccessibilityAbilityInitParams initParamsDefault;
678 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo =
679 std::make_shared<AccessibilityAbilityInfo>(initParamsDefault);
680 AccessibilityAbilityInitParams initParams;
681 initParams.name = "TEST_ABILITY_NAME";
682 initParams.bundleName = "TEST_BUNDLE_NAME";
683 std::shared_ptr<AccessibilityAbilityInfo> installAbilityInfo =
684 std::make_shared<AccessibilityAbilityInfo>(initParams);
685 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
686 sptr<AccessibleAbilityConnection> connection =
687 new MockAccessibleAbilityConnection(accountId, connectCounter++, *abilityInfo);
688
689 EXPECT_NE(abilityInfo->GetId(), installAbilityInfo->GetId());
690
691 /* add connected ability */
692 EXPECT_EQ(0, (int)accountData->GetConnectedA11yAbilities().size());
693 accountData->AddConnectedAbility(connection);
694 EXPECT_EQ(1, (int)accountData->GetConnectedA11yAbilities().size());
695
696 /* add install ability */
697 EXPECT_EQ(0, (int)accountData->GetInstalledAbilities().size());
698 accountData->AddInstalledAbility(*installAbilityInfo);
699 EXPECT_EQ(1, (int)accountData->GetInstalledAbilities().size());
700 sleep(SLEEP_TIME_1);
701
702 /* ABILITY_STATE_DISABLE */
703 AbilityStateType state = AbilityStateType::ABILITY_STATE_DISABLE;
704
705 /* get ability */
706 std::vector<AccessibilityAbilityInfo> disabledAbilities;
707 accountData->GetAbilitiesByState(state, disabledAbilities);
708 EXPECT_EQ(1, (int)disabledAbilities.size());
709 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_GetAbilitiesByState003 end";
710 }
711
712 /**
713 * @tc.number: AccessibilityAccountData_Unittest_GetAbilitiesByState004
714 * @tc.name: GetAbilitiesByState
715 * @tc.desc: Check the get ability state.
716 */
717 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_GetAbilitiesByState004, TestSize.Level1)
718 {
719 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_GetAbilitiesByState004 start";
720 const int32_t accountId = 1;
721 int32_t connectCounter = 0;
722
723 AccessibilityAbilityInitParams initParamsDefault;
724 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo =
725 std::make_shared<AccessibilityAbilityInfo>(initParamsDefault);
726 AccessibilityAbilityInitParams initParams;
727 initParams.name = "TEST_ABILITY_NAME";
728 initParams.bundleName = "TEST_BUNDLE_NAME";
729 std::shared_ptr<AccessibilityAbilityInfo> installAbilityInfo =
730 std::make_shared<AccessibilityAbilityInfo>(initParams);
731 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
732 sptr<AccessibleAbilityConnection> connection =
733 new MockAccessibleAbilityConnection(accountId, connectCounter++, *abilityInfo);
734
735 EXPECT_NE(abilityInfo->GetId(), installAbilityInfo->GetId());
736
737 /* add connected ability */
738 EXPECT_EQ(0, (int)accountData->GetConnectedA11yAbilities().size());
739 accountData->AddConnectedAbility(connection);
740 EXPECT_EQ(1, (int)accountData->GetConnectedA11yAbilities().size());
741
742 /* add install ability */
743 EXPECT_EQ(0, (int)accountData->GetInstalledAbilities().size());
744 accountData->AddInstalledAbility(*installAbilityInfo);
745 EXPECT_EQ(1, (int)accountData->GetInstalledAbilities().size());
746 sleep(SLEEP_TIME_1);
747
748 /* ABILITY_STATE_DISABLE */
749 AbilityStateType state = AbilityStateType::ABILITY_STATE_INVALID;
750
751 /* get ability */
752 std::vector<AccessibilityAbilityInfo> disabledAbilities;
753 accountData->GetAbilitiesByState(state, disabledAbilities);
754 EXPECT_EQ(1, (int)disabledAbilities.size());
755 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_GetAbilitiesByState004 end";
756 }
757
758 /**
759 * @tc.number: AccessibilityAccountData_Unittest_AddAccessibilityWindowConnection001
760 * @tc.name: AddAccessibilityWindowConnection
761 * @tc.desc: Check the add accessibility interaction connection.
762 */
763 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_AddAccessibilityWindowConnection001,
764 TestSize.Level1)
765 {
766 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_AddAccessibilityWindowConnection001 star";
767 const int32_t accountId = 1;
768 const int32_t windowId = 1;
769 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
770 sptr<AccessibilityElementOperatorStub> stub = new MockAccessibilityElementOperatorStub();
771 sptr<IAccessibilityElementOperator> operation = new MockAccessibilityElementOperatorProxy(stub);
772 sptr<AccessibilityWindowConnection> connection = new AccessibilityWindowConnection(windowId, operation, accountId);
773 EXPECT_EQ(0, (int)accountData->GetAsacConnections().size());
774 /* add */
775 accountData->AddAccessibilityWindowConnection(windowId, connection);
776 EXPECT_EQ(1, (int)accountData->GetAsacConnections().size());
777 /* get */
778 EXPECT_EQ(connection, accountData->GetAccessibilityWindowConnection(windowId));
779
780 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_AddAccessibilityWindowConnection001 end";
781 }
782
783 /**
784 * @tc.number: AccessibilityAccountData_Unittest_UpdateEnableAbilityListsState001
785 * @tc.name: UpdateEnableAbilityListsState
786 * @tc.desc: Check the add connecting A11y ability.
787 */
788 HWTEST_F(AccessibilityAccountDataTest,
789 AccessibilityAccountData_Unittest_UpdateEnableAbilityListsState001, TestSize.Level1)
790 {
791 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_UpdateEnableAbilityListsState001 start";
792 const int32_t accountId = 1;
793 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
794 sptr<AccessibilityEnableAbilityListsObserverStub> stub = new MockAccessibilityEnableAbilityListsObserverStub();
795 sptr<IAccessibilityEnableAbilityListsObserver> observer =
796 new MockAccessibilityEnableAbilityListsObserverProxy(stub);
797 accountData->AddEnableAbilityListsObserver(observer);
798 EXPECT_NE(accountData.GetRefPtr(), nullptr);
799 accountData->UpdateEnableAbilityListsState();
800 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_UpdateEnableAbilityListsState001 end";
801 }
802
803 /**
804 * @tc.number: AccessibilityAccountData_Unittest_UpdateEnableAbilityListsState002
805 * @tc.name: UpdateEnableAbilityListsState
806 * @tc.desc: Check the add connecting A11y ability.
807 */
808 HWTEST_F(AccessibilityAccountDataTest,
809 AccessibilityAccountData_Unittest_UpdateEnableAbilityListsState002, TestSize.Level1)
810 {
811 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_UpdateEnableAbilityListsState002 start";
812 const int32_t accountId = 1;
813 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
814 sptr<AccessibilityEnableAbilityListsObserverStub> stub = new MockAccessibilityEnableAbilityListsObserverStub();
815 sptr<IAccessibilityEnableAbilityListsObserver> observer =
816 new AccessibilityEnableAbilityListsObserverProxy(stub);
817 accountData->AddEnableAbilityListsObserver(observer);
818 EXPECT_NE(accountData.GetRefPtr(), nullptr);
819 accountData->UpdateEnableAbilityListsState();
820 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_UpdateEnableAbilityListsState002 end";
821 }
822
823 /**
824 * @tc.number: AccessibilityAccountData_Unittest_GetAccessibilityWindowConnection001
825 * @tc.name: GetAccessibilityWindowConnection
826 * @tc.desc: Check the get accessibility interaction connection.
827 */
828 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_GetAccessibilityWindowConnection001,
829 TestSize.Level1)
830 {
831 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_GetAccessibilityWindowConnection001 star";
832 const int32_t accountId = 1;
833 const int32_t windowId = 1;
834 const int32_t windowIdTest = 2;
835 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
836 sptr<AccessibilityElementOperatorStub> stub = new MockAccessibilityElementOperatorStub();
837 sptr<IAccessibilityElementOperator> operation = new MockAccessibilityElementOperatorProxy(stub);
838 sptr<AccessibilityWindowConnection> connection = new AccessibilityWindowConnection(windowId, operation, accountId);
839 EXPECT_EQ(0, (int)accountData->GetAsacConnections().size());
840 /* add */
841 accountData->AddAccessibilityWindowConnection(windowId, connection);
842 EXPECT_EQ(1, (int)accountData->GetAsacConnections().size());
843 /* get */
844 EXPECT_EQ(nullptr, accountData->GetAccessibilityWindowConnection(windowIdTest));
845
846 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_GetAccessibilityWindowConnection001 end";
847 }
848
849 /**
850 * @tc.number: AccessibilityAccountData_Unittest_RemoveAccessibilityWindowConnection001
851 * @tc.name: RemoveAccessibilityWindowConnection
852 * @tc.desc: Check the remove accessibility interaction connection.
853 */
854 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_RemoveAccessibilityWindowConnection001,
855 TestSize.Level1)
856 {
857 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_RemoveAccessibilityWindowConnection001 star";
858 const int32_t accountId = 1;
859 const int32_t windowId = 1;
860 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
861 sptr<AccessibilityElementOperatorStub> stub = new MockAccessibilityElementOperatorStub();
862 sptr<IAccessibilityElementOperator> operation = new MockAccessibilityElementOperatorProxy(stub);
863 sptr<AccessibilityWindowConnection> connection = new AccessibilityWindowConnection(windowId, operation, accountId);
864 EXPECT_EQ(0, (int)accountData->GetAsacConnections().size());
865 /* add */
866 accountData->AddAccessibilityWindowConnection(windowId, connection);
867 EXPECT_EQ(1, (int)accountData->GetAsacConnections().size());
868 /* remove */
869 accountData->RemoveAccessibilityWindowConnection(windowId);
870 EXPECT_EQ(0, (int)accountData->GetAsacConnections().size());
871
872 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_RemoveAccessibilityWindowConnection001 end";
873 }
874
875 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_SetCaptionState, TestSize.Level1)
876 {
877 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_SetCaptionState start";
878 const int32_t accountId = 1;
879 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
880
881 accountData->Init();
882 bool state = true;
883 accountData->GetConfig()->SetCaptionState(state);
884
885 bool result = accountData->GetConfig()->GetCaptionState();
886 EXPECT_TRUE(result);
887
888 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_SetCaptionState end";
889 }
890
891 /**
892 * @tc.number: AccessibilityAccountData_Unittest_OnAccountSwitched001
893 * @tc.name: OnAccountSwitched
894 * @tc.desc: Check the account switched.
895 */
896 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_OnAccountSwitched001, TestSize.Level1)
897 {
898 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_OnAccountSwitched001 start";
899 // new accountData
900 auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
901 accountData->Init();
902 // new abilityInfo
903 AccessibilityAbilityInitParams initParams;
904 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
905 abilityInfo->SetCapabilityValues(CAPABILITY_RETRIEVE | CAPABILITY_TOUCH_GUIDE | CAPABILITY_GESTURE |
906 CAPABILITY_KEY_EVENT_OBSERVER | CAPABILITY_ZOOM);
907 // new AAconnection
908 sptr<AccessibleAbilityConnection> AAConnection =
909 new AccessibleAbilityConnection(accountData->GetAccountId(), 0, *abilityInfo);
910 // new aastub
911 sptr<AccessibleAbilityClientStub> aastub = new MockAccessibleAbilityClientStubImpl();
912 GTEST_LOG_(INFO) << "OnAbilityConnectDoneSync start !!!!!";
913 const AppExecFwk::ElementName elementName("aaa", "bbb", "ccc");
914 AAConnection->OnAbilityConnectDoneSync(elementName, aastub);
915 GTEST_LOG_(INFO) << "add connected A11y Ability";
916 EXPECT_EQ(1, (int)accountData->GetConnectedA11yAbilities().size());
917 /* CapabilityValues */
918 accountData->UpdateAccountCapabilities();
919 EXPECT_TRUE(accountData->GetGesturesSimulationFlag());
920 EXPECT_TRUE(accountData->GetFilteringKeyEventsFlag());
921 EXPECT_TRUE(accountData->GetEventTouchGuideStateFlag());
922 EXPECT_TRUE(accountData->GetScreenMagnificationFlag());
923 /* Account Switched */
924 GTEST_LOG_(INFO) << "OnAccountSwitched";
925 accountData->OnAccountSwitched();
__anon60aa68d50202() 926 bool ret = AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([=]() -> bool {
927 if (AccessibilityAbilityHelper::GetInstance().GetTestChannelId() == INVALID_CHANNEL_ID) {
928 return true;
929 } else {
930 return false;
931 }
932 }), 1);
933 EXPECT_TRUE(ret);
934 accountData->UpdateAccountCapabilities();
935 /* initialization */
936 EXPECT_EQ(0, (int)accountData->GetConnectedA11yAbilities().size());
937 EXPECT_FALSE(accountData->GetGesturesSimulationFlag());
938 EXPECT_FALSE(accountData->GetFilteringKeyEventsFlag());
939 EXPECT_FALSE(accountData->GetEventTouchGuideStateFlag());
940 EXPECT_FALSE(accountData->GetScreenMagnificationFlag());
941 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_OnAccountSwitched001 end";
942 }
943
944 /**
945 * @tc.number: AccessibilityAccountData_Unittest_AddConnectingA11yAbility001
946 * @tc.name: AddConnectingA11yAbility
947 * @tc.desc: Check the add connecting A11y ability.
948 */
949 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_AddConnectingA11yAbility001, TestSize.Level1)
950 {
951 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_AddConnectingA11yAbility001 start";
952 const int32_t accountId = 1;
953 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
954 const std::string bundleName = "bbb";
955 EXPECT_FALSE(accountData->GetConnectingA11yAbility(bundleName));
956 /* add connecting A11y ability */
957 AccessibilityAbilityInitParams initParams;
958 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
959 sptr<AccessibleAbilityConnection> connection = new MockAccessibleAbilityConnection(accountId, 0, *abilityInfo);
960 accountData->AddConnectingA11yAbility(bundleName, connection);
961 accountData->AddConnectingA11yAbility(bundleName, connection);
962 EXPECT_TRUE(accountData->GetConnectingA11yAbility(bundleName));
963 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_AddConnectingA11yAbility001 end";
964 }
965
966 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_SetTouchGuideState, TestSize.Level1)
967 {
968 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_SetTouchGuideState start";
969 const int32_t accountId = 1;
970 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
971
972 accountData->Init();
973 bool state = true;
974 RetError test = accountData->GetConfig()->SetTouchGuideState(state);
975 EXPECT_EQ(test, RET_OK);
976
977 bool result = accountData->GetConfig()->GetTouchGuideState();
978 EXPECT_TRUE(result);
979
980 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_SetTouchGuideState end";
981 }
982
983 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_SetGestureState, TestSize.Level1)
984 {
985 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_SetGestureState start";
986 const int32_t accountId = 1;
987 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
988
989 accountData->Init();
990 bool state = false;
991 RetError test = accountData->GetConfig()->SetGestureState(state);
992 EXPECT_EQ(test, RET_OK);
993
994 bool result = accountData->GetConfig()->GetGestureState();
995 EXPECT_FALSE(result);
996
997 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_SetGestureState end";
998 }
999
1000 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_SetKeyEventObserverState, TestSize.Level1)
1001 {
1002 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_SetKeyEventObserverState start";
1003 const int32_t accountId = 1;
1004 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
1005
1006 accountData->Init();
1007 bool state = true;
1008 RetError test = accountData->GetConfig()->SetKeyEventObserverState(state);
1009 EXPECT_EQ(test, RET_OK);
1010
1011 bool result = accountData->GetConfig()->GetKeyEventObserverState();
1012 EXPECT_TRUE(result);
1013
1014 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_SetKeyEventObserverState end";
1015 }
1016
1017 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_SetCaptionProperty, TestSize.Level1)
1018 {
1019 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_SetCaptionProperty start";
1020 const int32_t accountId = 1;
1021 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
1022
1023 AccessibilityConfig::CaptionProperty caption;
1024 accountData->Init();
1025 accountData->GetConfig()->SetCaptionProperty(caption);
1026
1027 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_SetCaptionProperty end";
1028 }
1029
1030 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_ClearInstalledAbility, TestSize.Level1)
1031 {
1032 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_ClearInstalledAbility start";
1033 const int32_t accountId = 1;
1034 AccessibilityAbilityInitParams initParams;
1035 initParams.bundleName = "TEST_BUNDLE_NAME";
1036 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
1037 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
1038
1039 accountData->AddInstalledAbility(*abilityInfo);
1040 accountData->ClearInstalledAbility();
1041 EXPECT_NE(accountData.GetRefPtr(), nullptr);
1042 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_ClearInstalledAbility end";
1043 }
1044
1045 /**
1046 * @tc.number: AccessibilityAccountData_Unittest_RemoveEnabledAbility
1047 * @tc.name: RemoveEnabledAbility
1048 * @tc.desc: Remove the enabled ability.
1049 */
1050 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_RemoveEnabledAbility, TestSize.Level1)
1051 {
1052 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_RemoveEnabledAbility start";
1053 const int32_t accountId = 1;
1054 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
1055
1056 const std::string bundleName = "bbb";
1057 accountData->Init();
1058 accountData->RemoveEnabledAbility(bundleName);
1059 EXPECT_NE(accountData.GetRefPtr(), nullptr);
1060 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_RemoveEnabledAbility end";
1061 }
1062
1063 /**
1064 * @tc.number: AccessibilityAccountData_Unittest_EnableAbility_001
1065 * @tc.name: EnableAbility
1066 * @tc.desc: Enable specified ability with no capability
1067 */
1068 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_EnableAbility_001, TestSize.Level1)
1069 {
1070 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_EnableAbility_001 start";
1071 const int32_t accountId = 1;
1072 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
1073 accountData->Init();
1074
1075 AccessibilityAbilityInitParams initParams;
1076 initParams.bundleName = "bundle";
1077 initParams.name = "ability";
1078 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
1079 accountData->AddInstalledAbility(*abilityInfo);
1080
1081 const std::string name = "bundle/ability";
1082 uint32_t capabilities = 0;
1083 RetError test = accountData->EnableAbility(name, capabilities);
1084 EXPECT_EQ(test, RET_ERR_NO_CAPABILITY);
1085
1086 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_EnableAbility_001 end";
1087 }
1088
1089 /**
1090 * @tc.number: AccessibilityAccountData_Unittest_EnableAbility_002
1091 * @tc.name: EnableAbility
1092 * @tc.desc: Enable specified ability which is already enabled.
1093 */
1094 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_EnableAbility_002, TestSize.Level1)
1095 {
1096 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_EnableAbility_002 start";
1097 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(0);
1098 accountData->Init();
1099
1100 AccessibilityAbilityInitParams initParams;
1101 initParams.bundleName = "bundle";
1102 initParams.name = "ability";
1103 initParams.staticCapabilities = CAPABILITY_RETRIEVE;
1104 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
1105 accountData->AddInstalledAbility(*abilityInfo);
1106 std::string name = "bundle/ability";
1107 accountData->AddEnabledAbility(name);
1108 EXPECT_EQ(RET_ERR_CONNECTION_EXIST, accountData->EnableAbility(name, CAPABILITY_RETRIEVE));
1109
1110 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_EnableAbility_002 end";
1111 }
1112
1113 /**
1114 * @tc.number: AccessibilityAccountData_Unittest_EnableAbility_003
1115 * @tc.name: EnableAbility
1116 * @tc.desc: Enable specified ability successfully.
1117 */
1118 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_EnableAbility_003, TestSize.Level1)
1119 {
1120 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_EnableAbility_003 start";
1121 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(0);
1122 accountData->Init();
1123
1124 AccessibilityAbilityInitParams initParams;
1125 initParams.bundleName = "bundle";
1126 initParams.name = "ability";
1127 initParams.staticCapabilities = CAPABILITY_RETRIEVE;
1128 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
1129 accountData->AddInstalledAbility(*abilityInfo);
1130 const std::string name = "bundle/ability";
1131 EXPECT_EQ(RET_OK, accountData->EnableAbility(name, CAPABILITY_RETRIEVE));
1132
1133 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_EnableAbility_003 end";
1134 }
1135
1136 /**
1137 * @tc.number: AccessibilityAccountData_Unittest_EnableAbility_004
1138 * @tc.name: EnableAbility
1139 * @tc.desc: Enable specified ability which is not installed.
1140 */
1141 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_EnableAbility_004, TestSize.Level1)
1142 {
1143 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_EnableAbility_004 start";
1144 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(0);
1145 EXPECT_EQ(RET_ERR_NOT_INSTALLED, accountData->EnableAbility("bundle/ability", 0));
1146 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_EnableAbility_004 end";
1147 }
1148
1149 /**
1150 * @tc.number: AccessibilityAccountData_Unittest_EnableAbility_005
1151 * @tc.name: EnableAbility
1152 * @tc.desc: Enable specified ability successfully.
1153 */
1154 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_EnableAbility_005, TestSize.Level1)
1155 {
1156 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_EnableAbility_005 start";
1157 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(0);
1158 accountData->Init();
1159 AccessibilityAbilityInitParams initParams;
1160 initParams.bundleName = "bundle";
1161 initParams.name = "ability";
1162 initParams.staticCapabilities = CAPABILITY_RETRIEVE;
1163 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
1164 accountData->AddInstalledAbility(*abilityInfo);
1165 const std::string name = "bundle/ability";
1166 EXPECT_EQ(RET_ERR_NO_CAPABILITY, accountData->EnableAbility(name, 0));
1167 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_EnableAbility_005 end";
1168 }
1169
1170 /**
1171 * @tc.number: AccessibilityAccountData_Unittest_GetImportantEnabledAbilities_001
1172 * @tc.name: GetImportantEnabledAbilities
1173 * @tc.desc: Get important enabled abilities when there is no installed ability.
1174 */
1175 HWTEST_F(AccessibilityAccountDataTest,
1176 AccessibilityAccountData_Unittest_GetImportantEnabledAbilities_001, TestSize.Level1)
1177 {
1178 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_GetImportantEnabledAbilities_001 start";
1179 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(0);
1180 std::map<std::string, uint32_t> abilities;
1181 accountData->GetImportantEnabledAbilities(abilities);
1182 EXPECT_EQ(0, static_cast<int>(abilities.size()));
1183 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_GetImportantEnabledAbilities_001 end";
1184 }
1185
1186 /**
1187 * @tc.number: AccessibilityAccountData_Unittest_GetImportantEnabledAbilities_002
1188 * @tc.name: GetImportantEnabledAbilities
1189 * @tc.desc: Get important enabled abilities when there is no enabled ability.
1190 */
1191 HWTEST_F(AccessibilityAccountDataTest,
1192 AccessibilityAccountData_Unittest_GetImportantEnabledAbilities_002, TestSize.Level1)
1193 {
1194 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_GetImportantEnabledAbilities_002 start";
1195 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(0);
1196 AccessibilityAbilityInitParams initParams;
1197 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
1198 accountData->AddInstalledAbility(*abilityInfo);
1199
1200 std::map<std::string, uint32_t> abilities;
1201 accountData->GetImportantEnabledAbilities(abilities);
1202 EXPECT_EQ(0, static_cast<int>(abilities.size()));
1203 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_GetImportantEnabledAbilities_002 end";
1204 }
1205
1206 /**
1207 * @tc.number: AccessibilityAccountData_Unittest_GetImportantEnabledAbilities_003
1208 * @tc.name: GetImportantEnabledAbilities
1209 * @tc.desc: Get important enabled abilities.
1210 */
1211 HWTEST_F(AccessibilityAccountDataTest,
1212 AccessibilityAccountData_Unittest_GetImportantEnabledAbilities_003, TestSize.Level1)
1213 {
1214 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_GetImportantEnabledAbilities_003 start";
1215 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(0);
1216
1217 AccessibilityAbilityInitParams initParams;
1218 initParams.bundleName = "testBundle1";
1219 initParams.name = "testAbility1";
1220 initParams.isImportant = false;
1221 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
1222 accountData->AddInstalledAbility(*abilityInfo);
1223
1224 initParams.bundleName = "testBundle2";
1225 initParams.name = "testAbility2";
1226 initParams.isImportant = true;
1227 std::shared_ptr<AccessibilityAbilityInfo> importantAbilityInfo =
1228 std::make_shared<AccessibilityAbilityInfo>(initParams);
1229 accountData->AddInstalledAbility(*importantAbilityInfo);
1230
1231 accountData->AddEnabledAbility("testBundle1/testAbility1");
1232 accountData->AddEnabledAbility("testBundle2/testAbility2");
1233
1234 std::map<std::string, uint32_t> abilities;
1235 accountData->GetImportantEnabledAbilities(abilities);
1236 EXPECT_EQ(IMPORTANT_ABILITIES_SIZE, abilities.size());
1237 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_GetImportantEnabledAbilities_003 end";
1238 }
1239
1240 /**
1241 * @tc.number: AccessibilityAccountData_Unittest_GetImportantEnabledAbilities_004
1242 * @tc.name: GetImportantEnabledAbilities
1243 * @tc.desc: Get important enabled abilities.
1244 */
1245 HWTEST_F(AccessibilityAccountDataTest,
1246 AccessibilityAccountData_Unittest_GetImportantEnabledAbilities_004, TestSize.Level1)
1247 {
1248 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_GetImportantEnabledAbilities_004 start";
1249 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(0);
1250
1251 AccessibilityAbilityInitParams initParams;
1252 initParams.bundleName = "testBundle1";
1253 initParams.name = "testAbility1";
1254 initParams.isImportant = false;
1255 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
1256 accountData->AddInstalledAbility(*abilityInfo);
1257 initParams.bundleName = "testBundle2";
1258 initParams.name = "testAbility2";
1259 initParams.isImportant = true;
1260 std::shared_ptr<AccessibilityAbilityInfo> importantAbilityInfo =
1261 std::make_shared<AccessibilityAbilityInfo>(initParams);
1262 accountData->AddInstalledAbility(*importantAbilityInfo);
1263 accountData->AddEnabledAbility("testBundle1/testAbility1");
1264 accountData->AddEnabledAbility("testBundle2/testAbility2");
1265 std::map<std::string, uint32_t> abilities;
1266 accountData->GetImportantEnabledAbilities(abilities);
1267 abilities.emplace(std::make_pair("testBundle2/testAbility2", CAPABILITY_RETRIEVE));
1268 EXPECT_NE(IMPORTANT_ABILITIES_SIZE, abilities.size());
1269 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_GetImportantEnabledAbilities_004 end";
1270 }
1271
1272 /**
1273 * @tc.number: AccessibilityAccountData_Unittest_UpdateImportantEnabledAbilities
1274 * @tc.name: UpdateImportantEnabledAbilities
1275 * @tc.desc: Update important enabled abilities.
1276 */
1277 HWTEST_F(AccessibilityAccountDataTest,
1278 AccessibilityAccountData_Unittest_UpdateImportantEnabledAbilities, TestSize.Level1)
1279 {
1280 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_UpdateImportantEnabledAbilities start";
1281 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(0);
1282
1283 std::map<std::string, uint32_t> abilities;
1284 accountData->UpdateImportantEnabledAbilities(abilities);
1285
1286 abilities.emplace(std::make_pair("testBundle/testAbility", CAPABILITY_RETRIEVE));
1287 accountData->UpdateImportantEnabledAbilities(abilities);
1288
1289 AccessibilityAbilityInitParams initParams;
1290 initParams.bundleName = "testBundle";
1291 initParams.name = "testAbility";
1292 initParams.isImportant = true;
1293 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
1294 abilityInfo->SetCapabilityValues(CAPABILITY_RETRIEVE | CAPABILITY_GESTURE);
1295 accountData->AddInstalledAbility(*abilityInfo);
1296
1297 accountData->UpdateImportantEnabledAbilities(abilities);
1298 ASSERT_EQ(1, static_cast<int>(accountData->GetInstalledAbilities().size()));
1299 EXPECT_EQ(accountData->GetInstalledAbilities().front().GetCapabilityValues(), CAPABILITY_RETRIEVE);
1300 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_UpdateImportantEnabledAbilities end";
1301 }
1302
1303 /**
1304 * @tc.number: AccessibilityAccountData_Unittest_UpdateAbilities_001
1305 * @tc.name: UpdateAbilities
1306 * @tc.desc: Update all abilities when there is an installed ability which is connecting.
1307 */
1308 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_UpdateAbilities_001, TestSize.Level1)
1309 {
1310 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_UpdateAbilities_001 start";
1311 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(0);
1312
1313 AccessibilityAbilityInitParams initParams;
1314 initParams.bundleName = "connectingBundle";
1315 initParams.name = "connectingAbility";
1316 std::shared_ptr<AccessibilityAbilityInfo> connectingAbilityInfo =
1317 std::make_shared<AccessibilityAbilityInfo>(initParams);
1318 accountData->AddInstalledAbility(*connectingAbilityInfo);
1319
1320 sptr<AccessibleAbilityConnection> connection = new MockAccessibleAbilityConnection(0, 0, *connectingAbilityInfo);
1321 accountData->AddConnectingA11yAbility("connectingBundle/connectingAbility", connection);
1322 accountData->UpdateAbilities();
1323 EXPECT_TRUE(accountData->GetConnectingA11yAbility("connectingBundle/connectingAbility"));
1324 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_UpdateAbilities_001 end";
1325 }
1326
1327 /**
1328 * @tc.number: AccessibilityAccountData_Unittest_UpdateAbilities_002
1329 * @tc.name: UpdateAbilities
1330 * @tc.desc: Update all abilities when there is an ability which is already connected.
1331 */
1332 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_UpdateAbilities_002, TestSize.Level1)
1333 {
1334 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_UpdateAbilities_002 start";
1335 auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
1336
1337 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>();
1338 accountData->AddInstalledAbility(*abilityInfo);
1339
1340 AppExecFwk::ElementName elementName("testDeviceId", "testBundle", "testAbility");
1341 sptr<AccessibleAbilityConnection> connection =
1342 new MockAccessibleAbilityConnection(accountData->GetAccountId(), 0, *abilityInfo);
1343 accountData->AddEnabledAbility(Utils::GetUri(connection->GetElementName()));
1344
1345 connection->Connect(elementName);
1346 accountData->AddConnectedAbility(connection);
1347 EXPECT_TRUE(accountData->GetAccessibleAbilityConnection(Utils::GetUri(connection->GetElementName())));
1348
1349 accountData->UpdateAbilities();
1350 EXPECT_TRUE(accountData->GetAccessibleAbilityConnection(Utils::GetUri(connection->GetElementName())));
1351 accountData->OnAccountSwitched();
1352 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_UpdateAbilities_002 end";
1353 }
1354
1355 /**
1356 * @tc.number: AccessibilityAccountData_Unittest_UpdateAbilities_003
1357 * @tc.name: UpdateAbilities
1358 * @tc.desc: Update all abilities when there is an enabled ability which is no connected.
1359 */
1360 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_UpdateAbilities_003, TestSize.Level1)
1361 {
1362 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_UpdateAbilities_003 start";
1363 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(0);
1364
1365 AccessibilityAbilityInitParams initParams;
1366 initParams.bundleName = "testBundle";
1367 initParams.name = "testAbility";
1368 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo =
1369 std::make_shared<AccessibilityAbilityInfo>(initParams);
1370 accountData->AddInstalledAbility(*abilityInfo);
1371
1372 accountData->AddEnabledAbility("testBundle/testAbility");
1373
1374 accountData->UpdateAbilities();
1375 EXPECT_TRUE(accountData->GetConnectingA11yAbility("testBundle/testAbility"));
1376 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_UpdateAbilities_003 end";
1377 }
1378
1379 /**
1380 * @tc.number: AccessibilityAccountData_Unittest_UpdateAbilities_004
1381 * @tc.name: UpdateAbilities
1382 * @tc.desc: Update all abilities when there is an connected ability which is no enabled.
1383 */
1384 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_UpdateAbilities_004, TestSize.Level1)
1385 {
1386 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_UpdateAbilities_004 start";
1387 auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
1388
1389 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>();
1390 accountData->AddInstalledAbility(*abilityInfo);
1391
1392 sptr<AccessibleAbilityConnection> connection =
1393 new MockAccessibleAbilityConnection(accountData->GetAccountId(), 0, *abilityInfo);
1394 AppExecFwk::ElementName elementName("testDeviceId", "testBundle", "testAbility");
1395 connection->Connect(elementName);
1396 accountData->AddConnectedAbility(connection);
1397 EXPECT_TRUE(accountData->GetAccessibleAbilityConnection(Utils::GetUri(connection->GetElementName())));
1398
1399 AccessibilityAbilityHelper::GetInstance().SetTestChannelId(0);
1400 EXPECT_EQ(AccessibilityAbilityHelper::GetInstance().GetTestChannelId(), 0);
1401
1402 accountData->UpdateAbilities();
1403 EXPECT_EQ(AccessibilityAbilityHelper::GetInstance().GetTestChannelId(), -1);
1404 accountData->OnAccountSwitched();
1405 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_UpdateAbilities_004 end";
1406 }
1407
1408 /**
1409 * @tc.number: AccessibilityAccountData_Unittest_RemoveAbility_001
1410 * @tc.name: RemoveAbility
1411 * @tc.desc: Remove ability when there is no ability
1412 */
1413 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_RemoveAbility_001, TestSize.Level1)
1414 {
1415 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_RemoveAbility_001 start";
1416 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(0);
1417 EXPECT_FALSE(accountData->RemoveAbility("bundle"));
1418 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_RemoveAbility_001 end";
1419 }
1420
1421 /**
1422 * @tc.number: AccessibilityAccountData_Unittest_RemoveAbility_002
1423 * @tc.name: RemoveAbility
1424 * @tc.desc: Remove ability successfully
1425 */
1426 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_RemoveAbility_002, TestSize.Level1)
1427 {
1428 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_RemoveAbility_002 start";
1429 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(0);
1430
1431 AccessibilityAbilityInitParams initParams;
1432 initParams.bundleName = "testBundle";
1433 initParams.name = "testAbility";
1434 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo =
1435 std::make_shared<AccessibilityAbilityInfo>(initParams);
1436 accountData->AddInstalledAbility(*abilityInfo);
1437
1438 accountData->AddEnabledAbility("testBundle/testAbility");
1439
1440 sptr<AccessibleAbilityConnection> connection = new MockAccessibleAbilityConnection(0, 0, *abilityInfo);
1441 accountData->AddConnectedAbility(connection);
1442
1443 EXPECT_TRUE(accountData->RemoveAbility("testBundle"));
1444 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_RemoveAbility_002 end";
1445 }
1446
1447 /**
1448 * @tc.number: AccessibilityAccountData_Unittest_ChangeAbility_001
1449 * @tc.name: ChangeAbility
1450 * @tc.desc: Change ability when there is no ability
1451 */
1452 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_ChangeAbility_001, TestSize.Level1)
1453 {
1454 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_ChangeAbility_001 start";
1455 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(0);
1456 accountData->ChangeAbility("bundle");
1457 EXPECT_EQ(0, static_cast<int>(accountData->GetInstalledAbilities().size()));
1458 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_ChangeAbility_001 end";
1459 }
1460
1461 /**
1462 * @tc.number: AccessibilityAccountData_Unittest_ChangeAbility_002
1463 * @tc.name: ChangeAbility
1464 * @tc.desc: Change ability which is not installed.
1465 */
1466 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_ChangeAbility_002, TestSize.Level1)
1467 {
1468 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_ChangeAbility_002 start";
1469 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(0);
1470
1471 AccessibilityAbilityInitParams initParams;
1472 initParams.bundleName = "testBundle";
1473 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo =
1474 std::make_shared<AccessibilityAbilityInfo>(initParams);
1475 accountData->AddInstalledAbility(*abilityInfo);
1476 EXPECT_EQ(1, static_cast<int>(accountData->GetInstalledAbilities().size()));
1477
1478 accountData->ChangeAbility("test");
1479 EXPECT_EQ(1, static_cast<int>(accountData->GetInstalledAbilities().size()));
1480 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_ChangeAbility_002 end";
1481 }
1482
1483 /**
1484 * @tc.number: AccessibilityAccountData_Unittest_ChangeAbility_003
1485 * @tc.name: ChangeAbility
1486 * @tc.desc: Change ability which is installed.
1487 */
1488 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_ChangeAbility_003, TestSize.Level1)
1489 {
1490 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_ChangeAbility_003 start";
1491 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(0);
1492 AccessibilityAbilityInitParams initParams;
1493 initParams.bundleName = "testBundle";
1494 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo =
1495 std::make_shared<AccessibilityAbilityInfo>(initParams);
1496 accountData->AddInstalledAbility(*abilityInfo);
1497 EXPECT_EQ(1, static_cast<int>(accountData->GetInstalledAbilities().size()));
1498 const std::string abilityName = "testBundle";
1499 accountData->SetAbilityAutoStartState("testBundle", true);
1500 accountData->ChangeAbility("testBundle");
1501 EXPECT_EQ(0, static_cast<int>(accountData->GetInstalledAbilities().size()));
1502 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_ChangeAbility_003 end";
1503 }
1504
1505 /**
1506 * @tc.number: AccessibilityAccountData_Unittest_AddUITestClient
1507 * @tc.name: AddUITestClient
1508 * @tc.desc: Add ui test client
1509 */
1510 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_AddUITestClient, TestSize.Level1)
1511 {
1512 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_AddUITestClient start";
1513 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(0);
1514 accountData->AddUITestClient(nullptr, "uitestBundle", "uitestAbility");
1515 EXPECT_EQ(1, static_cast<int>(accountData->GetInstalledAbilities().size()));
1516 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_AddUITestClient end";
1517 }
1518
1519 /**
1520 * @tc.number: AccessibilityAccountData_Unittest_RemoveUITestClient_001
1521 * @tc.name: RemoveUITestClient
1522 * @tc.desc: Remove ui test client failed.
1523 */
1524 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_RemoveUITestClient_001, TestSize.Level1)
1525 {
1526 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_RemoveUITestClient_001 start";
1527 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(0);
1528 accountData->AddUITestClient(nullptr, "uitestBundle", "uitestAbility");
1529 EXPECT_EQ(1, static_cast<int>(accountData->GetInstalledAbilities().size()));
1530
1531 sptr<AccessibleAbilityConnection> connection = nullptr;
1532 accountData->RemoveUITestClient(connection, "uitestBundle");
1533 EXPECT_EQ(1, static_cast<int>(accountData->GetInstalledAbilities().size()));
1534 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_RemoveUITestClient_001 end";
1535 }
1536
1537 /**
1538 * @tc.number: AccessibilityAccountData_Unittest_RemoveUITestClient_002
1539 * @tc.name: RemoveUITestClient
1540 * @tc.desc: Remove ui test client successfully.
1541 */
1542 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_RemoveUITestClient_002, TestSize.Level1)
1543 {
1544 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_RemoveUITestClient_002 start";
1545 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(0);
1546
1547 AccessibilityAbilityInitParams initParams;
1548 initParams.bundleName = "uitestBundle";
1549 initParams.name = "uitestAbility";
1550 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
1551 sptr<AccessibleAbilityConnection> connection = new MockAccessibleAbilityConnection(0, 0, *abilityInfo);
1552
1553 accountData->AddUITestClient(nullptr, "uitestBundle", "uitestAbility");
1554 EXPECT_EQ(1, static_cast<int>(accountData->GetInstalledAbilities().size()));
1555
1556 accountData->RemoveUITestClient(connection, "uitestBundle");
1557 EXPECT_EQ(0, static_cast<int>(accountData->GetInstalledAbilities().size()));
1558 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_RemoveUITestClient_002 end";
1559 }
1560
1561 /**
1562 * @tc.number: AccessibilityAccountData_Unittest_CaptionPropertyCallback
1563 * @tc.name: CaptionPropertyCallback
1564 * @tc.desc: Check the functions of AddCaptionPropertyCallback and RemoveCaptionPropertyCallback.
1565 */
1566 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_CaptionPropertyCallback, TestSize.Level1)
1567 {
1568 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_CaptionPropertyCallback start";
1569 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(0);
1570 sptr<AccessibleAbilityManagerCaptionObserverStub> stub = new MockAccessibleAbilityManagerCaptionObserverStub();
1571 sptr<IAccessibleAbilityManagerCaptionObserver> caption =
1572 new MockAccessibleAbilityManagerCaptionObserverProxy(stub);
1573 EXPECT_EQ(0, static_cast<int>(accountData->GetCaptionPropertyCallbacks().size()));
1574
1575 accountData->AddCaptionPropertyCallback(caption);
1576 EXPECT_EQ(1, static_cast<int>(accountData->GetCaptionPropertyCallbacks().size()));
1577
1578 accountData->RemoveCaptionPropertyCallback(caption->AsObject());
1579 EXPECT_EQ(0, static_cast<int>(accountData->GetCaptionPropertyCallbacks().size()));
1580
1581 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_CaptionPropertyCallback end";
1582 }
1583
1584 /**
1585 * @tc.number: AccessibilityAccountData_Unittest_EnableAbilityListsObserver
1586 * @tc.name: EnableAbilityListsObserver
1587 * @tc.desc: Check the functions of AddEnableAbilityListsObserver and RemoveEnableAbilityListsObserver.
1588 */
1589 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_EnableAbilityListsObserver, TestSize.Level1)
1590 {
1591 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_EnableAbilityListsObserver start";
1592 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(0);
1593 sptr<AccessibilityEnableAbilityListsObserverStub> stub = new MockAccessibilityEnableAbilityListsObserverStub();
1594 sptr<IAccessibilityEnableAbilityListsObserver> observer =
1595 new MockAccessibilityEnableAbilityListsObserverProxy(stub);
1596
1597 accountData->AddEnableAbilityListsObserver(observer);
1598 accountData->AddEnableAbilityListsObserver(observer);
1599 accountData->RemoveEnableAbilityListsObserver(observer->AsObject());
1600 EXPECT_NE(accountData.GetRefPtr(), nullptr);
1601 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_EnableAbilityListsObserver end";
1602 }
1603
1604 /**
1605 * @tc.number: AccessibilityAccountData_Unittest_ConfigCallback
1606 * @tc.name: ConfigCallback
1607 * @tc.desc: Check the functions of AddConfigCallback and RemoveConfigCallback.
1608 */
1609 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_ConfigCallback, TestSize.Level1)
1610 {
1611 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_ConfigCallback start";
1612 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(0);
1613 sptr<AccessibleAbilityManagerConfigObserverStub> stub = new MockAccessibleAbilityManagerConfigObserverStub();
1614 sptr<IAccessibleAbilityManagerConfigObserver> observer = new MockAccessibleAbilityManagerConfigObserverProxy(stub);
1615 EXPECT_EQ(0, static_cast<int>(accountData->GetConfigCallbacks().size()));
1616
1617 accountData->AddConfigCallback(observer);
1618 EXPECT_EQ(1, static_cast<int>(accountData->GetConfigCallbacks().size()));
1619
1620 accountData->RemoveConfigCallback(observer->AsObject());
1621 EXPECT_EQ(0, static_cast<int>(accountData->GetConfigCallbacks().size()));
1622
1623 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_ConfigCallback end";
1624 }
1625
1626 /**
1627 * @tc.number: AccessibilityAccountData_Unittest_AddAccessibilityAbility_001
1628 * @tc.name: AddAccessibilityAbility
1629 * @tc.desc: Check add accessibility ability.
1630 */
1631 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_AddAccessibilityAbility001, TestSize.Level1)
1632 {
1633 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_AddAccessibilityAbility_001 start";
1634 const int32_t accountId = 1;
1635 int32_t connectCounter = 0;
1636 AccessibilityAbilityInitParams initParams;
1637 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
1638 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
1639 sptr<AccessibleAbilityConnection> connection =
1640 new MockAccessibleAbilityConnection(accountId, connectCounter++, *abilityInfo);
1641 std::string uri = Utils::GetUri(connection->GetElementName());
1642 accountData->AddConnectingA11yAbility(uri, connection);
1643 auto connnection = accountData->GetConnectingA11yAbility(uri);
1644 EXPECT_NE(connnection.GetRefPtr(), nullptr);
1645 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_AddAccessibilityAbility_001 end";
1646 }
1647
1648 /**
1649 * @tc.number: AccessibilityAccountData_Unittest_SetAbilityAutoStartState_001
1650 * @tc.name: SetAbilityAutoStartState
1651 * @tc.desc: Check set and get AbilityAutoStartState.
1652 */
1653 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_SetAbilityAutoStartState, TestSize.Level1)
1654 {
1655 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_SetAbilityAutoStartState_001 start";
1656 const int32_t accountId = 1;
1657 const std::string abilityName = "test";
1658 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
1659 accountData->SetAbilityAutoStartState(abilityName, false);
1660 EXPECT_EQ(accountData->GetAbilityAutoStartState(abilityName), false);
1661 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_SetAbilityAutoStartState_001 end";
1662 }
1663
1664 /**
1665 * @tc.number: AccessibilityAccountData_Unittest_SetAbilityAutoStartState_002
1666 * @tc.name: SetAbilityAutoStartState
1667 * @tc.desc: Check set and get AbilityAutoStartState.
1668 */
1669 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_SetAbilityAutoStartState002, TestSize.Level1)
1670 {
1671 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_SetAbilityAutoStartState002 start";
1672 const int32_t accountId = 1;
1673 const std::string abilityName = "com.huawei.hmos.screenreader/AccessibilityExtAbility";
1674 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
1675 accountData->SetAbilityAutoStartState(abilityName, false);
1676 EXPECT_EQ(accountData->GetAbilityAutoStartState(abilityName), false);
1677 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_SetAbilityAutoStartState002 end";
1678 }
1679
1680 /**
1681 * @tc.number: AccessibilityAccountData_Unittest_SetAbilityAutoStartState_003
1682 * @tc.name: SetAbilityAutoStartState
1683 * @tc.desc: Check set and get AbilityAutoStartState.
1684 */
1685 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_SetAbilityAutoStartState_003, TestSize.Level1)
1686 {
1687 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_SetAbilityAutoStartState_003 start";
1688 const int32_t accountId = 1;
1689 const std::string abilityName = "com.huawei.hmos.screenreader/AccessibilityExtAbility";
1690 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
1691 accountData->SetAbilityAutoStartState(abilityName, true);
1692 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_SetAbilityAutoStartState_003 end";
1693 }
1694
1695 /**
1696 * @tc.number: AccessibilityAccountData_Unittest_UpdateAutoStartEnabledAbilities_001
1697 * @tc.name: UpdateAutoStartEnabledAbilities
1698 * @tc.desc: Check UpdateAutoStartEnabledAbilities.
1699 */
1700 HWTEST_F(AccessibilityAccountDataTest,
1701 AccessibilityAccountData_Unittest_UpdateAutoStartEnabledAbilities001, TestSize.Level1)
1702 {
1703 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_UpdateAutoStartEnabledAbilities001 start";
1704 const int32_t accountId = -1;
1705 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
1706 accountData->UpdateAutoStartEnabledAbilities();
1707 EXPECT_EQ(-1, accountData->GetAccountId());
1708 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_UpdateAutoStartEnabledAbilities001 end";
1709 }
1710
1711 /**
1712 * @tc.number: AccessibilityAccountData_Unittest_UpdateAutoStartEnabledAbilities_002
1713 * @tc.name: UpdateAutoStartEnabledAbilities
1714 * @tc.desc: Check UpdateAutoStartEnabledAbilities.
1715 */
1716 HWTEST_F(AccessibilityAccountDataTest,
1717 AccessibilityAccountData_Unittest_UpdateAutoStartEnabledAbilities002, TestSize.Level1)
1718 {
1719 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_UpdateAutoStartEnabledAbilities002 start";
1720 const int32_t accountId = 1;
1721 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
1722 accountData->UpdateAutoStartEnabledAbilities();
1723 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_UpdateAutoStartEnabledAbilities002 end";
1724 }
1725
1726 /**
1727 * @tc.number: AccessibilityAccountData_Unittest_UpdateAutoStartEnabledAbilities_003
1728 * @tc.name: UpdateAutoStartEnabledAbilities
1729 * @tc.desc: Check UpdateAutoStartEnabledAbilities.
1730 */
1731 HWTEST_F(AccessibilityAccountDataTest,
1732 AccessibilityAccountData_Unittest_UpdateAutoStartEnabledAbilities_003, TestSize.Level1)
1733 {
1734 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_UpdateAutoStartEnabledAbilities_003 start";
1735 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(0);
1736 std::map<std::string, uint32_t> abilities;
1737 accountData->UpdateImportantEnabledAbilities(abilities);
1738 abilities.emplace(std::make_pair("testBundle/testAbility", CAPABILITY_RETRIEVE));
1739 accountData->UpdateImportantEnabledAbilities(abilities);
1740 AccessibilityAbilityInitParams initParams;
1741 initParams.bundleName = "testBundle";
1742 initParams.name = "testAbility";
1743 initParams.isImportant = true;
1744 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
1745 abilityInfo->SetCapabilityValues(CAPABILITY_RETRIEVE | CAPABILITY_GESTURE);
1746 accountData->AddInstalledAbility(*abilityInfo);
1747 accountData->Init();
1748 accountData->UpdateAutoStartEnabledAbilities();
1749 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_UpdateAutoStartEnabledAbilities_003 end";
1750 }
1751
1752 /**
1753 * @tc.number: AccessibilityAccountData_Unittest_GetInputFilterFlag_001
1754 * @tc.name: GetInputFilterFlag
1755 * @tc.desc: Check GetInputFilterFlag.
1756 */
1757 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_GetInputFilterFlag001, TestSize.Level1)
1758 {
1759 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_GetInputFilterFlag001 start";
1760 const int32_t accountId = 1;
1761 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
1762 EXPECT_EQ(0, accountData->GetInputFilterFlag());
1763 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_GetInputFilterFlag001 end";
1764 }
1765
1766 /**
1767 * @tc.number: AccessibilityAccountData_Unittest_GetInputFilterFlag_002
1768 * @tc.name: GetInputFilterFlag
1769 * @tc.desc: Check GetInputFilterFlag.
1770 */
1771 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_GetInputFilterFlag_002, TestSize.Level1)
1772 {
1773 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_GetInputFilterFlag_002 start";
1774 const int32_t accountId = 0;
1775 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
1776 accountData->Init();
1777 EXPECT_EQ(0, accountData->GetInputFilterFlag());
1778 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_GetInputFilterFlag_002 end";
1779 }
1780
1781 /**
1782 * @tc.number: AccessibilityAccountData_Unittest_GetInputFilterFlag_003
1783 * @tc.name: GetInputFilterFlag
1784 * @tc.desc: Check GetInputFilterFlag.
1785 */
1786 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_GetInputFilterFlag_003, TestSize.Level1)
1787 {
1788 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_GetInputFilterFlag_003 start";
1789 auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
1790 accountData->Init();
1791 AccessibilityAbilityInitParams initParams;
1792 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
1793 abilityInfo->SetCapabilityValues(CAPABILITY_ZOOM);
1794 sptr<AccessibleAbilityConnection> AAConnection =
1795 new AccessibleAbilityConnection(accountData->GetAccountId(), 0, *abilityInfo);
1796 sptr<AccessibleAbilityClientStub> aastub = new MockAccessibleAbilityClientStubImpl();
1797 const AppExecFwk::ElementName elementName("aaa", "bbb", "ccc");
1798 AAConnection->OnAbilityConnectDoneSync(elementName, aastub);
1799 EXPECT_EQ(1, (int)accountData->GetConnectedA11yAbilities().size());
1800 accountData->UpdateAccountCapabilities();
1801 EXPECT_EQ(0, accountData->GetInputFilterFlag());
1802 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_GetInputFilterFlag_003 end";
1803 }
1804
1805 /**
1806 * @tc.number: AccessibilityAccountData_Unittest_SetScreenReaderState_001
1807 * @tc.name: SetScreenReaderState
1808 * @tc.desc: Check SetScreenReaderState.
1809 */
1810 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_SetScreenReaderState001, TestSize.Level1)
1811 {
1812 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_SetScreenReaderState001 start";
1813 const int32_t accountId = 1;
1814 const std::string abilityName = "test";
1815 const std::string state = "off";
1816 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
1817 accountData->SetScreenReaderState(abilityName, state);
1818 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_SetScreenReaderState001 end";
1819 }
1820
1821 /**
1822 * @tc.number: AccessibilityAccountData_Unittest_SetScreenReaderState_002
1823 * @tc.name: SetScreenReaderState
1824 * @tc.desc: Check SetScreenReaderState.
1825 */
1826 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_SetScreenReaderState_002, TestSize.Level1)
1827 {
1828 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_SetScreenReaderState_002 start";
1829 const int32_t accountId = 1;
1830 const std::string name = "com.huawei.hmos.screenreader/AccessibilityExtAbility";
1831 const std::string state = "on";
1832 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
1833 accountData->SetScreenReaderState(name, state);
1834 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_SetScreenReaderState_002 end";
1835 }
1836
1837 /**
1838 * @tc.number: AccessibilityAccountData_Unittest_GetDefaultUserScreenReaderState_001
1839 * @tc.name: GetDefaultUserScreenReaderState
1840 * @tc.desc: Check the GetDefaultUserScreenReaderState.
1841 */
1842 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_GetDefaultUserScreenReaderState_001,
1843 TestSize.Level1)
1844 {
1845 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_GetDefaultUserScreenReaderState_001 start";
1846 const int32_t accountId = 1;
1847 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
1848 accountData->Init();
1849 accountData->GetDefaultUserScreenReaderState();
1850 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_GetDefaultUserScreenReaderState_001 end";
1851 }
1852
1853 /**
1854 * @tc.number: AccessibilityAccountData_Unittest_GetAbilityAutoStartState_001
1855 * @tc.name: GetAbilityAutoStartState
1856 * @tc.desc: Check GetAbilityAutoStartState.
1857 */
1858 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_GetAbilityAutoStartState_001, TestSize.Level1)
1859 {
1860 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_GetAbilityAutoStartState_001 start";
1861 const int32_t accountId = 1;
1862 const std::string abilityName = "com.huawei.hmos.screenreader/AccessibilityExtAbility";
1863 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
1864 accountData->SetAbilityAutoStartState(abilityName, false);
1865 EXPECT_EQ(accountData->GetAbilityAutoStartState(abilityName), false);
1866 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_GetAbilityAutoStartState_001 end";
1867 }
1868
1869 /**
1870 * @tc.number: AccessibilityAccountData_Unittest_AddAbility001
1871 * @tc.name: AddAbility
1872 * @tc.desc: Check the AddAbility.
1873 */
1874 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_AddAbility001,
1875 TestSize.Level1)
1876 {
1877 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_AddAbility001 start";
1878 const int32_t accountId = 1;
1879 const std::string bundleName = "test";
1880 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
1881 accountData->AddAbility(bundleName);
1882 EXPECT_EQ(0, static_cast<int>(accountData->GetInstalledAbilities().size()));
1883 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_AddAbility001 end";
1884 }
1885 } // namespace Accessibility
1886 } // namespace OHOS
1887