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