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 sleep(1);
71 GTEST_LOG_(INFO) << "AccessibleAbilityManagerService is published";
72 }
73
TearDown()74 void AAMSServerTest::TearDown()
75 {
76 GTEST_LOG_(INFO) << "AAMSServerTest TearDown";
77 AccessibilityHelper::GetInstance().SetTestStub(nullptr);
78 AccessibilityHelper::GetInstance().SetTestStateType(-1);
79 AccessibilityHelper::GetInstance().SetTestEventType(-1);
80 AccessibilityHelper::GetInstance().SetTestWindowChangeTypes(-1);
81 AccessibilityHelper::GetInstance().SetTestWindowId(-1);
82 Singleton<AccessibleAbilityManagerService>::GetInstance().OnStop();
83 accountData_ = nullptr;
84 aastub_ = nullptr;
85 elementName_ = nullptr;
86 AAConnection_ = nullptr;
87 }
88
WritefileAll(const char * fname,const char * data)89 void AAMSServerTest::WritefileAll(const char* fname, const char* data)
90 {
91 FILE* fp = nullptr;
92 if (!(fp = fopen(fname, "w"))) {
93 printf("open file %s fail \n", fname);
94 return;
95 }
96
97 (void)fprintf(fp, "%s", data);
98 (void)fclose(fp);
99 }
100
AddAccessibleAbilityConnection()101 void AAMSServerTest::AddAccessibleAbilityConnection()
102 {
103 GTEST_LOG_(INFO) << "AAMSServerTest AddAccessibleAbilityConnection";
104 // accessibleAbility connection
105 AAFwk::Want want;
106 AppExecFwk::ElementName name;
107 std::string deviceId;
108 name.SetAbilityName("com.example.aalisttest.MainAbility");
109 name.SetBundleName("com.example.aalisttest");
110 want.SetElement(name);
111
112 AccessibilityAbilityInitParams initParams;
113 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
114 abilityInfo->SetAccessibilityAbilityType(AccessibilityAbilityTypes::ACCESSIBILITY_ABILITY_TYPE_ALL);
115 accountData_ = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
116 AAConnection_ = new AccessibleAbilityConnection(accountData_->GetAccountId(), 0, *abilityInfo);
117 elementName_ = new AppExecFwk::ElementName(deviceId, initParams.bundleName, initParams.name);
118 aastub_ = new AccessibleAbilityChannel(accountData_->GetAccountId(), abilityInfo->GetId());
119 AAConnection_->OnAbilityConnectDoneSync(*elementName_, aastub_);
120 accountData_->AddInstalledAbility(*abilityInfo);
121 sleep(1);
122 }
123
124 /**
125 * @tc.number: AAMS_moduletest_SendEvent_001
126 * @tc.name: SendEvent
127 * @tc.desc: Test function SendEvent aams send event to accessibility,and check the parm of event.
128 *
129 */
130 HWTEST_F(AAMSServerTest, SendEvent_001, TestSize.Level1)
131 {
132 GTEST_LOG_(INFO) << "AAMSServerTest SendEvent_001 start";
133 // register AA
134 AddAccessibleAbilityConnection();
135 // make an event
136 AccessibilityEventInfo eventInfo;
137 eventInfo.SetEventType(EventType::TYPE_WINDOW_UPDATE);
138 // aams send event
139 Singleton<AccessibleAbilityManagerService>::GetInstance().SendEvent(eventInfo);
140 sleep(1);
141 // check aa proxy
142 EXPECT_EQ(AccessibilityHelper::GetInstance().GetTestEventType(), int(EventType::TYPE_WINDOW_UPDATE));
143
144 AAConnection_->OnAbilityDisconnectDoneSync(*elementName_);
145 accountData_->ClearInstalledAbility();
146
147 GTEST_LOG_(INFO) << "AAMSServerTest SendEvent_001 end";
148 }
149
150 /**
151 * @tc.number: AAMS_moduletest_GetAbilityList_001
152 * @tc.name: GetAbilityList
153 * @tc.desc: Test function GetAbilityList
154 * The func with Illegal parameter 1
155 */
156 HWTEST_F(AAMSServerTest, GetAbilityList_001, TestSize.Level1)
157 {
158 GTEST_LOG_(INFO) << "AAMSServerTest GetAbilityList_001 start";
159 std::vector<OHOS::Accessibility::AccessibilityAbilityInfo> infos;
160 auto &aams = Singleton<AccessibleAbilityManagerService>::GetInstance();
161 auto ret = aams.GetAbilityList(0, AbilityStateType::ABILITY_STATE_ENABLE, infos);
162 EXPECT_EQ(RET_OK, ret);
163 EXPECT_EQ(infos.size(), 0);
164
165 GTEST_LOG_(INFO) << "AAMSServerTest GetAbilityList_001 end";
166 }
167
168 /**
169 * @tc.number: AAMS_moduletest_GetAbilityList_002
170 * @tc.name: GetAbilityList
171 * @tc.desc: Test function GetAbilityList
172 * Get Enable Ability list.
173 */
174 HWTEST_F(AAMSServerTest, GetAbilityList_002, TestSize.Level1)
175 {
176 GTEST_LOG_(INFO) << "AAMSServerTest GetAbilityList_002 start";
177 sleep(1);
178 AddAccessibleAbilityConnection();
179
180 std::vector<OHOS::Accessibility::AccessibilityAbilityInfo> infos;
181 Singleton<AccessibleAbilityManagerService>::GetInstance().GetAbilityList(
182 AccessibilityAbilityTypes::ACCESSIBILITY_ABILITY_TYPE_SPOKEN, AbilityStateType::ABILITY_STATE_ENABLE, infos);
183 EXPECT_EQ(infos.size(), 1);
184
185 AAConnection_->OnAbilityDisconnectDoneSync(*elementName_);
186 accountData_->ClearInstalledAbility();
187 GTEST_LOG_(INFO) << "AAMSServerTest GetAbilityList_002 end";
188 }
189
190 /**
191 * @tc.number: AAMS_moduletest_GetAbilityList_003
192 * @tc.name: GetAbilityList
193 * @tc.desc: Test function GetAbilityList
194 * Get Disable Ability list with 2 installed ability accessibility and a connected accessibility ability.
195 */
196 HWTEST_F(AAMSServerTest, GetAbilityList_003, TestSize.Level1)
197 {
198 GTEST_LOG_(INFO) << "AAMSServerTest GetAbilityList_003 start";
199 sleep(1);
200 AddAccessibleAbilityConnection();
201
202 AccessibilityAbilityInitParams initParams;
203 std::shared_ptr<AccessibilityAbilityInfo> installAbilityInfo =
204 std::make_shared<AccessibilityAbilityInfo>(initParams);
205 installAbilityInfo->SetAccessibilityAbilityType(AccessibilityAbilityTypes::ACCESSIBILITY_ABILITY_TYPE_ALL);
206 installAbilityInfo->SetPackageName("123");
207 auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
208
209 // add install ability dummy
210 EXPECT_EQ(1, (int)accountData->GetInstalledAbilities().size());
211 accountData->AddInstalledAbility(*installAbilityInfo);
212 EXPECT_EQ(2, (int)accountData->GetInstalledAbilities().size());
213
214 // ABILITY_STATE_DISABLE
215 int32_t stateType = AbilityStateType::ABILITY_STATE_DISABLE;
216 std::vector<OHOS::Accessibility::AccessibilityAbilityInfo> infos;
217 Singleton<AccessibleAbilityManagerService>::GetInstance().GetAbilityList(
218 AccessibilityAbilityTypes::ACCESSIBILITY_ABILITY_TYPE_SPOKEN, stateType, infos);
219 EXPECT_EQ(infos.size(), 1);
220
221 AAConnection_->OnAbilityDisconnectDoneSync(*elementName_);
222 accountData_->ClearInstalledAbility();
223 GTEST_LOG_(INFO) << "AAMSServerTest GetAbilityList_003 end";
224 }
225
226 /**
227 * @tc.number: AAMS_moduletest_GetAbilityList_004
228 * @tc.name: GetAbilityList
229 * @tc.desc: Test function GetAbilityList
230 * Get Disabled Ability list.
231 */
232 HWTEST_F(AAMSServerTest, GetAbilityList_004, TestSize.Level1)
233 {
234 GTEST_LOG_(INFO) << "AAMSServerTest GetAbilityList_004 start";
235 sleep(1);
236 AddAccessibleAbilityConnection();
237 int32_t stateType = AbilityStateType::ABILITY_STATE_DISABLE;
238 std::vector<OHOS::Accessibility::AccessibilityAbilityInfo> infos;
239 Singleton<AccessibleAbilityManagerService>::GetInstance().GetAbilityList(
240 AccessibilityAbilityTypes::ACCESSIBILITY_ABILITY_TYPE_SPOKEN, stateType, infos);
241 EXPECT_EQ(infos.size(), 0);
242
243 AAConnection_->OnAbilityDisconnectDoneSync(*elementName_);
244 accountData_->ClearInstalledAbility();
245 GTEST_LOG_(INFO) << "AAMSServerTest GetAbilityList_004 end";
246 }
247
248 /**
249 * @tc.number: AAMS_moduletest_GetAbilityList_005
250 * @tc.name: GetAbilityList
251 * @tc.desc: Test function GetAbilityList
252 * Get Installed ability
253 */
254 HWTEST_F(AAMSServerTest, GetAbilityList_005, TestSize.Level1)
255 {
256 GTEST_LOG_(INFO) << "AAMSServerTest GetAbilityList_005 start";
257
258 AddAccessibleAbilityConnection();
259
260 std::vector<OHOS::Accessibility::AccessibilityAbilityInfo> infos;
261 Singleton<AccessibleAbilityManagerService>::GetInstance().GetAbilityList(
262 AccessibilityAbilityTypes::ACCESSIBILITY_ABILITY_TYPE_SPOKEN,
263 AbilityStateType::ABILITY_STATE_INSTALLED, infos);
264 EXPECT_EQ(infos.size(), 1);
265
266 AAConnection_->OnAbilityDisconnectDoneSync(*elementName_);
267 accountData_->ClearInstalledAbility();
268 GTEST_LOG_(INFO) << "AAMSServerTest GetAbilityList_005 end";
269 }
270
271 /**
272 * @tc.number: AAMS_moduletest_RegisterElementOperator_001
273 * @tc.name: RegisterElementOperator
274 * @tc.desc: Test function RegisterElementOperator
275 * Register a ElementOperator and check account data and event detail.
276 */
277 HWTEST_F(AAMSServerTest, RegisterElementOperator_001, TestSize.Level1)
278 {
279 GTEST_LOG_(INFO) << "AAMSServerTest RegisterElementOperator_001 start";
280 AddAccessibleAbilityConnection();
281 auto &aams = Singleton<AccessibleAbilityManagerService>::GetInstance();
282 auto accountData = aams.GetCurrentAccountData();
283 auto map = accountData->GetAsacConnections();
284 EXPECT_EQ(int(map.size()), 0);
285 EXPECT_EQ(RET_OK, aams.RegisterElementOperator(0, nullptr, true));
286 sleep(1);
287 GTEST_LOG_(INFO) << "RegisterElementOperator OK";
288 map = accountData->GetAsacConnections();
289 EXPECT_EQ(int(map.size()), 1);
290
291 aams.DeregisterElementOperator(0);
292 sleep(1);
293 AAConnection_->OnAbilityDisconnectDoneSync(*elementName_);
294 accountData_->ClearInstalledAbility();
295 sleep(1);
296 GTEST_LOG_(INFO) << "AAMSServerTest RegisterElementOperator_001 end";
297 }
298
299 /**
300 * @tc.number: AAMS_moduletest_DeregisterElementOperator_001
301 * @tc.name: DeregisterElementOperator
302 * @tc.desc: Test function DeregisterElementOperator
303 * Deregister a ElementOperator and check account data and event detail.
304 */
305 HWTEST_F(AAMSServerTest, DeregisterElementOperator_001, TestSize.Level1)
306 {
307 GTEST_LOG_(INFO) << "AAMSServerTest DeregisterElementOperator_001 start";
308 auto &aams = Singleton<AccessibleAbilityManagerService>::GetInstance();
309 auto accountData = aams.GetCurrentAccountData();
310 auto map = accountData->GetAsacConnections();
311 EXPECT_EQ(int(map.size()), 0);
312
313 AddAccessibleAbilityConnection();
314 sleep(1);
315 aams.RegisterElementOperator(0, nullptr, true);
316 sleep(1);
317 map = accountData->GetAsacConnections();
318 EXPECT_EQ(int(map.size()), 1);
319
320 // wrong windowId
321 aams.DeregisterElementOperator(1);
322 sleep(1);
323 map = accountData->GetAsacConnections();
324 EXPECT_EQ(int(map.size()), 1);
325
326 // true windowId
327 aams.DeregisterElementOperator(0);
328 sleep(1);
329 map = accountData->GetAsacConnections();
330 EXPECT_EQ(int(map.size()), 0);
331
332 AAConnection_->OnAbilityDisconnectDoneSync(*elementName_);
333 accountData_->ClearInstalledAbility();
334 sleep(1);
335 GTEST_LOG_(INFO) << "AAMSServerTest DeregisterElementOperator_001 end";
336 }
337 } // namespace Accessibility
338 } // namespace OHOS