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