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 <cstdio>
17 #include <gtest/gtest.h>
18 #include "accessibility_common_helper.h"
19 #include "accessibility_element_operator_proxy.h"
20 #include "accessibility_element_operator_stub.h"
21 #include "accessibility_ut_helper.h"
22 #include "accessible_ability_connection.h"
23 #include "accessible_ability_manager_service.h"
24 #include "iservice_registry.h"
25 #include "mock_accessibility_account_data.h"
26 #include "mock_accessibility_element_operator_proxy.h"
27 #include "mock_accessibility_element_operator_stub.h"
28 #include "mock_accessible_ability_client_stub_impl.h"
29 #include "mock_accessible_ability_manager_service.h"
30 #include "mock_bundle_manager.h"
31 #include "utils.h"
32
33 using namespace testing;
34 using namespace testing::ext;
35
36 namespace OHOS {
37 namespace Accessibility {
38 namespace {
39 constexpr uint32_t SLEEP_TIME_2 = 2;
40 constexpr int32_t CHANNEL_ID = 2;
41 constexpr int32_t INVALID_ACCOUNT_ID = -1;
42 } // namespace
43
44 class AccessibleAbilityConnectionUnitTest : public ::testing::Test {
45 public:
AccessibleAbilityConnectionUnitTest()46 AccessibleAbilityConnectionUnitTest()
47 {}
~AccessibleAbilityConnectionUnitTest()48 ~AccessibleAbilityConnectionUnitTest()
49 {}
50
51 static void SetUpTestCase();
52 static void TearDownTestCase();
53 void SetUp() override;
54 void TearDown() override;
55
56 sptr<AccessibleAbilityConnection> connection_ = nullptr;
57 sptr<AppExecFwk::ElementName> elementName_ = nullptr;
58 sptr<IRemoteObject> obj_ = nullptr;
59 sptr<AccessibilityAccountData> accountData_ = nullptr;
60 };
61
SetUpTestCase()62 void AccessibleAbilityConnectionUnitTest::SetUpTestCase()
63 {
64 GTEST_LOG_(INFO) << "###################### AccessibleAbilityConnectionUnitTest Start ######################";
65 Singleton<AccessibleAbilityManagerService>::GetInstance().OnStart();
66 AccessibilityCommonHelper::GetInstance().WaitForServicePublish();
67 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(AccessibilityAbilityHelper::accountId_);
68 }
69
TearDownTestCase()70 void AccessibleAbilityConnectionUnitTest::TearDownTestCase()
71 {
72 GTEST_LOG_(INFO) << "###################### AccessibleAbilityConnectionUnitTest End ######################";
73 Singleton<AccessibleAbilityManagerService>::GetInstance().OnStop();
74 }
75
SetUp()76 void AccessibleAbilityConnectionUnitTest::SetUp()
77 {
78 GTEST_LOG_(INFO) << "SetUp";
79 // new Interaction proxy
80 sptr<AccessibilityElementOperatorStub> stub = new MockAccessibilityElementOperatorStub();
81 sptr<IAccessibilityElementOperator> proxy = new MockAccessibilityElementOperatorProxy(stub);
82 sptr<AccessibilityWindowConnection> connection = new AccessibilityWindowConnection(0, proxy, 0);
83
84 // new AAconnection
85 AccessibilityAbilityInitParams initParams;
86 initParams.abilityTypes = ACCESSIBILITY_ABILITY_TYPE_ALL;
87 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
88 abilityInfo->SetEventTypes(EventType::TYPES_ALL_MASK);
89 accountData_ = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
90 if (accountData_ != nullptr) {
91 accountData_->AddAccessibilityWindowConnection(0, connection);
92 }
93 connection_ = new AccessibleAbilityConnection(AccessibilityAbilityHelper::accountId_, 0, *abilityInfo);
94 elementName_ = new AppExecFwk::ElementName("1", "2", "3");
95 obj_ = new IPCObjectProxy(0);
96 if (obj_ != nullptr && connection_ != nullptr) {
97 connection_->OnAbilityConnectDoneSync(*elementName_, obj_);
98 }
99 }
100
TearDown()101 void AccessibleAbilityConnectionUnitTest::TearDown()
102 {
103 GTEST_LOG_(INFO) << "TearDown";
104 AccessibilityAbilityHelper::GetInstance().SetTestChannelId(INVALID_CHANNEL_ID);
105 if (accountData_) {
106 accountData_->RemoveAccessibilityWindowConnection(0);
107 }
108
109 if (connection_) {
110 connection_->OnAbilityDisconnectDoneSync(*elementName_);
111 }
112 connection_ = nullptr;
113 elementName_ = nullptr;
114 obj_ = nullptr;
115 accountData_ = nullptr;
116 }
117
118 /**
119 * @tc.number: AccessibleAbilityConnection_Unittest_OnRemoteDied_001
120 * @tc.name: OnRemoteDied
121 * @tc.desc: Test function OnRemoteDied
122 */
123 HWTEST_F(AccessibleAbilityConnectionUnitTest, AccessibleAbilityConnection_Unittest_OnRemoteDied_001, TestSize.Level1)
124 {
125 GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_OnRemoteDied_001 start";
126 if (connection_ && obj_) {
127 std::string uri = Utils::GetUri(*elementName_);
128 accountData_->AddEnabledAbility(uri);
129 EXPECT_EQ(1, accountData_->GetEnabledAbilities().size());
130 IPCObjectProxy* proxy = static_cast<IPCObjectProxy*>(obj_.GetRefPtr());
131 proxy->SendObituary();
132 sleep(1);
133 }
134 GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_OnRemoteDied_001 end";
135 }
136
137 /**
138 * @tc.number: AccessibleAbilityConnection_Unittest_GetAbilityInfo_001
139 * @tc.name: GetAbilityInfo
140 * @tc.desc: Test function GetAbilityInfo
141 */
142 HWTEST_F(AccessibleAbilityConnectionUnitTest, AccessibleAbilityConnection_Unittest_GetAbilityInfo_001, TestSize.Level1)
143 {
144 GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_GetAbilityInfo_001 start";
145 if (connection_ != nullptr) {
146 auto abilityInfo = connection_->GetAbilityInfo();
147 auto abilities = abilityInfo.GetAccessibilityAbilityType();
148 EXPECT_EQ(abilities, ACCESSIBILITY_ABILITY_TYPE_ALL);
149 }
150 GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_GetAbilityInfo_001 end";
151 }
152
153 /**
154 * @tc.number: AccessibleAbilityConnection_Unittest_GetElementName_001
155 * @tc.name: GetElementName
156 * @tc.desc: Test function GetElementName
157 */
158 HWTEST_F(AccessibleAbilityConnectionUnitTest, AccessibleAbilityConnection_Unittest_GetElementName_001, TestSize.Level1)
159 {
160 GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_GetElementName_001 start";
161 if (connection_ != nullptr) {
162 auto elementName = connection_->GetElementName();
163 auto ret = elementName.GetDeviceID();
164 EXPECT_STREQ(ret.c_str(), "1");
165 }
166 GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_GetElementName_001 end";
167 }
168
169 /**
170 * @tc.number: AccessibleAbilityConnection_Unittest_GetAbilityClient_001
171 * @tc.name: GetAbilityClient
172 * @tc.desc: Test function GetAbilityClient
173 */
174 HWTEST_F(
175 AccessibleAbilityConnectionUnitTest, AccessibleAbilityConnection_Unittest_GetAbilityClient_001, TestSize.Level1)
176 {
177 GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_GetProxy_001 start";
178 if (connection_ != nullptr) {
179 auto ret = connection_->GetAbilityClient();
180 EXPECT_TRUE(ret);
181 }
182 GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_GetProxy_001 end";
183 }
184
185 /**
186 * @tc.number: AccessibleAbilityConnection_Unittest_OnAccessibilityEvent_001
187 * @tc.name: OnAccessibilityEvent
188 * @tc.desc: Test function OnAccessibilityEvent
189 */
190 HWTEST_F(
191 AccessibleAbilityConnectionUnitTest, AccessibleAbilityConnection_Unittest_OnAccessibilityEvent_001, TestSize.Level1)
192 {
193 GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_OnAccessibilityEvent_001 start";
194 if (connection_ != nullptr) {
195 AccessibilityEventInfo eventInfo;
196 /* EventType is in the allowed list */
197 eventInfo.SetEventType(EventType::TYPE_PAGE_STATE_UPDATE);
198 sleep(SLEEP_TIME_2);
199 connection_->OnAccessibilityEvent(eventInfo);
200 sleep(SLEEP_TIME_2);
201 EXPECT_EQ(int(EventType::TYPE_PAGE_STATE_UPDATE), AccessibilityAbilityHelper::GetInstance().GetTestEventType());
202 }
203 GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_OnAccessibilityEvent_001 end";
204 }
205
206 /**
207 * @tc.number: AccessibleAbilityConnection_Unittest_OnAccessibilityEvent_002
208 * @tc.name: OnAccessibilityEvent
209 * @tc.desc: Test function OnAccessibilityEvent
210 */
211 HWTEST_F(
212 AccessibleAbilityConnectionUnitTest, AccessibleAbilityConnection_Unittest_OnAccessibilityEvent_002, TestSize.Level1)
213 {
214 GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_OnAccessibilityEvent_002 start";
215 if (connection_ != nullptr) {
216 AccessibilityEventInfo eventInfo;
217 /* EventType is in the allowed list */
218 eventInfo.SetEventType(EventType::TYPE_VIEW_CLICKED_EVENT);
219 /* invalid window */
220 eventInfo.SetWindowId(3);
221 sleep(SLEEP_TIME_2);
222 connection_->OnAccessibilityEvent(eventInfo);
223 sleep(SLEEP_TIME_2);
224 EXPECT_EQ(1, AccessibilityAbilityHelper::GetInstance().GetTestEventType());
225 }
226 GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_OnAccessibilityEvent_002 end";
227 }
228
229 /**
230 * @tc.number: AccessibleAbilityConnection_Unittest_OnAccessibilityEvent_003
231 * @tc.name: OnAccessibilityEvent
232 * @tc.desc: Test function OnAccessibilityEvent
233 */
234 HWTEST_F(
235 AccessibleAbilityConnectionUnitTest, AccessibleAbilityConnection_Unittest_OnAccessibilityEvent_003, TestSize.Level1)
236 {
237 GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_OnAccessibilityEvent_003 start";
238 if (connection_ != nullptr) {
239 AccessibilityEventInfo eventInfo;
240 /* EventType is not in the allowed list */
241 eventInfo.SetEventType(TYPE_VIEW_INVALID);
242 sleep(SLEEP_TIME_2);
243 connection_->OnAccessibilityEvent(eventInfo);
244 sleep(SLEEP_TIME_2);
245 EXPECT_EQ(0, AccessibilityAbilityHelper::GetInstance().GetTestEventType());
246 }
247 GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_OnAccessibilityEvent_003 end";
248 }
249
250 /**
251 * @tc.number: AccessibleAbilityConnection_Unittest_OnAccessibilityEvent_004
252 * @tc.name: OnAccessibilityEvent
253 * @tc.desc: Test function OnAccessibilityEvent
254 */
255 HWTEST_F(
256 AccessibleAbilityConnectionUnitTest, AccessibleAbilityConnection_Unittest_OnAccessibilityEvent_004, TestSize.Level1)
257 {
258 GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_OnAccessibilityEvent_004 start";
259 AccessibilityAbilityInitParams initParams;
260 initParams.abilityTypes = ACCESSIBILITY_ABILITY_TYPE_ALL;
261 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
262 abilityInfo->SetEventTypes(EventType::TYPES_ALL_MASK);
263 sptr<AccessibleAbilityConnection> connection =
264 new AccessibleAbilityConnection(AccessibilityAbilityHelper::accountId_, 0, *abilityInfo);
265 if (connection != nullptr) {
266 AccessibilityEventInfo eventInfo;
267 /* EventType is not in the allowed list */
268 eventInfo.SetEventType(TYPE_VIEW_INVALID);
269 sleep(SLEEP_TIME_2);
270 connection->OnAccessibilityEvent(eventInfo);
271 sleep(SLEEP_TIME_2);
272 EXPECT_EQ(0, AccessibilityAbilityHelper::GetInstance().GetTestEventType());
273 }
274 GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_OnAccessibilityEvent_004 end";
275 }
276
277 /**
278 * @tc.number: AccessibleAbilityConnection_Unittest_OnAccessibilityEvent_005
279 * @tc.name: OnAccessibilityEvent
280 * @tc.desc: Test function OnAccessibilityEvent
281 */
282 HWTEST_F(
283 AccessibleAbilityConnectionUnitTest, AccessibleAbilityConnection_Unittest_OnAccessibilityEvent_005, TestSize.Level1)
284 {
285 GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_OnAccessibilityEvent_005 start";
286
287 // new AAconnection
288 AccessibilityAbilityInitParams initParams;
289 initParams.abilityTypes = ACCESSIBILITY_ABILITY_TYPE_ALL;
290 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
291 abilityInfo->SetEventTypes(EventType::TYPE_VIEW_INVALID);
292
293 sptr<AccessibleAbilityConnection> connection = new AccessibleAbilityConnection(
294 AccessibilityAbilityHelper::accountId_, 0, *abilityInfo);
295 sptr<AppExecFwk::ElementName> elementName = new AppExecFwk::ElementName("1", "2", "3");
296 sptr<IRemoteObject> obj = new IPCObjectProxy(0);
297 if (obj != nullptr && connection != nullptr) {
298 connection->OnAbilityConnectDoneSync(*elementName, obj);
299 }
300
301 if (connection != nullptr) {
302 AccessibilityEventInfo eventInfo;
303 /* EventType is not in the allowed list */
304 AccessibilityAbilityHelper::GetInstance().SetTestEventType(-1);
305 eventInfo.SetEventType(TYPE_VIEW_CLICKED_EVENT);
306 sleep(SLEEP_TIME_2);
307 connection->OnAccessibilityEvent(eventInfo);
308 sleep(SLEEP_TIME_2);
309 EXPECT_EQ(-1, AccessibilityAbilityHelper::GetInstance().GetTestEventType());
310 }
311
312 AccessibilityAbilityHelper::GetInstance().SetTestChannelId(INVALID_CHANNEL_ID);
313 if (accountData_) {
314 accountData_->RemoveAccessibilityWindowConnection(0);
315 }
316
317 if (connection) {
318 connection->OnAbilityDisconnectDoneSync(*elementName);
319 }
320 connection = nullptr;
321 elementName = nullptr;
322 obj = nullptr;
323 GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_OnAccessibilityEvent_005 end";
324 }
325
326 /**
327 * @tc.number: AccessibleAbilityConnection_Unittest_OnAbilityDisconnectDoneSync_001
328 * @tc.name: OnAbilityDisconnectDoneSync
329 * @tc.desc: Test function OnAbilityDisconnectDoneSync
330 */
331 HWTEST_F(AccessibleAbilityConnectionUnitTest,
332 AccessibleAbilityConnection_Unittest_OnAbilityDisconnectDoneSync_001, TestSize.Level1)
333 {
334 GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_OnAbilityDisconnectDoneSync_001 start";
335 // new AAconnection
336 AccessibilityAbilityInitParams initParams;
337 initParams.abilityTypes = ACCESSIBILITY_ABILITY_TYPE_ALL;
338 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
339 abilityInfo->SetEventTypes(EventType::TYPES_ALL_MASK);
340 sptr<AccessibleAbilityConnection> connection =
341 new AccessibleAbilityConnection(AccessibilityAbilityHelper::accountId_, 0, *abilityInfo);
342 if (connection != nullptr) {
343 AccessibilityEventInfo eventInfo;
344 /* EventType is not in the allowed list */
345 eventInfo.SetEventType(TYPE_VIEW_INVALID);
346 sleep(SLEEP_TIME_2);
347 connection->OnAbilityDisconnectDoneSync(*elementName_);
348 }
349 GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_OnAbilityDisconnectDoneSync_001 end";
350 }
351
352 /**
353 * @tc.number: AccessibleAbilityConnection_Unittest_Connect_001
354 * @tc.name: Connect
355 * @tc.desc: Test function Connect
356 */
357 HWTEST_F(AccessibleAbilityConnectionUnitTest, AccessibleAbilityConnection_Unittest_Connect_001, TestSize.Level1)
358 {
359 GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_Connect_001 start";
360 if (connection_ != nullptr) {
361 AppExecFwk::ElementName element("deviceId", "bundleName", "abilityName");
362 connection_->Connect(element);
363 sptr<AccessibleAbilityClientStub> obj = new MockAccessibleAbilityClientStubImpl();
364 connection_->OnAbilityConnectDoneSync(element, obj);
365 EXPECT_TRUE(accountData_->GetAccessibleAbilityConnection(Utils::GetUri(
366 element.GetBundleName(), element.GetAbilityName())));
367 }
368 GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_Connect_001 end";
369 }
370
371 /**
372 * @tc.number: AccessibleAbilityConnection_Unittest_Disconnect_001
373 * @tc.name: Disconnect
374 * @tc.desc: Test function Disconnect
375 */
376 HWTEST_F(AccessibleAbilityConnectionUnitTest, AccessibleAbilityConnection_Unittest_Disconnect_001, TestSize.Level1)
377 {
378 GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_Disconnect_001 start";
379 if (connection_ != nullptr) {
380 connection_->Disconnect();
381 EXPECT_EQ(AccessibilityAbilityHelper::GetInstance().GetTestChannelId(), 0);
382 }
383 GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_Reset_001 end";
384 }
385
386 /**
387 * @tc.number: AccessibleAbilityConnection_Unittest_OnAbilityConnectDone_001
388 * @tc.name: OnAbilityConnectDone
389 * @tc.desc: Test function OnAbilityConnectDone
390 */
391 HWTEST_F(AccessibleAbilityConnectionUnitTest,
392 AccessibleAbilityConnection_Unittest_OnAbilityConnectDone_001, TestSize.Level1)
393 {
394 GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_OnAbilityConnectDone_001 start";
395 auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
396 ASSERT_TRUE(accountData);
397
398 sptr<AppExecFwk::ElementName> elementName = new AppExecFwk::ElementName("device", "bundle", "ability");
399 accountData->AddEnabledAbility(Utils::GetUri(*elementName));
400 EXPECT_EQ(static_cast<int>(accountData->GetEnabledAbilities().size()), 1);
401
402 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>();
403 sptr<AccessibleAbilityConnection> connection = new AccessibleAbilityConnection(
404 Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountId(), 0, *abilityInfo);
405 accountData->AddConnectingA11yAbility(Utils::GetUri(*elementName), connection);
406 EXPECT_TRUE(accountData->GetConnectingA11yAbility(Utils::GetUri(*elementName)));
407
408 ASSERT_TRUE(connection);
409 sptr<AccessibleAbilityClientStub> client = new MockAccessibleAbilityClientStubImpl();
410 connection->OnAbilityConnectDone(*elementName, client, 1);
411
__anon7ba9b83c0202() 412 bool ret = AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([=]() -> bool {
413 auto &aams = Singleton<AccessibleAbilityManagerService>::GetInstance();
414 if (static_cast<int>(accountData->GetEnabledAbilities().size()) == 0 &&
415 !(accountData->GetConnectingA11yAbility(Utils::GetUri(*elementName)))) {
416 return true;
417 } else {
418 return false;
419 }
420 }), 1);
421 EXPECT_TRUE(ret);
422 GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_OnAbilityConnectDone_001 end";
423 }
424
425 /**
426 * @tc.number: AccessibleAbilityConnection_Unittest_OnAbilityConnectDone_002
427 * @tc.name: OnAbilityConnectDone
428 * @tc.desc: Test function OnAbilityConnectDone
429 */
430 HWTEST_F(AccessibleAbilityConnectionUnitTest,
431 AccessibleAbilityConnection_Unittest_OnAbilityConnectDone_002, TestSize.Level1)
432 {
433 GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_OnAbilityConnectDone_002 start";
434 auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
435 ASSERT_TRUE(accountData);
436
437 // add aa client
438 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>();
439 sptr<AccessibleAbilityConnection> connection = new AccessibleAbilityConnection(
440 Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountId(), CHANNEL_ID, *abilityInfo);
441 sptr<AppExecFwk::ElementName> name = new AppExecFwk::ElementName("device", "bundle", "ability");
442 accountData->AddConnectingA11yAbility(Utils::GetUri(*name), connection);
443 EXPECT_TRUE(accountData->GetConnectingA11yAbility(Utils::GetUri(*name)));
444
445 ASSERT_TRUE(connection);
446 sptr<AccessibleAbilityClientStub> client = new MockAccessibleAbilityClientStubImpl();
447 connection->OnAbilityConnectDone(*name, client, NO_ERROR);
448
__anon7ba9b83c0302() 449 bool ret = AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([=]() -> bool {
450 if (AccessibilityAbilityHelper::GetInstance().GetTestChannelId() == CHANNEL_ID) {
451 return true;
452 } else {
453 return false;
454 }
455 }), 1);
456 EXPECT_TRUE(ret);
457 GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_OnAbilityConnectDone_002 end";
458 }
459
460 /**
461 * @tc.number: AccessibleAbilityConnection_Unittest_OnAbilityConnectDone_003
462 * @tc.name: OnAbilityConnectDone
463 * @tc.desc: Test function OnAbilityConnectDone
464 */
465 HWTEST_F(AccessibleAbilityConnectionUnitTest,
466 AccessibleAbilityConnection_Unittest_OnAbilityConnectDone_003, TestSize.Level1)
467 {
468 GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_OnAbilityConnectDone_003 start";
469 auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
470 ASSERT_TRUE(accountData);
471 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>();
472 sptr<AccessibleAbilityConnection> connection = new AccessibleAbilityConnection(
473 accountData->GetAccountId(), CHANNEL_ID, *abilityInfo);
474 sptr<AppExecFwk::ElementName> elementName = new AppExecFwk::ElementName("device", "bundle", "ability");
475 accountData->AddConnectingA11yAbility(Utils::GetUri(*elementName), connection);
476 EXPECT_TRUE(accountData->GetConnectingA11yAbility(Utils::GetUri(*elementName)));
477 connection->OnAbilityConnectDone(*elementName, nullptr, NO_ERROR);
478 sleep(SLEEP_TIME_2);
__anon7ba9b83c0402() 479 bool ret = AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([=]() -> bool {
480 auto &aams = Singleton<AccessibleAbilityManagerService>::GetInstance();
481 if (accountData->GetConnectingA11yAbility(Utils::GetUri(*elementName))) {
482 return true;
483 } else {
484 return false;
485 }
486 }), 1);
487 EXPECT_TRUE(ret);
488 GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_OnAbilityConnectDone_003 end";
489 }
490
491 /**
492 * @tc.number: AccessibleAbilityConnection_Unittest_OnAbilityConnectDone_004
493 * @tc.name: OnAbilityConnectDone
494 * @tc.desc: Test function OnAbilityConnectDone
495 */
496 HWTEST_F(AccessibleAbilityConnectionUnitTest,
497 AccessibleAbilityConnection_Unittest_OnAbilityConnectDone_004, TestSize.Level1)
498 {
499 GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_OnAbilityConnectDone_004 start";
500 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>();
501 sptr<AccessibleAbilityConnection> connection = new AccessibleAbilityConnection(
502 INVALID_ACCOUNT_ID, CHANNEL_ID, *abilityInfo);
503 sptr<AppExecFwk::ElementName> elementName = new AppExecFwk::ElementName("device", "bundle", "ability");
504
505 EXPECT_FALSE(Singleton<AccessibleAbilityManagerService>::GetInstance().GetAccountData(INVALID_ACCOUNT_ID));
506 connection->OnAbilityConnectDone(*elementName, nullptr, NO_ERROR);
507 sleep(SLEEP_TIME_2);
508
__anon7ba9b83c0502() 509 bool ret = AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([=]() -> bool {
510 auto &aams = Singleton<AccessibleAbilityManagerService>::GetInstance();
511 if (static_cast<int>(accountData_->GetEnabledAbilities().size()) == 0 &&
512 accountData_->GetConnectingA11yAbility(Utils::GetUri(*elementName))) {
513 return true;
514 } else {
515 return false;
516 }
517 }), 1);
518 EXPECT_TRUE(ret);
519 GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_OnAbilityConnectDone_004 end";
520 }
521
522 /**
523 * @tc.number: AccessibleAbilityConnection_Unittest_OnAbilityConnectDone_005
524 * @tc.name: OnAbilityConnectDone
525 * @tc.desc: Test function OnAbilityConnectDone
526 */
527 HWTEST_F(AccessibleAbilityConnectionUnitTest,
528 AccessibleAbilityConnection_Unittest_OnAbilityConnectDone_005, TestSize.Level1)
529 {
530 GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_OnAbilityConnectDone_005 start";
531 auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
532 ASSERT_TRUE(accountData);
533
534 // add aa client
535 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>();
536 sptr<AccessibleAbilityConnection> connection = new AccessibleAbilityConnection(
537 Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountId(), CHANNEL_ID, *abilityInfo);
538 sptr<AppExecFwk::ElementName> name =
539 new AppExecFwk::ElementName("clientDevice", "clientBundleName", "clientAbilityName");
540 sptr<AccessibleAbilityClientStub> client = new MockAccessibleAbilityClientStubImpl();
541
542 connection->OnAbilityConnectDone(*name, client, NO_ERROR);
543 sleep(SLEEP_TIME_2);
544
__anon7ba9b83c0602() 545 bool ret = AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([=]() -> bool {
546 auto &aams = Singleton<AccessibleAbilityManagerService>::GetInstance();
547 if (static_cast<int>(accountData->GetEnabledAbilities().size()) == 0 &&
548 !(accountData->GetConnectingA11yAbility(Utils::GetUri(*name)))) {
549 return true;
550 } else {
551 return false;
552 }
553 }), 1);
554 EXPECT_TRUE(ret);
555 GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_OnAbilityConnectDone_005 end";
556 }
557
558 /**
559 * @tc.number: AccessibleAbilityConnection_Unittest_OnAbilityDisconnectDone_001
560 * @tc.name: OnAbilityDisconnectDone
561 * @tc.desc: Test function OnAbilityDisconnectDone
562 */
563 HWTEST_F(AccessibleAbilityConnectionUnitTest,
564 AccessibleAbilityConnection_Unittest_OnAbilityDisconnectDone_001, TestSize.Level1)
565 {
566 GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_OnAbilityDisconnectDone_001 start";
567 ASSERT_TRUE(connection_);
568 AppExecFwk::ElementName element;
569 connection_->OnAbilityDisconnectDone(element, 0);
570 GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_OnAbilityDisconnectDone_001 end";
571 }
572
573 /**
574 * @tc.number: AccessibleAbilityConnection_Unittest_OnKeyPressEvent_001
575 * @tc.name: OnKeyPressEvent
576 * @tc.desc: Test function OnKeyPressEvent
577 */
578 HWTEST_F(AccessibleAbilityConnectionUnitTest,
579 AccessibleAbilityConnection_Unittest_OnKeyPressEvent_001, TestSize.Level1)
580 {
581 GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_OnKeyPressEvent_001 start";
582 auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
583 ASSERT_TRUE(accountData);
584
585 // add aa client
586 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>();
587 abilityInfo->SetCapabilityValues(0);
588 sptr<AccessibleAbilityConnection> connection = new AccessibleAbilityConnection(
589 accountData->GetAccountId(), CHANNEL_ID, *abilityInfo);
590 ASSERT_TRUE(connection);
591 AppExecFwk::ElementName element("deviceId", "bundleName", "abilityName");
592 sptr<AccessibleAbilityClientStub> obj = new MockAccessibleAbilityClientStubImpl();
593 connection->OnAbilityConnectDoneSync(element, obj);
594 EXPECT_EQ(AccessibilityAbilityHelper::GetInstance().GetTestChannelId(), CHANNEL_ID);
595
596 std::shared_ptr<MMI::KeyEvent> keyEvent = MMI::KeyEvent::Create();
597 EXPECT_FALSE(connection_->OnKeyPressEvent(*keyEvent, 0));
598 GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_OnKeyPressEvent_001 end";
599 }
600
601 /**
602 * @tc.number: AccessibleAbilityConnection_Unittest_SetAbilityInfoTargetBundleName_001
603 * @tc.name: SetAbilityInfoTargetBundleName
604 * @tc.desc: Test function SetAbilityInfoTargetBundleName.
605 */
606 HWTEST_F(AccessibleAbilityConnectionUnitTest,
607 AccessibleAbilityConnection_Unittest_SetAbilityInfoTargetBundleName_001, TestSize.Level1)
608 {
609 GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_SetAbilityInfoTargetBundleName_001 start";
610 ASSERT_TRUE(connection_);
611 std::vector<std::string> targetBundleNames;
612 targetBundleNames.push_back("target");
613 connection_->SetAbilityInfoTargetBundleName(targetBundleNames);
614 ASSERT_EQ(static_cast<int>(connection_->GetAbilityInfo().GetFilterBundleNames().size()), 1);
615 EXPECT_STREQ(connection_->GetAbilityInfo().GetFilterBundleNames().front().c_str(), "target");
616 GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_SetAbilityInfoTargetBundleName_001 end";
617 }
618
619 /**
620 * @tc.number: AccessibleAbilityConnection_Unittest_GetChannelId_001
621 * @tc.name: GetChannelId
622 * @tc.desc: Test function GetChannelId.
623 */
624 HWTEST_F(AccessibleAbilityConnectionUnitTest,
625 AccessibleAbilityConnection_Unittest_GetChannelId_001, TestSize.Level1)
626 {
627 GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_GetChannelId_001 start";
628 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>();
629 sptr<AccessibleAbilityConnection> connection = new AccessibleAbilityConnection(0, CHANNEL_ID, *abilityInfo);
630 EXPECT_EQ(connection->GetChannelId(), CHANNEL_ID);
631 GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_GetChannelId_001 end";
632 }
633 } // namespace Accessibility
634 } // namespace OHOS