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 #define private public
18 #define protected public
19 #include "ability_manager_service.h"
20 #include "mission_list_manager.h"
21 #undef private
22 #undef protected
23 #include "ability_manager_errors.h"
24 
25 using namespace testing;
26 using namespace testing::ext;
27 using namespace OHOS::AppExecFwk;
28 
29 namespace OHOS {
30 namespace AAFwk {
31 namespace {
32 const int32_t MOCK_MAIN_USER_ID = 100;
33 }  // namespace
34 class RunningInfosTest : public testing::Test {
35 public:
36     static void SetUpTestCase();
37     static void TearDownTestCase();
38     void SetUp();
39     void TearDown();
40 };
41 
SetUpTestCase()42 void RunningInfosTest::SetUpTestCase() {}
43 
TearDownTestCase()44 void RunningInfosTest::TearDownTestCase() {}
45 
SetUp()46 void RunningInfosTest::SetUp() {}
47 
TearDown()48 void RunningInfosTest::TearDown() {}
49 
50 /*
51  * Feature: AbilityManagerService
52  * Function: GetAbilityRunningInfos
53  * SubFunction: NA
54  * FunctionPoints:query ability running infos
55  * EnvConditions: NA
56  * CaseDescription: start page ability, call query function.
57  */
58 HWTEST_F(RunningInfosTest, GetAbilityRunningInfos_001, TestSize.Level1)
59 {
60     auto abilityMs_ = std::make_shared<AbilityManagerService>();
61     Want want;
62     ElementName element("device", "com.ix.hiMusic", "MusicAbility");
63     want.SetElement(element);
64     auto result = abilityMs_->StartAbility(want);
65 
66     if (result == OHOS::ERR_OK) {
67         std::vector<AbilityRunningInfo> infos;
68         abilityMs_->GetAbilityRunningInfos(infos);
69         size_t infoCount{ 1 };
70         EXPECT_TRUE(infos.size() == infoCount);
71         if (infos.size() == infoCount) {
72             EXPECT_TRUE(infos[0].ability.GetAbilityName() == element.GetAbilityName());
73             EXPECT_TRUE(infos[0].abilityState == static_cast<int>(AbilityState::INITIAL));
74         }
75     }
76 }
77 
78 /*
79  * Feature: AbilityManagerService
80  * Function: GetAbilityRunningInfos
81  * SubFunction: NA
82  * FunctionPoints:query ability running infos
83  * EnvConditions: NA
84  * CaseDescription: start service ability, call query function.
85  */
86 HWTEST_F(RunningInfosTest, GetAbilityRunningInfos_002, TestSize.Level1)
87 {
88     auto abilityMs_ = std::make_shared<AbilityManagerService>();
89     Want want;
90     ElementName element("device", "com.ix.hiService", "ServiceAbility");
91     want.SetElement(element);
92     auto result = abilityMs_->StartAbility(want);
93 
94     if (result == OHOS::ERR_OK) {
95         std::vector<AbilityRunningInfo> infos;
96         abilityMs_->GetAbilityRunningInfos(infos);
97         size_t infoCount{ 1 };
98         EXPECT_TRUE(infos.size() == infoCount);
99         if (infos.size() == infoCount) {
100             EXPECT_TRUE(infos[0].ability.GetAbilityName() == element.GetAbilityName());
101             EXPECT_TRUE(infos[0].abilityState == static_cast<int>(AbilityState::INITIAL));
102         }
103     }
104 }
105 
106 /*
107  * Feature: AbilityManagerService
108  * Function: GetAbilityRunningInfos
109  * SubFunction: NA
110  * FunctionPoints:query ability running infos
111  * EnvConditions: NA
112  * CaseDescription: start launcher, call query function.
113  */
114 HWTEST_F(RunningInfosTest, GetAbilityRunningInfos_003, TestSize.Level1)
115 {
116     auto abilityMs_ = std::make_shared<AbilityManagerService>();
117     Want want;
118     ElementName element("device", "com.ohos.launcher", "com.ohos.launcher.MainAbility");
119     want.SetElement(element);
120     auto result = abilityMs_->StartAbility(want);
121 
122     if (result == OHOS::ERR_OK) {
123         std::vector<AbilityRunningInfo> infos;
124         abilityMs_->GetAbilityRunningInfos(infos);
125         size_t infoCount{ 1 };
126         EXPECT_TRUE(infos.size() == infoCount);
127         if (infos.size() == infoCount) {
128             EXPECT_TRUE(infos[0].ability.GetAbilityName() == element.GetAbilityName());
129             EXPECT_TRUE(infos[0].abilityState == static_cast<int>(AbilityState::INITIAL));
130         }
131     }
132 }
133 
134 /*
135  * Feature: AbilityManagerService
136  * Function: GetAbilityRunningInfos
137  * SubFunction: NA
138  * FunctionPoints:query ability running infos
139  * EnvConditions: NA
140  * CaseDescription: start two page abilities, call query function.
141  */
142 HWTEST_F(RunningInfosTest, GetAbilityRunningInfos_004, TestSize.Level1)
143 {
144     auto abilityMs_ = std::make_shared<AbilityManagerService>();
145     abilityMs_->subManagersHelper_ = std::make_shared<SubManagersHelper>(nullptr, nullptr);
146     Want want;
147     ElementName element("device", "com.ix.hiMusic", "MusicAbility");
148     want.SetElement(element);
149     auto result = abilityMs_->StartAbility(want);
150 
151     if (result == OHOS::ERR_OK) {
152         auto topAbility = reinterpret_cast<MissionListManager*>(abilityMs_->subManagersHelper_->
153             currentMissionListManager_.get())->GetCurrentTopAbilityLocked();
154         EXPECT_TRUE(topAbility);
155         topAbility->SetAbilityState(AbilityState::FOREGROUND);
156     }
157 
158     ElementName element2("device", "com.ix.hiMusicOther", "MusicAbilityOther");
159     want.SetElement(element2);
160     auto result2 = abilityMs_->StartAbility(want);
161 
162     if (result2 == OHOS::ERR_OK) {
163         std::vector<AbilityRunningInfo> infos;
164         abilityMs_->GetAbilityRunningInfos(infos);
165         size_t infoCount{ 2 };
166         EXPECT_TRUE(infos.size() == infoCount);
167         if (infos.size() == infoCount) {
168             EXPECT_TRUE(infos[0].ability.GetAbilityName() == element2.GetAbilityName());
169             EXPECT_TRUE(infos[0].abilityState == static_cast<int>(AbilityState::INITIAL));
170             EXPECT_TRUE(infos[1].ability.GetAbilityName() == element.GetAbilityName());
171             EXPECT_TRUE(infos[1].abilityState == static_cast<int>(AbilityState::FOREGROUND));
172         }
173     }
174 }
175 
176 /*
177  * Feature: AbilityManagerService
178  * Function: GetAbilityRunningInfos
179  * SubFunction: NA
180  * FunctionPoints:query ability running infos
181  * EnvConditions: NA
182  * CaseDescription: start two service abilities, call query function.
183  */
184 HWTEST_F(RunningInfosTest, GetAbilityRunningInfos_005, TestSize.Level1)
185 {
186     auto abilityMs_ = std::make_shared<AbilityManagerService>();
187     Want want;
188     ElementName element("device", "com.ix.hiService", "ServiceAbility");
189     want.SetElement(element);
190     abilityMs_->StartAbility(want);
191 
192     ElementName element2("device", "com.ix.hiServiceOther", "ServiceAbilityOther");
193     want.SetElement(element2);
194     auto result2 = abilityMs_->StartAbility(want);
195 
196     if (result2 == OHOS::ERR_OK) {
197         std::vector<AbilityRunningInfo> infos;
198         abilityMs_->GetAbilityRunningInfos(infos);
199         size_t infoCount{ 2 };
200         EXPECT_TRUE(infos.size() == infoCount);
201         if (infos.size() == infoCount) {
202             EXPECT_TRUE(infos[0].ability.GetAbilityName() == element.GetAbilityName());
203             EXPECT_TRUE(infos[0].abilityState == static_cast<int>(AbilityState::INITIAL));
204             EXPECT_TRUE(infos[1].ability.GetAbilityName() == element2.GetAbilityName());
205             EXPECT_TRUE(infos[1].abilityState == static_cast<int>(AbilityState::INITIAL));
206         }
207     }
208 }
209 
210 /*
211  * Feature: AbilityManagerService
212  * Function: GetAbilityRunningInfos
213  * SubFunction: NA
214  * FunctionPoints:query ability running infos
215  * EnvConditions: NA
216  * CaseDescription: start two launcher, call query function.
217  */
218 HWTEST_F(RunningInfosTest, GetAbilityRunningInfos_006, TestSize.Level1)
219 {
220     auto abilityMs_ = std::make_shared<AbilityManagerService>();
221     abilityMs_->subManagersHelper_ = std::make_shared<SubManagersHelper>(nullptr, nullptr);
222     Want want;
223     ElementName element("device", "com.ohos.launcher", "com.ohos.launcher.MainAbility");
224     want.SetElement(element);
225     auto result = abilityMs_->StartAbility(want);
226 
227     if (result == OHOS::ERR_OK) {
228         auto topAbility = reinterpret_cast<MissionListManager*>(abilityMs_->subManagersHelper_->
229             currentMissionListManager_.get())->GetCurrentTopAbilityLocked();
230         EXPECT_TRUE(topAbility);
231         topAbility->SetAbilityState(AbilityState::FOREGROUND);
232     }
233 
234     ElementName element2("device", "com.ohos.launcherOther", "com.ohos.launcher.MainAbilityOther");
235     want.SetElement(element2);
236     auto result2 = abilityMs_->StartAbility(want);
237 
238     if (result2 == OHOS::ERR_OK) {
239         std::vector<AbilityRunningInfo> infos;
240         abilityMs_->GetAbilityRunningInfos(infos);
241         size_t infoCount{ 2 };
242         EXPECT_TRUE(infos.size() == infoCount);
243         if (infos.size() == infoCount) {
244             EXPECT_TRUE(infos[0].ability.GetAbilityName() == element2.GetAbilityName());
245             EXPECT_TRUE(infos[0].abilityState == static_cast<int>(AbilityState::INITIAL));
246             EXPECT_TRUE(infos[1].ability.GetAbilityName() == element.GetAbilityName());
247             EXPECT_TRUE(infos[1].abilityState == static_cast<int>(AbilityState::FOREGROUND));
248         }
249     }
250 }
251 
252 /*
253  * @tc.name: GetAbilityRunningInfos_007
254  * @tc.desc: GetAbilityRunningInfos Test Foucs State
255  * @tc.type: FUNC
256  * @tc.require: issueI5PXW4
257  */
258 HWTEST_F(RunningInfosTest, GetAbilityRunningInfos_007, TestSize.Level1)
259 {
260     auto abilityMs_ = std::make_shared<AbilityManagerService>();
261     abilityMs_->subManagersHelper_ = std::make_shared<SubManagersHelper>(nullptr, nullptr);
262     Want want;
263     ElementName element("device", "com.ix.hiMusic", "MusicAbility");
264     want.SetElement(element);
265     auto result = abilityMs_->StartAbility(want);
266 
267     if (result == OHOS::ERR_OK) {
268         auto topAbility = reinterpret_cast<MissionListManager*>(abilityMs_->subManagersHelper_->
269             currentMissionListManager_.get())->GetCurrentTopAbilityLocked();
270         EXPECT_TRUE(topAbility);
271         topAbility->SetAbilityState(AbilityState::ACTIVE);
272 
273         std::vector<AbilityRunningInfo> infos;
274         abilityMs_->GetAbilityRunningInfos(infos);
275 
276         size_t infoCount{ 1 };
277         EXPECT_TRUE(infos.size() == infoCount);
278         if (infos.size() == infoCount) {
279             EXPECT_TRUE(infos[0].ability.GetAbilityName() == element.GetAbilityName());
280             EXPECT_TRUE(infos[0].abilityState == static_cast<int>(AbilityState::ACTIVE));
281         }
282     }
283 }
284 
285 /*
286  * Feature: AbilityManagerService
287  * Function: GetExtensionRunningInfos
288  * SubFunction: NA
289  * FunctionPoints:query extension running infos
290  * EnvConditions: NA
291  * CaseDescription: start service ability, call query function.
292  */
293 HWTEST_F(RunningInfosTest, GetExtensionRunningInfos_001, TestSize.Level1)
294 {
295     auto abilityMs_ = std::make_shared<AbilityManagerService>();
296     Want want;
297     ElementName element("device", "com.ix.hiExtension", "hiExtension");
298     want.SetElement(element);
299     auto result = abilityMs_->StartAbility(want);
300 
301     if (result == OHOS::ERR_OK) {
302         std::vector<ExtensionRunningInfo> infos;
303         size_t infoCount{ 1 };
304         int upperLimit = 10;
305         abilityMs_->GetExtensionRunningInfos(upperLimit, infos);
306         EXPECT_TRUE(infos.size() == infoCount);
307         if (infos.size() == infoCount) {
308             EXPECT_TRUE(infos[0].extension.GetAbilityName() == element.GetAbilityName());
309         }
310     }
311 }
312 
313 /*
314  * Feature: AbilityManagerService
315  * Function: GetExtensionRunningInfos
316  * SubFunction: NA
317  * FunctionPoints:query extension running infos
318  * EnvConditions: NA
319  * CaseDescription: start two service abilities, call query function.
320  */
321 HWTEST_F(RunningInfosTest, GetExtensionRunningInfos_002, TestSize.Level1)
322 {
323     auto abilityMs_ = std::make_shared<AbilityManagerService>();
324     Want want;
325     ElementName element("device", "com.ix.hiExtension", "hiExtension");
326     want.SetElement(element);
327     abilityMs_->StartAbility(want);
328 
329     ElementName element2("device", "com.ix.hiExtension", "hiExtensionOther");
330     want.SetElement(element2);
331     auto result2 = abilityMs_->StartAbility(want);
332 
333     if (result2 == OHOS::ERR_OK) {
334         std::vector<ExtensionRunningInfo> infos;
335         int upperLimit = 10;
336         abilityMs_->GetExtensionRunningInfos(upperLimit, infos);
337         size_t infoCount{ 2 };
338         EXPECT_TRUE(infos.size() == infoCount);
339         if (infos.size() == infoCount) {
340             EXPECT_TRUE(infos[0].extension.GetAbilityName() == element.GetAbilityName());
341             EXPECT_TRUE(infos[1].extension.GetAbilityName() == element2.GetAbilityName());
342         }
343     }
344 }
345 
346 /*
347  * @tc.name: GetAbilityRunningInfos_006
348  * @tc.desc: GetAbilityRunningInfos Test
349  * @tc.type: FUNC
350  * @tc.require: issueI5PXW4
351  */
352 HWTEST_F(RunningInfosTest, GetProcessRunningInfos_001, TestSize.Level1)
353 {
354     auto abilityMs_ = std::make_shared<AbilityManagerService>();
355     Want want;
356     ElementName element("device", "com.ix.hiExtension", "hiExtension");
357     want.SetElement(element);
358     auto result = abilityMs_->StartAbility(want);
359 
360     if (result == OHOS::ERR_OK) {
361         std::vector<RunningProcessInfo> infos;
362         auto ret = abilityMs_->GetProcessRunningInfos(infos);
363         EXPECT_EQ(OHOS::ERR_OK, ret);
364     }
365 }
366 
367 /*
368  * Feature: AbilityConnectManager
369  * Function: GetAbilityRunningInfos
370  * SubFunction: NA
371  * FunctionPoints:query ability running infos
372  * EnvConditions: NA
373  * CaseDescription: start service ability, call query function.
374  */
375 HWTEST_F(RunningInfosTest, ConnectManagerGetAbilityRunningInfos_001, TestSize.Level1)
376 {
377     auto abilityMs_ = std::make_shared<AbilityManagerService>();
378     Want want;
379     ElementName element("device", "com.ix.hiService", "ServiceAbility");
380     want.SetElement(element);
381     auto result = abilityMs_->StartAbility(want);
382 
383     if (result == OHOS::ERR_OK) {
384         std::vector<AbilityRunningInfo> infos;
385         abilityMs_->subManagersHelper_->currentConnectManager_->GetAbilityRunningInfos(infos, true);
386         size_t infoCount{ 1 };
387         EXPECT_TRUE(infos.size() == infoCount);
388         if (infos.size() == infoCount) {
389             EXPECT_TRUE(infos[0].ability.GetAbilityName() == element.GetAbilityName());
390             EXPECT_TRUE(infos[0].abilityState == static_cast<int>(AbilityState::INITIAL));
391         }
392     }
393 }
394 
395 /*
396  * Feature: AbilityConnectManager
397  * Function: GetAbilityRunningInfos
398  * SubFunction: NA
399  * FunctionPoints:query ability running infos
400  * EnvConditions: NA
401  * CaseDescription: start two service abilities, call query function.
402  */
403 HWTEST_F(RunningInfosTest, ConnectManagerGetAbilityRunningInfos_002, TestSize.Level1)
404 {
405     auto abilityMs_ = std::make_shared<AbilityManagerService>();
406     Want want;
407     ElementName element("device", "com.ix.hiService", "ServiceAbility");
408     want.SetElement(element);
409     abilityMs_->StartAbility(want);
410 
411     ElementName element2("device", "com.ix.hiServiceOther", "ServiceAbilityOther");
412     want.SetElement(element2);
413     auto result2 = abilityMs_->StartAbility(want);
414 
415     if (result2 == OHOS::ERR_OK) {
416         std::vector<AbilityRunningInfo> infos;
417         abilityMs_->subManagersHelper_->currentConnectManager_->GetAbilityRunningInfos(infos, true);
418 
419         size_t infoCount{ 2 };
420         EXPECT_TRUE(infos.size() == infoCount);
421         if (infos.size() == infoCount) {
422             EXPECT_TRUE(infos[0].ability.GetAbilityName() == element.GetAbilityName());
423             EXPECT_TRUE(infos[0].abilityState == static_cast<int>(AbilityState::INITIAL));
424             EXPECT_TRUE(infos[1].ability.GetAbilityName() == element2.GetAbilityName());
425             EXPECT_TRUE(infos[1].abilityState == static_cast<int>(AbilityState::INITIAL));
426         }
427     }
428 }
429 
430 /*
431  * Feature: AbilityConnectManager
432  * Function: GetExtensionRunningInfos
433  * SubFunction: NA
434  * FunctionPoints:query extension running infos
435  * EnvConditions: NA
436  * CaseDescription: start service ability, call query function.
437  */
438 HWTEST_F(RunningInfosTest, ConnectManagerGetExtensionRunningInfos_001, TestSize.Level1)
439 {
440     auto abilityMs_ = std::make_shared<AbilityManagerService>();
441     Want want;
442     ElementName element("device", "com.ix.hiExtension", "hiExtension");
443     want.SetElement(element);
444     auto result = abilityMs_->StartAbility(want);
445 
446     if (result == OHOS::ERR_OK) {
447         std::vector<ExtensionRunningInfo> infos;
448         int upperLimit = 10;
449         int userId = 100;
450         size_t infoCount{ 1 };
451         abilityMs_->subManagersHelper_->currentConnectManager_->GetExtensionRunningInfos(
452             upperLimit, infos, userId, true);
453         EXPECT_TRUE(infos.size() == infoCount);
454         if (infos.size() == infoCount) {
455             EXPECT_TRUE(infos[0].extension.GetAbilityName() == element.GetAbilityName());
456         }
457     }
458 }
459 
460 /*
461  * Feature: AbilityConnectManager
462  * Function: GetExtensionRunningInfos
463  * SubFunction: NA
464  * FunctionPoints:query extension running infos
465  * EnvConditions: NA
466  * CaseDescription: start two service abilities, call query function.
467  */
468 HWTEST_F(RunningInfosTest, ConnectManagerGetExtensionRunningInfos_002, TestSize.Level1)
469 {
470     auto abilityMs_ = std::make_shared<AbilityManagerService>();
471     Want want;
472     ElementName element("device", "com.ix.hiExtension", "hiExtension");
473     want.SetElement(element);
474     abilityMs_->StartAbility(want);
475 
476     ElementName element2("device", "com.ix.hiExtension", "hiExtensionOther");
477     want.SetElement(element2);
478     auto result2 = abilityMs_->StartAbility(want);
479 
480     if (result2 == OHOS::ERR_OK) {
481         std::vector<ExtensionRunningInfo> infos;
482         int upperLimit = 10;
483         int userId = 100;
484         size_t infoCount{ 2 };
485         abilityMs_->subManagersHelper_->currentConnectManager_->GetExtensionRunningInfos(
486             upperLimit, infos, userId, true);
487         EXPECT_TRUE(infos.size() == infoCount);
488         if (infos.size() == infoCount) {
489             EXPECT_TRUE(infos[0].extension.GetAbilityName() == element.GetAbilityName());
490             EXPECT_TRUE(infos[1].extension.GetAbilityName() == element2.GetAbilityName());
491         }
492     }
493 }
494 
495 /*
496  * Feature: MissionListManager
497  * Function: GetAbilityRunningInfos
498  * SubFunction: NA
499  * FunctionPoints:query ability running infos
500  * EnvConditions: NA
501  * CaseDescription: start page ability, call query function.
502  */
503 HWTEST_F(RunningInfosTest, MissionGetAbilityRunningInfos_001, TestSize.Level1)
504 {
505     auto abilityMs_ = std::make_shared<AbilityManagerService>();
506     abilityMs_->subManagersHelper_ = std::make_shared<SubManagersHelper>(nullptr, nullptr);
507     Want want;
508     ElementName element("device", "com.ix.hiMusic", "MusicAbility");
509     want.SetElement(element);
510     auto result = abilityMs_->StartAbility(want);
511 
512     if (result == OHOS::ERR_OK) {
513         std::vector<AbilityRunningInfo> infos;
514         abilityMs_->subManagersHelper_->currentMissionListManager_->GetAbilityRunningInfos(infos, true);
515         size_t infoCount{ 1 };
516         EXPECT_TRUE(infos.size() == infoCount);
517         if (infos.size() == infoCount) {
518             EXPECT_TRUE(infos[0].ability.GetAbilityName() == element.GetAbilityName());
519             EXPECT_TRUE(infos[0].abilityState == static_cast<int>(AbilityState::INITIAL));
520         }
521     }
522 }
523 
524 /*
525  * Feature: MissionListManager
526  * Function: GetAbilityRunningInfos
527  * SubFunction: NA
528  * FunctionPoints:query ability running infos
529  * EnvConditions: NA
530  * CaseDescription: start two page abilities, call query function.
531  */
532 HWTEST_F(RunningInfosTest, MissionGetAbilityRunningInfos_002, TestSize.Level1)
533 {
534     auto abilityMs_ = std::make_shared<AbilityManagerService>();
535     abilityMs_->subManagersHelper_ = std::make_shared<SubManagersHelper>(nullptr, nullptr);
536     Want want;
537     ElementName element("device", "com.ix.hiMusic", "MusicAbility");
538     want.SetElement(element);
539     auto result = abilityMs_->StartAbility(want);
540 
541     if (result == OHOS::ERR_OK) {
542         auto topAbility = reinterpret_cast<MissionListManager*>(abilityMs_->subManagersHelper_->
543             currentMissionListManager_.get())->GetCurrentTopAbilityLocked();
544         EXPECT_TRUE(topAbility);
545         topAbility->SetAbilityState(AbilityState::FOREGROUND);
546     }
547 
548     ElementName element2("device", "com.ix.hiMusicOther", "MusicAbilityOther");
549     want.SetElement(element2);
550     auto result2 = abilityMs_->StartAbility(want);
551 
552     if (result2 == OHOS::ERR_OK) {
553         std::vector<AbilityRunningInfo> infos;
554         abilityMs_->subManagersHelper_->currentMissionListManager_->GetAbilityRunningInfos(infos, true);
555 
556         size_t infoCount{ 2 };
557         EXPECT_TRUE(infos.size() == infoCount);
558         if (infos.size() == infoCount) {
559             EXPECT_TRUE(infos[0].ability.GetAbilityName() == element2.GetAbilityName());
560             EXPECT_TRUE(infos[0].abilityState == static_cast<int>(AbilityState::INITIAL));
561             EXPECT_TRUE(infos[1].ability.GetAbilityName() == element.GetAbilityName());
562             EXPECT_TRUE(infos[1].abilityState == static_cast<int>(AbilityState::FOREGROUND));
563         }
564     }
565 }
566 
567 /*
568  * Feature: DataAbilityManager
569  * Function: GetAbilityRunningInfos
570  * SubFunction: NA
571  * FunctionPoints:query ability running infos
572  * EnvConditions: NA
573  * CaseDescription: dataAbilityRecordsLoading insert data, call query function.
574  */
575 HWTEST_F(RunningInfosTest, DataGetAbilityRunningInfos_001, TestSize.Level1)
576 {
577     auto abilityMs_ = std::make_shared<AbilityManagerService>();
578     Want want;
579     ElementName element("device", "com.ix.hiMusic", "MusicAbility");
580     want.SetElement(element);
581 
582     AbilityRequest abilityRequest;
583     int userId = 100;
584     abilityMs_->GenerateAbilityRequest(want, -1, abilityRequest, nullptr, userId);
585     DataAbilityManager::DataAbilityRecordPtr dataAbilityRecord;
586     dataAbilityRecord = std::make_shared<DataAbilityRecord>(abilityRequest);
587     std::shared_ptr<AbilityRecord> abilityRecord = std::make_shared<AbilityRecord>(abilityRequest.want,
588         abilityRequest.abilityInfo,
589         abilityRequest.appInfo,
590         abilityRequest.requestCode);
591     dataAbilityRecord->ability_ = abilityRecord;
592     const std::string dataAbilityName(abilityRequest.abilityInfo.bundleName + '.' + abilityRequest.abilityInfo.name);
593     auto manager = std::make_shared<DataAbilityManager>();
594     manager->dataAbilityRecordsLoading_.insert(
595         std::pair<std::string, std::shared_ptr<DataAbilityRecord>>(dataAbilityName, dataAbilityRecord));
596 
597     std::vector<AbilityRunningInfo> infos;
598     manager->GetAbilityRunningInfos(infos, true);
599     size_t infoCount{ 1 };
600     EXPECT_TRUE(infos.size() == infoCount);
601     if (infos.size() == infoCount) {
602         EXPECT_TRUE(infos[0].ability.GetAbilityName() == element.GetAbilityName());
603         EXPECT_TRUE(infos[0].abilityState == static_cast<int>(AbilityState::INITIAL));
604     }
605 }
606 
607 /*
608  * Feature: DataAbilityManager
609  * Function: GetAbilityRunningInfos
610  * SubFunction: NA
611  * FunctionPoints:query ability running infos
612  * EnvConditions: NA
613  * CaseDescription: dataAbilityRecordsLoaded insert data, call query function.
614  */
615 HWTEST_F(RunningInfosTest, DataGetAbilityRunningInfos_002, TestSize.Level1)
616 {
617     auto abilityMs_ = std::make_shared<AbilityManagerService>();
618     Want want;
619     ElementName element("device", "com.ix.hiMusic", "MusicAbility");
620     want.SetElement(element);
621 
622     AbilityRequest abilityRequest;
623     int userId = 100;
624     abilityMs_->GenerateAbilityRequest(want, -1, abilityRequest, nullptr, userId);
625     DataAbilityManager::DataAbilityRecordPtr dataAbilityRecord;
626     dataAbilityRecord = std::make_shared<DataAbilityRecord>(abilityRequest);
627     std::shared_ptr<AbilityRecord> abilityRecord = std::make_shared<AbilityRecord>(abilityRequest.want,
628         abilityRequest.abilityInfo,
629         abilityRequest.appInfo,
630         abilityRequest.requestCode);
631     dataAbilityRecord->ability_ = abilityRecord;
632     const std::string dataAbilityName(abilityRequest.abilityInfo.bundleName + '.' + abilityRequest.abilityInfo.name);
633     auto manager = std::make_shared<DataAbilityManager>();
634     manager->dataAbilityRecordsLoaded_.insert(
635         std::pair<std::string, std::shared_ptr<DataAbilityRecord>>(dataAbilityName, dataAbilityRecord));
636 
637     std::vector<AbilityRunningInfo> infos;
638     manager->GetAbilityRunningInfos(infos, true);
639     size_t infoCount{ 1 };
640     EXPECT_TRUE(infos.size() == infoCount);
641     if (infos.size() == infoCount) {
642         EXPECT_TRUE(infos[0].ability.GetAbilityName() == element.GetAbilityName());
643         EXPECT_TRUE(infos[0].abilityState == static_cast<int>(AbilityState::INITIAL));
644     }
645 }
646 
647 /*
648  * Feature: DataAbilityManager
649  * Function: GetAbilityRunningInfos
650  * SubFunction: NA
651  * FunctionPoints:query ability running infos
652  * EnvConditions: NA
653  * CaseDescription: insert abilities, call query function.
654  */
655 HWTEST_F(RunningInfosTest, DataGetAbilityRunningInfos_003, TestSize.Level1)
656 {
657     auto abilityMs_ = std::make_shared<AbilityManagerService>();
658     Want want;
659     ElementName element("device", "com.ix.hiMusic", "MusicAbility");
660     want.SetElement(element);
661 
662     AbilityRequest abilityRequest;
663     int userId = 100;
664     abilityMs_->GenerateAbilityRequest(want, -1, abilityRequest, nullptr, userId);
665     DataAbilityManager::DataAbilityRecordPtr dataAbilityRecord;
666     dataAbilityRecord = std::make_shared<DataAbilityRecord>(abilityRequest);
667     std::shared_ptr<AbilityRecord> abilityRecord = std::make_shared<AbilityRecord>(abilityRequest.want,
668         abilityRequest.abilityInfo,
669         abilityRequest.appInfo,
670         abilityRequest.requestCode);
671     dataAbilityRecord->ability_ = abilityRecord;
672     const std::string dataAbilityName(abilityRequest.abilityInfo.bundleName + '.' + abilityRequest.abilityInfo.name);
673     auto manager = std::make_shared<DataAbilityManager>();
674     manager->dataAbilityRecordsLoading_.insert(
675         std::pair<std::string, std::shared_ptr<DataAbilityRecord>>(dataAbilityName, dataAbilityRecord));
676 
677     ElementName element2("device", "com.ix.hiMusic", "MusicAbilityOther");
678     want.SetElement(element2);
679     AbilityRequest abilityRequest2;
680     abilityMs_->GenerateAbilityRequest(want, -1, abilityRequest2, nullptr, userId);
681     DataAbilityManager::DataAbilityRecordPtr dataAbilityRecord2;
682     dataAbilityRecord2 = std::make_shared<DataAbilityRecord>(abilityRequest2);
683     std::shared_ptr<AbilityRecord> abilityRecord2 = std::make_shared<AbilityRecord>(abilityRequest2.want,
684         abilityRequest2.abilityInfo,
685         abilityRequest2.appInfo,
686         abilityRequest2.requestCode);
687     dataAbilityRecord2->ability_ = abilityRecord2;
688     const std::string dataAbilityName2(abilityRequest2.abilityInfo.bundleName + '.' + abilityRequest2.abilityInfo.name);
689     manager->dataAbilityRecordsLoaded_.insert(
690         std::pair<std::string, std::shared_ptr<DataAbilityRecord>>(dataAbilityName2, dataAbilityRecord2));
691 
692     std::vector<AbilityRunningInfo> infos;
693     manager->GetAbilityRunningInfos(infos, true);
694     size_t infoCount{ 2 };
695     EXPECT_TRUE(infos.size() == infoCount);
696     if (infos.size() == infoCount) {
697         EXPECT_TRUE(infos[0].ability.GetAbilityName() == element.GetAbilityName());
698         EXPECT_TRUE(infos[0].abilityState == static_cast<int>(AbilityState::INITIAL));
699         EXPECT_TRUE(infos[1].ability.GetAbilityName() == element2.GetAbilityName());
700         EXPECT_TRUE(infos[1].abilityState == static_cast<int>(AbilityState::INITIAL));
701     }
702 }
703 }  // namespace AAFwk
704 }  // namespace OHOS
705