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