1 /*
2 * Copyright (C) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <gtest/gtest.h>
17 #include "accessibility_common_helper.h"
18 #include "accessibility_display_manager.h"
19 #include "accessibility_element_operator_proxy.h"
20 #include "accessibility_element_operator_stub.h"
21 #include "accessibility_mt_helper.h"
22 #include "accessible_ability_manager_service.h"
23 #include "accessible_ability_manager_state_observer_proxy.h"
24 #include "accessible_ability_manager_state_observer_stub.h"
25 #include "iservice_registry.h"
26
27 using namespace testing;
28 using namespace testing::ext;
29
30 namespace OHOS {
31 namespace Accessibility {
32 class AAMSServerTest : public testing::Test {
33 public:
AAMSServerTest()34 AAMSServerTest()
35 {}
~AAMSServerTest()36 ~AAMSServerTest()
37 {}
38
39 static void SetUpTestCase();
40 static void TearDownTestCase();
41
42 void SetUp() override;
43 void TearDown() override;
44 void AddAccessibleAbilityConnection();
45 void WritefileAll(const char* fname, const char* data);
46 sptr<AccessibilityAccountData> accountData_ = nullptr;
47 sptr<AccessibleAbilityChannel> aastub_ = nullptr;
48 sptr<AppExecFwk::ElementName> elementName_ = nullptr;
49 sptr<AccessibleAbilityConnection> AAConnection_ = nullptr;
50 };
51
SetUpTestCase()52 void AAMSServerTest::SetUpTestCase()
53 {
54 GTEST_LOG_(INFO) << "AAMSServerTest SetUpTestCase";
55 }
56
TearDownTestCase()57 void AAMSServerTest::TearDownTestCase()
58 {
59 GTEST_LOG_(INFO) << "AAMSServerTest TearDownTestCase";
60 }
61
SetUp()62 void AAMSServerTest::SetUp()
63 {
64 GTEST_LOG_(INFO) << "AAMSServerTest SetUp";
65
66 // Start AAMS
67 Singleton<AccessibleAbilityManagerService>::GetInstance().OnStart();
68 AccessibilityCommonHelper::GetInstance().WaitForServicePublish();
69 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(AccessibilityHelper::accountId_);
70 GTEST_LOG_(INFO) << "AccessibleAbilityManagerService is published";
71 }
72
TearDown()73 void AAMSServerTest::TearDown()
74 {
75 GTEST_LOG_(INFO) << "AAMSServerTest TearDown";
76 AccessibilityHelper::GetInstance().SetTestStub(nullptr);
77 AccessibilityHelper::GetInstance().SetTestStateType(-1);
78 AccessibilityHelper::GetInstance().SetTestEventType(-1);
79 AccessibilityHelper::GetInstance().SetTestWindowChangeTypes(-1);
80 AccessibilityHelper::GetInstance().SetTestWindowId(-1);
81 Singleton<AccessibleAbilityManagerService>::GetInstance().OnStop();
82 accountData_ = nullptr;
83 aastub_ = nullptr;
84 elementName_ = nullptr;
85 AAConnection_ = nullptr;
86 }
87
WritefileAll(const char * fname,const char * data)88 void AAMSServerTest::WritefileAll(const char* fname, const char* data)
89 {
90 FILE* fp;
91 if (!(fp = fopen(fname, "w"))) {
92 printf("open file %s fail \n", fname);
93 return;
94 }
95
96 (void)fprintf(fp, "%s", data);
97 (void)fclose(fp);
98 }
99
AddAccessibleAbilityConnection()100 void AAMSServerTest::AddAccessibleAbilityConnection()
101 {
102 GTEST_LOG_(INFO) << "AAMSServerTest AddAccessibleAbilityConnection";
103 // accessibleAbility connection
104 AAFwk::Want want;
105 AppExecFwk::ElementName name;
106 std::string deviceId;
107 name.SetAbilityName("com.example.aalisttest.MainAbility");
108 name.SetBundleName("com.example.aalisttest");
109 want.SetElement(name);
110
111 AccessibilityAbilityInitParams initParams;
112 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
113 abilityInfo->SetAccessibilityAbilityType(AccessibilityAbilityTypes::ACCESSIBILITY_ABILITY_TYPE_ALL);
114 accountData_ = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
115 AAConnection_ = new AccessibleAbilityConnection(accountData_->GetAccountId(), 0, *abilityInfo);
116 elementName_ = new AppExecFwk::ElementName(deviceId, initParams.bundleName, initParams.name);
117 aastub_ = new AccessibleAbilityChannel(accountData_->GetAccountId(), abilityInfo->GetId());
118 AAConnection_->OnAbilityConnectDoneSync(*elementName_, aastub_);
119 accountData_->AddInstalledAbility(*abilityInfo);
120 }
121
122 /**
123 * @tc.number: AAMS_moduletest_SendEvent_001
124 * @tc.name: SendEvent
125 * @tc.desc: Test function SendEvent aams send event to accessibility,and check the parm of event.
126 *
127 */
128 HWTEST_F(AAMSServerTest, SendEvent_001, TestSize.Level1)
129 {
130 GTEST_LOG_(INFO) << "AAMSServerTest SendEvent_001 start";
131 // register AA
132 AddAccessibleAbilityConnection();
133 // make an event
134 AccessibilityEventInfo eventInfo;
135 eventInfo.SetEventType(EventType::TYPE_WINDOW_UPDATE);
136 // aams send event
137 Singleton<AccessibleAbilityManagerService>::GetInstance().SendEvent(eventInfo);
138 sleep(1);
139 // check aa proxy
140 EXPECT_EQ(AccessibilityHelper::GetInstance().GetTestEventType(), int(EventType::TYPE_WINDOW_UPDATE));
141
142 AAConnection_->OnAbilityDisconnectDoneSync(*elementName_);
143 accountData_->ClearInstalledAbility();
144
145 GTEST_LOG_(INFO) << "AAMSServerTest SendEvent_001 end";
146 }
147
148 /**
149 * @tc.number: AAMS_moduletest_GetAbilityList_001
150 * @tc.name: GetAbilityList
151 * @tc.desc: Test function GetAbilityList
152 * The func with Illegal parameter 1
153 */
154 HWTEST_F(AAMSServerTest, GetAbilityList_001, TestSize.Level1)
155 {
156 GTEST_LOG_(INFO) << "AAMSServerTest GetAbilityList_001 start";
157 std::vector<OHOS::Accessibility::AccessibilityAbilityInfo> infos;
158 auto &aams = Singleton<AccessibleAbilityManagerService>::GetInstance();
159 auto ret = aams.GetAbilityList(0, AbilityStateType::ABILITY_STATE_ENABLE, infos);
160 EXPECT_EQ(RET_OK, ret);
161 EXPECT_EQ(infos.size(), 0);
162
163 GTEST_LOG_(INFO) << "AAMSServerTest GetAbilityList_001 end";
164 }
165
166 /**
167 * @tc.number: AAMS_moduletest_GetAbilityList_002
168 * @tc.name: GetAbilityList
169 * @tc.desc: Test function GetAbilityList
170 * Get Enable Ability list.
171 */
172 HWTEST_F(AAMSServerTest, GetAbilityList_002, TestSize.Level1)
173 {
174 GTEST_LOG_(INFO) << "AAMSServerTest GetAbilityList_002 start";
175 AddAccessibleAbilityConnection();
176
177 std::vector<OHOS::Accessibility::AccessibilityAbilityInfo> infos;
178 Singleton<AccessibleAbilityManagerService>::GetInstance().GetAbilityList(
179 AccessibilityAbilityTypes::ACCESSIBILITY_ABILITY_TYPE_SPOKEN, AbilityStateType::ABILITY_STATE_ENABLE, infos);
180 EXPECT_EQ(infos.size(), 1);
181
182 AAConnection_->OnAbilityDisconnectDoneSync(*elementName_);
183 accountData_->ClearInstalledAbility();
184 GTEST_LOG_(INFO) << "AAMSServerTest GetAbilityList_002 end";
185 }
186
187 /**
188 * @tc.number: AAMS_moduletest_GetAbilityList_003
189 * @tc.name: GetAbilityList
190 * @tc.desc: Test function GetAbilityList
191 * Get Disable Ability list with 2 installed ability accessibility and a connected accessibility ability.
192 */
193 HWTEST_F(AAMSServerTest, GetAbilityList_003, TestSize.Level1)
194 {
195 GTEST_LOG_(INFO) << "AAMSServerTest GetAbilityList_003 start";
196
197 AddAccessibleAbilityConnection();
198
199 AccessibilityAbilityInitParams initParams;
200 std::shared_ptr<AccessibilityAbilityInfo> installAbilityInfo =
201 std::make_shared<AccessibilityAbilityInfo>(initParams);
202 installAbilityInfo->SetAccessibilityAbilityType(AccessibilityAbilityTypes::ACCESSIBILITY_ABILITY_TYPE_ALL);
203 installAbilityInfo->SetPackageName("123");
204 auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
205
206 // add install ability dummy
207 EXPECT_EQ(1, (int)accountData->GetInstalledAbilities().size());
208 accountData->AddInstalledAbility(*installAbilityInfo);
209 EXPECT_EQ(2, (int)accountData->GetInstalledAbilities().size());
210
211 // ABILITY_STATE_DISABLE
212 int32_t stateType = AbilityStateType::ABILITY_STATE_DISABLE;
213 std::vector<OHOS::Accessibility::AccessibilityAbilityInfo> infos;
214 Singleton<AccessibleAbilityManagerService>::GetInstance().GetAbilityList(
215 AccessibilityAbilityTypes::ACCESSIBILITY_ABILITY_TYPE_SPOKEN, stateType, infos);
216 EXPECT_EQ(infos.size(), 1);
217
218 AAConnection_->OnAbilityDisconnectDoneSync(*elementName_);
219 accountData_->ClearInstalledAbility();
220 GTEST_LOG_(INFO) << "AAMSServerTest GetAbilityList_003 end";
221 }
222
223 /**
224 * @tc.number: AAMS_moduletest_GetAbilityList_004
225 * @tc.name: GetAbilityList
226 * @tc.desc: Test function GetAbilityList
227 * Get Disabled Ability list.
228 */
229 HWTEST_F(AAMSServerTest, GetAbilityList_004, TestSize.Level1)
230 {
231 GTEST_LOG_(INFO) << "AAMSServerTest GetAbilityList_004 start";
232
233 AddAccessibleAbilityConnection();
234 int32_t stateType = AbilityStateType::ABILITY_STATE_DISABLE;
235 std::vector<OHOS::Accessibility::AccessibilityAbilityInfo> infos;
236 Singleton<AccessibleAbilityManagerService>::GetInstance().GetAbilityList(
237 AccessibilityAbilityTypes::ACCESSIBILITY_ABILITY_TYPE_SPOKEN, stateType, infos);
238 EXPECT_EQ(infos.size(), 0);
239
240 AAConnection_->OnAbilityDisconnectDoneSync(*elementName_);
241 accountData_->ClearInstalledAbility();
242 GTEST_LOG_(INFO) << "AAMSServerTest GetAbilityList_004 end";
243 }
244
245 /**
246 * @tc.number: AAMS_moduletest_GetAbilityList_005
247 * @tc.name: GetAbilityList
248 * @tc.desc: Test function GetAbilityList
249 * Get Installed ability
250 */
251 HWTEST_F(AAMSServerTest, GetAbilityList_005, TestSize.Level1)
252 {
253 GTEST_LOG_(INFO) << "AAMSServerTest GetAbilityList_005 start";
254
255 AddAccessibleAbilityConnection();
256
257 std::vector<OHOS::Accessibility::AccessibilityAbilityInfo> infos;
258 Singleton<AccessibleAbilityManagerService>::GetInstance().GetAbilityList(
259 AccessibilityAbilityTypes::ACCESSIBILITY_ABILITY_TYPE_SPOKEN,
260 AbilityStateType::ABILITY_STATE_INSTALLED, infos);
261 EXPECT_EQ(infos.size(), 1);
262
263 AAConnection_->OnAbilityDisconnectDoneSync(*elementName_);
264 accountData_->ClearInstalledAbility();
265 GTEST_LOG_(INFO) << "AAMSServerTest GetAbilityList_005 end";
266 }
267
268 /**
269 * @tc.number: AAMS_moduletest_RegisterElementOperator_001
270 * @tc.name: RegisterElementOperator
271 * @tc.desc: Test function RegisterElementOperator
272 * Register a ElementOperator and check account data and event detail.
273 */
274 HWTEST_F(AAMSServerTest, RegisterElementOperator_001, TestSize.Level1)
275 {
276 GTEST_LOG_(INFO) << "AAMSServerTest RegisterElementOperator_001 start";
277 AddAccessibleAbilityConnection();
278 auto &aams = Singleton<AccessibleAbilityManagerService>::GetInstance();
279 auto accountData = aams.GetCurrentAccountData();
280 auto map = accountData->GetAsacConnections();
281 EXPECT_EQ(int(map.size()), 0);
282 EXPECT_EQ(RET_OK, aams.RegisterElementOperator(0, nullptr));
283 sleep(1);
284 GTEST_LOG_(INFO) << "RegisterElementOperator OK";
285 map = accountData->GetAsacConnections();
286 EXPECT_EQ(int(map.size()), 1);
287
288 aams.DeregisterElementOperator(0);
289 sleep(1);
290 AAConnection_->OnAbilityDisconnectDoneSync(*elementName_);
291 accountData_->ClearInstalledAbility();
292 GTEST_LOG_(INFO) << "AAMSServerTest RegisterElementOperator_001 end";
293 }
294
295 /**
296 * @tc.number: AAMS_moduletest_DeregisterElementOperator_001
297 * @tc.name: DeregisterElementOperator
298 * @tc.desc: Test function DeregisterElementOperator
299 * Deregister a ElementOperator and check account data and event detail.
300 */
301 HWTEST_F(AAMSServerTest, DeregisterElementOperator_001, TestSize.Level1)
302 {
303 GTEST_LOG_(INFO) << "AAMSServerTest DeregisterElementOperator_001 start";
304 auto &aams = Singleton<AccessibleAbilityManagerService>::GetInstance();
305 auto accountData = aams.GetCurrentAccountData();
306 auto map = accountData->GetAsacConnections();
307 EXPECT_EQ(int(map.size()), 0);
308
309 AddAccessibleAbilityConnection();
310 sleep(1);
311 aams.RegisterElementOperator(0, nullptr);
312 sleep(1);
313 map = accountData->GetAsacConnections();
314 EXPECT_EQ(int(map.size()), 1);
315
316 // wrong windowId
317 aams.DeregisterElementOperator(1);
318 sleep(1);
319 map = accountData->GetAsacConnections();
320 EXPECT_EQ(int(map.size()), 1);
321
322 // true windowId
323 aams.DeregisterElementOperator(0);
324 sleep(1);
325 map = accountData->GetAsacConnections();
326 EXPECT_EQ(int(map.size()), 0);
327
328 AAConnection_->OnAbilityDisconnectDoneSync(*elementName_);
329 accountData_->ClearInstalledAbility();
330 GTEST_LOG_(INFO) << "AAMSServerTest DeregisterElementOperator_001 end";
331 }
332 } // namespace Accessibility
333 } // namespace OHOS