1 /*
2 * Copyright (c) 2021 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 <memory>
17 #include <thread>
18 #include <chrono>
19 #include <vector>
20 #include "system_ability_definition.h"
21 #include "ability_info.h"
22 #include "application_info.h"
23 #define private public
24 #define protected public
25 #include "ability_manager_service.h"
26 #undef private
27 #undef protected
28 #include "ability_manager_errors.h"
29 #include "gtest/gtest.h"
30 #include "mock_bundle_mgr.h"
31 #include "want.h"
32 #include "sa_mgr_client.h"
33 #include "appmgr_test_service.h"
34 #include "module_test_dump_util.h"
35
36 using namespace testing;
37 using namespace testing::ext;
38 using namespace OHOS::AppExecFwk;
39 using OHOS::MTUtil::MTDumpUtil;
40
41 namespace OHOS {
42 namespace AAFwk {
43 namespace {
44 #define SLEEP(milli) std::this_thread::sleep_for(std::chrono::milliseconds(milli))
45
46 const std::string NAME_BUNDLE_MGR_SERVICE = "BundleMgrService";
47 static std::shared_ptr<AbilityManagerService> g_abilityMs = nullptr;
48 static std::shared_ptr<AppManagerTestService> g_appTestService = nullptr;
49 static bool g_alreadyInit = false;
50
51 static const ElementName G_TESTABILITY1("device", "com.ix.hiMusic", "MainAbility1");
52 static const ElementName G_TESTABILITY2("device", "com.ix.hiMusic", "MainAbility2");
53 static const ElementName G_TESTABILITY3("device", "com.ix.hiRadio", "MainAbility3");
54 static const ElementName G_TESTABILITY4("device", "com.ix.hiRadio", "MainAbility4");
55 static const ElementName G_LAUNCHABILITY("device", "com.ix.hiworld", "LaunchAbility");
56 static const ElementName G_TESTBLOCKACTIVEABILITY("device", "com.ix.musicService", "ServiceAbility");
57 static const ElementName G_TESTABILITY5("device", "com.ix.hiRadio", "MainAbility5");
58 static const ElementName G_TESTABILITY6("device", "com.ix.hiRadio", "MainAbility6");
59 } // namespace
60
WaitUntilTaskFinished()61 static void WaitUntilTaskFinished()
62 {
63 const uint32_t maxRetryCount = 1000;
64 const uint32_t sleepTime = 1000;
65 uint32_t count = 0;
66 auto handler = OHOS::DelayedSingleton<AbilityManagerService>::GetInstance()->GetEventHandler();
67 std::atomic<bool> taskCalled(false);
68 auto f = [&taskCalled]() { taskCalled.store(true); };
69 if (handler->PostTask(f)) {
70 while (!taskCalled.load()) {
71 ++count;
72 if (count >= maxRetryCount) {
73 break;
74 }
75 usleep(sleepTime);
76 }
77 }
78 }
79
ShowDump(const std::vector<std::string> & strVec)80 std::string ShowDump(const std::vector<std::string> &strVec)
81 {
82 std::string ret;
83 for (const auto &str : strVec) {
84 ret += str + "\n";
85 }
86 return ret;
87 }
88
89 class DumpModuleTest : public testing::Test {
90 public:
91 static void SetUpTestCase();
92 static void TearDownTestCase();
93 void SetUp();
94 void TearDown();
95 void OnStartAms();
96 void StartAllAbilities();
97 bool SearchAbilityNameFromStackInfo(const std::string &abilityName, const std::vector<AbilityRecordInfo> &vec);
98
99 Want want11 {};
100 Want want22 {};
101 Want want33 {};
102 Want want44 {};
103 Want want55 {};
104 Want wantLauncher {};
105 };
106
SearchAbilityNameFromStackInfo(const std::string & abilityName,const std::vector<AbilityRecordInfo> & vec)107 bool DumpModuleTest::SearchAbilityNameFromStackInfo(
108 const std::string &abilityName, const std::vector<AbilityRecordInfo> &vec)
109 {
110 auto iter = std::find_if(vec.begin(), vec.end(), [&abilityName](const AbilityRecordInfo &abilityRecordInfo) {
111 return (abilityRecordInfo.mainName == abilityName);
112 });
113 return ((iter == vec.end()) ? false : true);
114 }
115
OnStartAms()116 void DumpModuleTest::OnStartAms()
117 {
118 if (g_abilityMs) {
119 if (g_abilityMs->state_ == ServiceRunningState::STATE_RUNNING) {
120 return;
121 }
122
123 g_abilityMs->state_ = ServiceRunningState::STATE_RUNNING;
124 g_abilityMs->eventLoop_ = AppExecFwk::EventRunner::Create(AbilityConfig::NAME_ABILITY_MGR_SERVICE);
125 EXPECT_TRUE(g_abilityMs->eventLoop_);
126
127 g_abilityMs->handler_ = std::make_shared<AbilityEventHandler>(g_abilityMs->eventLoop_, g_abilityMs);
128 g_abilityMs->connectManager_ = std::make_shared<AbilityConnectManager>(0);
129 g_abilityMs->connectManagers_.emplace(0, g_abilityMs->connectManager_);
130 EXPECT_TRUE(g_abilityMs->handler_);
131 EXPECT_TRUE(g_abilityMs->connectManager_);
132
133 g_abilityMs->connectManager_->SetEventHandler(g_abilityMs->handler_);
134
135 g_abilityMs->dataAbilityManager_ = std::make_shared<DataAbilityManager>();
136 g_abilityMs->dataAbilityManagers_.emplace(0, g_abilityMs->dataAbilityManager_);
137 EXPECT_TRUE(g_abilityMs->dataAbilityManager_);
138
139 g_abilityMs->currentMissionListManager_ = std::make_shared<MissionListManager>(0);
140 g_abilityMs->currentMissionListManager_->Init();
141 g_abilityMs->pendingWantManager_ = std::make_shared<PendingWantManager>();
142 EXPECT_TRUE(g_abilityMs->pendingWantManager_);
143
144 int userId = g_abilityMs->GetUserId();
145 g_abilityMs->SetStackManager(userId, true);
146 g_abilityMs->stackManagers_.emplace(0, g_abilityMs->GetStackManager());
147 g_abilityMs->eventLoop_->Run();
148 GTEST_LOG_(INFO) << "OnStart success";
149 return;
150 }
151
152 GTEST_LOG_(INFO) << "OnStart fail";
153 }
154
SetUpTestCase()155 void DumpModuleTest::SetUpTestCase()
156 {
157 OHOS::DelayedSingleton<SaMgrClient>::GetInstance()->RegisterSystemAbility(
158 OHOS::BUNDLE_MGR_SERVICE_SYS_ABILITY_ID, new BundleMgrService());
159 GTEST_LOG_(INFO) << "SetUpTestCase OK";
160 }
161
TearDownTestCase()162 void DumpModuleTest::TearDownTestCase()
163 {
164 OHOS::DelayedSingleton<SaMgrClient>::DestroyInstance();
165 GTEST_LOG_(INFO) << "TearDownTestCase OK";
166 }
167
SetUp()168 void DumpModuleTest::SetUp()
169 {
170 g_abilityMs = OHOS::DelayedSingleton<AbilityManagerService>::GetInstance();
171 OnStartAms();
172
173 WaitUntilTaskFinished();
174
175 want11.SetElement(G_TESTABILITY1);
176 want22.SetElement(G_TESTABILITY2);
177 want33.SetElement(G_TESTABILITY3);
178 want44.SetElement(G_TESTABILITY4);
179 want55.SetElement(G_TESTABILITY6);
180 wantLauncher.SetElement(G_LAUNCHABILITY);
181 StartAllAbilities();
182 GTEST_LOG_(INFO) << "SetUp OK";
183 }
184
TearDown()185 void DumpModuleTest::TearDown()
186 {
187 g_abilityMs->OnStop();
188 GTEST_LOG_(INFO) << "TearDown OK";
189 }
190
StartAllAbilities()191 void DumpModuleTest::StartAllAbilities()
192 {
193 if (g_alreadyInit) {
194 return;
195 }
196 g_alreadyInit = true;
197 wantLauncher.AddEntity(Want::FLAG_HOME_INTENT_FROM_SYSTEM);
198 g_abilityMs->StartAbility(wantLauncher);
199 WaitUntilTaskFinished();
200 auto topAbilityLuncher = g_abilityMs->GetStackManager()->GetCurrentTopAbility();
201 if (topAbilityLuncher) {
202 topAbilityLuncher->SetAbilityState(OHOS::AAFwk::AbilityState::ACTIVE);
203 }
204
205 g_abilityMs->StartAbility(want11);
206 WaitUntilTaskFinished();
207 auto topAbility11 = g_abilityMs->GetStackManager()->GetCurrentTopAbility();
208 if (topAbility11) {
209 topAbility11->SetAbilityState(OHOS::AAFwk::AbilityState::ACTIVE);
210 }
211
212 g_abilityMs->StartAbility(want22);
213 WaitUntilTaskFinished();
214 auto topAbility22 = g_abilityMs->GetStackManager()->GetCurrentTopAbility();
215 if (topAbility22) {
216 topAbility22->SetAbilityState(OHOS::AAFwk::AbilityState::ACTIVE);
217 }
218
219 g_abilityMs->StartAbility(want33);
220 WaitUntilTaskFinished();
221 auto topAbility33 = g_abilityMs->GetStackManager()->GetCurrentTopAbility();
222 if (topAbility33) {
223 topAbility33->SetAbilityState(OHOS::AAFwk::AbilityState::ACTIVE);
224 }
225
226 g_abilityMs->StartAbility(want44);
227 WaitUntilTaskFinished();
228 auto topAbility44 = g_abilityMs->GetStackManager()->GetCurrentTopAbility();
229 if (topAbility44) {
230 topAbility44->SetAbilityState(OHOS::AAFwk::AbilityState::ACTIVE);
231 }
232
233 g_abilityMs->StartAbility(want55);
234 WaitUntilTaskFinished();
235 auto topAbility55 = g_abilityMs->GetStackManager()->GetCurrentTopAbility();
236 if (topAbility55) {
237 topAbility55->SetAbilityState(OHOS::AAFwk::AbilityState::ACTIVE);
238 }
239 }
240
241 /*
242 * Feature: Aafwk
243 * Function: DumpState
244 * SubFunction: NA
245 * FunctionPoints: test AbilityManagerService DumpState
246 * EnvConditions: System running normally
247 * CaseDescription: DumpState to show info of stacks respectively
248 */
249 HWTEST_F(DumpModuleTest, dump_module_test_001, TestSize.Level2)
250 {
251 std::vector<std::string> dumpInfo;
252 g_abilityMs->DumpState("--stack 1", dumpInfo);
253 std::vector<std::string> abilityNames;
254 MTDumpUtil::GetInstance()->GetAll("AbilityName", dumpInfo, abilityNames);
255 EXPECT_EQ(0, abilityNames.size());
256 dumpInfo.clear();
257
258 g_abilityMs->DumpState("--stack 0", dumpInfo);
259 MTDumpUtil::GetInstance()->GetAll("AbilityName", dumpInfo, abilityNames);
260 EXPECT_EQ(6, abilityNames.size());
261
262 dumpInfo.clear();
263 g_abilityMs->DumpState("--stack 1 abc", dumpInfo);
264 MTDumpUtil::GetInstance()->GetAll("AbilityName", dumpInfo, abilityNames);
265 EXPECT_EQ(0, abilityNames.size());
266
267 dumpInfo.clear();
268 g_abilityMs->DumpState(" --stack 1", dumpInfo);
269 MTDumpUtil::GetInstance()->GetAll("AbilityName", dumpInfo, abilityNames);
270 EXPECT_EQ(0, abilityNames.size());
271 }
272
273 /*
274 * Feature: Aafwk
275 * Function: DumpStack
276 * SubFunction: NA
277 * FunctionPoints: test AbilityStackManager DumpStack
278 * EnvConditions: System running normally
279 * CaseDescription: DumpStack directly to show info of stacks respectively
280 */
281 HWTEST_F(DumpModuleTest, dump_module_test_002, TestSize.Level2)
282 {
283 std::vector<std::string> dumpInfo;
284 g_abilityMs->GetStackManager()->DumpStack(1, dumpInfo);
285 std::vector<std::string> abilityNames;
286 MTDumpUtil::GetInstance()->GetAll("AbilityName", dumpInfo, abilityNames);
287 GTEST_LOG_(INFO) << "abilityNames.size() = " << abilityNames.size();
288 EXPECT_EQ(0, abilityNames.size());
289 dumpInfo.clear();
290 g_abilityMs->GetStackManager()->DumpStack(0, dumpInfo);
291 MTDumpUtil::GetInstance()->GetAll("AbilityName", dumpInfo, abilityNames);
292 EXPECT_EQ(6, abilityNames.size());
293 }
294
295 /*
296 * Feature: Aafwk
297 * Function: DumpState
298 * SubFunction: NA
299 * FunctionPoints: testAbilityManagerService DumpState
300 * EnvConditions: System running normally
301 * CaseDescription: Handle wrong args about missionStack
302 */
303 HWTEST_F(DumpModuleTest, dump_module_test_003, TestSize.Level2)
304 {
305 std::string expectedResult1 = "error: invalid argument, please see 'ability dump -h'.";
306 std::string expectedResult2 = "Invalid stack number, please see ability dump stack-list.";
307 std::vector<std::string> dumpInfo;
308
309 g_abilityMs->DumpState("--stack", dumpInfo);
310 EXPECT_EQ(1UL, dumpInfo.size());
311 EXPECT_EQ(dumpInfo[0], expectedResult1);
312
313 dumpInfo.clear();
314
315 g_abilityMs->DumpState("--sta ck", dumpInfo);
316 EXPECT_EQ(0UL, dumpInfo.size());
317
318 dumpInfo.clear();
319
320 g_abilityMs->DumpState("--stack1", dumpInfo);
321 EXPECT_EQ(0UL, dumpInfo.size());
322
323 dumpInfo.clear();
324
325 g_abilityMs->DumpState("--stack a", dumpInfo);
326 EXPECT_EQ(2UL, dumpInfo.size());
327 EXPECT_EQ(dumpInfo[1], expectedResult2);
328
329 dumpInfo.clear();
330
331 g_abilityMs->DumpState("--stack 10", dumpInfo);
332 EXPECT_EQ(2UL, dumpInfo.size());
333 EXPECT_EQ(dumpInfo[1], expectedResult2);
334
335 dumpInfo.clear();
336
337 g_abilityMs->DumpState(" ", dumpInfo);
338 EXPECT_EQ(0UL, dumpInfo.size());
339
340 dumpInfo.clear();
341
342 g_abilityMs->DumpState("", dumpInfo);
343 EXPECT_EQ(0UL, dumpInfo.size());
344
345 dumpInfo.clear();
346
347 g_abilityMs->DumpState("--", dumpInfo);
348 EXPECT_EQ(0UL, dumpInfo.size());
349
350 dumpInfo.clear();
351
352 g_abilityMs->DumpState("-", dumpInfo);
353 EXPECT_EQ(0UL, dumpInfo.size());
354
355 dumpInfo.clear();
356
357 g_abilityMs->DumpState("-ss", dumpInfo);
358 EXPECT_EQ(0UL, dumpInfo.size());
359
360 dumpInfo.clear();
361
362 g_abilityMs->DumpState("!.. --stack 1", dumpInfo);
363 EXPECT_EQ(0UL, dumpInfo.size());
364
365 dumpInfo.clear();
366
367 g_abilityMs->GetStackManager()->DumpStack(10, dumpInfo);
368 // index 0 :"User ID #"
369 // index 2 :"Invalid stack number, please see ability dump stack-list."
370 EXPECT_EQ(2UL, dumpInfo.size());
371 EXPECT_EQ(dumpInfo[0], "User ID #0");
372 EXPECT_EQ(dumpInfo[1], expectedResult2);
373 }
374
375 /*
376 * Feature: Aafwk
377 * Function: DumpState
378 * SubFunction: NA
379 * FunctionPoints: test AbilityManagerService DumpState
380 * EnvConditions: System running normally
381 * CaseDescription: DumpState to show info of the top ability
382 */
383 HWTEST_F(DumpModuleTest, dump_module_test_004, TestSize.Level2)
384 {
385 std::string args("--top");
386 std::vector<std::string> dumpInfo;
387 g_abilityMs->DumpState(args, dumpInfo);
388 std::vector<std::string> abilityNames;
389 int abilityNum = MTDumpUtil::GetInstance()->GetAll("AbilityName", dumpInfo, abilityNames);
390 EXPECT_EQ(1, abilityNum);
391 EXPECT_EQ("MainAbility6", abilityNames[0]);
392 }
393
394 /*
395 * Feature: Aafwk
396 * Function: DumpTopAbility
397 * SubFunction: NA
398 * FunctionPoints: test AbilityStackManager DumpTopAbility
399 * EnvConditions: System running normally
400 * CaseDescription: DumpTopAbility directly to show info of the top ability
401 */
402 HWTEST_F(DumpModuleTest, dump_module_test_005, TestSize.Level2)
403 {
404 std::vector<std::string> dumpInfo;
405 std::vector<std::string> abilityNames;
406 g_abilityMs->GetStackManager()->DumpTopAbility(dumpInfo);
407 int abilityNum = MTDumpUtil::GetInstance()->GetAll("AbilityName", dumpInfo, abilityNames);
408 EXPECT_EQ(1, abilityNum);
409 EXPECT_EQ("MainAbility6", abilityNames[0]);
410 }
411
412 /*
413 * Feature: Aafwk
414 * Function: DumpState
415 * SubFunction: NA
416 * FunctionPoints: test AbilityManagerService DumpState
417 * EnvConditions: System running normally
418 * CaseDescription: DumpState to show all dump info
419 */
420 HWTEST_F(DumpModuleTest, dump_module_test_006, TestSize.Level2)
421 {
422 std::string args("--all");
423 std::vector<std::string> dumpInfo;
424 g_abilityMs->DumpState(args, dumpInfo);
425 std::vector<Want> abilitiesStarted = {
426 want55,
427 want44,
428 want33,
429 want22,
430 want11,
431 wantLauncher,
432 };
433 std::vector<std::string> abilityNames;
434 MTDumpUtil::GetInstance()->GetAll("AbilityName", dumpInfo, abilityNames);
435 EXPECT_EQ(abilitiesStarted.size(), abilityNames.size());
436 for (unsigned int i = 0; i < abilityNames.size(); ++i) {
437 GTEST_LOG_(INFO) << "abilitiesStarted = " << abilitiesStarted[i].GetElement().GetAbilityName();
438 GTEST_LOG_(INFO) << "abilityNames = " << abilityNames[i];
439 EXPECT_EQ(0, abilitiesStarted[i].GetElement().GetAbilityName().compare(abilityNames[i]));
440 }
441
442 dumpInfo.clear();
443 g_abilityMs->GetStackManager()->Dump(dumpInfo);
444 MTDumpUtil::GetInstance()->GetAll("AbilityName", dumpInfo, abilityNames);
445 EXPECT_EQ(abilitiesStarted.size(), abilityNames.size());
446 for (unsigned int i = 0; i < abilityNames.size(); ++i) {
447 EXPECT_EQ(0, abilitiesStarted[i].GetElement().GetAbilityName().compare(abilityNames[i]));
448 }
449 }
450
451 /*
452 * Feature: Aafwk
453 * Function: DumpTopAbility
454 * SubFunction: NA
455 * FunctionPoints: test AbilityStackManager DumpTopAbility
456 * EnvConditions: System running normally
457 * CaseDescription: Dump directly to show all dump info
458 */
459 HWTEST_F(DumpModuleTest, dump_module_test_007, TestSize.Level2)
460 {
461 std::vector<std::string> dumpInfo;
462 std::vector<Want> abilitiesStarted = {want55, want44, want33, want22, want11, wantLauncher};
463 std::vector<std::string> abilityNames;
464 g_abilityMs->GetStackManager()->Dump(dumpInfo);
465 MTDumpUtil::GetInstance()->GetAll("AbilityName", dumpInfo, abilityNames);
466 EXPECT_EQ(abilitiesStarted.size(), abilityNames.size());
467 for (unsigned int i = 0; i < abilityNames.size(); ++i) {
468 GTEST_LOG_(INFO) << "abilitiesStarted = " << abilitiesStarted[i].GetElement().GetAbilityName();
469 GTEST_LOG_(INFO) << "abilityNames = " << abilityNames[i];
470 EXPECT_EQ(0, abilitiesStarted[i].GetElement().GetAbilityName().compare(abilityNames[i]));
471 }
472 }
473
474 /*
475 * Feature: Aafwk
476 * Function: DumpState
477 * SubFunction: NA
478 * FunctionPoints: test AbilityManagerService DumpState
479 * EnvConditions: System running normally
480 * CaseDescription: DumpState to show info of missionRecords respectively
481 */
482 HWTEST_F(DumpModuleTest, dump_module_test_008, TestSize.Level2)
483 {
484
485 std::string args("--mission");
486 std::vector<std::string> dumpInfo;
487 std::vector<std::string> abilityNames;
488
489 EXPECT_TRUE(g_abilityMs);
490 auto stackMgr = g_abilityMs->GetStackManager();
491 EXPECT_TRUE(stackMgr);
492 auto missionRecord = stackMgr->GetTopMissionRecord();
493 EXPECT_TRUE(missionRecord);
494 int id = missionRecord->GetMissionRecordId();
495 args += " ";
496 args += std::to_string(id);
497 GTEST_LOG_(INFO) << "args = " << args;
498
499 g_abilityMs->DumpState(args, dumpInfo);
500 MTDumpUtil::GetInstance()->GetAll("AbilityName", dumpInfo, abilityNames);
501 EXPECT_EQ(6, abilityNames.size());
502 }
503
504 /*
505 * Feature: Aafwk
506 * Function: DumpState
507 * SubFunction: NA
508 * FunctionPoints: test AbilityManagerService DumpState
509 * EnvConditions: System running normally
510 * CaseDescription: Handle wrong args about missionRecord
511 */
512 HWTEST_F(DumpModuleTest, dump_module_test_09, TestSize.Level2)
513 {
514 std::string args;
515 std::vector<std::string> dumpInfo;
516 std::string expectedResult1 = "error: invalid argument, please see 'ability dump -h'.";
517 std::string expectedResult2 = "error: invalid mission number, please see 'ability dump --stack-list'.";
518
519 args = "--mission 10";
520 g_abilityMs->DumpState(args, dumpInfo);
521 EXPECT_EQ(2UL, dumpInfo.size());
522 EXPECT_EQ(dumpInfo[1], expectedResult2);
523
524 dumpInfo.clear();
525
526 args = "--mission a";
527 g_abilityMs->DumpState(args, dumpInfo);
528 EXPECT_EQ(2UL, dumpInfo.size());
529 EXPECT_EQ(dumpInfo[1], expectedResult2);
530
531 dumpInfo.clear();
532
533 args = "--mission";
534 g_abilityMs->DumpState(args, dumpInfo);
535 EXPECT_EQ(1UL, dumpInfo.size());
536 EXPECT_EQ(dumpInfo[0], expectedResult1);
537
538 dumpInfo.clear();
539
540 args = "--mission1";
541 g_abilityMs->DumpState(args, dumpInfo);
542 EXPECT_EQ(0UL, dumpInfo.size());
543
544 dumpInfo.clear();
545
546 args = "--miss ion";
547 g_abilityMs->DumpState(args, dumpInfo);
548 EXPECT_EQ(0UL, dumpInfo.size());
549
550 dumpInfo.clear();
551
552 args = "-m 1";
553 g_abilityMs->DumpState(args, dumpInfo);
554 EXPECT_EQ(2UL, dumpInfo.size());
555 }
556
557 /*
558 * Feature: Aafwk
559 * Function: GetAllStackInfo
560 * SubFunction: NA
561 * FunctionPoints: test AbilityManagerService GetAllStackInfo
562 * EnvConditions: System running normally
563 * CaseDescription: Get info of all stacks
564 */
565
566 HWTEST_F(DumpModuleTest, dump_module_test_010, TestSize.Level2)
567 {
568 std::string args;
569 StackInfo stackInfo;
570 g_abilityMs->GetAllStackInfo(stackInfo);
571
572 int findFlag = 0;
573 for (auto &stackInfo : stackInfo.missionStackInfos) {
574 for (auto &missionRecord : stackInfo.missionRecords) {
575
576 if (SearchAbilityNameFromStackInfo(G_TESTABILITY1.GetAbilityName(), missionRecord.abilityRecordInfos)) {
577 ++findFlag;
578 }
579 if (SearchAbilityNameFromStackInfo(G_TESTABILITY2.GetAbilityName(), missionRecord.abilityRecordInfos)) {
580 ++findFlag;
581 }
582 if (SearchAbilityNameFromStackInfo(G_TESTABILITY3.GetAbilityName(), missionRecord.abilityRecordInfos)) {
583 ++findFlag;
584 }
585 if (SearchAbilityNameFromStackInfo(G_TESTABILITY4.GetAbilityName(), missionRecord.abilityRecordInfos)) {
586 ++findFlag;
587 }
588 if (SearchAbilityNameFromStackInfo(G_TESTABILITY6.GetAbilityName(), missionRecord.abilityRecordInfos)) {
589 ++findFlag;
590 }
591 if (SearchAbilityNameFromStackInfo(G_LAUNCHABILITY.GetAbilityName(), missionRecord.abilityRecordInfos)) {
592 ++findFlag;
593 }
594 }
595 }
596
597 EXPECT_EQ(6, findFlag);
598 }
599
600 /*
601 * Feature: Aafwk
602 * Function: DumpWaittingAbilityQueue
603 * SubFunction: NA
604 * FunctionPoints: test AbilityStackManager DumpWaittingAbilityQueue
605 * EnvConditions: System running normally
606 * CaseDescription: Dump info of abilities in waiting queue
607 */
608 HWTEST_F(DumpModuleTest, dump_module_test_011, TestSize.Level2)
609 {
610 Want want1;
611 Want want2;
612 std::string expectResult("The waitting ability queue is empty.");
613
614 std::string args("--waitting-queue");
615 std::vector<std::string> result;
616 std::string waitingQueueResult;
617
618 g_abilityMs->DumpState(args, result);
619 auto stackMgr = g_abilityMs->GetStackManager();
620 EXPECT_TRUE(stackMgr);
621 g_abilityMs->DumpWaittingAbilityQueue(waitingQueueResult);
622 EXPECT_EQ(waitingQueueResult, expectResult);
623
624 result.clear();
625 waitingQueueResult.clear();
626
627 want1.SetElement(G_TESTABILITY1);
628 want2.SetElement(G_TESTABILITY5);
629
630 int ref = g_abilityMs->StartAbility(want1);
631 EXPECT_EQ(ref, 0);
632 int refwant2 = g_abilityMs->StartAbility(want2);
633 EXPECT_EQ(refwant2, START_ABILITY_WAITING);
634
635 g_abilityMs->DumpState(args, result);
636 EXPECT_TRUE(stackMgr);
637 stackMgr->DumpWaittingAbilityQueue(waitingQueueResult);
638 EXPECT_NE(std::string::npos, waitingQueueResult.find("com.ix.hiRadio"));
639 }
640
641 } // namespace AAFwk
642 } // namespace OHOS
643