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();
__anon5fd981bb0202() 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 && aams.GetMainRunner()->GetEventQueue()->IsIdle()) {
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_Connect_001
261 * @tc.name: Connect
262 * @tc.desc: Test function Connect
263 */
264 HWTEST_F(AccessibleAbilityConnectionUnitTest, AccessibleAbilityConnection_Unittest_Connect_001, TestSize.Level1)
265 {
266 GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_Connect_001 start";
267 if (connection_ != nullptr) {
268 AppExecFwk::ElementName element("deviceId", "bundleName", "abilityName");
269 connection_->Connect(element);
270 sptr<AccessibleAbilityClientStub> obj = new MockAccessibleAbilityClientStubImpl();
271 connection_->OnAbilityConnectDoneSync(element, obj);
272 EXPECT_TRUE(accountData_->GetAccessibleAbilityConnection(Utils::GetUri(
273 element.GetBundleName(), element.GetAbilityName())));
274 }
275 GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_Connect_001 end";
276 }
277
278 /**
279 * @tc.number: AccessibleAbilityConnection_Unittest_Disconnect_001
280 * @tc.name: Disconnect
281 * @tc.desc: Test function Disconnect
282 */
283 HWTEST_F(AccessibleAbilityConnectionUnitTest, AccessibleAbilityConnection_Unittest_Disconnect_001, TestSize.Level1)
284 {
285 GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_Disconnect_001 start";
286 if (connection_ != nullptr) {
287 connection_->Disconnect();
288 EXPECT_EQ(AccessibilityAbilityHelper::GetInstance().GetTestChannelId(), 0);
289 }
290 GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_Reset_001 end";
291 }
292
293 /**
294 * @tc.number: AccessibleAbilityConnection_Unittest_OnAbilityConnectDone_001
295 * @tc.name: OnAbilityConnectDone
296 * @tc.desc: Test function OnAbilityConnectDone
297 */
298 HWTEST_F(AccessibleAbilityConnectionUnitTest,
299 AccessibleAbilityConnection_Unittest_OnAbilityConnectDone_001, TestSize.Level1)
300 {
301 GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_OnAbilityConnectDone_001 start";
302 auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
303 ASSERT_TRUE(accountData);
304
305 sptr<AppExecFwk::ElementName> elementName = new AppExecFwk::ElementName("device", "bundle", "ability");
306 accountData->AddEnabledAbility(Utils::GetUri(*elementName));
307 EXPECT_EQ(static_cast<int>(accountData->GetEnabledAbilities().size()), 1);
308
309 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>();
310 sptr<AccessibleAbilityConnection> connection = new AccessibleAbilityConnection(
311 Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountId(), 0, *abilityInfo);
312 accountData->AddConnectingA11yAbility(Utils::GetUri(*elementName), connection);
313 EXPECT_TRUE(accountData->GetConnectingA11yAbility(Utils::GetUri(*elementName)));
314
315 ASSERT_TRUE(connection);
316 sptr<AccessibleAbilityClientStub> client = new MockAccessibleAbilityClientStubImpl();
317 connection->OnAbilityConnectDone(*elementName, client, 1);
318
__anon5fd981bb0302() 319 bool ret = AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([=]() -> bool {
320 auto &aams = Singleton<AccessibleAbilityManagerService>::GetInstance();
321 if (static_cast<int>(accountData->GetEnabledAbilities().size()) == 0 &&
322 !(accountData->GetConnectingA11yAbility(Utils::GetUri(*elementName))) &&
323 aams.GetMainRunner()->GetEventQueue()->IsIdle()) {
324 return true;
325 } else {
326 return false;
327 }
328 }), 1);
329 EXPECT_TRUE(ret);
330 GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_OnAbilityConnectDone_001 end";
331 }
332
333 /**
334 * @tc.number: AccessibleAbilityConnection_Unittest_OnAbilityConnectDone_002
335 * @tc.name: OnAbilityConnectDone
336 * @tc.desc: Test function OnAbilityConnectDone
337 */
338 HWTEST_F(AccessibleAbilityConnectionUnitTest,
339 AccessibleAbilityConnection_Unittest_OnAbilityConnectDone_002, TestSize.Level1)
340 {
341 GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_OnAbilityConnectDone_002 start";
342 auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
343 ASSERT_TRUE(accountData);
344
345 // add aa client
346 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>();
347 sptr<AccessibleAbilityConnection> connection = new AccessibleAbilityConnection(
348 Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountId(), CHANNEL_ID, *abilityInfo);
349 sptr<AppExecFwk::ElementName> name = new AppExecFwk::ElementName("device", "bundle", "ability");
350 accountData->AddConnectingA11yAbility(Utils::GetUri(*name), connection);
351 EXPECT_TRUE(accountData->GetConnectingA11yAbility(Utils::GetUri(*name)));
352
353 ASSERT_TRUE(connection);
354 sptr<AccessibleAbilityClientStub> client = new MockAccessibleAbilityClientStubImpl();
355 connection->OnAbilityConnectDone(*name, client, NO_ERROR);
356
__anon5fd981bb0402() 357 bool ret = AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([=]() -> bool {
358 if (AccessibilityAbilityHelper::GetInstance().GetTestChannelId() == CHANNEL_ID) {
359 return true;
360 } else {
361 return false;
362 }
363 }), 1);
364 EXPECT_TRUE(ret);
365 GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_OnAbilityConnectDone_002 end";
366 }
367
368 /**
369 * @tc.number: AccessibleAbilityConnection_Unittest_OnAbilityConnectDone_003
370 * @tc.name: OnAbilityConnectDone
371 * @tc.desc: Test function OnAbilityConnectDone
372 */
373 HWTEST_F(AccessibleAbilityConnectionUnitTest,
374 AccessibleAbilityConnection_Unittest_OnAbilityConnectDone_003, TestSize.Level1)
375 {
376 GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_OnAbilityConnectDone_003 start";
377 auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
378 ASSERT_TRUE(accountData);
379 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>();
380 sptr<AccessibleAbilityConnection> connection = new AccessibleAbilityConnection(
381 accountData->GetAccountId(), CHANNEL_ID, *abilityInfo);
382 sptr<AppExecFwk::ElementName> elementName = new AppExecFwk::ElementName("device", "bundle", "ability");
383 accountData->AddConnectingA11yAbility(Utils::GetUri(*elementName), connection);
384 EXPECT_TRUE(accountData->GetConnectingA11yAbility(Utils::GetUri(*elementName)));
385 connection->OnAbilityConnectDone(*elementName, nullptr, NO_ERROR);
386 sleep(SLEEP_TIME_2);
__anon5fd981bb0502() 387 bool ret = AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([=]() -> bool {
388 auto &aams = Singleton<AccessibleAbilityManagerService>::GetInstance();
389 if (accountData->GetConnectingA11yAbility(Utils::GetUri(*elementName)) &&
390 aams.GetMainRunner()->GetEventQueue()->IsIdle()) {
391 return true;
392 } else {
393 return false;
394 }
395 }), 1);
396 EXPECT_TRUE(ret);
397 GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_OnAbilityConnectDone_003 end";
398 }
399
400 /**
401 * @tc.number: AccessibleAbilityConnection_Unittest_OnAbilityConnectDone_004
402 * @tc.name: OnAbilityConnectDone
403 * @tc.desc: Test function OnAbilityConnectDone
404 */
405 HWTEST_F(AccessibleAbilityConnectionUnitTest,
406 AccessibleAbilityConnection_Unittest_OnAbilityConnectDone_004, TestSize.Level1)
407 {
408 GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_OnAbilityConnectDone_004 start";
409 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>();
410 sptr<AccessibleAbilityConnection> connection = new AccessibleAbilityConnection(
411 INVALID_ACCOUNT_ID, CHANNEL_ID, *abilityInfo);
412 sptr<AppExecFwk::ElementName> elementName = new AppExecFwk::ElementName("device", "bundle", "ability");
413
414 EXPECT_FALSE(Singleton<AccessibleAbilityManagerService>::GetInstance().GetAccountData(INVALID_ACCOUNT_ID));
415 connection->OnAbilityConnectDone(*elementName, nullptr, NO_ERROR);
416 sleep(SLEEP_TIME_2);
417
__anon5fd981bb0602() 418 bool ret = AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([=]() -> bool {
419 auto &aams = Singleton<AccessibleAbilityManagerService>::GetInstance();
420 if (aams.GetMainRunner()->GetEventQueue()->IsIdle()) {
421 return true;
422 } else {
423 return false;
424 }
425 }), 1);
426 EXPECT_TRUE(ret);
427 GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_OnAbilityConnectDone_004 end";
428 }
429
430 /**
431 * @tc.number: AccessibleAbilityConnection_Unittest_OnAbilityConnectDone_005
432 * @tc.name: OnAbilityConnectDone
433 * @tc.desc: Test function OnAbilityConnectDone
434 */
435 HWTEST_F(AccessibleAbilityConnectionUnitTest,
436 AccessibleAbilityConnection_Unittest_OnAbilityConnectDone_005, TestSize.Level1)
437 {
438 GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_OnAbilityConnectDone_005 start";
439 auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
440 ASSERT_TRUE(accountData);
441
442 // add aa client
443 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>();
444 sptr<AccessibleAbilityConnection> connection = new AccessibleAbilityConnection(
445 Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountId(), CHANNEL_ID, *abilityInfo);
446 sptr<AppExecFwk::ElementName> name =
447 new AppExecFwk::ElementName("clientDevice", "clientBundleName", "clientAbilityName");
448 sptr<AccessibleAbilityClientStub> client = new MockAccessibleAbilityClientStubImpl();
449
450 connection->OnAbilityConnectDone(*name, client, NO_ERROR);
451 sleep(SLEEP_TIME_2);
452
__anon5fd981bb0702() 453 bool ret = AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([=]() -> bool {
454 auto &aams = Singleton<AccessibleAbilityManagerService>::GetInstance();
455 if (aams.GetMainRunner()->GetEventQueue()->IsIdle()) {
456 return true;
457 } else {
458 return false;
459 }
460 }), 1);
461 EXPECT_TRUE(ret);
462 GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_OnAbilityConnectDone_005 end";
463 }
464
465 /**
466 * @tc.number: AccessibleAbilityConnection_Unittest_OnAbilityDisconnectDone_001
467 * @tc.name: OnAbilityDisconnectDone
468 * @tc.desc: Test function OnAbilityDisconnectDone
469 */
470 HWTEST_F(AccessibleAbilityConnectionUnitTest,
471 AccessibleAbilityConnection_Unittest_OnAbilityDisconnectDone_001, TestSize.Level1)
472 {
473 GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_OnAbilityDisconnectDone_001 start";
474 ASSERT_TRUE(connection_);
475 AppExecFwk::ElementName element;
476 connection_->OnAbilityDisconnectDone(element, 0);
477 GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_OnAbilityDisconnectDone_001 end";
478 }
479
480 /**
481 * @tc.number: AccessibleAbilityConnection_Unittest_OnKeyPressEvent_001
482 * @tc.name: OnKeyPressEvent
483 * @tc.desc: Test function OnKeyPressEvent
484 */
485 HWTEST_F(AccessibleAbilityConnectionUnitTest,
486 AccessibleAbilityConnection_Unittest_OnKeyPressEvent_001, TestSize.Level1)
487 {
488 GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_OnKeyPressEvent_001 start";
489 auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
490 ASSERT_TRUE(accountData);
491
492 // add aa client
493 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>();
494 abilityInfo->SetCapabilityValues(0);
495 sptr<AccessibleAbilityConnection> connection = new AccessibleAbilityConnection(
496 accountData->GetAccountId(), CHANNEL_ID, *abilityInfo);
497 ASSERT_TRUE(connection);
498 AppExecFwk::ElementName element("deviceId", "bundleName", "abilityName");
499 sptr<AccessibleAbilityClientStub> obj = new MockAccessibleAbilityClientStubImpl();
500 connection->OnAbilityConnectDoneSync(element, obj);
501 EXPECT_EQ(AccessibilityAbilityHelper::GetInstance().GetTestChannelId(), CHANNEL_ID);
502
503 std::shared_ptr<MMI::KeyEvent> keyEvent = MMI::KeyEvent::Create();
504 EXPECT_FALSE(connection_->OnKeyPressEvent(*keyEvent, 0));
505 GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_OnKeyPressEvent_001 end";
506 }
507
508 /**
509 * @tc.number: AccessibleAbilityConnection_Unittest_SetAbilityInfoTargetBundleName_001
510 * @tc.name: SetAbilityInfoTargetBundleName
511 * @tc.desc: Test function SetAbilityInfoTargetBundleName.
512 */
513 HWTEST_F(AccessibleAbilityConnectionUnitTest,
514 AccessibleAbilityConnection_Unittest_SetAbilityInfoTargetBundleName_001, TestSize.Level1)
515 {
516 GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_SetAbilityInfoTargetBundleName_001 start";
517 ASSERT_TRUE(connection_);
518 std::vector<std::string> targetBundleNames;
519 targetBundleNames.push_back("target");
520 connection_->SetAbilityInfoTargetBundleName(targetBundleNames);
521 ASSERT_EQ(static_cast<int>(connection_->GetAbilityInfo().GetFilterBundleNames().size()), 1);
522 EXPECT_STREQ(connection_->GetAbilityInfo().GetFilterBundleNames().front().c_str(), "target");
523 GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_SetAbilityInfoTargetBundleName_001 end";
524 }
525
526 /**
527 * @tc.number: AccessibleAbilityConnection_Unittest_GetChannelId_001
528 * @tc.name: GetChannelId
529 * @tc.desc: Test function GetChannelId.
530 */
531 HWTEST_F(AccessibleAbilityConnectionUnitTest,
532 AccessibleAbilityConnection_Unittest_GetChannelId_001, TestSize.Level1)
533 {
534 GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_GetChannelId_001 start";
535 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>();
536 sptr<AccessibleAbilityConnection> connection = new AccessibleAbilityConnection(0, CHANNEL_ID, *abilityInfo);
537 EXPECT_EQ(connection->GetChannelId(), CHANNEL_ID);
538 GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_GetChannelId_001 end";
539 }
540 } // namespace Accessibility
541 } // namespace OHOS