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