1 /*
2  * Copyright (c) 2021-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 <unistd.h>
17 #include "gtest/gtest.h"
18 
19 #include "mock_ability_mgr_service.h"
20 #include "ability_manager_interface.h"
21 #include "want.h"
22 #include "iremote_object.h"
23 #include "mock_ability_scheduler.h"
24 #include "ability_record.h"
25 #include "ability_info.h"
26 #include "application_info.h"
27 
28 using namespace testing;
29 using namespace testing::ext;
30 using namespace OHOS;
31 using namespace OHOS::AAFwk;
32 using namespace OHOS::AppExecFwk;
33 using OHOS::iface_cast;
34 using OHOS::sptr;
35 using testing::_;
36 using testing::Invoke;
37 using testing::InvokeWithoutArgs;
38 class IpcAbilityMgrModuleTest : public testing::Test {
39 public:
40     static void SetUpTestCase();
41     static void TearDownTestCase();
42     void SetUp();
43     void TearDown();
44     AbilityRequest CreateAbilityRequest(const std::string& abilityName, const std::string& bundleName);
45 
46     static constexpr int COUNT = 5;
47 };
48 
SetUpTestCase()49 void IpcAbilityMgrModuleTest::SetUpTestCase()
50 {}
51 
TearDownTestCase()52 void IpcAbilityMgrModuleTest::TearDownTestCase()
53 {}
54 
SetUp()55 void IpcAbilityMgrModuleTest::SetUp()
56 {}
57 
TearDown()58 void IpcAbilityMgrModuleTest::TearDown()
59 {}
60 
CreateAbilityRequest(const std::string & abilityName,const std::string & bundleName)61 AbilityRequest IpcAbilityMgrModuleTest::CreateAbilityRequest(
62     const std::string& abilityName, const std::string& bundleName)
63 {
64     AbilityRequest abilityRequest;
65 
66     ElementName element("device", bundleName, abilityName);
67     Want want;
68     want.SetElement(element);
69 
70     AbilityInfo abilityInfo;
71     abilityInfo.name = abilityName;
72     abilityInfo.applicationName = bundleName;
73     abilityInfo.bundleName = bundleName;
74     abilityInfo.type = AbilityType::PAGE;
75 
76     ApplicationInfo appInfo;
77     appInfo.name = bundleName;
78     appInfo.bundleName = bundleName;
79 
80     abilityRequest.want = want;
81     abilityRequest.abilityInfo = abilityInfo;
82     abilityRequest.appInfo = appInfo;
83     return abilityRequest;
84 }
85 
86 /*
87  * Feature: AAFwk
88  * Function: AbilityManagerService
89  * SubFunction: IPC of client and server
90  * FunctionPoints: start ability
91  * EnvConditions: NA
92  * CaseDescription: verify StartAbility IPC between client and server.
93  */
94 HWTEST_F(IpcAbilityMgrModuleTest, AbilityMgrService_IPC_001, TestSize.Level1)
95 {
96     GTEST_LOG_(INFO) << "IpcAbilityMgrModuleTest AbilityMgrService_IPC_001 start";
97     for (int i = 0; i < COUNT; i++) {
98         sptr<MockAbilityMgrService> mockAbilityMgr(new MockAbilityMgrService());
99         sptr<IAbilityManager> abilityMgrClient = iface_cast<IAbilityManager>(mockAbilityMgr);
100         const Want want;
101 
102         EXPECT_CALL(*mockAbilityMgr, StartAbility(_, _, _))
103             .Times(1)
104             .WillOnce(InvokeWithoutArgs(mockAbilityMgr.GetRefPtr(), &MockAbilityMgrService::Post));
105         abilityMgrClient->StartAbility(want, -1, 0);
106         mockAbilityMgr->Wait();
107     }
108 
109     GTEST_LOG_(INFO) << "IpcAbilityMgrModuleTest AbilityMgrService_IPC_001 end";
110 }
111 
112 /*
113  * Feature: AAFwk
114  * Function: AbilityManagerService
115  * SubFunction: IPC of client and server
116  * FunctionPoints: AbilityTransitionDone
117  * EnvConditions: NA
118  * CaseDescription: verify AbilityTransitionDone IPC between client and server.
119  */
120 HWTEST_F(IpcAbilityMgrModuleTest, AbilityMgrService_IPC_002, TestSize.Level1)
121 {
122     GTEST_LOG_(INFO) << "IpcAbilityMgrModuleTest AbilityMgrService_IPC_002 start";
123     std::string abilityName = "ability_name";
124     std::string bundleName = "com.ix.aafwk.moduletest";
125     auto abilityRequest = CreateAbilityRequest(abilityName, bundleName);
126     auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
127     EXPECT_TRUE(abilityRecord);
128     for (int i = 0; i < COUNT; i++) {
129         sptr<MockAbilityMgrService> mockAbilityMgr(new MockAbilityMgrService());
130         sptr<IAbilityManager> abilityMgrClient = iface_cast<IAbilityManager>(mockAbilityMgr);
131         EXPECT_CALL(*mockAbilityMgr, AbilityTransitionDone(_, _, _))
132             .Times(1)
133             .WillOnce(InvokeWithoutArgs(mockAbilityMgr.GetRefPtr(), &MockAbilityMgrService::Post));
134         PacMap pmap;
135         abilityMgrClient->AbilityTransitionDone(abilityRecord->GetToken(), 0, pmap);
136         mockAbilityMgr->Wait();
137     }
138 
139     GTEST_LOG_(INFO) << "IpcAbilityMgrModuleTest AbilityMgrService_IPC_002 end";
140 }
141 
142 /*
143  * Feature: AAFwk
144  * Function: AbilityManagerService
145  * SubFunction: IPC of client and server
146  * FunctionPoints: ScheduleConnectAbilityDone
147  * EnvConditions: NA
148  * CaseDescription: verify ScheduleConnectAbilityDone IPC between client and server.
149  */
150 HWTEST_F(IpcAbilityMgrModuleTest, AbilityMgrService_IPC_003, TestSize.Level1)
151 {
152     GTEST_LOG_(INFO) << "IpcAbilityMgrModuleTest AbilityMgrService_IPC_003 start";
153     for (int i = 0; i < COUNT; i++) {
154         sptr<MockAbilityMgrService> mockAbilityMgr(new MockAbilityMgrService());
155         sptr<IAbilityManager> abilityMgrClient = iface_cast<IAbilityManager>(mockAbilityMgr);
156 
157         EXPECT_CALL(*mockAbilityMgr, ScheduleConnectAbilityDone(_, _))
158             .Times(1)
159             .WillOnce(InvokeWithoutArgs(mockAbilityMgr.GetRefPtr(), &MockAbilityMgrService::Post));
160         abilityMgrClient->ScheduleConnectAbilityDone(nullptr, nullptr);
161         mockAbilityMgr->Wait();
162     }
163 
164     GTEST_LOG_(INFO) << "IpcAbilityMgrModuleTest AbilityMgrService_IPC_003 end";
165 }
166 
167 /*
168  * Feature: AAFwk
169  * Function: AbilityManagerService
170  * SubFunction: IPC of client and server
171  * FunctionPoints: ScheduleDisconnectAbilityDone
172  * EnvConditions: NA
173  * CaseDescription: verify ScheduleDisconnectAbilityDone IPC between client and server.
174  */
175 HWTEST_F(IpcAbilityMgrModuleTest, AbilityMgrService_IPC_004, TestSize.Level1)
176 {
177     GTEST_LOG_(INFO) << "IpcAbilityMgrModuleTest AbilityMgrService_IPC_004 start";
178     for (int i = 0; i < COUNT; i++) {
179         sptr<MockAbilityMgrService> mockAbilityMgr(new MockAbilityMgrService());
180         sptr<IAbilityManager> abilityMgrClient = iface_cast<IAbilityManager>(mockAbilityMgr);
181 
182         EXPECT_CALL(*mockAbilityMgr, ScheduleDisconnectAbilityDone(_))
183             .Times(1)
184             .WillOnce(InvokeWithoutArgs(mockAbilityMgr.GetRefPtr(), &MockAbilityMgrService::Post));
185         abilityMgrClient->ScheduleDisconnectAbilityDone(nullptr);
186         mockAbilityMgr->Wait();
187     }
188 
189     GTEST_LOG_(INFO) << "IpcAbilityMgrModuleTest AbilityMgrService_IPC_004 end";
190 }
191 
192 /*
193  * Feature: AAFwk
194  * Function: AbilityManagerService
195  * SubFunction: IPC of client and server
196  * FunctionPoints: ConnectAbility
197  * EnvConditions: NA
198  * CaseDescription: verify ConnectAbility IPC between client and server.
199  */
200 HWTEST_F(IpcAbilityMgrModuleTest, AbilityMgrService_IPC_006, TestSize.Level1)
201 {
202     GTEST_LOG_(INFO) << "IpcAbilityMgrModuleTest AbilityMgrService_IPC_006 start";
203     for (int i = 0; i < COUNT; i++) {
204         sptr<MockAbilityMgrService> mockAbilityMgr(new MockAbilityMgrService());
205         sptr<IAbilityManager> abilityMgrClient = iface_cast<IAbilityManager>(mockAbilityMgr);
206         Want want;
207 
208         EXPECT_CALL(*mockAbilityMgr, ConnectAbility(_, _, _, _))
209             .Times(1)
210             .WillOnce(InvokeWithoutArgs(mockAbilityMgr.GetRefPtr(), &MockAbilityMgrService::Post));
211         abilityMgrClient->ConnectAbility(want, nullptr, nullptr, -1);
212         mockAbilityMgr->Wait();
213     }
214 
215     GTEST_LOG_(INFO) << "IpcAbilityMgrModuleTest AbilityMgrService_IPC_006 end";
216 }
217 
218 /*
219  * Feature: AAFwk
220  * Function: AbilityManagerService
221  * SubFunction: IPC of client and server
222  * FunctionPoints: DisconnectAbility
223  * EnvConditions: NA
224  * CaseDescription: verify DisconnectAbility IPC between client and server.
225  */
226 HWTEST_F(IpcAbilityMgrModuleTest, AbilityMgrService_IPC_007, TestSize.Level1)
227 {
228     GTEST_LOG_(INFO) << "IpcAbilityMgrModuleTest AbilityMgrService_IPC_007 start";
229     for (int i = 0; i < COUNT; i++) {
230         sptr<MockAbilityMgrService> mockAbilityMgr(new MockAbilityMgrService());
231         sptr<IAbilityManager> abilityMgrClient = iface_cast<IAbilityManager>(mockAbilityMgr);
232         Want want;
233 
234         EXPECT_CALL(*mockAbilityMgr, DisconnectAbility(_))
235             .Times(1)
236             .WillOnce(InvokeWithoutArgs(mockAbilityMgr.GetRefPtr(), &MockAbilityMgrService::Post));
237         abilityMgrClient->DisconnectAbility(nullptr);
238         mockAbilityMgr->Wait();
239     }
240 
241     GTEST_LOG_(INFO) << "IpcAbilityMgrModuleTest AbilityMgrService_IPC_007 end";
242 }
243 
244 /*
245  * Feature: AAFwk
246  * Function: AbilityManagerService
247  * SubFunction: IPC of client and server
248  * FunctionPoints: DumpState
249  * EnvConditions: NA
250  * CaseDescription: verify DumpState IPC between client and server.
251  */
252 HWTEST_F(IpcAbilityMgrModuleTest, AbilityMgrService_IPC_008, TestSize.Level1)
253 {
254     GTEST_LOG_(INFO) << "IpcAbilityMgrModuleTest AbilityMgrService_IPC_008 start";
255     for (int i = 0; i < COUNT; i++) {
256         sptr<MockAbilityMgrService> mockAbilityMgr(new MockAbilityMgrService());
257         sptr<IAbilityManager> abilityMgrClient = iface_cast<IAbilityManager>(mockAbilityMgr);
258         std::vector<std::string> state;
259         std::string args = "key";
260 
261         EXPECT_CALL(*mockAbilityMgr, DumpState(_, _))
262             .Times(1)
263             .WillOnce(InvokeWithoutArgs(mockAbilityMgr.GetRefPtr(), &MockAbilityMgrService::PostVoid));
264         abilityMgrClient->DumpState(args, state);
265         mockAbilityMgr->Wait();
266     }
267 
268     GTEST_LOG_(INFO) << "IpcAbilityMgrModuleTest AbilityMgrService_IPC_008 end";
269 }
270 
271 /*
272  * Feature: AAFwk
273  * Function: AbilityManagerService
274  * SubFunction: IPC of client and server
275  * FunctionPoints: AttachAbilityThread
276  * EnvConditions: NA
277  * CaseDescription: verify AttachAbilityThread IPC between client and server.
278  */
279 HWTEST_F(IpcAbilityMgrModuleTest, AbilityMgrService_IPC_009, TestSize.Level1)
280 {
281     GTEST_LOG_(INFO) << "IpcAbilityMgrModuleTest AbilityMgrService_IPC_009 start";
282     sptr<MockAbilityScheduler> scheduler = new MockAbilityScheduler();
283     std::string abilityName = "ability_name";
284     std::string bundleName = "com.ix.aafwk.moduletest";
285 
286     auto abilityRequest = CreateAbilityRequest(abilityName, bundleName);
287     auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
288     abilityRecord->SetAbilityState(OHOS::AAFwk::AbilityState::ACTIVE);
289 
290     for (int i = 0; i < COUNT; i++) {
291         sptr<MockAbilityMgrService> mockAbilityMgr(new MockAbilityMgrService());
292         sptr<IAbilityManager> abilityMgrClient = iface_cast<IAbilityManager>(mockAbilityMgr);
293 
294         EXPECT_CALL(*mockAbilityMgr, AttachAbilityThread(_, _))
295             .Times(1)
296             .WillOnce(InvokeWithoutArgs(mockAbilityMgr.GetRefPtr(), &MockAbilityMgrService::Post));
297         abilityMgrClient->AttachAbilityThread(scheduler, abilityRecord->GetToken());
298         mockAbilityMgr->Wait();
299     }
300 
301     GTEST_LOG_(INFO) << "IpcAbilityMgrModuleTest AbilityMgrService_IPC_009 end";
302 }
303 
304 /*
305  * Feature: AAFwk
306  * Function: AbilityManagerService
307  * SubFunction: IPC of client and server
308  * FunctionPoints: TerminateAbility
309  * EnvConditions: NA
310  * CaseDescription: verify TerminateAbility IPC between client and server.
311  */
312 HWTEST_F(IpcAbilityMgrModuleTest, AbilityMgrService_IPC_010, TestSize.Level1)
313 {
314     GTEST_LOG_(INFO) << "IpcAbilityMgrModuleTest AbilityMgrService_IPC_010 start";
315     sptr<MockAbilityScheduler> scheduler = new MockAbilityScheduler();
316     std::string abilityName = "ability_name";
317     std::string bundleName = "com.ix.aafwk.moduletest";
318 
319     AbilityRequest abilityRequest = CreateAbilityRequest(abilityName, bundleName);
320     std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
321     abilityRecord->SetAbilityState(OHOS::AAFwk::AbilityState::ACTIVE);
322 
323     for (int i = 0; i < COUNT; i++) {
324         sptr<MockAbilityMgrService> mockAbilityMgr(new MockAbilityMgrService());
325         sptr<IAbilityManager> abilityMgrClient = iface_cast<IAbilityManager>(mockAbilityMgr);
326 
327         EXPECT_CALL(*mockAbilityMgr, TerminateAbility(_, _, _))
328             .Times(1)
329             .WillOnce(InvokeWithoutArgs(mockAbilityMgr.GetRefPtr(), &MockAbilityMgrService::Post));
330         abilityMgrClient->TerminateAbility(abilityRecord->GetToken(), -1, nullptr);
331         mockAbilityMgr->Wait();
332     }
333 
334     GTEST_LOG_(INFO) << "IpcAbilityMgrModuleTest AbilityMgrService_IPC_010 end";
335 }
336 
337 /*
338  * Feature: AAFwk
339  * Function: AbilityManagerService
340  * SubFunction: IPC of client and server
341  * FunctionPoints: ScheduleCommandAbilityDone
342  * EnvConditions: NA
343  * CaseDescription: verify ScheduleCommandAbilityDone IPC between client and server.
344  */
345 HWTEST_F(IpcAbilityMgrModuleTest, AbilityMgrService_IPC_012, TestSize.Level1)
346 {
347     GTEST_LOG_(INFO) << "IpcAbilityMgrModuleTest AbilityMgrService_IPC_012 start";
348     for (int i = 0; i < COUNT; i++) {
349         sptr<MockAbilityMgrService> mockAbilityMgr(new MockAbilityMgrService());
350         sptr<IAbilityManager> abilityMgrClient = iface_cast<IAbilityManager>(mockAbilityMgr);
351 
352         EXPECT_CALL(*mockAbilityMgr, ScheduleCommandAbilityDone(_))
353             .Times(1)
354             .WillOnce(InvokeWithoutArgs(mockAbilityMgr.GetRefPtr(), &MockAbilityMgrService::Post));
355         abilityMgrClient->ScheduleCommandAbilityDone(nullptr);
356         mockAbilityMgr->Wait();
357     }
358 
359     GTEST_LOG_(INFO) << "IpcAbilityMgrModuleTest AbilityMgrService_IPC_012 end";
360 }
361 
362 /*
363  * Feature: AAFwk
364  * Function: AbilityManagerService
365  * SubFunction: IPC of client and server
366  * FunctionPoints: StopServiceAbility
367  * EnvConditions: NA
368  * CaseDescription: verify StopServiceAbility IPC between client and server.
369  */
370 HWTEST_F(IpcAbilityMgrModuleTest, AbilityMgrService_IPC_013, TestSize.Level1)
371 {
372     GTEST_LOG_(INFO) << "IpcAbilityMgrModuleTest AbilityMgrService_IPC_013 start";
373     for (int i = 0; i < COUNT; i++) {
374         sptr<MockAbilityMgrService> mockAbilityMgr(new MockAbilityMgrService());
375         sptr<IAbilityManager> abilityMgrClient = iface_cast<IAbilityManager>(mockAbilityMgr);
376         const Want want;
377 
378         EXPECT_CALL(*mockAbilityMgr, StopServiceAbility(_, _, _))
379             .Times(1)
380             .WillOnce(InvokeWithoutArgs(mockAbilityMgr.GetRefPtr(), &MockAbilityMgrService::Post));
381         abilityMgrClient->StopServiceAbility(want);
382         mockAbilityMgr->Wait();
383     }
384 
385     GTEST_LOG_(INFO) << "IpcAbilityMgrModuleTest AbilityMgrService_IPC_013 end";
386 }
387 
388 /*
389  * Feature: AAFwk
390  * Function: AbilityManagerService
391  * SubFunction: IPC of client and server
392  * FunctionPoints: AcquireDataAbility
393  * EnvConditions: NA
394  * CaseDescription: verify data ability acquire IPC between client and server.
395  */
396 HWTEST_F(IpcAbilityMgrModuleTest, AbilityMgrService_IPC_019, TestSize.Level1)
397 {
398     GTEST_LOG_(INFO) << "IpcAbilityMgrModuleTest AbilityMgrService_IPC_019 start";
399 
400     AbilityRequest abilityRequest;
401 
402     auto clientAbilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
403     Uri testUri("testuri");
404     bool testTryBind = true;
405 
406     for (int i = 0; i < COUNT; i++) {
407         sptr<MockAbilityMgrService> mockAbilityMgr(new MockAbilityMgrService());
408         sptr<IAbilityManager> abilityMgrClient = iface_cast<IAbilityManager>(mockAbilityMgr);
409 
410         bool testResult = false;
411 
__anon011b81870102(const Uri& uri, bool tryBind, const sptr<IRemoteObject>& callerToken) 412         auto mockHandler = [&](const Uri& uri, bool tryBind, const sptr<IRemoteObject>& callerToken) {
413             testResult = (uri.ToString() == testUri.ToString() && tryBind == testTryBind &&
414                 Token::GetAbilityRecordByToken(callerToken) == clientAbilityRecord);
415             mockAbilityMgr->Post();
416             return nullptr;
417         };
418 
419         EXPECT_CALL(*mockAbilityMgr, AcquireDataAbility(_, _, _)).Times(1).WillOnce(Invoke(mockHandler));
420 
421         abilityMgrClient->AcquireDataAbility(testUri, testTryBind, clientAbilityRecord->GetToken());
422 
423         mockAbilityMgr->Wait();
424 
425         EXPECT_TRUE(testResult);
426     }
427 
428     GTEST_LOG_(INFO) << "IpcAbilityMgrModuleTest AbilityMgrService_IPC_019 end";
429 }
430