1 /*
2 * Copyright (C) 2022-2025 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 #define private public
17 #define protected public
18 #include <gtest/gtest.h>
19 #include "accessibility_common_helper.h"
20 #include "accessibility_mt_helper.h"
21 #include "accessible_ability_channel.h"
22 #include "accessible_ability_connection.h"
23 #include "accessible_ability_manager_service.h"
24 #include "iservice_registry.h"
25 #undef private
26 #undef protected
27
28 using namespace testing;
29 using namespace testing::ext;
30
31 namespace OHOS {
32 namespace Accessibility {
33 namespace {
34 constexpr uint8_t TEST_NUM_2 = 2;
35 } // namespace
36 class AAMSServerTest : public testing::Test {
37 public:
AAMSServerTest()38 AAMSServerTest()
39 {}
~AAMSServerTest()40 ~AAMSServerTest()
41 {}
42
43 sptr<AccessibleAbilityChannel> aastub_ = nullptr;
44 sptr<AccessibleAbilityChannel> aacs_ = nullptr;
45
46 int32_t tempData_ = 0;
47 static void SetUpTestCase(void);
48 static void TearDownTestCase(void);
49 void SetUp();
50 void AddConnection();
51 void TearDown();
52 void WritefileAll(const char* fname, const char* data) const;
53 };
54
SetUpTestCase(void)55 void AAMSServerTest::SetUpTestCase(void)
56 {
57 Singleton<AccessibleAbilityManagerService>::GetInstance().OnStart();
58 AccessibilityCommonHelper::GetInstance().WaitForServicePublish();
59 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(AccessibilityHelper::accountId_);
60 GTEST_LOG_(INFO) << "AccessibleAbilityManagerService is published";
61 }
62
TearDownTestCase(void)63 void AAMSServerTest::TearDownTestCase(void)
64 {
65 Singleton<AccessibleAbilityManagerService>::GetInstance().OnStop();
66 }
67
SetUp()68 void AAMSServerTest::SetUp()
69 {
70 GTEST_LOG_(INFO) << "AAMSServerTest ModuleTest SetUp";
71
72 // Add an ability connection client
73 AccessibilityAbilityInitParams initParams;
74 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
75 abilityInfo->SetCapabilityValues(CAPABILITY_KEY_EVENT_OBSERVER);
76 AppExecFwk::ElementName elementName("deviceId", "bundleName", "name");
77 auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
78 accountData->AddInstalledAbility(*abilityInfo);
79 sleep(TEST_NUM_2);
80 sptr<AccessibleAbilityConnection> connection =
81 new AccessibleAbilityConnection(accountData->GetAccountId(), 0, *abilityInfo);
82 aastub_ = new AccessibleAbilityChannel(accountData->GetAccountId(), abilityInfo->GetId());
83 connection->OnAbilityConnectDoneSync(elementName, aastub_);
84 }
85
TearDown()86 void AAMSServerTest::TearDown()
87 {
88 GTEST_LOG_(INFO) << "AAMSServerTest ModuleTest TearDown";
89 aastub_ = nullptr;
90 }
91
WritefileAll(const char * fname,const char * data) const92 void AAMSServerTest::WritefileAll(const char* fname, const char* data) const
93 {
94 FILE* fp = nullptr;
95 if (!(fp = fopen(fname, "w"))) {
96 printf("open file %s fail \n", fname);
97 return;
98 }
99
100 (void)fprintf(fp, "%s", data);
101 (void)fclose(fp);
102 }
103
104 /**
105 * @tc.number: AAMS_moduletest_SendEvent_001
106 * @tc.name: SendEvent
107 * @tc.desc: Test function SendEvent aams send event to accessibility,and check the parm of event.
108 *
109 */
110 HWTEST_F(AAMSServerTest, SendEvent_001, TestSize.Level1)
111 {
112 GTEST_LOG_(INFO) << "AAMSServerTestSendEvent_001 start";
113 // make an event
114 auto &aams = Singleton<AccessibleAbilityManagerService>::GetInstance();
115 int32_t tempWindowId = aams.GetFocusWindowId();
116 AccessibilityEventInfo evtInf(tempWindowId, WINDOW_UPDATE_ACTIVE);
117 evtInf.SetEventType(EventType::TYPE_WINDOW_UPDATE);
118 AccessibilityEventInfoParcel evtInfParcel(evtInf);
119 // aams send event
120 aams.SendEvent(evtInfParcel, 0);
121 sleep(1);
122 // check aa proxy
123 EXPECT_EQ(AccessibilityHelper::GetInstance().GetTestEventType(), int(EventType::TYPE_WINDOW_UPDATE));
124 GTEST_LOG_(INFO) << "AAMSServerTestSendEvent_001 end";
125 }
126
127 /**
128 * @tc.number: AAMS_moduletest_GetAbilityList_001
129 * @tc.name: GetAbilityList
130 * @tc.desc: Test function GetAbilityList
131 * The func with Illegal parameter 1
132 */
133 HWTEST_F(AAMSServerTest, GetAbilityList_001, TestSize.Level1)
134 {
135 GTEST_LOG_(INFO) << "AAMSServerTestGetAbilityList_001 start";
136 std::vector<AccessibilityAbilityInfoParcel> infos;
137 auto &aams = Singleton<AccessibleAbilityManagerService>::GetInstance();
138 auto ret = aams.GetAbilityList(0, AbilityStateType::ABILITY_STATE_ENABLE, infos);
139 EXPECT_EQ(RET_OK, ret);
140 EXPECT_EQ(infos.size(), 0);
141
142 GTEST_LOG_(INFO) << "AAMSServerTestGetAbilityList_001 end";
143 }
144
145 /**
146 * @tc.number: AAMS_moduletest_GetAbilityList_002
147 * @tc.name: GetAbilityList
148 * @tc.desc: Test function GetAbilityList
149 * Get Enable Ability list.
150 */
151 HWTEST_F(AAMSServerTest, GetAbilityList_002, TestSize.Level1)
152 {
153 GTEST_LOG_(INFO) << "AAMSServerTestGetAbilityList_002 start";
154 std::vector<AccessibilityAbilityInfoParcel> infos;
155 Singleton<AccessibleAbilityManagerService>::GetInstance().GetAbilityList(
156 AccessibilityAbilityTypes::ACCESSIBILITY_ABILITY_TYPE_SPOKEN, AbilityStateType::ABILITY_STATE_ENABLE, infos);
157 EXPECT_EQ(infos.size(), 0);
158 GTEST_LOG_(INFO) << "AAMSServerTestGetAbilityList_002 end";
159 }
160
161 /**
162 * @tc.number: AAMS_moduletest_GetAbilityList_003
163 * @tc.name: GetAbilityList
164 * @tc.desc: Test function GetAbilityList
165 * Get Disable Ability list with 2 installed ability accessibility and a connected accessibility ability.
166 */
167 HWTEST_F(AAMSServerTest, GetAbilityList_003, TestSize.Level1)
168 {
169 GTEST_LOG_(INFO) << "AAMSServerTestGetAbilityList_003 start";
170 AccessibilityAbilityInitParams initParams;
171 std::shared_ptr<AccessibilityAbilityInfo> installAbilityInfo =
172 std::make_shared<AccessibilityAbilityInfo>(initParams);
173 installAbilityInfo->SetAccessibilityAbilityType(AccessibilityAbilityTypes::ACCESSIBILITY_ABILITY_TYPE_ALL);
174 installAbilityInfo->SetPackageName("123");
175 auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
176
177 // add install ability dummy
178 EXPECT_EQ(1, (int)accountData->GetInstalledAbilities().size());
179 accountData->AddInstalledAbility(*installAbilityInfo);
180 EXPECT_EQ(2, (int)accountData->GetInstalledAbilities().size());
181
182 // ABILITY_STATE_DISABLE
183 int32_t stateType = AbilityStateType::ABILITY_STATE_DISABLE;
184 std::vector<AccessibilityAbilityInfoParcel> infos;
185 Singleton<AccessibleAbilityManagerService>::GetInstance().GetAbilityList(
186 AccessibilityAbilityTypes::ACCESSIBILITY_ABILITY_TYPE_SPOKEN, stateType, infos);
187 EXPECT_EQ(infos.size(), 1);
188 GTEST_LOG_(INFO) << "AAMSServerTestGetAbilityList_003 end";
189 }
190
191 /**
192 * @tc.number: AAMS_moduletest_GetAbilityList_004
193 * @tc.name: GetAbilityList
194 * @tc.desc: Test function GetAbilityList
195 * Get Disabled Ability list.
196 */
197 HWTEST_F(AAMSServerTest, GetAbilityList_004, TestSize.Level1)
198 {
199 GTEST_LOG_(INFO) << "AAMSServerTestGetAbilityList_004 start";
200 int32_t stateType = AbilityStateType::ABILITY_STATE_DISABLE;
201 std::vector<AccessibilityAbilityInfoParcel> infos;
202 Singleton<AccessibleAbilityManagerService>::GetInstance().GetAbilityList(
203 AccessibilityAbilityTypes::ACCESSIBILITY_ABILITY_TYPE_SPOKEN, stateType, infos);
204 EXPECT_EQ(infos.size(), 1);
205 GTEST_LOG_(INFO) << "AAMSServerTestGetAbilityList_004 end";
206 }
207
208 /**
209 * @tc.number: AAMS_moduletest_GetAbilityList_005
210 * @tc.name: GetAbilityList
211 * @tc.desc: Test function GetAbilityList
212 * Get Installed ability
213 */
214 HWTEST_F(AAMSServerTest, GetAbilityList_005, TestSize.Level1)
215 {
216 GTEST_LOG_(INFO) << "AAMSServerTestGetAbilityList_005 start";
217 std::vector<AccessibilityAbilityInfoParcel> infos;
218 Singleton<AccessibleAbilityManagerService>::GetInstance().GetAbilityList(
219 AccessibilityAbilityTypes::ACCESSIBILITY_ABILITY_TYPE_SPOKEN,
220 AbilityStateType::ABILITY_STATE_INSTALLED, infos);
221 EXPECT_EQ(infos.size(), 1);
222 GTEST_LOG_(INFO) << "AAMSServerTestGetAbilityList_005 end";
223 }
224
225 /**
226 * @tc.number: AAMS_moduletest_RegisterElementOperatorByWindowId_001
227 * @tc.name: RegisterElementOperatorByWindowId
228 * @tc.desc: Test function RegisterElementOperatorByWindowId
229 * Register a ElementOperator and check account data and event detail.
230 */
231 HWTEST_F(AAMSServerTest, RegisterElementOperatorByWindowId_001, TestSize.Level1)
232 {
233 GTEST_LOG_(INFO) << "AAMSServerTestRegisterElementOperatorByWindowId_001 start";
234
235 auto &aams = Singleton<AccessibleAbilityManagerService>::GetInstance();
236 auto accountData = aams.GetCurrentAccountData();
237 auto map = accountData->GetAsacConnections();
238 EXPECT_EQ(int(map.size()), 0);
239 EXPECT_EQ(RET_OK, aams.RegisterElementOperatorByWindowId(0, nullptr));
240 sleep(1);
241 GTEST_LOG_(INFO) << "RegisterElementOperatorByWindowId OK";
242 map = accountData->GetAsacConnections();
243 EXPECT_EQ(int(map.size()), 1);
244
245 aams.DeregisterElementOperatorByWindowId(0);
246 GTEST_LOG_(INFO) << "AAMSServerTestRegisterElementOperatorByWindowId_001 end";
247 }
248
249 /**
250 * @tc.number: AAMS_moduletest_DeregisterElementOperatorByWindowId_001
251 * @tc.name: DeregisterElementOperatorByWindowId
252 * @tc.desc: Test function DeregisterElementOperatorByWindowId
253 * Deregister a ElementOperator and check account data and event detail.
254 */
255 HWTEST_F(AAMSServerTest, DeregisterElementOperatorByWindowId_001, TestSize.Level1)
256 {
257 GTEST_LOG_(INFO) << "AAMSServerTestDeregisterElementOperatorByWindowId_001 start";
258 auto &aams = Singleton<AccessibleAbilityManagerService>::GetInstance();
259 auto accountData = aams.GetCurrentAccountData();
260 auto map = accountData->GetAsacConnections();
261 EXPECT_EQ(int(map.size()), 1);
262
263 aams.RegisterElementOperatorByWindowId(0, nullptr);
264 sleep(1);
265 map = accountData->GetAsacConnections();
266 EXPECT_EQ(int(map.size()), 1);
267
268 // wrong windowId
269 aams.DeregisterElementOperatorByWindowId(1);
270 sleep(1);
271 map = accountData->GetAsacConnections();
272 EXPECT_EQ(int(map.size()), 1);
273
274 // true windowId
275 aams.DeregisterElementOperatorByWindowId(0);
276 sleep(1);
277 map = accountData->GetAsacConnections();
278 EXPECT_EQ(int(map.size()), 1);
279 GTEST_LOG_(INFO) << "AAMSServerTestDeregisterElementOperatorByWindowId_001 end";
280 }
281 } // namespace Accessibility
282 } // namespace OHOS