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 sleep(1);
176 AddAccessibleAbilityConnection();
177
178 std::vector<OHOS::Accessibility::AccessibilityAbilityInfo> infos;
179 Singleton<AccessibleAbilityManagerService>::GetInstance().GetAbilityList(
180 AccessibilityAbilityTypes::ACCESSIBILITY_ABILITY_TYPE_SPOKEN, AbilityStateType::ABILITY_STATE_ENABLE, infos);
181 EXPECT_GE(infos.size(), 0);
182
183 AAConnection_->OnAbilityDisconnectDoneSync(*elementName_);
184 accountData_->ClearInstalledAbility();
185 GTEST_LOG_(INFO) << "AAMSServerTest GetAbilityList_002 end";
186 }
187
188 /**
189 * @tc.number: AAMS_moduletest_GetAbilityList_003
190 * @tc.name: GetAbilityList
191 * @tc.desc: Test function GetAbilityList
192 * Get Disable Ability list with 2 installed ability accessibility and a connected accessibility ability.
193 */
194 HWTEST_F(AAMSServerTest, GetAbilityList_003, TestSize.Level1)
195 {
196 GTEST_LOG_(INFO) << "AAMSServerTest GetAbilityList_003 start";
197 sleep(1);
198 AddAccessibleAbilityConnection();
199
200 AccessibilityAbilityInitParams initParams;
201 std::shared_ptr<AccessibilityAbilityInfo> installAbilityInfo =
202 std::make_shared<AccessibilityAbilityInfo>(initParams);
203 installAbilityInfo->SetAccessibilityAbilityType(AccessibilityAbilityTypes::ACCESSIBILITY_ABILITY_TYPE_ALL);
204 installAbilityInfo->SetPackageName("123");
205 auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
206
207 // add install ability dummy
208 EXPECT_EQ(1, (int)accountData->GetInstalledAbilities().size());
209 accountData->AddInstalledAbility(*installAbilityInfo);
210 EXPECT_EQ(2, (int)accountData->GetInstalledAbilities().size());
211
212 // ABILITY_STATE_DISABLE
213 int32_t stateType = AbilityStateType::ABILITY_STATE_DISABLE;
214 std::vector<OHOS::Accessibility::AccessibilityAbilityInfo> infos;
215 Singleton<AccessibleAbilityManagerService>::GetInstance().GetAbilityList(
216 AccessibilityAbilityTypes::ACCESSIBILITY_ABILITY_TYPE_SPOKEN, stateType, infos);
217 EXPECT_GE(infos.size(), 0);
218
219 AAConnection_->OnAbilityDisconnectDoneSync(*elementName_);
220 accountData_->ClearInstalledAbility();
221 GTEST_LOG_(INFO) << "AAMSServerTest GetAbilityList_003 end";
222 }
223
224 /**
225 * @tc.number: AAMS_moduletest_GetAbilityList_004
226 * @tc.name: GetAbilityList
227 * @tc.desc: Test function GetAbilityList
228 * Get Disabled Ability list.
229 */
230 HWTEST_F(AAMSServerTest, GetAbilityList_004, TestSize.Level1)
231 {
232 GTEST_LOG_(INFO) << "AAMSServerTest GetAbilityList_004 start";
233 sleep(1);
234 AddAccessibleAbilityConnection();
235 int32_t stateType = AbilityStateType::ABILITY_STATE_DISABLE;
236 std::vector<OHOS::Accessibility::AccessibilityAbilityInfo> infos;
237 Singleton<AccessibleAbilityManagerService>::GetInstance().GetAbilityList(
238 AccessibilityAbilityTypes::ACCESSIBILITY_ABILITY_TYPE_SPOKEN, stateType, infos);
239 EXPECT_GE(infos.size(), 0);
240
241 AAConnection_->OnAbilityDisconnectDoneSync(*elementName_);
242 accountData_->ClearInstalledAbility();
243 GTEST_LOG_(INFO) << "AAMSServerTest GetAbilityList_004 end";
244 }
245
246 /**
247 * @tc.number: AAMS_moduletest_GetAbilityList_005
248 * @tc.name: GetAbilityList
249 * @tc.desc: Test function GetAbilityList
250 * Get Installed ability
251 */
252 HWTEST_F(AAMSServerTest, GetAbilityList_005, TestSize.Level1)
253 {
254 GTEST_LOG_(INFO) << "AAMSServerTest GetAbilityList_005 start";
255
256 AddAccessibleAbilityConnection();
257
258 std::vector<OHOS::Accessibility::AccessibilityAbilityInfo> infos;
259 Singleton<AccessibleAbilityManagerService>::GetInstance().GetAbilityList(
260 AccessibilityAbilityTypes::ACCESSIBILITY_ABILITY_TYPE_SPOKEN,
261 AbilityStateType::ABILITY_STATE_INSTALLED, infos);
262 EXPECT_EQ(infos.size(), 1);
263
264 AAConnection_->OnAbilityDisconnectDoneSync(*elementName_);
265 accountData_->ClearInstalledAbility();
266 GTEST_LOG_(INFO) << "AAMSServerTest GetAbilityList_005 end";
267 }
268
269 /**
270 * @tc.number: AAMS_moduletest_RegisterElementOperator_001
271 * @tc.name: RegisterElementOperator
272 * @tc.desc: Test function RegisterElementOperator
273 * Register a ElementOperator and check account data and event detail.
274 */
275 HWTEST_F(AAMSServerTest, RegisterElementOperator_001, TestSize.Level1)
276 {
277 GTEST_LOG_(INFO) << "AAMSServerTest RegisterElementOperator_001 start";
278 AddAccessibleAbilityConnection();
279 auto &aams = Singleton<AccessibleAbilityManagerService>::GetInstance();
280 auto accountData = aams.GetCurrentAccountData();
281 auto map = accountData->GetAsacConnections();
282 EXPECT_EQ(int(map.size()), 0);
283 EXPECT_EQ(RET_OK, aams.RegisterElementOperator(0, nullptr));
284 sleep(1);
285 GTEST_LOG_(INFO) << "RegisterElementOperator OK";
286 map = accountData->GetAsacConnections();
287 EXPECT_EQ(int(map.size()), 1);
288
289 aams.DeregisterElementOperator(0);
290 sleep(1);
291 AAConnection_->OnAbilityDisconnectDoneSync(*elementName_);
292 accountData_->ClearInstalledAbility();
293 GTEST_LOG_(INFO) << "AAMSServerTest RegisterElementOperator_001 end";
294 }
295
296 /**
297 * @tc.number: AAMS_moduletest_DeregisterElementOperator_001
298 * @tc.name: DeregisterElementOperator
299 * @tc.desc: Test function DeregisterElementOperator
300 * Deregister a ElementOperator and check account data and event detail.
301 */
302 HWTEST_F(AAMSServerTest, DeregisterElementOperator_001, TestSize.Level1)
303 {
304 GTEST_LOG_(INFO) << "AAMSServerTest DeregisterElementOperator_001 start";
305 auto &aams = Singleton<AccessibleAbilityManagerService>::GetInstance();
306 auto accountData = aams.GetCurrentAccountData();
307 auto map = accountData->GetAsacConnections();
308 EXPECT_EQ(int(map.size()), 0);
309
310 AddAccessibleAbilityConnection();
311 sleep(1);
312 aams.RegisterElementOperator(0, nullptr);
313 sleep(1);
314 map = accountData->GetAsacConnections();
315 EXPECT_EQ(int(map.size()), 1);
316
317 // wrong windowId
318 aams.DeregisterElementOperator(1);
319 sleep(1);
320 map = accountData->GetAsacConnections();
321 EXPECT_EQ(int(map.size()), 1);
322
323 // true windowId
324 aams.DeregisterElementOperator(0);
325 sleep(1);
326 map = accountData->GetAsacConnections();
327 EXPECT_EQ(int(map.size()), 0);
328
329 AAConnection_->OnAbilityDisconnectDoneSync(*elementName_);
330 accountData_->ClearInstalledAbility();
331 GTEST_LOG_(INFO) << "AAMSServerTest DeregisterElementOperator_001 end";
332 }
333 } // namespace Accessibility
334 } // namespace OHOS