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