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