1 /*
2 * Copyright (C) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <gtest/gtest.h>
17 #include "accessibility_ability_info.h"
18 #include "accessibility_account_data.h"
19 #include "accessibility_common_helper.h"
20 #include "accessibility_constants.h"
21 #include "accessibility_element_operator_proxy.h"
22 #include "accessibility_element_operator_stub.h"
23 #include "accessibility_ut_helper.h"
24 #include "accessible_ability_manager_service.h"
25 #include "mock_accessibility_element_operator_proxy.h"
26 #include "mock_accessibility_element_operator_stub.h"
27 #include "mock_accessible_ability_client_stub_impl.h"
28 #include "mock_accessible_ability_connection.h"
29 #include "mock_accessible_ability_manager_service_config_observer_proxy.h"
30 #include "mock_accessible_ability_manager_service_config_observer_stub.h"
31 #include "mock_accessible_ability_manager_service_state_observer_proxy.h"
32 #include "mock_accessible_ability_manager_service_state_observer_stub.h"
33 #include "utils.h"
34
35 using namespace testing;
36 using namespace testing::ext;
37
38 namespace OHOS {
39 namespace Accessibility {
40 namespace {
41 constexpr uint32_t SLEEP_TIME_1 = 1;
42 constexpr size_t IMPORTANT_ABILITIES_SIZE = 1;
43 } // namespace
44
45 class AccessibilityAccountDataTest : public testing::Test {
46 public:
AccessibilityAccountDataTest()47 AccessibilityAccountDataTest()
48 {}
~AccessibilityAccountDataTest()49 ~AccessibilityAccountDataTest()
50 {}
51
52 static void SetUpTestCase();
53 static void TearDownTestCase();
54 void SetUp() override;
55 void TearDown() override;
56 };
57
SetUpTestCase()58 void AccessibilityAccountDataTest::SetUpTestCase()
59 {
60 GTEST_LOG_(INFO) << "AccessibilityAccountDataTest SetUpTestCase";
61 Singleton<AccessibleAbilityManagerService>::GetInstance().OnStart();
62 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(AccessibilityAbilityHelper::accountId_);
63 }
64
TearDownTestCase()65 void AccessibilityAccountDataTest::TearDownTestCase()
66 {
67 GTEST_LOG_(INFO) << "AccessibilityAccountDataTest TearDownTestCase";
68 Singleton<AccessibleAbilityManagerService>::GetInstance().OnStop();
69 }
70
SetUp()71 void AccessibilityAccountDataTest::SetUp()
72 {
73 GTEST_LOG_(INFO) << "AccessibilityAccountDataTest SetUp";
74 }
75
TearDown()76 void AccessibilityAccountDataTest::TearDown()
77 {
78 GTEST_LOG_(INFO) << "AccessibilityAccountDataTest TearDown";
79 }
80
81 /**
82 * @tc.number: AccessibilityAccountData_Unittest_GetAccessibilityState001
83 * @tc.name: GetAccessibilityState
84 * @tc.desc: Check the get accessibility state.
85 */
86 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_GetAccessibilityState001, TestSize.Level1)
87 {
88 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_GetAccessibilityState001 start";
89 int32_t accountId = 1;
90 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
91 /* Initial state */
92
93 accountData->Init();
94 accountData->GetConfig()->SetTouchGuideState(true);
95 uint32_t stateType = accountData->GetAccessibilityState();
96 uint32_t stateTypeTest = Accessibility::STATE_EXPLORATION_ENABLED;
97 EXPECT_EQ(stateTypeTest, stateType);
98 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_GetAccessibilityState001 end";
99 }
100
101 /**
102 * @tc.number: AccessibilityAccountData_Unittest_GetAccessibilityState002
103 * @tc.name: GetAccessibilityState
104 * @tc.desc: Check the get accessibility state.
105 */
106 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_GetAccessibilityState002, TestSize.Level1)
107 {
108 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_GetAccessibilityState002 start";
109 const int32_t accountId = 1;
110 int32_t connectCounter = 0;
111 AccessibilityAbilityInitParams initParams;
112 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
113
114 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
115 sptr<AccessibleAbilityConnection> connection =
116 new MockAccessibleAbilityConnection(accountId, connectCounter++, *abilityInfo);
117 EXPECT_EQ(0, (int)accountData->GetConnectedA11yAbilities().size());
118 /* add connected ability */
119 accountData->AddConnectedAbility(connection);
120 const std::string elementName = Utils::GetUri(connection->GetElementName());
121 EXPECT_EQ(connection, accountData->GetAccessibleAbilityConnection(elementName));
122 EXPECT_EQ(1, (int)accountData->GetConnectedA11yAbilities().size());
123
124 accountData->Init();
125 uint32_t stateType = accountData->GetAccessibilityState();
126 uint32_t stateTypeTest = Accessibility::STATE_ACCESSIBILITY_ENABLED;
127 EXPECT_EQ(stateTypeTest, stateType);
128
129 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_GetAccessibilityState002 end";
130 }
131
132 /**
133 * @tc.number: AccessibilityAccountData_Unittest_GetAccessibilityState003
134 * @tc.name: GetAccessibilityState
135 * @tc.desc: Check the get accessibility state.
136 */
137 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_GetAccessibilityState003, TestSize.Level1)
138 {
139 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_GetAccessibilityState003 start";
140 const int32_t accountId = 1;
141 int32_t connectCounter = 0;
142 AccessibilityAbilityInitParams initParams;
143 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
144 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
145 sptr<AccessibleAbilityConnection> connection =
146 new MockAccessibleAbilityConnection(accountId, connectCounter++, *abilityInfo);
147 const std::string bundleName = "bbb";
148 EXPECT_FALSE(accountData->GetConnectingA11yAbility(bundleName));
149 /* add connecting A11y ability */
150
151 accountData->AddConnectingA11yAbility(bundleName, connection);
152 EXPECT_TRUE(accountData->GetConnectingA11yAbility(bundleName));
153
154 accountData->Init();
155 accountData->GetConfig()->SetKeyEventObserverState(true);
156
157 uint32_t stateType = accountData->GetAccessibilityState();
158 uint32_t stateTypeTest = Accessibility::STATE_ACCESSIBILITY_ENABLED | Accessibility::STATE_KEYEVENT_ENABLED;
159 EXPECT_EQ(stateTypeTest, stateType);
160
161 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_GetAccessibilityState003 end";
162 }
163
164 /**
165 * @tc.number: AccessibilityAccountData_Unittest_GetAccessibilityState004
166 * @tc.name: GetAccessibilityState
167 * @tc.desc: Check the get accessibility state.
168 */
169 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_GetAccessibilityState004, TestSize.Level1)
170 {
171 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_GetAccessibilityState004 start";
172 const int32_t accountId = 1;
173 int32_t connectCounter = 0;
174 AccessibilityAbilityInitParams initParams;
175 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
176 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
177 sptr<AccessibleAbilityConnection> connection =
178 new MockAccessibleAbilityConnection(accountId, connectCounter++, *abilityInfo);
179 /* add connected ability */
180 accountData->AddConnectedAbility(connection);
181 /* add connecting A11y ability */
182
183 const std::string bundleName = "bbb";
184 accountData->AddConnectingA11yAbility(bundleName, connection);
185
186 accountData->Init();
187 accountData->GetConfig()->SetGestureState(true);
188
189 uint32_t stateType = accountData->GetAccessibilityState();
190 uint32_t stateTypeTest = Accessibility::STATE_ACCESSIBILITY_ENABLED | Accessibility::STATE_GESTURE_ENABLED;
191 EXPECT_EQ(stateTypeTest, stateType);
192
193 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_GetAccessibilityState004 end";
194 }
195
196 /**
197 * @tc.number: AccessibilityAccountData_Unittest_AddConnectedAbility001
198 * @tc.name: AddConnectedAbility
199 * @tc.desc: Check the add connected ability.
200 */
201 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_AddConnectedAbility001, TestSize.Level1)
202 {
203 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_AddConnectedAbility001 start";
204 const int32_t accountId = 1;
205 int32_t connectCounter = 0;
206 AccessibilityAbilityInitParams initParams;
207 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
208 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
209 sptr<AccessibleAbilityConnection> connection =
210 new MockAccessibleAbilityConnection(accountId, connectCounter++, *abilityInfo);
211 EXPECT_EQ(0, (int)accountData->GetConnectedA11yAbilities().size());
212 /* add connected ability */
213 accountData->AddConnectedAbility(connection);
214 const std::string elementName = Utils::GetUri(connection->GetElementName());
215 EXPECT_EQ(connection, accountData->GetAccessibleAbilityConnection(elementName));
216 EXPECT_EQ(1, (int)accountData->GetConnectedA11yAbilities().size());
217
218 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_AddConnectedAbility001 end";
219 }
220
221 /**
222 * @tc.number: AccessibilityAccountData_Unittest_RemoveConnectedAbility001
223 * @tc.name: RemoveConnectedAbility
224 * @tc.desc: Check the remove connected ability.
225 */
226 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_RemoveConnectedAbility001, TestSize.Level1)
227 {
228 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_RemoveConnectedAbility001 start";
229 const int32_t accountId = 1;
230 int32_t connectCounter = 0;
231 AccessibilityAbilityInitParams initParams;
232 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
233 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
234 sptr<AccessibleAbilityConnection> connection =
235 new MockAccessibleAbilityConnection(accountId, connectCounter++, *abilityInfo);
236 EXPECT_EQ(0, (int)accountData->GetConnectedA11yAbilities().size());
237 /* add */
238 accountData->AddConnectedAbility(connection);
239 EXPECT_EQ(1, (int)accountData->GetConnectedA11yAbilities().size());
240 const std::string elementName = Utils::GetUri(connection->GetElementName());
241 EXPECT_EQ(connection, accountData->GetAccessibleAbilityConnection(elementName));
242 /* remove */
243 accountData->RemoveConnectedAbility(connection->GetElementName());
244 EXPECT_EQ(0, (int)accountData->GetConnectedA11yAbilities().size());
245
246 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_RemoveConnectedAbility001 end";
247 }
248
249 /**
250 * @tc.number: AccessibilityAccountData_Unittest_AbilityDisconnected001
251 * @tc.name: AbilityDisconnected
252 * @tc.desc: Check the ability disconnected.
253 */
254 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_AbilityDisconnected001, TestSize.Level1)
255 {
256 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_AbilityDisconnected001 start";
257 const int32_t accountId = 1;
258 int32_t connectCounter = 0;
259 AccessibilityAbilityInitParams initParams;
260 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
261 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
262 sptr<AccessibleAbilityConnection> connection =
263 new MockAccessibleAbilityConnection(accountId, connectCounter++, *abilityInfo);
264 EXPECT_EQ(0, (int)accountData->GetConnectedA11yAbilities().size());
265 /* add */
266 accountData->AddConnectedAbility(connection);
267 const std::string elementNameURI = Utils::GetUri(connection->GetElementName());
268 EXPECT_EQ(1, (int)accountData->GetConnectedA11yAbilities().size());
269 EXPECT_EQ(connection, accountData->GetAccessibleAbilityConnection(elementNameURI));
270
271 EXPECT_FALSE(accountData->GetConnectingA11yAbility(elementNameURI));
272 /* disconnect */
273 accountData->RemoveConnectedAbility(connection->GetElementName());
274 EXPECT_EQ(0, (int)accountData->GetConnectedA11yAbilities().size());
275 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_AbilityDisconnected001 end";
276 }
277
278 /**
279 * @tc.number: AccessibilityAccountData_Unittest_RemoveConnectingA11yAbility001
280 * @tc.name: RemoveConnectingA11yAbility
281 * @tc.desc: Check the remove connecting A11y ability.GetAccessibilityWindows
282 */
283 HWTEST_F(
284 AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_RemoveConnectingA11yAbility001, TestSize.Level1)
285 {
286 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_RemoveConnectingA11yAbility001 start";
287 const int32_t accountId = 1;
288 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
289 const std::string bundleName = "bbb";
290 EXPECT_FALSE(accountData->GetConnectingA11yAbility(bundleName));
291 /* add connecting A11y ability */
292
293 AccessibilityAbilityInitParams initParams;
294 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
295 sptr<AccessibleAbilityConnection> connection =
296 new MockAccessibleAbilityConnection(accountId, 0, *abilityInfo);
297 accountData->AddConnectingA11yAbility(bundleName, connection);
298 EXPECT_TRUE(accountData->GetConnectingA11yAbility(bundleName));
299 /* remove */
300 accountData->RemoveConnectingA11yAbility(bundleName);
301 EXPECT_FALSE(accountData->GetConnectingA11yAbility(bundleName));
302
303 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_RemoveConnectingA11yAbility001 end";
304 }
305
306 /**
307 * @tc.number: AccessibilityAccountData_Unittest_AddEnabledAbility001
308 * @tc.name: AddEnabledAbility
309 * @tc.desc: Check the add enable ability.
310 */
311 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_AddEnabledAbility001, TestSize.Level1)
312 {
313 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_AddEnabledAbility001 start";
314 const int32_t accountId = 1;
315 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
316 const std::string bundleName = "/bbb";
317 accountData->Init();
318 EXPECT_EQ(0, (int)accountData->GetConfig()->GetEnabledAbilityInfos().size());
319 /* add */
320 AccessibilityAbilityInitParams initParams;
321 initParams.name = "bbb";
322 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
323 abilityInfo->SetCapabilityValues(1);
324 accountData->AddInstalledAbility(*abilityInfo);
325 accountData->AddEnabledAbility(bundleName);
326 accountData->AddEnabledAbility(bundleName);
327 EXPECT_EQ(1, (int)accountData->GetEnabledAbilities().size());
328 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_AddEnabledAbility001 end";
329 }
330
331 /**
332 * @tc.number: AccessibilityAccountData_Unittest_RemoveEnabledAbility001
333 * @tc.name: RemoveEnabledAbility
334 * @tc.desc: Check the remove enable ability.
335 */
336 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_RemoveEnabledAbility001, TestSize.Level1)
337 {
338 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_RemoveEnabledAbility001 start";
339 const int32_t accountId = 1;
340 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
341 const std::string bundleName = "/bbb";
342 accountData->Init();
343 EXPECT_EQ(0, (int)accountData->GetConfig()->GetEnabledAbilityInfos().size());
344
345 /* remove */
346 accountData->RemoveEnabledAbility(bundleName);
347 EXPECT_EQ(0, (int)accountData->GetEnabledAbilities().size());
348
349 /* add */
350 AccessibilityAbilityInitParams initParams;
351 initParams.name = "bbb";
352 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
353 abilityInfo->SetCapabilityValues(1);
354 accountData->AddInstalledAbility(*abilityInfo);
355
356 accountData->AddEnabledAbility(bundleName);
357 EXPECT_EQ(1, (int)accountData->GetEnabledAbilities().size());
358
359 /* remove */
360 accountData->RemoveEnabledAbility(bundleName);
361 EXPECT_EQ(0, (int)accountData->GetEnabledAbilities().size());
362
363 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_RemoveEnabledAbility001 end";
364 }
365
366 /**
367 * @tc.number: AccessibilityAccountData_Unittest_AddInstalledAbility001
368 * @tc.name: AddInstalledAbility
369 * @tc.desc: Check the add install ability.
370 */
371 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_AddInstalledAbility001, TestSize.Level1)
372 {
373 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_AddInstalledAbility001 start";
374 const int32_t accountId = 1;
375 AccessibilityAbilityInitParams initParams;
376 initParams.bundleName = "TEST_BUNDLE_NAME";
377 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
378 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
379 EXPECT_EQ(0, (int)accountData->GetInstalledAbilities().size());
380 /* add */
381 accountData->AddInstalledAbility(*abilityInfo);
382 EXPECT_EQ(1, (int)accountData->GetInstalledAbilities().size());
383
384 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_AddInstalledAbility001 end";
385 }
386
387 /**
388 * @tc.number: AccessibilityAccountData_Unittest_RemoveInstalledAbility001
389 * @tc.name: RemoveInstalledAbility
390 * @tc.desc: Check the remove install ability.
391 */
392 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_RemoveInstalledAbility001, TestSize.Level1)
393 {
394 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_RemoveInstalledAbility001 start";
395 const int32_t accountId = 1;
396 AccessibilityAbilityInitParams initParams;
397 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
398 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
399 EXPECT_EQ(0, (int)accountData->GetInstalledAbilities().size());
400 /* add */
401 accountData->AddInstalledAbility(*abilityInfo);
402 EXPECT_EQ(1, (int)accountData->GetInstalledAbilities().size());
403 /* remove */
404 accountData->RemoveInstalledAbility(abilityInfo->GetPackageName());
405 EXPECT_EQ(0, (int)accountData->GetInstalledAbilities().size());
406
407 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_RemoveInstalledAbility001 end";
408 }
409
410 /**
411 * @tc.number: AccessibilityAccountData_Unittest_ClearInstalledAbility001
412 * @tc.name: ClearInstalledAbility
413 * @tc.desc: Check the clear install ability.
414 */
415 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_ClearInstalledAbility001, TestSize.Level1)
416 {
417 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_ClearInstalledAbility001 start";
418 const int32_t accountId = 1;
419 AccessibilityAbilityInitParams initParams;
420 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
421 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
422 EXPECT_EQ(0, (int)accountData->GetInstalledAbilities().size());
423 /* add */
424 accountData->AddInstalledAbility(*abilityInfo);
425 EXPECT_EQ(1, (int)accountData->GetInstalledAbilities().size());
426 /* clear */
427 accountData->ClearInstalledAbility();
428 EXPECT_EQ(0, (int)accountData->GetInstalledAbilities().size());
429
430 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_ClearInstalledAbility001 end";
431 }
432
433 /**
434 * @tc.number: AccessibilityAccountData_Unittest_GetAccessibleAbilityConnection001
435 * @tc.name: GetAccessibleAbilityConnection
436 * @tc.desc: Check the get accessibility connection.
437 */
438 HWTEST_F(
439 AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_GetAccessibleAbilityConnection001, TestSize.Level1)
440 {
441 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_GetAccessibleAbilityConnection001 start";
442 const int32_t accountId = 1;
443 int32_t connectCounter = 0;
444 AccessibilityAbilityInitParams initParams;
445 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
446 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
447 sptr<AccessibleAbilityConnection> connection =
448 new MockAccessibleAbilityConnection(accountId, connectCounter++, *abilityInfo);
449 EXPECT_EQ(0, (int)accountData->GetConnectedA11yAbilities().size());
450 std::string elementName = Utils::GetUri(connection->GetElementName());
451 EXPECT_FALSE(accountData->GetAccessibleAbilityConnection(elementName));
452 accountData->AddConnectedAbility(connection);
453 EXPECT_EQ(1, (int)accountData->GetConnectedA11yAbilities().size());
454 /* get */
455 EXPECT_EQ(connection, accountData->GetAccessibleAbilityConnection(elementName));
456 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_GetAccessibleAbilityConnection001 end";
457 }
458
459 /**
460 * @tc.number: AccessibilityAccountData_Unittest_GetAccessibleAbilityConnection002
461 * @tc.name: GetAccessibleAbilityConnection
462 * @tc.desc: Check the get accessibility connection.
463 */
464 HWTEST_F(
465 AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_GetAccessibleAbilityConnection002, TestSize.Level1)
466 {
467 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_GetAccessibleAbilityConnection002 start";
468 const int32_t accountId = 1;
469 int32_t connectCounter = 0;
470 AccessibilityAbilityInitParams initParams;
471 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
472 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
473 sptr<AccessibleAbilityConnection> connection =
474 new MockAccessibleAbilityConnection(accountId, connectCounter++, *abilityInfo);
475 accountData->AddConnectedAbility(connection);
476 const std::string elementName = "111name";
477 /* get */
478 EXPECT_EQ(nullptr, accountData->GetAccessibleAbilityConnection(elementName));
479 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_GetAccessibleAbilityConnection002 end";
480 }
481
482 /**
483 * @tc.number: AccessibilityAccountData_Unittest_GetConnectedA11yAbilities001
484 * @tc.name: GetConnectedA11yAbilities
485 * @tc.desc: Check the get connected abilities.
486 */
487 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_GetConnectedA11yAbilities001, TestSize.Level1)
488 {
489 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_GetConnectedA11yAbilities001 start";
490 const int32_t accountId = 1;
491 int32_t connectCounter = 0;
492 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
493 AccessibilityAbilityInitParams initParams;
494 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
495 sptr<AccessibleAbilityConnection> connection =
496 new MockAccessibleAbilityConnection(accountId, connectCounter++, *abilityInfo);
497 /* get */
498 size_t size = accountData->GetConnectedA11yAbilities().size();
499 EXPECT_EQ(0, size);
500 /* add */
501 accountData->AddConnectedAbility(connection);
502 /* get */
503 EXPECT_EQ(1, accountData->GetConnectedA11yAbilities().size());
504
505 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_GetConnectedA11yAbilities001 end";
506 }
507
508 /**
509 * @tc.number: AccessibilityAccountData_Unittest_GetAsacConnections001
510 * @tc.name: GetAsacConnections
511 * @tc.desc: Check the get asac connections.
512 */
513 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_GetAsacConnections001, TestSize.Level1)
514 {
515 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_GetAsacConnections001 start";
516 const int32_t accountId = 1;
517 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
518 /* get */
519 size_t size = accountData->GetAsacConnections().size();
520 EXPECT_EQ(0, size);
521
522 const int32_t windowId = 1;
523 sptr<AccessibilityElementOperatorStub> operationStub = new MockAccessibilityElementOperatorStub();
524 sptr<IAccessibilityElementOperator> operation = new MockAccessibilityElementOperatorProxy(operationStub);
525 sptr<AccessibilityWindowConnection> operationConnection =
526 new AccessibilityWindowConnection(windowId, operation, accountId);
527 /* add asacConnections */
528 accountData->AddAccessibilityWindowConnection(windowId, operationConnection);
529 /* get */
530 EXPECT_EQ(1, accountData->GetAsacConnections().size());
531
532 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_GetAsacConnections001 end";
533 }
534
535 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_SetEnabled, TestSize.Level1)
536 {
537 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_SetEnabled start";
538 const int32_t accountId = 1;
539 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
540
541 accountData->Init();
542 bool state = true;
543 bool test = accountData->GetConfig()->SetEnabled(state);
544 EXPECT_TRUE(test);
545
546 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_SetEnabled end";
547 }
548
549 /**
550 * @tc.number: AccessibilityAccountData_Unittest_GetAbilitiesByState001
551 * @tc.name: GetAbilitiesByState
552 * @tc.desc: Check the get ability state.
553 */
554 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_GetAbilitiesByState001, TestSize.Level1)
555 {
556 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_GetAbilitiesByState001 start";
557 const int32_t accountId = 1;
558 int32_t connectCounter = 0;
559 AccessibilityAbilityInitParams initParams;
560 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
561 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
562 sptr<AccessibleAbilityConnection> connection =
563 new MockAccessibleAbilityConnection(accountId, connectCounter++, *abilityInfo);
564 /* add connected ability */
565 EXPECT_EQ(0, (int)accountData->GetConnectedA11yAbilities().size());
566 accountData->AddConnectedAbility(connection);
567 EXPECT_EQ(1, (int)accountData->GetConnectedA11yAbilities().size());
568 /* ABILITY_STATE_ENABLE */
569 AbilityStateType state = AbilityStateType::ABILITY_STATE_ENABLE;;
570 /* get ability */
571 std::vector<AccessibilityAbilityInfo> enabledAbilities;
572 accountData->GetAbilitiesByState(state, enabledAbilities);
573 EXPECT_EQ(1, (int)enabledAbilities.size());
574 EXPECT_EQ(connection->GetAbilityInfo().GetPackageName(), enabledAbilities.begin()->GetPackageName());
575
576 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_GetAbilitiesByState001 end";
577 }
578
579 /**
580 * @tc.number: AccessibilityAccountData_Unittest_GetAbilitiesByState003
581 * @tc.name: GetAbilitiesByState
582 * @tc.desc: Check the get ability state.
583 */
584 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_GetAbilitiesByState003, TestSize.Level1)
585 {
586 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_GetAbilitiesByState003 start";
587 const int32_t accountId = 1;
588 int32_t connectCounter = 0;
589
590 AccessibilityAbilityInitParams initParamsDefault;
591 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo =
592 std::make_shared<AccessibilityAbilityInfo>(initParamsDefault);
593 AccessibilityAbilityInitParams initParams;
594 initParams.name = "TEST_ABILITY_NAME";
595 initParams.bundleName = "TEST_BUNDLE_NAME";
596 std::shared_ptr<AccessibilityAbilityInfo> installAbilityInfo =
597 std::make_shared<AccessibilityAbilityInfo>(initParams);
598 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
599 sptr<AccessibleAbilityConnection> connection =
600 new MockAccessibleAbilityConnection(accountId, connectCounter++, *abilityInfo);
601
602 EXPECT_NE(abilityInfo->GetId(), installAbilityInfo->GetId());
603
604 /* add connected ability */
605 EXPECT_EQ(0, (int)accountData->GetConnectedA11yAbilities().size());
606 accountData->AddConnectedAbility(connection);
607 EXPECT_EQ(1, (int)accountData->GetConnectedA11yAbilities().size());
608
609 /* add install ability */
610 EXPECT_EQ(0, (int)accountData->GetInstalledAbilities().size());
611 accountData->AddInstalledAbility(*installAbilityInfo);
612 EXPECT_EQ(1, (int)accountData->GetInstalledAbilities().size());
613 sleep(SLEEP_TIME_1);
614
615 /* ABILITY_STATE_DISABLE */
616 AbilityStateType state = AbilityStateType::ABILITY_STATE_DISABLE;
617
618 /* get ability */
619 std::vector<AccessibilityAbilityInfo> disabledAbilities;
620 accountData->GetAbilitiesByState(state, disabledAbilities);
621 EXPECT_EQ(1, (int)disabledAbilities.size());
622 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_GetAbilitiesByState003 end";
623 }
624
625 /**
626 * @tc.number: AccessibilityAccountData_Unittest_AddAccessibilityWindowConnection001
627 * @tc.name: AddAccessibilityWindowConnection
628 * @tc.desc: Check the add accessibility interaction connection.
629 */
630 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_AddAccessibilityWindowConnection001,
631 TestSize.Level1)
632 {
633 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_AddAccessibilityWindowConnection001 star";
634 const int32_t accountId = 1;
635 const int32_t windowId = 1;
636 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
637 sptr<AccessibilityElementOperatorStub> stub = new MockAccessibilityElementOperatorStub();
638 sptr<IAccessibilityElementOperator> operation = new MockAccessibilityElementOperatorProxy(stub);
639 sptr<AccessibilityWindowConnection> connection = new AccessibilityWindowConnection(windowId, operation, accountId);
640 EXPECT_EQ(0, (int)accountData->GetAsacConnections().size());
641 /* add */
642 accountData->AddAccessibilityWindowConnection(windowId, connection);
643 EXPECT_EQ(1, (int)accountData->GetAsacConnections().size());
644 /* get */
645 EXPECT_EQ(connection, accountData->GetAccessibilityWindowConnection(windowId));
646
647 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_AddAccessibilityWindowConnection001 end";
648 }
649
650 /**
651 * @tc.number: AccessibilityAccountData_Unittest_GetAccessibilityWindowConnection001
652 * @tc.name: GetAccessibilityWindowConnection
653 * @tc.desc: Check the get accessibility interaction connection.
654 */
655 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_GetAccessibilityWindowConnection001,
656 TestSize.Level1)
657 {
658 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_GetAccessibilityWindowConnection001 star";
659 const int32_t accountId = 1;
660 const int32_t windowId = 1;
661 const int32_t windowIdTest = 2;
662 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
663 sptr<AccessibilityElementOperatorStub> stub = new MockAccessibilityElementOperatorStub();
664 sptr<IAccessibilityElementOperator> operation = new MockAccessibilityElementOperatorProxy(stub);
665 sptr<AccessibilityWindowConnection> connection = new AccessibilityWindowConnection(windowId, operation, accountId);
666 EXPECT_EQ(0, (int)accountData->GetAsacConnections().size());
667 /* add */
668 accountData->AddAccessibilityWindowConnection(windowId, connection);
669 EXPECT_EQ(1, (int)accountData->GetAsacConnections().size());
670 /* get */
671 EXPECT_EQ(nullptr, accountData->GetAccessibilityWindowConnection(windowIdTest));
672
673 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_GetAccessibilityWindowConnection001 end";
674 }
675
676 /**
677 * @tc.number: AccessibilityAccountData_Unittest_RemoveAccessibilityWindowConnection001
678 * @tc.name: RemoveAccessibilityWindowConnection
679 * @tc.desc: Check the remove accessibility interaction connection.
680 */
681 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_RemoveAccessibilityWindowConnection001,
682 TestSize.Level1)
683 {
684 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_RemoveAccessibilityWindowConnection001 star";
685 const int32_t accountId = 1;
686 const int32_t windowId = 1;
687 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
688 sptr<AccessibilityElementOperatorStub> stub = new MockAccessibilityElementOperatorStub();
689 sptr<IAccessibilityElementOperator> operation = new MockAccessibilityElementOperatorProxy(stub);
690 sptr<AccessibilityWindowConnection> connection = new AccessibilityWindowConnection(windowId, operation, accountId);
691 EXPECT_EQ(0, (int)accountData->GetAsacConnections().size());
692 /* add */
693 accountData->AddAccessibilityWindowConnection(windowId, connection);
694 EXPECT_EQ(1, (int)accountData->GetAsacConnections().size());
695 /* remove */
696 accountData->RemoveAccessibilityWindowConnection(windowId);
697 EXPECT_EQ(0, (int)accountData->GetAsacConnections().size());
698
699 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_RemoveAccessibilityWindowConnection001 end";
700 }
701
702 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_SetCaptionState, TestSize.Level1)
703 {
704 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_SetCaptionState start";
705 const int32_t accountId = 1;
706 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
707
708 accountData->Init();
709 bool state = true;
710 accountData->GetConfig()->SetCaptionState(state);
711
712 bool result = accountData->GetConfig()->GetCaptionState();
713 EXPECT_TRUE(result);
714
715 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_SetCaptionState end";
716 }
717
718 /**
719 * @tc.number: AccessibilityAccountData_Unittest_OnAccountSwitched001
720 * @tc.name: OnAccountSwitched
721 * @tc.desc: Check the account switched.
722 */
723 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_OnAccountSwitched001, TestSize.Level1)
724 {
725 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_OnAccountSwitched001 start";
726 // new accountData
727 auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
728 accountData->Init();
729 // new abilityInfo
730 AccessibilityAbilityInitParams initParams;
731 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
732 abilityInfo->SetCapabilityValues(CAPABILITY_RETRIEVE | CAPABILITY_TOUCH_GUIDE | CAPABILITY_GESTURE |
733 CAPABILITY_KEY_EVENT_OBSERVER | CAPABILITY_ZOOM);
734 // new AAconnection
735 sptr<AccessibleAbilityConnection> AAConnection =
736 new AccessibleAbilityConnection(accountData->GetAccountId(), 0, *abilityInfo);
737 // new aastub
738 sptr<AccessibleAbilityClientStub> aastub = new MockAccessibleAbilityClientStubImpl();
739 GTEST_LOG_(INFO) << "OnAbilityConnectDoneSync start !!!!!";
740 const AppExecFwk::ElementName elementName("aaa", "bbb", "ccc");
741 AAConnection->OnAbilityConnectDoneSync(elementName, aastub);
742 GTEST_LOG_(INFO) << "add connected A11y Ability";
743 EXPECT_EQ(1, (int)accountData->GetConnectedA11yAbilities().size());
744 /* CapabilityValues */
745 accountData->UpdateAccountCapabilities();
746 EXPECT_TRUE(accountData->GetGesturesSimulationFlag());
747 EXPECT_TRUE(accountData->GetFilteringKeyEventsFlag());
748 EXPECT_TRUE(accountData->GetEventTouchGuideStateFlag());
749 EXPECT_TRUE(accountData->GetScreenMagnificationFlag());
750 /* Account Switched */
751 GTEST_LOG_(INFO) << "OnAccountSwitched";
752 accountData->OnAccountSwitched();
__anon32b2f41d0202() 753 bool ret = AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([=]() -> bool {
754 if (AccessibilityAbilityHelper::GetInstance().GetTestChannelId() == INVALID_CHANNEL_ID) {
755 return true;
756 } else {
757 return false;
758 }
759 }), 1);
760 EXPECT_TRUE(ret);
761 accountData->UpdateAccountCapabilities();
762 /* initialization */
763 EXPECT_EQ(0, (int)accountData->GetConnectedA11yAbilities().size());
764 EXPECT_FALSE(accountData->GetGesturesSimulationFlag());
765 EXPECT_FALSE(accountData->GetFilteringKeyEventsFlag());
766 EXPECT_FALSE(accountData->GetEventTouchGuideStateFlag());
767 EXPECT_FALSE(accountData->GetScreenMagnificationFlag());
768 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_OnAccountSwitched001 end";
769 }
770
771 /**
772 * @tc.number: AccessibilityAccountData_Unittest_AddConnectingA11yAbility001
773 * @tc.name: AddConnectingA11yAbility
774 * @tc.desc: Check the add connecting A11y ability.
775 */
776 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_AddConnectingA11yAbility001, TestSize.Level1)
777 {
778 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_AddConnectingA11yAbility001 start";
779 const int32_t accountId = 1;
780 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
781 const std::string bundleName = "bbb";
782 EXPECT_FALSE(accountData->GetConnectingA11yAbility(bundleName));
783 /* add connecting A11y ability */
784 AccessibilityAbilityInitParams initParams;
785 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
786 sptr<AccessibleAbilityConnection> connection = new MockAccessibleAbilityConnection(accountId, 0, *abilityInfo);
787 accountData->AddConnectingA11yAbility(bundleName, connection);
788 accountData->AddConnectingA11yAbility(bundleName, connection);
789 EXPECT_TRUE(accountData->GetConnectingA11yAbility(bundleName));
790 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_AddConnectingA11yAbility001 end";
791 }
792
793 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_SetTouchGuideState, TestSize.Level1)
794 {
795 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_SetTouchGuideState start";
796 const int32_t accountId = 1;
797 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
798
799 accountData->Init();
800 bool state = true;
801 bool test = accountData->GetConfig()->SetTouchGuideState(state);
802 EXPECT_TRUE(test);
803
804 bool result = accountData->GetConfig()->GetTouchGuideState();
805 EXPECT_TRUE(result);
806
807 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_SetTouchGuideState end";
808 }
809
810 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_SetGestureState, TestSize.Level1)
811 {
812 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_SetGestureState start";
813 const int32_t accountId = 1;
814 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
815
816 accountData->Init();
817 bool state = false;
818 bool test = accountData->GetConfig()->SetGestureState(state);
819 EXPECT_TRUE(test);
820
821 bool result = accountData->GetConfig()->GetGestureState();
822 EXPECT_FALSE(result);
823
824 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_SetGestureState end";
825 }
826
827 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_SetKeyEventObserverState, TestSize.Level1)
828 {
829 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_SetKeyEventObserverState start";
830 const int32_t accountId = 1;
831 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
832
833 accountData->Init();
834 bool state = true;
835 bool test = accountData->GetConfig()->SetKeyEventObserverState(state);
836 EXPECT_TRUE(test);
837
838 bool result = accountData->GetConfig()->GetKeyEventObserverState();
839 EXPECT_TRUE(result);
840
841 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_SetKeyEventObserverState end";
842 }
843
844 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_SetCaptionProperty, TestSize.Level1)
845 {
846 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_SetCaptionProperty start";
847 const int32_t accountId = 1;
848 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
849
850 AccessibilityConfig::CaptionProperty caption;
851 accountData->Init();
852 accountData->GetConfig()->SetCaptionProperty(caption);
853
854 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_SetCaptionProperty end";
855 }
856
857 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_ClearInstalledAbility, TestSize.Level1)
858 {
859 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_ClearInstalledAbility start";
860 const int32_t accountId = 1;
861 AccessibilityAbilityInitParams initParams;
862 initParams.bundleName = "TEST_BUNDLE_NAME";
863 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
864 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
865
866 accountData->AddInstalledAbility(*abilityInfo);
867 accountData->ClearInstalledAbility();
868
869 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_ClearInstalledAbility end";
870 }
871
872 /**
873 * @tc.number: AccessibilityAccountData_Unittest_RemoveEnabledAbility
874 * @tc.name: RemoveEnabledAbility
875 * @tc.desc: Remove the enabled ability.
876 */
877 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_RemoveEnabledAbility, TestSize.Level1)
878 {
879 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_RemoveEnabledAbility start";
880 const int32_t accountId = 1;
881 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
882
883 const std::string bundleName = "bbb";
884 accountData->Init();
885 accountData->RemoveEnabledAbility(bundleName);
886
887 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_RemoveEnabledAbility end";
888 }
889
890 /**
891 * @tc.number: AccessibilityAccountData_Unittest_EnableAbility_001
892 * @tc.name: EnableAbility
893 * @tc.desc: Enable specified ability with no capability
894 */
895 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_EnableAbility_001, TestSize.Level1)
896 {
897 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_EnableAbility_001 start";
898 const int32_t accountId = 1;
899 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(accountId);
900 accountData->Init();
901
902 AccessibilityAbilityInitParams initParams;
903 initParams.bundleName = "bundle";
904 initParams.name = "ability";
905 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
906 accountData->AddInstalledAbility(*abilityInfo);
907
908 const std::string name = "bundle/ability";
909 uint32_t capabilities = 0;
910 RetError test = accountData->EnableAbility(name, capabilities);
911 EXPECT_EQ(test, RET_ERR_NO_CAPABILITY);
912 ASSERT_EQ(0, (int)accountData->GetConfig()->GetEnabledAbilityInfos().size());
913
914 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_EnableAbility_001 end";
915 }
916
917 /**
918 * @tc.number: AccessibilityAccountData_Unittest_EnableAbility_002
919 * @tc.name: EnableAbility
920 * @tc.desc: Enable specified ability which is already enabled.
921 */
922 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_EnableAbility_002, TestSize.Level1)
923 {
924 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_EnableAbility_002 start";
925 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(0);
926 accountData->Init();
927
928 AccessibilityAbilityInitParams initParams;
929 initParams.bundleName = "bundle";
930 initParams.name = "ability";
931 initParams.staticCapabilities = CAPABILITY_RETRIEVE;
932 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
933 accountData->AddInstalledAbility(*abilityInfo);
934 std::string name = "bundle/ability";
935 accountData->AddEnabledAbility(name);
936 EXPECT_EQ(RET_ERR_CONNECTION_EXIST, accountData->EnableAbility(name, CAPABILITY_RETRIEVE));
937
938 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_EnableAbility_002 end";
939 }
940
941 /**
942 * @tc.number: AccessibilityAccountData_Unittest_EnableAbility_003
943 * @tc.name: EnableAbility
944 * @tc.desc: Enable specified ability successfully.
945 */
946 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_EnableAbility_003, TestSize.Level1)
947 {
948 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_EnableAbility_003 start";
949 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(0);
950 accountData->Init();
951
952 AccessibilityAbilityInitParams initParams;
953 initParams.bundleName = "bundle";
954 initParams.name = "ability";
955 initParams.staticCapabilities = CAPABILITY_RETRIEVE;
956 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
957 accountData->AddInstalledAbility(*abilityInfo);
958 const std::string name = "bundle/ability";
959 EXPECT_EQ(RET_OK, accountData->EnableAbility(name, CAPABILITY_RETRIEVE));
960
961 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_EnableAbility_003 end";
962 }
963
964 /**
965 * @tc.number: AccessibilityAccountData_Unittest_EnableAbility_004
966 * @tc.name: EnableAbility
967 * @tc.desc: Enable specified ability which is not installed.
968 */
969 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_EnableAbility_004, TestSize.Level1)
970 {
971 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_EnableAbility_004 start";
972 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(0);
973 EXPECT_EQ(RET_ERR_NOT_INSTALLED, accountData->EnableAbility("bundle/ability", 0));
974 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_EnableAbility_004 end";
975 }
976
977 /**
978 * @tc.number: AccessibilityAccountData_Unittest_GetImportantEnabledAbilities_001
979 * @tc.name: GetImportantEnabledAbilities
980 * @tc.desc: Get important enabled abilities when there is no installed ability.
981 */
982 HWTEST_F(AccessibilityAccountDataTest,
983 AccessibilityAccountData_Unittest_GetImportantEnabledAbilities_001, TestSize.Level1)
984 {
985 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_GetImportantEnabledAbilities_001 start";
986 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(0);
987 std::map<std::string, uint32_t> abilities;
988 accountData->GetImportantEnabledAbilities(abilities);
989 EXPECT_EQ(0, static_cast<int>(abilities.size()));
990 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_GetImportantEnabledAbilities_001 end";
991 }
992
993 /**
994 * @tc.number: AccessibilityAccountData_Unittest_GetImportantEnabledAbilities_002
995 * @tc.name: GetImportantEnabledAbilities
996 * @tc.desc: Get important enabled abilities when there is no enabled ability.
997 */
998 HWTEST_F(AccessibilityAccountDataTest,
999 AccessibilityAccountData_Unittest_GetImportantEnabledAbilities_002, TestSize.Level1)
1000 {
1001 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_GetImportantEnabledAbilities_002 start";
1002 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(0);
1003 AccessibilityAbilityInitParams initParams;
1004 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
1005 accountData->AddInstalledAbility(*abilityInfo);
1006
1007 std::map<std::string, uint32_t> abilities;
1008 accountData->GetImportantEnabledAbilities(abilities);
1009 EXPECT_EQ(0, static_cast<int>(abilities.size()));
1010 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_GetImportantEnabledAbilities_002 end";
1011 }
1012
1013 /**
1014 * @tc.number: AccessibilityAccountData_Unittest_GetImportantEnabledAbilities_003
1015 * @tc.name: GetImportantEnabledAbilities
1016 * @tc.desc: Get important enabled abilities.
1017 */
1018 HWTEST_F(AccessibilityAccountDataTest,
1019 AccessibilityAccountData_Unittest_GetImportantEnabledAbilities_003, TestSize.Level1)
1020 {
1021 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_GetImportantEnabledAbilities_003 start";
1022 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(0);
1023
1024 AccessibilityAbilityInitParams initParams;
1025 initParams.bundleName = "testBundle1";
1026 initParams.name = "testAbility1";
1027 initParams.isImportant = false;
1028 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
1029 accountData->AddInstalledAbility(*abilityInfo);
1030
1031 initParams.bundleName = "testBundle2";
1032 initParams.name = "testAbility2";
1033 initParams.isImportant = true;
1034 std::shared_ptr<AccessibilityAbilityInfo> importantAbilityInfo =
1035 std::make_shared<AccessibilityAbilityInfo>(initParams);
1036 accountData->AddInstalledAbility(*importantAbilityInfo);
1037
1038 accountData->AddEnabledAbility("testBundle1/testAbility1");
1039 accountData->AddEnabledAbility("testBundle2/testAbility2");
1040
1041 std::map<std::string, uint32_t> abilities;
1042 accountData->GetImportantEnabledAbilities(abilities);
1043 EXPECT_EQ(IMPORTANT_ABILITIES_SIZE, abilities.size());
1044 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_GetImportantEnabledAbilities_003 end";
1045 }
1046
1047 /**
1048 * @tc.number: AccessibilityAccountData_Unittest_UpdateImportantEnabledAbilities
1049 * @tc.name: UpdateImportantEnabledAbilities
1050 * @tc.desc: Update important enabled abilities.
1051 */
1052 HWTEST_F(AccessibilityAccountDataTest,
1053 AccessibilityAccountData_Unittest_UpdateImportantEnabledAbilities, TestSize.Level1)
1054 {
1055 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_UpdateImportantEnabledAbilities start";
1056 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(0);
1057
1058 std::map<std::string, uint32_t> abilities;
1059 accountData->UpdateImportantEnabledAbilities(abilities);
1060
1061 abilities.emplace(std::make_pair("testBundle/testAbility", CAPABILITY_RETRIEVE));
1062 accountData->UpdateImportantEnabledAbilities(abilities);
1063
1064 AccessibilityAbilityInitParams initParams;
1065 initParams.bundleName = "testBundle";
1066 initParams.name = "testAbility";
1067 initParams.isImportant = true;
1068 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
1069 abilityInfo->SetCapabilityValues(CAPABILITY_RETRIEVE | CAPABILITY_GESTURE);
1070 accountData->AddInstalledAbility(*abilityInfo);
1071
1072 accountData->UpdateImportantEnabledAbilities(abilities);
1073 ASSERT_EQ(1, static_cast<int>(accountData->GetInstalledAbilities().size()));
1074 EXPECT_EQ(accountData->GetInstalledAbilities().front().GetCapabilityValues(), CAPABILITY_RETRIEVE);
1075 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_UpdateImportantEnabledAbilities end";
1076 }
1077
1078 /**
1079 * @tc.number: AccessibilityAccountData_Unittest_UpdateAbilities_001
1080 * @tc.name: UpdateAbilities
1081 * @tc.desc: Update all abilities when there is an installed ability which is connecting.
1082 */
1083 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_UpdateAbilities_001, TestSize.Level1)
1084 {
1085 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_UpdateAbilities_001 start";
1086 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(0);
1087
1088 AccessibilityAbilityInitParams initParams;
1089 initParams.bundleName = "connectingBundle";
1090 initParams.name = "connectingAbility";
1091 std::shared_ptr<AccessibilityAbilityInfo> connectingAbilityInfo =
1092 std::make_shared<AccessibilityAbilityInfo>(initParams);
1093 accountData->AddInstalledAbility(*connectingAbilityInfo);
1094
1095 sptr<AccessibleAbilityConnection> connection = new MockAccessibleAbilityConnection(0, 0, *connectingAbilityInfo);
1096 accountData->AddConnectingA11yAbility("connectingBundle/connectingAbility", connection);
1097 accountData->UpdateAbilities();
1098 EXPECT_TRUE(accountData->GetConnectingA11yAbility("connectingBundle/connectingAbility"));
1099 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_UpdateAbilities_001 end";
1100 }
1101
1102 /**
1103 * @tc.number: AccessibilityAccountData_Unittest_UpdateAbilities_002
1104 * @tc.name: UpdateAbilities
1105 * @tc.desc: Update all abilities when there is an ability which is already connected.
1106 */
1107 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_UpdateAbilities_002, TestSize.Level1)
1108 {
1109 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_UpdateAbilities_002 start";
1110 auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
1111
1112 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>();
1113 accountData->AddInstalledAbility(*abilityInfo);
1114
1115 AppExecFwk::ElementName elementName("testDeviceId", "testBundle", "testAbility");
1116 sptr<AccessibleAbilityConnection> connection =
1117 new MockAccessibleAbilityConnection(accountData->GetAccountId(), 0, *abilityInfo);
1118 accountData->AddEnabledAbility(Utils::GetUri(connection->GetElementName()));
1119
1120 connection->Connect(elementName);
1121 accountData->AddConnectedAbility(connection);
1122 EXPECT_TRUE(accountData->GetAccessibleAbilityConnection(Utils::GetUri(connection->GetElementName())));
1123
1124 accountData->UpdateAbilities();
1125 EXPECT_TRUE(accountData->GetAccessibleAbilityConnection(Utils::GetUri(connection->GetElementName())));
1126 accountData->OnAccountSwitched();
1127 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_UpdateAbilities_002 end";
1128 }
1129
1130 /**
1131 * @tc.number: AccessibilityAccountData_Unittest_UpdateAbilities_003
1132 * @tc.name: UpdateAbilities
1133 * @tc.desc: Update all abilities when there is an enabled ability which is no connected.
1134 */
1135 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_UpdateAbilities_003, TestSize.Level1)
1136 {
1137 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_UpdateAbilities_003 start";
1138 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(0);
1139
1140 AccessibilityAbilityInitParams initParams;
1141 initParams.bundleName = "testBundle";
1142 initParams.name = "testAbility";
1143 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo =
1144 std::make_shared<AccessibilityAbilityInfo>(initParams);
1145 accountData->AddInstalledAbility(*abilityInfo);
1146
1147 accountData->AddEnabledAbility("testBundle/testAbility");
1148
1149 accountData->UpdateAbilities();
1150 EXPECT_TRUE(accountData->GetConnectingA11yAbility("testBundle/testAbility"));
1151 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_UpdateAbilities_003 end";
1152 }
1153
1154 /**
1155 * @tc.number: AccessibilityAccountData_Unittest_UpdateAbilities_004
1156 * @tc.name: UpdateAbilities
1157 * @tc.desc: Update all abilities when there is an connected ability which is no enabled.
1158 */
1159 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_UpdateAbilities_004, TestSize.Level1)
1160 {
1161 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_UpdateAbilities_004 start";
1162 auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
1163
1164 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>();
1165 accountData->AddInstalledAbility(*abilityInfo);
1166
1167 sptr<AccessibleAbilityConnection> connection =
1168 new MockAccessibleAbilityConnection(accountData->GetAccountId(), 0, *abilityInfo);
1169 AppExecFwk::ElementName elementName("testDeviceId", "testBundle", "testAbility");
1170 connection->Connect(elementName);
1171 accountData->AddConnectedAbility(connection);
1172 EXPECT_TRUE(accountData->GetAccessibleAbilityConnection(Utils::GetUri(connection->GetElementName())));
1173
1174 AccessibilityAbilityHelper::GetInstance().SetTestChannelId(0);
1175 EXPECT_EQ(AccessibilityAbilityHelper::GetInstance().GetTestChannelId(), 0);
1176
1177 accountData->UpdateAbilities();
1178 EXPECT_EQ(AccessibilityAbilityHelper::GetInstance().GetTestChannelId(), -1);
1179 accountData->OnAccountSwitched();
1180 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_UpdateAbilities_004 end";
1181 }
1182
1183 /**
1184 * @tc.number: AccessibilityAccountData_Unittest_RemoveAbility_001
1185 * @tc.name: RemoveAbility
1186 * @tc.desc: Remove ability when there is no ability
1187 */
1188 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_RemoveAbility_001, TestSize.Level1)
1189 {
1190 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_RemoveAbility_001 start";
1191 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(0);
1192 EXPECT_FALSE(accountData->RemoveAbility("bundle"));
1193 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_RemoveAbility_001 end";
1194 }
1195
1196 /**
1197 * @tc.number: AccessibilityAccountData_Unittest_RemoveAbility_002
1198 * @tc.name: RemoveAbility
1199 * @tc.desc: Remove ability successfully
1200 */
1201 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_RemoveAbility_002, TestSize.Level1)
1202 {
1203 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_RemoveAbility_002 start";
1204 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(0);
1205
1206 AccessibilityAbilityInitParams initParams;
1207 initParams.bundleName = "testBundle";
1208 initParams.name = "testAbility";
1209 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo =
1210 std::make_shared<AccessibilityAbilityInfo>(initParams);
1211 accountData->AddInstalledAbility(*abilityInfo);
1212
1213 accountData->AddEnabledAbility("testBundle/testAbility");
1214
1215 sptr<AccessibleAbilityConnection> connection = new MockAccessibleAbilityConnection(0, 0, *abilityInfo);
1216 accountData->AddConnectedAbility(connection);
1217
1218 EXPECT_TRUE(accountData->RemoveAbility("testBundle"));
1219 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_RemoveAbility_002 end";
1220 }
1221
1222 /**
1223 * @tc.number: AccessibilityAccountData_Unittest_ChangeAbility_001
1224 * @tc.name: ChangeAbility
1225 * @tc.desc: Change ability when there is no ability
1226 */
1227 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_ChangeAbility_001, TestSize.Level1)
1228 {
1229 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_ChangeAbility_001 start";
1230 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(0);
1231 accountData->ChangeAbility("bundle");
1232 EXPECT_EQ(0, static_cast<int>(accountData->GetInstalledAbilities().size()));
1233 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_ChangeAbility_001 end";
1234 }
1235
1236 /**
1237 * @tc.number: AccessibilityAccountData_Unittest_ChangeAbility_002
1238 * @tc.name: ChangeAbility
1239 * @tc.desc: Change ability which is not installed.
1240 */
1241 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_ChangeAbility_002, TestSize.Level1)
1242 {
1243 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_ChangeAbility_002 start";
1244 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(0);
1245
1246 AccessibilityAbilityInitParams initParams;
1247 initParams.bundleName = "testBundle";
1248 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo =
1249 std::make_shared<AccessibilityAbilityInfo>(initParams);
1250 accountData->AddInstalledAbility(*abilityInfo);
1251 EXPECT_EQ(1, static_cast<int>(accountData->GetInstalledAbilities().size()));
1252
1253 accountData->ChangeAbility("test");
1254 EXPECT_EQ(1, static_cast<int>(accountData->GetInstalledAbilities().size()));
1255 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_ChangeAbility_002 end";
1256 }
1257
1258 /**
1259 * @tc.number: AccessibilityAccountData_Unittest_AddUITestClient
1260 * @tc.name: AddUITestClient
1261 * @tc.desc: Add ui test client
1262 */
1263 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_AddUITestClient, TestSize.Level1)
1264 {
1265 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_AddUITestClient start";
1266 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(0);
1267 accountData->AddUITestClient(nullptr, "uitestBundle", "uitestAbility");
1268 EXPECT_EQ(1, static_cast<int>(accountData->GetInstalledAbilities().size()));
1269 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_AddUITestClient end";
1270 }
1271
1272 /**
1273 * @tc.number: AccessibilityAccountData_Unittest_RemoveUITestClient_001
1274 * @tc.name: RemoveUITestClient
1275 * @tc.desc: Remove ui test client failed.
1276 */
1277 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_RemoveUITestClient_001, TestSize.Level1)
1278 {
1279 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_RemoveUITestClient_001 start";
1280 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(0);
1281 accountData->AddUITestClient(nullptr, "uitestBundle", "uitestAbility");
1282 EXPECT_EQ(1, static_cast<int>(accountData->GetInstalledAbilities().size()));
1283
1284 sptr<AccessibleAbilityConnection> connection = nullptr;
1285 accountData->RemoveUITestClient(connection, "uitestBundle");
1286 EXPECT_EQ(1, static_cast<int>(accountData->GetInstalledAbilities().size()));
1287 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_RemoveUITestClient_001 end";
1288 }
1289
1290 /**
1291 * @tc.number: AccessibilityAccountData_Unittest_RemoveUITestClient_002
1292 * @tc.name: RemoveUITestClient
1293 * @tc.desc: Remove ui test client successfully.
1294 */
1295 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_RemoveUITestClient_002, TestSize.Level1)
1296 {
1297 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_RemoveUITestClient_002 start";
1298 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(0);
1299
1300 AccessibilityAbilityInitParams initParams;
1301 initParams.bundleName = "uitestBundle";
1302 initParams.name = "uitestAbility";
1303 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
1304 sptr<AccessibleAbilityConnection> connection = new MockAccessibleAbilityConnection(0, 0, *abilityInfo);
1305
1306 accountData->AddUITestClient(nullptr, "uitestBundle", "uitestAbility");
1307 EXPECT_EQ(1, static_cast<int>(accountData->GetInstalledAbilities().size()));
1308
1309 accountData->RemoveUITestClient(connection, "uitestBundle");
1310 EXPECT_EQ(0, static_cast<int>(accountData->GetInstalledAbilities().size()));
1311 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_RemoveUITestClient_002 end";
1312 }
1313
1314 /**
1315 * @tc.number: AccessibilityAccountData_Unittest_CaptionPropertyCallback
1316 * @tc.name: CaptionPropertyCallback
1317 * @tc.desc: Check the functions of AddCaptionPropertyCallback and RemoveCaptionPropertyCallback.
1318 */
1319 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_CaptionPropertyCallback, TestSize.Level1)
1320 {
1321 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_CaptionPropertyCallback start";
1322 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(0);
1323 sptr<AccessibleAbilityManagerCaptionObserverStub> stub = new MockAccessibleAbilityManagerCaptionObserverStub();
1324 sptr<IAccessibleAbilityManagerCaptionObserver> caption =
1325 new MockAccessibleAbilityManagerCaptionObserverProxy(stub);
1326 EXPECT_EQ(0, static_cast<int>(accountData->GetCaptionPropertyCallbacks().size()));
1327
1328 accountData->AddCaptionPropertyCallback(caption);
1329 EXPECT_EQ(1, static_cast<int>(accountData->GetCaptionPropertyCallbacks().size()));
1330
1331 accountData->RemoveCaptionPropertyCallback(caption->AsObject());
1332 EXPECT_EQ(0, static_cast<int>(accountData->GetCaptionPropertyCallbacks().size()));
1333
1334 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_CaptionPropertyCallback end";
1335 }
1336
1337 /**
1338 * @tc.number: AccessibilityAccountData_Unittest_EnableAbilityListsObserver
1339 * @tc.name: EnableAbilityListsObserver
1340 * @tc.desc: Check the functions of AddEnableAbilityListsObserver and RemoveEnableAbilityListsObserver.
1341 */
1342 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_EnableAbilityListsObserver, TestSize.Level1)
1343 {
1344 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_EnableAbilityListsObserver start";
1345 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(0);
1346 sptr<AccessibilityEnableAbilityListsObserverStub> stub = new MockAccessibilityEnableAbilityListsObserverStub();
1347 sptr<IAccessibilityEnableAbilityListsObserver> observer =
1348 new MockAccessibilityEnableAbilityListsObserverProxy(stub);
1349
1350 accountData->AddEnableAbilityListsObserver(observer);
1351 accountData->AddEnableAbilityListsObserver(observer);
1352 accountData->RemoveEnableAbilityListsObserver(observer->AsObject());
1353
1354 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_EnableAbilityListsObserver end";
1355 }
1356
1357 /**
1358 * @tc.number: AccessibilityAccountData_Unittest_ConfigCallback
1359 * @tc.name: ConfigCallback
1360 * @tc.desc: Check the functions of AddConfigCallback and RemoveConfigCallback.
1361 */
1362 HWTEST_F(AccessibilityAccountDataTest, AccessibilityAccountData_Unittest_ConfigCallback, TestSize.Level1)
1363 {
1364 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_ConfigCallback start";
1365 sptr<AccessibilityAccountData> accountData = new AccessibilityAccountData(0);
1366 sptr<AccessibleAbilityManagerConfigObserverStub> stub = new MockAccessibleAbilityManagerConfigObserverStub();
1367 sptr<IAccessibleAbilityManagerConfigObserver> observer = new MockAccessibleAbilityManagerConfigObserverProxy(stub);
1368 EXPECT_EQ(0, static_cast<int>(accountData->GetConfigCallbacks().size()));
1369
1370 accountData->AddConfigCallback(observer);
1371 EXPECT_EQ(1, static_cast<int>(accountData->GetConfigCallbacks().size()));
1372
1373 accountData->RemoveConfigCallback(observer->AsObject());
1374 EXPECT_EQ(0, static_cast<int>(accountData->GetConfigCallbacks().size()));
1375
1376 GTEST_LOG_(INFO) << "AccessibilityAccountData_Unittest_ConfigCallback end";
1377 }
1378 } // namespace Accessibility
1379 } // namespace OHOS