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 "ams_configuration_parameter.h"
22 #include "mission_list_manager.h"
23 #undef private
24 #undef protected
25
26 #include "app_process_data.h"
27 #include "system_ability_definition.h"
28 #include "ability_manager_errors.h"
29 #include "ability_scheduler.h"
30 #include "bundlemgr/mock_bundle_manager.h"
31 #include "sa_mgr_client.h"
32 #include "mock_ability_connect_callback.h"
33 #include "mock_ability_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 namespace OHOS {
41 namespace AAFwk {
42 class MissionDumpTest : public testing::Test {
43 public:
44 static void SetUpTestCase();
45 static void TearDownTestCase();
46 void SetUp();
47 void TearDown();
48 };
49
SetUpTestCase()50 void MissionDumpTest::SetUpTestCase()
51 {}
52
TearDownTestCase()53 void MissionDumpTest::TearDownTestCase()
54 {}
55
SetUp()56 void MissionDumpTest::SetUp()
57 {}
58
TearDown()59 void MissionDumpTest::TearDown()
60 {}
61
62 /*
63 * Feature: MissionListManager
64 * Function: DumpMissionList
65 * SubFunction: NA
66 * FunctionPoints:
67 * EnvConditions: NA
68 * CaseDescription:
69 */
70 HWTEST_F(MissionDumpTest, Dump_Mission_List_001, TestSize.Level1)
71 {
72 int userId = 100;
73 auto missionListManager = std::make_shared<MissionListManager>(userId);
74 EXPECT_TRUE(missionListManager);
75 missionListManager->Init();
76
77 Want want;
78 ElementName element("device", "com.ix.hiMusic", "MusicAbility");
79 want.SetElement(element);
80 AbilityInfo abilityInfo;
81 ApplicationInfo applicationInfo;
82 int requestCode = -1;
83 auto abilityRecord = std::make_shared<AbilityRecord>(want, abilityInfo, applicationInfo, requestCode);
84 EXPECT_TRUE(abilityRecord);
85
86 int32_t id = 1;
87 std::string missionName = "missionName";
88 auto mission = std::make_shared<Mission>(id, abilityRecord, missionName);
89 EXPECT_TRUE(mission);
90
91 auto missionList = std::make_shared<MissionList>(MissionListType::LAUNCHER);
92 EXPECT_TRUE(missionList);
93 missionListManager->currentMissionLists_.push_back(missionList);
94 missionList->AddMissionToTop(mission);
95
96 std::vector<std::string> info;
97 bool isClient = true;
98 std::string args = "NORMAL";
99 missionListManager->DumpMissionList(info, isClient, args);
100 EXPECT_TRUE(info.size() != 0);
101
102 std::string result = "";
103 std::string::size_type idx;
104 for (auto it : info) {
105 result += it + "\n";
106 }
107
108 idx = result.find("Current");
109 EXPECT_TRUE(idx != string::npos);
110
111 std::string::size_type idx1;
112 idx1 = result.find("lockedState");
113 EXPECT_TRUE(idx1 != string::npos);
114
115 std::string::size_type idx2;
116 idx2 = result.find("AbilityRecord");
117 EXPECT_TRUE(idx2 != string::npos);
118 }
119
120 /*
121 * Feature: MissionListManager
122 * Function: DumpMissionList
123 * SubFunction: NA
124 * FunctionPoints:
125 * EnvConditions: NA
126 * CaseDescription:
127 */
128 HWTEST_F(MissionDumpTest, Dump_Mission_List_002, TestSize.Level1)
129 {
130 int userId = 100;
131 auto missionListManager = std::make_shared<MissionListManager>(userId);
132 EXPECT_TRUE(missionListManager);
133 missionListManager->Init();
134
135 Want want;
136 ElementName element("device", "com.ix.hiMusic", "MusicAbility");
137 want.SetElement(element);
138 AbilityInfo abilityInfo;
139 ApplicationInfo applicationInfo;
140 int requestCode = -1;
141 auto abilityRecord = std::make_shared<AbilityRecord>(want, abilityInfo, applicationInfo, requestCode);
142 EXPECT_TRUE(abilityRecord);
143
144 int32_t id = 1;
145 std::string missionName = "missionName";
146 auto mission = std::make_shared<Mission>(id, abilityRecord, missionName);
147 EXPECT_TRUE(mission);
148
149 auto missionList = std::make_shared<MissionList>(MissionListType::LAUNCHER);
150 EXPECT_TRUE(missionList);
151 missionListManager->launcherList_ = missionList;
152 missionList->AddMissionToTop(mission);
153
154 std::vector<std::string> info;
155 bool isClient = true;
156 std::string args = "LAUNCHER";
157 missionListManager->DumpMissionList(info, isClient, args);
158 EXPECT_TRUE(info.size() != 0);
159
160 std::string result = "";
161 std::string::size_type idx;
162 for (auto it : info) {
163 result += it + "\n";
164 }
165
166 idx = result.find("launcher");
167 EXPECT_TRUE(idx != string::npos);
168
169 idx = result.find("lockedState");
170 EXPECT_TRUE(idx != string::npos);
171
172 idx = result.find("AbilityRecord");
173 EXPECT_TRUE(idx != string::npos);
174 }
175
176 /*
177 * Feature: MissionListManager
178 * Function: DumpMissionList
179 * SubFunction: NA
180 * FunctionPoints:
181 * EnvConditions: NA
182 * CaseDescription:
183 */
184 HWTEST_F(MissionDumpTest, Dump_Mission_List_003, TestSize.Level1)
185 {
186 int userId = 100;
187 auto missionListManager = std::make_shared<MissionListManager>(userId);
188 EXPECT_TRUE(missionListManager);
189 missionListManager->Init();
190
191 Want want;
192 ElementName element("device", "com.ix.hiMusic", "MusicAbility");
193 want.SetElement(element);
194 AbilityInfo abilityInfo;
195 ApplicationInfo applicationInfo;
196 int requestCode = -1;
197 auto abilityRecord = std::make_shared<AbilityRecord>(want, abilityInfo, applicationInfo, requestCode);
198 EXPECT_TRUE(abilityRecord);
199
200 int32_t id = 1;
201 std::string missionName = "missionName";
202 auto mission = std::make_shared<Mission>(id, abilityRecord, missionName);
203 EXPECT_TRUE(mission);
204
205 auto missionList = std::make_shared<MissionList>(MissionListType::DEFAULT_STANDARD);
206 EXPECT_TRUE(missionList);
207 missionListManager->defaultStandardList_ = missionList;
208 missionList->AddMissionToTop(mission);
209
210 std::vector<std::string> info;
211 bool isClient = true;
212 std::string args = "DEFAULT_STANDARD";
213 missionListManager->DumpMissionList(info, isClient, args);
214 EXPECT_TRUE(info.size() != 0);
215
216 std::string result = "";
217 std::string::size_type idx;
218 for (auto it : info) {
219 result += it + "\n";
220 }
221
222 idx = result.find("stand");
223 EXPECT_TRUE(idx != string::npos);
224
225 idx = result.find("lockedState");
226 EXPECT_TRUE(idx != string::npos);
227
228 idx = result.find("AbilityRecord");
229 EXPECT_TRUE(idx != string::npos);
230 }
231
232 /*
233 * Feature: MissionListManager
234 * Function: DumpMissionList
235 * SubFunction: NA
236 * FunctionPoints:
237 * EnvConditions: NA
238 * CaseDescription:
239 */
240 HWTEST_F(MissionDumpTest, Dump_Mission_List_004, TestSize.Level1)
241 {
242 int userId = 100;
243 auto missionListManager = std::make_shared<MissionListManager>(userId);
244 EXPECT_TRUE(missionListManager);
245 missionListManager->Init();
246
247 Want want;
248 ElementName element("device", "com.ix.hiMusic", "MusicAbility");
249 want.SetElement(element);
250 AbilityInfo abilityInfo;
251 ApplicationInfo applicationInfo;
252 int requestCode = -1;
253 auto abilityRecord = std::make_shared<AbilityRecord>(want, abilityInfo, applicationInfo, requestCode);
254 EXPECT_TRUE(abilityRecord);
255
256 int32_t id = 1;
257 std::string missionName = "missionName";
258 auto mission = std::make_shared<Mission>(id, abilityRecord, missionName);
259 EXPECT_TRUE(mission);
260
261 auto missionList = std::make_shared<MissionList>(MissionListType::DEFAULT_SINGLE);
262 EXPECT_TRUE(missionList);
263 missionListManager->defaultSingleList_ = missionList;
264 missionList->AddMissionToTop(mission);
265
266 std::vector<std::string> info;
267 bool isClient = true;
268 std::string args = "DEFAULT_SINGLE";
269 missionListManager->DumpMissionList(info, isClient, args);
270 EXPECT_TRUE(info.size() != 0);
271
272 std::string result = "";
273 std::string::size_type idx;
274 for (auto it : info) {
275 result += it + "\n";
276 }
277
278 idx = result.find("single");
279 EXPECT_TRUE(idx != string::npos);
280
281 idx = result.find("lockedState");
282 EXPECT_TRUE(idx != string::npos);
283
284 idx = result.find("AbilityRecord");
285 EXPECT_TRUE(idx != string::npos);
286 }
287
288 /*
289 * Feature: MissionListManager
290 * Function: DumpMissionListByRecordId
291 * SubFunction: NA
292 * FunctionPoints:
293 * EnvConditions: NA
294 * CaseDescription:
295 */
296 HWTEST_F(MissionDumpTest, Dump_MissionList_ByRecordId_001, TestSize.Level1)
297 {
298 int userId = 100;
299 auto missionListManager = std::make_shared<MissionListManager>(userId);
300 EXPECT_TRUE(missionListManager);
301 missionListManager->Init();
302
303 Want want;
304 ElementName element("device", "com.ix.hiMusic", "MusicAbility");
305 want.SetElement(element);
306 AbilityInfo abilityInfo;
307 ApplicationInfo applicationInfo;
308 int requestCode = -1;
309 auto abilityRecord = std::make_shared<AbilityRecord>(want, abilityInfo, applicationInfo, requestCode);
310 EXPECT_TRUE(abilityRecord);
311 abilityRecord->recordId_ = 101;
312
313 int32_t id = 1;
314 std::string missionName = "missionName";
315 auto mission = std::make_shared<Mission>(id, abilityRecord, missionName);
316 EXPECT_TRUE(mission);
317
318 auto missionList = std::make_shared<MissionList>(MissionListType::LAUNCHER);
319 EXPECT_TRUE(missionList);
320 missionListManager->launcherList_ = missionList;
321 missionList->AddMissionToTop(mission);
322
323 std::vector<std::string> info;
324 bool isClient = true;
325 std::vector<std::string> params;
326 missionListManager->DumpMissionListByRecordId(info, isClient, abilityRecord->recordId_, params);
327 EXPECT_TRUE(info.size() != 0);
328
329 std::string result = "";
330 std::string::size_type idx;
331 for (auto it : info) {
332 result += it + "\n";
333 }
334
335 idx = result.find("AbilityRecord");
336 EXPECT_TRUE(idx != string::npos);
337 }
338
339 /*
340 * Feature: MissionListManager
341 * Function: DumpMissionListByRecordId
342 * SubFunction: NA
343 * FunctionPoints:
344 * EnvConditions: NA
345 * CaseDescription:
346 */
347 HWTEST_F(MissionDumpTest, Dump_MissionList_ByRecordId_002, TestSize.Level1)
348 {
349 int userId = 100;
350 auto missionListManager = std::make_shared<MissionListManager>(userId);
351 EXPECT_TRUE(missionListManager);
352 missionListManager->Init();
353
354 Want want;
355 ElementName element("device", "com.ix.hiMusic", "MusicAbility");
356 want.SetElement(element);
357 AbilityInfo abilityInfo;
358 ApplicationInfo applicationInfo;
359 int requestCode = -1;
360 auto abilityRecord = std::make_shared<AbilityRecord>(want, abilityInfo, applicationInfo, requestCode);
361 EXPECT_TRUE(abilityRecord);
362 abilityRecord->recordId_ = 101;
363
364 int32_t id = 1;
365 std::string missionName = "missionName";
366 auto mission = std::make_shared<Mission>(id, abilityRecord, missionName);
367 EXPECT_TRUE(mission);
368
369 auto missionList = std::make_shared<MissionList>(MissionListType::DEFAULT_SINGLE);
370 EXPECT_TRUE(missionList);
371 missionListManager->defaultSingleList_ = missionList;
372 missionList->AddMissionToTop(mission);
373
374 std::vector<std::string> info;
375 bool isClient = true;
376 std::vector<std::string> params;
377 missionListManager->DumpMissionListByRecordId(info, isClient, abilityRecord->recordId_, params);
378 EXPECT_TRUE(info.size() != 0);
379
380 std::string result = "";
381 std::string::size_type idx;
382 for (auto it : info) {
383 result += it + "\n";
384 }
385
386 idx = result.find("AbilityRecord");
387 EXPECT_TRUE(idx != string::npos);
388 }
389
390 /*
391 * Feature: MissionListManager
392 * Function: DumpMissionListByRecordId
393 * SubFunction: NA
394 * FunctionPoints:
395 * EnvConditions: NA
396 * CaseDescription:
397 */
398 HWTEST_F(MissionDumpTest, Dump_MissionList_ByRecordId_003, TestSize.Level1)
399 {
400 int userId = 100;
401 auto missionListManager = std::make_shared<MissionListManager>(userId);
402 EXPECT_TRUE(missionListManager);
403 missionListManager->Init();
404
405 Want want;
406 ElementName element("device", "com.ix.hiMusic", "MusicAbility");
407 want.SetElement(element);
408 AbilityInfo abilityInfo;
409 ApplicationInfo applicationInfo;
410 int requestCode = -1;
411 auto abilityRecord = std::make_shared<AbilityRecord>(want, abilityInfo, applicationInfo, requestCode);
412 EXPECT_TRUE(abilityRecord);
413 abilityRecord->recordId_ = 101;
414
415 int32_t id = 1;
416 std::string missionName = "missionName";
417 auto mission = std::make_shared<Mission>(id, abilityRecord, missionName);
418 EXPECT_TRUE(mission);
419
420 auto missionList = std::make_shared<MissionList>(MissionListType::DEFAULT_STANDARD);
421 EXPECT_TRUE(missionList);
422 missionListManager->defaultStandardList_ = missionList;
423 missionList->AddMissionToTop(mission);
424
425 std::vector<std::string> info;
426 bool isClient = true;
427 std::vector<std::string> params;
428 missionListManager->DumpMissionListByRecordId(info, isClient, abilityRecord->recordId_, params);
429 EXPECT_TRUE(info.size() != 0);
430
431 std::string result = "";
432 std::string::size_type idx;
433 for (auto it : info) {
434 result += it + "\n";
435 }
436
437 idx = result.find("AbilityRecord");
438 EXPECT_TRUE(idx != string::npos);
439 }
440 } // namespace AAFwk
441 } // namespace OHOS
442