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();
__anone60ffe920202() 132         bool ret = AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([=]() -> bool {
133             size_t count = accountData_->GetEnabledAbilities().size();
134             auto &aams = Singleton<AccessibleAbilityManagerService>::GetInstance();
135             if (count == 0) {
136                 return true;
137             } else {
138                 return false;
139             }
140             }), 1);
141         EXPECT_TRUE(ret);
142     }
143     GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_OnRemoteDied_001 end";
144 }
145 
146 /**
147  * @tc.number: AccessibleAbilityConnection_Unittest_GetAbilityInfo_001
148  * @tc.name: GetAbilityInfo
149  * @tc.desc: Test function GetAbilityInfo
150  */
151 HWTEST_F(AccessibleAbilityConnectionUnitTest, AccessibleAbilityConnection_Unittest_GetAbilityInfo_001, TestSize.Level1)
152 {
153     GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_GetAbilityInfo_001 start";
154     if (connection_ != nullptr) {
155         auto abilityInfo = connection_->GetAbilityInfo();
156         auto abilities = abilityInfo.GetAccessibilityAbilityType();
157         EXPECT_EQ(abilities, ACCESSIBILITY_ABILITY_TYPE_ALL);
158     }
159     GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_GetAbilityInfo_001 end";
160 }
161 
162 /**
163  * @tc.number: AccessibleAbilityConnection_Unittest_GetElementName_001
164  * @tc.name: GetElementName
165  * @tc.desc: Test function GetElementName
166  */
167 HWTEST_F(AccessibleAbilityConnectionUnitTest, AccessibleAbilityConnection_Unittest_GetElementName_001, TestSize.Level1)
168 {
169     GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_GetElementName_001 start";
170     if (connection_ != nullptr) {
171         auto elementName = connection_->GetElementName();
172         auto ret = elementName.GetDeviceID();
173         EXPECT_STREQ(ret.c_str(), "1");
174     }
175     GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_GetElementName_001 end";
176 }
177 
178 /**
179  * @tc.number: AccessibleAbilityConnection_Unittest_GetAbilityClient_001
180  * @tc.name: GetAbilityClient
181  * @tc.desc: Test function GetAbilityClient
182  */
183 HWTEST_F(
184     AccessibleAbilityConnectionUnitTest, AccessibleAbilityConnection_Unittest_GetAbilityClient_001, TestSize.Level1)
185 {
186     GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_GetProxy_001 start";
187     if (connection_ != nullptr) {
188         auto ret = connection_->GetAbilityClient();
189         EXPECT_TRUE(ret);
190     }
191     GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_GetProxy_001 end";
192 }
193 
194 /**
195  * @tc.number: AccessibleAbilityConnection_Unittest_OnAccessibilityEvent_001
196  * @tc.name: OnAccessibilityEvent
197  * @tc.desc: Test function OnAccessibilityEvent
198  */
199 HWTEST_F(
200     AccessibleAbilityConnectionUnitTest, AccessibleAbilityConnection_Unittest_OnAccessibilityEvent_001, TestSize.Level1)
201 {
202     GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_OnAccessibilityEvent_001 start";
203     if (connection_ != nullptr) {
204         AccessibilityEventInfo eventInfo;
205         /* EventType is in the allowed list */
206         eventInfo.SetEventType(EventType::TYPE_PAGE_STATE_UPDATE);
207         sleep(SLEEP_TIME_2);
208         connection_->OnAccessibilityEvent(eventInfo);
209         sleep(SLEEP_TIME_2);
210         EXPECT_EQ(int(EventType::TYPE_PAGE_STATE_UPDATE), AccessibilityAbilityHelper::GetInstance().GetTestEventType());
211     }
212     GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_OnAccessibilityEvent_001 end";
213 }
214 
215 /**
216  * @tc.number: AccessibleAbilityConnection_Unittest_OnAccessibilityEvent_002
217  * @tc.name: OnAccessibilityEvent
218  * @tc.desc: Test function OnAccessibilityEvent
219  */
220 HWTEST_F(
221     AccessibleAbilityConnectionUnitTest, AccessibleAbilityConnection_Unittest_OnAccessibilityEvent_002, TestSize.Level1)
222 {
223     GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_OnAccessibilityEvent_002 start";
224     if (connection_ != nullptr) {
225         AccessibilityEventInfo eventInfo;
226         /* EventType is in the allowed list */
227         eventInfo.SetEventType(EventType::TYPE_VIEW_CLICKED_EVENT);
228         /* invalid window */
229         eventInfo.SetWindowId(3);
230         sleep(SLEEP_TIME_2);
231         connection_->OnAccessibilityEvent(eventInfo);
232         sleep(SLEEP_TIME_2);
233         EXPECT_EQ(1, AccessibilityAbilityHelper::GetInstance().GetTestEventType());
234     }
235     GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_OnAccessibilityEvent_002 end";
236 }
237 
238 /**
239  * @tc.number: AccessibleAbilityConnection_Unittest_OnAccessibilityEvent_003
240  * @tc.name: OnAccessibilityEvent
241  * @tc.desc: Test function OnAccessibilityEvent
242  */
243 HWTEST_F(
244     AccessibleAbilityConnectionUnitTest, AccessibleAbilityConnection_Unittest_OnAccessibilityEvent_003, TestSize.Level1)
245 {
246     GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_OnAccessibilityEvent_003 start";
247     if (connection_ != nullptr) {
248         AccessibilityEventInfo eventInfo;
249         /* EventType is not in the allowed list */
250         eventInfo.SetEventType(TYPE_VIEW_INVALID);
251         sleep(SLEEP_TIME_2);
252         connection_->OnAccessibilityEvent(eventInfo);
253         sleep(SLEEP_TIME_2);
254         EXPECT_EQ(0, AccessibilityAbilityHelper::GetInstance().GetTestEventType());
255     }
256     GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_OnAccessibilityEvent_003 end";
257 }
258 
259 /**
260  * @tc.number: AccessibleAbilityConnection_Unittest_OnAccessibilityEvent_004
261  * @tc.name: OnAccessibilityEvent
262  * @tc.desc: Test function OnAccessibilityEvent
263  */
264 HWTEST_F(
265     AccessibleAbilityConnectionUnitTest, AccessibleAbilityConnection_Unittest_OnAccessibilityEvent_004, TestSize.Level1)
266 {
267     GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_OnAccessibilityEvent_004 start";
268     AccessibilityAbilityInitParams initParams;
269     initParams.abilityTypes = ACCESSIBILITY_ABILITY_TYPE_ALL;
270     std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
271     abilityInfo->SetEventTypes(EventType::TYPES_ALL_MASK);
272     sptr<AccessibleAbilityConnection> connection =
273         new AccessibleAbilityConnection(AccessibilityAbilityHelper::accountId_, 0, *abilityInfo);
274     if (connection != nullptr) {
275         AccessibilityEventInfo eventInfo;
276         /* EventType is not in the allowed list */
277         eventInfo.SetEventType(TYPE_VIEW_INVALID);
278         sleep(SLEEP_TIME_2);
279         connection->OnAccessibilityEvent(eventInfo);
280         sleep(SLEEP_TIME_2);
281         EXPECT_EQ(0, AccessibilityAbilityHelper::GetInstance().GetTestEventType());
282     }
283     GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_OnAccessibilityEvent_004 end";
284 }
285 
286 /**
287  * @tc.number: AccessibleAbilityConnection_Unittest_OnAccessibilityEvent_005
288  * @tc.name: OnAccessibilityEvent
289  * @tc.desc: Test function OnAccessibilityEvent
290  */
291 HWTEST_F(
292     AccessibleAbilityConnectionUnitTest, AccessibleAbilityConnection_Unittest_OnAccessibilityEvent_005, TestSize.Level1)
293 {
294     GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_OnAccessibilityEvent_005 start";
295 
296     // new AAconnection
297     AccessibilityAbilityInitParams initParams;
298     initParams.abilityTypes = ACCESSIBILITY_ABILITY_TYPE_ALL;
299     std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
300     abilityInfo->SetEventTypes(EventType::TYPE_VIEW_INVALID);
301 
302     sptr<AccessibleAbilityConnection> connection = new AccessibleAbilityConnection(
303         AccessibilityAbilityHelper::accountId_, 0, *abilityInfo);
304     sptr<AppExecFwk::ElementName> elementName = new AppExecFwk::ElementName("1", "2", "3");
305     sptr<IRemoteObject> obj = new IPCObjectProxy(0);
306     if (obj != nullptr && connection != nullptr) {
307         connection->OnAbilityConnectDoneSync(*elementName, obj);
308     }
309 
310     if (connection != nullptr) {
311         AccessibilityEventInfo eventInfo;
312         /* EventType is not in the allowed list */
313         AccessibilityAbilityHelper::GetInstance().SetTestEventType(-1);
314         eventInfo.SetEventType(TYPE_VIEW_CLICKED_EVENT);
315         sleep(SLEEP_TIME_2);
316         connection->OnAccessibilityEvent(eventInfo);
317         sleep(SLEEP_TIME_2);
318         EXPECT_EQ(-1, AccessibilityAbilityHelper::GetInstance().GetTestEventType());
319     }
320 
321     AccessibilityAbilityHelper::GetInstance().SetTestChannelId(INVALID_CHANNEL_ID);
322     if (accountData_) {
323         accountData_->RemoveAccessibilityWindowConnection(0);
324     }
325 
326     if (connection) {
327         connection->OnAbilityDisconnectDoneSync(*elementName);
328     }
329     connection = nullptr;
330     elementName = nullptr;
331     obj = nullptr;
332     GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_OnAccessibilityEvent_005 end";
333 }
334 
335 /**
336  * @tc.number: AccessibleAbilityConnection_Unittest_OnAbilityDisconnectDoneSync_001
337  * @tc.name: OnAbilityDisconnectDoneSync
338  * @tc.desc: Test function OnAbilityDisconnectDoneSync
339  */
340 HWTEST_F(AccessibleAbilityConnectionUnitTest,
341     AccessibleAbilityConnection_Unittest_OnAbilityDisconnectDoneSync_001, TestSize.Level1)
342 {
343     GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_OnAbilityDisconnectDoneSync_001 start";
344     // new AAconnection
345     AccessibilityAbilityInitParams initParams;
346     initParams.abilityTypes = ACCESSIBILITY_ABILITY_TYPE_ALL;
347     std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
348     abilityInfo->SetEventTypes(EventType::TYPES_ALL_MASK);
349     sptr<AccessibleAbilityConnection> connection =
350         new AccessibleAbilityConnection(AccessibilityAbilityHelper::accountId_, 0, *abilityInfo);
351     if (connection != nullptr) {
352         AccessibilityEventInfo eventInfo;
353         /* EventType is not in the allowed list */
354         eventInfo.SetEventType(TYPE_VIEW_INVALID);
355         sleep(SLEEP_TIME_2);
356         connection->OnAbilityDisconnectDoneSync(*elementName_);
357     }
358     GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_OnAbilityDisconnectDoneSync_001 end";
359 }
360 
361 /**
362  * @tc.number: AccessibleAbilityConnection_Unittest_Connect_001
363  * @tc.name: Connect
364  * @tc.desc: Test function Connect
365  */
366 HWTEST_F(AccessibleAbilityConnectionUnitTest, AccessibleAbilityConnection_Unittest_Connect_001, TestSize.Level1)
367 {
368     GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_Connect_001 start";
369     if (connection_ != nullptr) {
370         AppExecFwk::ElementName element("deviceId", "bundleName", "abilityName");
371         connection_->Connect(element);
372         sptr<AccessibleAbilityClientStub> obj = new MockAccessibleAbilityClientStubImpl();
373         connection_->OnAbilityConnectDoneSync(element, obj);
374         EXPECT_TRUE(accountData_->GetAccessibleAbilityConnection(Utils::GetUri(
375             element.GetBundleName(), element.GetAbilityName())));
376     }
377     GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_Connect_001 end";
378 }
379 
380 /**
381  * @tc.number: AccessibleAbilityConnection_Unittest_Disconnect_001
382  * @tc.name: Disconnect
383  * @tc.desc: Test function Disconnect
384  */
385 HWTEST_F(AccessibleAbilityConnectionUnitTest, AccessibleAbilityConnection_Unittest_Disconnect_001, TestSize.Level1)
386 {
387     GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_Disconnect_001 start";
388     if (connection_ != nullptr) {
389         connection_->Disconnect();
390         EXPECT_EQ(AccessibilityAbilityHelper::GetInstance().GetTestChannelId(), 0);
391     }
392     GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_Reset_001 end";
393 }
394 
395 /**
396  * @tc.number: AccessibleAbilityConnection_Unittest_OnAbilityConnectDone_001
397  * @tc.name: OnAbilityConnectDone
398  * @tc.desc: Test function OnAbilityConnectDone
399  */
400 HWTEST_F(AccessibleAbilityConnectionUnitTest,
401     AccessibleAbilityConnection_Unittest_OnAbilityConnectDone_001, TestSize.Level1)
402 {
403     GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_OnAbilityConnectDone_001 start";
404     auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
405     ASSERT_TRUE(accountData);
406 
407     sptr<AppExecFwk::ElementName> elementName = new AppExecFwk::ElementName("device", "bundle", "ability");
408     accountData->AddEnabledAbility(Utils::GetUri(*elementName));
409     EXPECT_EQ(static_cast<int>(accountData->GetEnabledAbilities().size()), 1);
410 
411     std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>();
412     sptr<AccessibleAbilityConnection> connection = new AccessibleAbilityConnection(
413         Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountId(), 0, *abilityInfo);
414     accountData->AddConnectingA11yAbility(Utils::GetUri(*elementName), connection);
415     EXPECT_TRUE(accountData->GetConnectingA11yAbility(Utils::GetUri(*elementName)));
416 
417     ASSERT_TRUE(connection);
418     sptr<AccessibleAbilityClientStub> client = new MockAccessibleAbilityClientStubImpl();
419     connection->OnAbilityConnectDone(*elementName, client, 1);
420 
__anone60ffe920302() 421     bool ret = AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([=]() -> bool {
422         auto &aams = Singleton<AccessibleAbilityManagerService>::GetInstance();
423         if (static_cast<int>(accountData->GetEnabledAbilities().size()) == 0 &&
424             !(accountData->GetConnectingA11yAbility(Utils::GetUri(*elementName)))) {
425             return true;
426         } else {
427             return false;
428         }
429         }), 1);
430     EXPECT_TRUE(ret);
431     GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_OnAbilityConnectDone_001 end";
432 }
433 
434 /**
435  * @tc.number: AccessibleAbilityConnection_Unittest_OnAbilityConnectDone_002
436  * @tc.name: OnAbilityConnectDone
437  * @tc.desc: Test function OnAbilityConnectDone
438  */
439 HWTEST_F(AccessibleAbilityConnectionUnitTest,
440     AccessibleAbilityConnection_Unittest_OnAbilityConnectDone_002, TestSize.Level1)
441 {
442     GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_OnAbilityConnectDone_002 start";
443     auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
444     ASSERT_TRUE(accountData);
445 
446     // add aa client
447     std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>();
448     sptr<AccessibleAbilityConnection> connection = new AccessibleAbilityConnection(
449         Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountId(), CHANNEL_ID, *abilityInfo);
450     sptr<AppExecFwk::ElementName> name = new AppExecFwk::ElementName("device", "bundle", "ability");
451     accountData->AddConnectingA11yAbility(Utils::GetUri(*name), connection);
452     EXPECT_TRUE(accountData->GetConnectingA11yAbility(Utils::GetUri(*name)));
453 
454     ASSERT_TRUE(connection);
455     sptr<AccessibleAbilityClientStub> client = new MockAccessibleAbilityClientStubImpl();
456     connection->OnAbilityConnectDone(*name, client, NO_ERROR);
457 
__anone60ffe920402() 458     bool ret = AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([=]() -> bool {
459         if (AccessibilityAbilityHelper::GetInstance().GetTestChannelId() == CHANNEL_ID) {
460             return true;
461         } else {
462             return false;
463         }
464         }), 1);
465     EXPECT_TRUE(ret);
466     GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_OnAbilityConnectDone_002 end";
467 }
468 
469 /**
470  * @tc.number: AccessibleAbilityConnection_Unittest_OnAbilityConnectDone_003
471  * @tc.name: OnAbilityConnectDone
472  * @tc.desc: Test function OnAbilityConnectDone
473  */
474 HWTEST_F(AccessibleAbilityConnectionUnitTest,
475     AccessibleAbilityConnection_Unittest_OnAbilityConnectDone_003, TestSize.Level1)
476 {
477     GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_OnAbilityConnectDone_003 start";
478     auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
479     ASSERT_TRUE(accountData);
480     std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>();
481     sptr<AccessibleAbilityConnection> connection = new AccessibleAbilityConnection(
482         accountData->GetAccountId(), CHANNEL_ID, *abilityInfo);
483     sptr<AppExecFwk::ElementName> elementName = new AppExecFwk::ElementName("device", "bundle", "ability");
484     accountData->AddConnectingA11yAbility(Utils::GetUri(*elementName), connection);
485     EXPECT_TRUE(accountData->GetConnectingA11yAbility(Utils::GetUri(*elementName)));
486     connection->OnAbilityConnectDone(*elementName, nullptr, NO_ERROR);
487     sleep(SLEEP_TIME_2);
__anone60ffe920502() 488     bool ret = AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([=]() -> bool {
489         auto &aams = Singleton<AccessibleAbilityManagerService>::GetInstance();
490         if (accountData->GetConnectingA11yAbility(Utils::GetUri(*elementName))) {
491             return true;
492         } else {
493             return false;
494         }
495         }), 1);
496     EXPECT_TRUE(ret);
497     GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_OnAbilityConnectDone_003 end";
498 }
499 
500 /**
501  * @tc.number: AccessibleAbilityConnection_Unittest_OnAbilityConnectDone_004
502  * @tc.name: OnAbilityConnectDone
503  * @tc.desc: Test function OnAbilityConnectDone
504  */
505 HWTEST_F(AccessibleAbilityConnectionUnitTest,
506     AccessibleAbilityConnection_Unittest_OnAbilityConnectDone_004, TestSize.Level1)
507 {
508     GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_OnAbilityConnectDone_004 start";
509     std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>();
510     sptr<AccessibleAbilityConnection> connection = new AccessibleAbilityConnection(
511         INVALID_ACCOUNT_ID, CHANNEL_ID, *abilityInfo);
512     sptr<AppExecFwk::ElementName> elementName = new AppExecFwk::ElementName("device", "bundle", "ability");
513 
514     EXPECT_FALSE(Singleton<AccessibleAbilityManagerService>::GetInstance().GetAccountData(INVALID_ACCOUNT_ID));
515     connection->OnAbilityConnectDone(*elementName, nullptr, NO_ERROR);
516     sleep(SLEEP_TIME_2);
517 
__anone60ffe920602() 518     bool ret = AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([=]() -> bool {
519         auto &aams = Singleton<AccessibleAbilityManagerService>::GetInstance();
520         if (static_cast<int>(accountData_->GetEnabledAbilities().size()) == 0 &&
521             accountData_->GetConnectingA11yAbility(Utils::GetUri(*elementName))) {
522             return true;
523         } else {
524             return false;
525         }
526         }), 1);
527     EXPECT_TRUE(ret);
528     GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_OnAbilityConnectDone_004 end";
529 }
530 
531 /**
532  * @tc.number: AccessibleAbilityConnection_Unittest_OnAbilityConnectDone_005
533  * @tc.name: OnAbilityConnectDone
534  * @tc.desc: Test function OnAbilityConnectDone
535  */
536 HWTEST_F(AccessibleAbilityConnectionUnitTest,
537     AccessibleAbilityConnection_Unittest_OnAbilityConnectDone_005, TestSize.Level1)
538 {
539     GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_OnAbilityConnectDone_005 start";
540     auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
541     ASSERT_TRUE(accountData);
542 
543     // add aa client
544     std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>();
545     sptr<AccessibleAbilityConnection> connection = new AccessibleAbilityConnection(
546         Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountId(), CHANNEL_ID, *abilityInfo);
547     sptr<AppExecFwk::ElementName> name =
548         new AppExecFwk::ElementName("clientDevice", "clientBundleName", "clientAbilityName");
549     sptr<AccessibleAbilityClientStub> client = new MockAccessibleAbilityClientStubImpl();
550 
551     connection->OnAbilityConnectDone(*name, client, NO_ERROR);
552     sleep(SLEEP_TIME_2);
553 
__anone60ffe920702() 554     bool ret = AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([=]() -> bool {
555         auto &aams = Singleton<AccessibleAbilityManagerService>::GetInstance();
556         if (static_cast<int>(accountData->GetEnabledAbilities().size()) == 0 &&
557             !(accountData->GetConnectingA11yAbility(Utils::GetUri(*name)))) {
558             return true;
559         } else {
560             return false;
561         }
562         }), 1);
563     EXPECT_TRUE(ret);
564     GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_OnAbilityConnectDone_005 end";
565 }
566 
567 /**
568  * @tc.number: AccessibleAbilityConnection_Unittest_OnAbilityDisconnectDone_001
569  * @tc.name: OnAbilityDisconnectDone
570  * @tc.desc: Test function OnAbilityDisconnectDone
571  */
572 HWTEST_F(AccessibleAbilityConnectionUnitTest,
573     AccessibleAbilityConnection_Unittest_OnAbilityDisconnectDone_001, TestSize.Level1)
574 {
575     GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_OnAbilityDisconnectDone_001 start";
576     ASSERT_TRUE(connection_);
577     AppExecFwk::ElementName element;
578     connection_->OnAbilityDisconnectDone(element, 0);
579     GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_OnAbilityDisconnectDone_001 end";
580 }
581 
582 /**
583  * @tc.number: AccessibleAbilityConnection_Unittest_OnKeyPressEvent_001
584  * @tc.name: OnKeyPressEvent
585  * @tc.desc: Test function OnKeyPressEvent
586  */
587 HWTEST_F(AccessibleAbilityConnectionUnitTest,
588     AccessibleAbilityConnection_Unittest_OnKeyPressEvent_001, TestSize.Level1)
589 {
590     GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_OnKeyPressEvent_001 start";
591     auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
592     ASSERT_TRUE(accountData);
593 
594     // add aa client
595     std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>();
596     abilityInfo->SetCapabilityValues(0);
597     sptr<AccessibleAbilityConnection> connection = new AccessibleAbilityConnection(
598         accountData->GetAccountId(), CHANNEL_ID, *abilityInfo);
599     ASSERT_TRUE(connection);
600     AppExecFwk::ElementName element("deviceId", "bundleName", "abilityName");
601     sptr<AccessibleAbilityClientStub> obj = new MockAccessibleAbilityClientStubImpl();
602     connection->OnAbilityConnectDoneSync(element, obj);
603     EXPECT_EQ(AccessibilityAbilityHelper::GetInstance().GetTestChannelId(), CHANNEL_ID);
604 
605     std::shared_ptr<MMI::KeyEvent> keyEvent = MMI::KeyEvent::Create();
606     EXPECT_FALSE(connection_->OnKeyPressEvent(*keyEvent, 0));
607     GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_OnKeyPressEvent_001 end";
608 }
609 
610 /**
611  * @tc.number: AccessibleAbilityConnection_Unittest_SetAbilityInfoTargetBundleName_001
612  * @tc.name: SetAbilityInfoTargetBundleName
613  * @tc.desc: Test function SetAbilityInfoTargetBundleName.
614  */
615 HWTEST_F(AccessibleAbilityConnectionUnitTest,
616     AccessibleAbilityConnection_Unittest_SetAbilityInfoTargetBundleName_001, TestSize.Level1)
617 {
618     GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_SetAbilityInfoTargetBundleName_001 start";
619     ASSERT_TRUE(connection_);
620     std::vector<std::string> targetBundleNames;
621     targetBundleNames.push_back("target");
622     connection_->SetAbilityInfoTargetBundleName(targetBundleNames);
623     ASSERT_EQ(static_cast<int>(connection_->GetAbilityInfo().GetFilterBundleNames().size()), 1);
624     EXPECT_STREQ(connection_->GetAbilityInfo().GetFilterBundleNames().front().c_str(), "target");
625     GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_SetAbilityInfoTargetBundleName_001 end";
626 }
627 
628 /**
629  * @tc.number: AccessibleAbilityConnection_Unittest_GetChannelId_001
630  * @tc.name: GetChannelId
631  * @tc.desc: Test function GetChannelId.
632  */
633 HWTEST_F(AccessibleAbilityConnectionUnitTest,
634     AccessibleAbilityConnection_Unittest_GetChannelId_001, TestSize.Level1)
635 {
636     GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_GetChannelId_001 start";
637     std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>();
638     sptr<AccessibleAbilityConnection> connection = new AccessibleAbilityConnection(0, CHANNEL_ID, *abilityInfo);
639     EXPECT_EQ(connection->GetChannelId(), CHANNEL_ID);
640     GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_GetChannelId_001 end";
641 }
642 } // namespace Accessibility
643 } // namespace OHOS