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
27using namespace testing;
28using namespace testing::ext;
29
30namespace OHOS {
31namespace Accessibility {
32class MockAAMSServerTest : public testing::Test {
33public:
34    AAMSServerTest()
35    {}
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
52void AAMSServerTest::SetUpTestCase()
53{
54    GTEST_LOG_(INFO) << "AAMSServerTest SetUpTestCase";
55}
56
57void AAMSServerTest::TearDownTestCase()
58{
59    GTEST_LOG_(INFO) << "AAMSServerTest TearDownTestCase";
60}
61
62void 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
74void 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
89void 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
101void 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 */
130HWTEST_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 */
156HWTEST_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 */
174HWTEST_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 */
196HWTEST_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 */
232HWTEST_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 */
254HWTEST_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 */
277HWTEST_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    GTEST_LOG_(INFO) << "AAMSServerTest RegisterElementOperator_001 end";
296}
297
298/**
299 * @tc.number: AAMS_moduletest_DeregisterElementOperator_001
300 * @tc.name: DeregisterElementOperator
301 * @tc.desc: Test function DeregisterElementOperator
302 * Deregister a ElementOperator and check account data and event detail.
303 */
304HWTEST_F(AAMSServerTest, DeregisterElementOperator_001, TestSize.Level1)
305{
306    GTEST_LOG_(INFO) << "AAMSServerTest DeregisterElementOperator_001 start";
307    auto &aams = Singleton<AccessibleAbilityManagerService>::GetInstance();
308    auto accountData = aams.GetCurrentAccountData();
309    auto map = accountData->GetAsacConnections();
310    EXPECT_EQ(int(map.size()), 0);
311
312    AddAccessibleAbilityConnection();
313    sleep(1);
314    aams.RegisterElementOperator(0, nullptr, true);
315    sleep(1);
316    map = accountData->GetAsacConnections();
317    EXPECT_EQ(int(map.size()), 1);
318
319    // wrong windowId
320    aams.DeregisterElementOperator(1);
321    sleep(1);
322    map = accountData->GetAsacConnections();
323    EXPECT_EQ(int(map.size()), 1);
324
325    // true windowId
326    aams.DeregisterElementOperator(0);
327    sleep(1);
328    map = accountData->GetAsacConnections();
329    EXPECT_EQ(int(map.size()), 0);
330
331    AAConnection_->OnAbilityDisconnectDoneSync(*elementName_);
332    accountData_->ClearInstalledAbility();
333    GTEST_LOG_(INFO) << "AAMSServerTest DeregisterElementOperator_001 end";
334}
335} // namespace Accessibility
336} // namespace OHOS