1 /*
2 * Copyright (c) 2025 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
18 #include "ability_manager_service.h"
19 #include "ability_record.h"
20 #include "hilog_tag_wrapper.h"
21 #include "mock_ability_token.h"
22 #include "sa_mgr_client.h"
23 #include "task_handler_wrap.h"
24
25 using namespace testing::ext;
26 using namespace OHOS::AAFwk;
27
28 namespace OHOS {
29 namespace AppExecFwk {
30 namespace {
31 const int BUNDLE_MGR_SERVICE_SYS_ABILITY_ID = 401;
32 }
33 class FreeInstallTest : public testing::Test {
34 public:
FreeInstallTest()35 FreeInstallTest()
36 {}
~FreeInstallTest()37 ~FreeInstallTest()
38 {}
39 static void SetUpTestCase(void);
40 static void TearDownTestCase(void);
41 void SetUp();
42 void TearDown();
43 sptr<Token> MockToken();
44 std::shared_ptr<FreeInstallManager> freeInstallManager_ = nullptr;
45 };
46
SetUpTestCase(void)47 void FreeInstallTest::SetUpTestCase(void) {}
48
TearDownTestCase(void)49 void FreeInstallTest::TearDownTestCase(void) {}
50
SetUp(void)51 void FreeInstallTest::SetUp(void) {}
52
TearDown(void)53 void FreeInstallTest::TearDown(void)
54 {}
55
MockToken()56 sptr<Token> FreeInstallTest::MockToken()
57 {
58 sptr<Token> token = nullptr;
59 AbilityRequest abilityRequest;
60 abilityRequest.appInfo.bundleName = "com.test.demo";
61 abilityRequest.abilityInfo.name = "MainAbility";
62 abilityRequest.abilityInfo.type = AbilityType::PAGE;
63 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
64 if (!abilityRecord) {
65 return nullptr;
66 }
67 return abilityRecord->GetToken();
68 }
69
70 /**
71 * @tc.number: RemoteFreeInstall_001
72 * @tc.name: RemoteFreeInstall
73 * @tc.desc: Test RemoteFreeInstall.
74 */
75 HWTEST_F(FreeInstallTest, FreeInstall_RemoteFreeInstall_001, TestSize.Level1)
76 {
77 auto abilityMs_ = std::make_shared<AbilityManagerService>();
78 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs_);
79 Want want;
80 ElementName element("", "com.test.demo", "MainAbility");
81 want.SetElement(element);
82 const int32_t userId = 100;
83 const int requestCode = 0;
84 want.SetParam(Want::PARAM_RESV_START_TIME, std::string("0"));
85 // mock callerToken
86 const sptr<IRemoteObject> callerToken = MockToken();
87 int res = 0;
88
89 usleep(100000); // 100000 means us.
90 // from freeInstallManager_->freeInstallList_ find startInstallTime
91 for (auto it = freeInstallManager_->freeInstallList_.begin(); it != freeInstallManager_->freeInstallList_.end();) {
92 std::string bundleName = (*it).want.GetElement().GetBundleName();
93 std::string abilityName = (*it).want.GetElement().GetAbilityName();
94 if (want.GetElement().GetBundleName().compare(bundleName) != 0 ||
95 want.GetElement().GetAbilityName().compare(abilityName) != 0) {
96 want.SetParam(Want::PARAM_RESV_START_TIME, (*it).want.GetStringParam(Want::PARAM_RESV_START_TIME));
97 break;
98 }
99 }
100 res = freeInstallManager_->RemoteFreeInstall(want, userId, requestCode, callerToken);
101 EXPECT_EQ(res, NOT_TOP_ABILITY);
102 }
103
104 /**
105 * @tc.number: RemoteFreeInstall_002
106 * @tc.name: RemoteFreeInstall
107 * @tc.desc: Test RemoteFreeInstall.
108 */
109 HWTEST_F(FreeInstallTest, FreeInstall_RemoteFreeInstall_002, TestSize.Level1)
110 {
111 auto abilityMs_ = std::make_shared<AbilityManagerService>();
112 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs_);
113 Want want;
114 ElementName element("", "com.test.demo", "MainAbility");
115 want.SetElement(element);
116 const int32_t userId = 100;
117 const int requestCode = 0;
118 want.SetParam(Want::PARAM_RESV_START_TIME, std::string("0"));
119 want.SetParam(FROM_REMOTE_KEY, true);
120 // mock callerToken
121 const sptr<IRemoteObject> callerToken = MockToken();
122 int res = 0;
123
124 usleep(100000); // 100000 means us.
125 // from freeInstallManager_->freeInstallList_ find startInstallTime
126 for (auto it = freeInstallManager_->freeInstallList_.begin(); it != freeInstallManager_->freeInstallList_.end();) {
127 std::string bundleName = (*it).want.GetElement().GetBundleName();
128 std::string abilityName = (*it).want.GetElement().GetAbilityName();
129 if (want.GetElement().GetBundleName().compare(bundleName) != 0 ||
130 want.GetElement().GetAbilityName().compare(abilityName) != 0) {
131 want.SetParam(Want::PARAM_RESV_START_TIME, (*it).want.GetStringParam(Want::PARAM_RESV_START_TIME));
132 break;
133 }
134 }
135 res = freeInstallManager_->RemoteFreeInstall(want, userId, requestCode, callerToken);
136 EXPECT_NE(res, ERR_OK);
137 }
138
139 /**
140 * @tc.number: StartRemoteFreeInstall_001
141 * @tc.name: StartRemoteFreeInstall
142 * @tc.desc: Test StartRemoteFreeInstall.
143 */
144 HWTEST_F(FreeInstallTest, FreeInstall_StartRemoteFreeInstall_001, TestSize.Level1)
145 {
146 auto abilityMs_ = std::make_shared<AbilityManagerService>();
147 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs_);
148 Want want;
149 ElementName element("", "com.test.demo", "MainAbility");
150 want.SetElement(element);
151 const int32_t userId = 100;
152 const int requestCode = 0;
153 want.SetParam(Want::PARAM_RESV_START_TIME, std::string("0"));
154 want.SetParam(Want::PARAM_RESV_FOR_RESULT, true);
155 // mock callerToken
156 const sptr<IRemoteObject> callerToken = MockToken();
157 int res = 0;
158
159 usleep(100000); // 100000 means us.
160 // from freeInstallManager_->freeInstallList_ find startInstallTime
161 for (auto it = freeInstallManager_->freeInstallList_.begin(); it != freeInstallManager_->freeInstallList_.end();) {
162 std::string bundleName = (*it).want.GetElement().GetBundleName();
163 std::string abilityName = (*it).want.GetElement().GetAbilityName();
164 if (want.GetElement().GetBundleName().compare(bundleName) != 0 ||
165 want.GetElement().GetAbilityName().compare(abilityName) != 0) {
166 want.SetParam(Want::PARAM_RESV_START_TIME, (*it).want.GetStringParam(Want::PARAM_RESV_START_TIME));
167 break;
168 }
169 }
170 res = freeInstallManager_->StartRemoteFreeInstall(want, userId, requestCode, callerToken);
171 EXPECT_NE(res, ERR_OK);
172 }
173
174 /**
175 * @tc.number: StartRemoteFreeInstall_002
176 * @tc.name: StartRemoteFreeInstall
177 * @tc.desc: Test StartRemoteFreeInstall.
178 */
179 HWTEST_F(FreeInstallTest, FreeInstall_StartRemoteFreeInstall_002, TestSize.Level1)
180 {
181 auto abilityMs_ = std::make_shared<AbilityManagerService>();
182 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs_);
183 Want want;
184 ElementName element("", "com.test.demo", "MainAbility");
185 want.SetElement(element);
186 const int32_t userId = 100;
187 const int requestCode = 0;
188 want.SetParam(Want::PARAM_RESV_START_TIME, std::string("0"));
189 want.SetParam(Want::PARAM_RESV_FOR_RESULT, false);
190 // mock callerToken
191 const sptr<IRemoteObject> callerToken = MockToken();
192 int res = 0;
193 usleep(100000); // 100000 means us.
194 // from freeInstallManager_->freeInstallList_ find startInstallTime
195 for (auto it = freeInstallManager_->freeInstallList_.begin(); it != freeInstallManager_->freeInstallList_.end();) {
196 std::string bundleName = (*it).want.GetElement().GetBundleName();
197 std::string abilityName = (*it).want.GetElement().GetAbilityName();
198 if (want.GetElement().GetBundleName().compare(bundleName) != 0 ||
199 want.GetElement().GetAbilityName().compare(abilityName) != 0) {
200 want.SetParam(Want::PARAM_RESV_START_TIME, (*it).want.GetStringParam(Want::PARAM_RESV_START_TIME));
201 break;
202 }
203 }
204 res = freeInstallManager_->StartRemoteFreeInstall(want, userId, requestCode, callerToken);
205 EXPECT_NE(res, ERR_OK);
206 }
207
208 /**
209 * @tc.number: NotifyDmsCallback_001
210 * @tc.name: NotifyDmsCallback
211 * @tc.desc: Test NotifyDmsCallback.
212 */
213 HWTEST_F(FreeInstallTest, FreeInstall_NotifyDmsCallback_001, TestSize.Level1)
214 {
215 auto abilityMs_ = std::make_shared<AbilityManagerService>();
216 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs_);
217 Want want;
218 ElementName element("", "com.test.demo", "MainAbility");
219 want.SetElement(element);
220 const int32_t userId = 100;
221 const int requestCode = 0;
222 want.SetParam(Want::PARAM_RESV_START_TIME, std::string("0"));
223 int res = 0;
224 res = freeInstallManager_->NotifyDmsCallback(want, requestCode);
225 EXPECT_EQ(res, ERR_INVALID_VALUE);
226 }
227
228 /**
229 * @tc.number: HandleOnFreeInstallSuccess_001
230 * @tc.name: HandleOnFreeInstallSuccess
231 * @tc.desc: Test HandleOnFreeInstallSuccess.
232 */
233 HWTEST_F(FreeInstallTest, FreeInstall_HandleOnFreeInstallSuccess_001, TestSize.Level1)
234 {
235 auto abilityMs_ = std::make_shared<AbilityManagerService>();
236 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs_);
237 Want want;
238 ElementName element("", "com.test.demo", "MainAbility");
239 want.SetElement(element);
240 want.SetParam(Want::PARAM_RESV_START_TIME, std::string("0"));
241 int32_t recordId = 100;
242 FreeInstallInfo freeInstallInfo;
243 freeInstallInfo.want = want;
244 bool isAsync = true;
245 freeInstallInfo.isPreStartMissionCalled = true;
246 freeInstallManager_->HandleOnFreeInstallSuccess(recordId, freeInstallInfo, isAsync);
247 EXPECT_EQ(freeInstallInfo.isOpenAtomicServiceShortUrl, false);
248 }
249
250 /**
251 * @tc.number: HandleOnFreeInstallSuccess_002
252 * @tc.name: HandleOnFreeInstallSuccess
253 * @tc.desc: Test HandleOnFreeInstallSuccess.
254 */
255 HWTEST_F(FreeInstallTest, FreeInstall_HandleOnFreeInstallSuccess_002, TestSize.Level1)
256 {
257 auto abilityMs_ = std::make_shared<AbilityManagerService>();
258 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs_);
259 Want want;
260 ElementName element("", "com.test.demo", "MainAbility");
261 want.SetElement(element);
262 int32_t recordId = 100;
263 want.SetParam(Want::PARAM_RESV_START_TIME, std::string("0"));
264 FreeInstallInfo freeInstallInfo;
265 freeInstallInfo.want = want;
266 bool isAsync = true;
267 freeInstallInfo.isOpenAtomicServiceShortUrl = true;
268 freeInstallManager_->HandleOnFreeInstallSuccess(recordId, freeInstallInfo, isAsync);
269 EXPECT_EQ(freeInstallInfo.isPreStartMissionCalled, false);
270 }
271
272 /**
273 * @tc.number: HandleOnFreeInstallFail_001
274 * @tc.name: HandleOnFreeInstallFail
275 * @tc.desc: Test HandleOnFreeInstallFail.
276 */
277 HWTEST_F(FreeInstallTest, FreeInstall_HandleOnFreeInstallFail_001, TestSize.Level1)
278 {
279 auto abilityMs_ = std::make_shared<AbilityManagerService>();
280 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs_);
281 Want want;
282 ElementName element("", "com.ohos.param.sessionId", "MainAbility");
283 want.SetElement(element);
284 int32_t recordId = 100;
285 int resultCode = 0;
286 want.SetParam(Want::PARAM_RESV_START_TIME, std::string("0"));
287 FreeInstallInfo freeInstallInfo;
288 freeInstallInfo.want = want;
289 bool isAsync = true;
290 freeInstallInfo.isPreStartMissionCalled = true;
291 freeInstallInfo.isStartUIAbilityBySCBCalled = true;
292 freeInstallManager_->HandleOnFreeInstallFail(recordId, freeInstallInfo, resultCode, isAsync);
293 EXPECT_EQ(freeInstallInfo.isOpenAtomicServiceShortUrl, false);
294 }
295
296 /**
297 * @tc.number: HandleOnFreeInstallFail_002
298 * @tc.name: HandleOnFreeInstallFail
299 * @tc.desc: Test HandleOnFreeInstallFail.
300 */
301 HWTEST_F(FreeInstallTest, FreeInstall_HandleOnFreeInstallFail_002, TestSize.Level1)
302 {
303 auto abilityMs_ = std::make_shared<AbilityManagerService>();
304 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs_);
305 Want want;
306 ElementName element("", "com.ohos.param.sessionId", "MainAbility");
307 want.SetElement(element);
308 int32_t recordId = 100;
309 int resultCode = 0;
310 want.SetParam(Want::PARAM_RESV_START_TIME, std::string("0"));
311 FreeInstallInfo freeInstallInfo;
312 freeInstallInfo.want = want;
313 bool isAsync = true;
314 freeInstallInfo.isOpenAtomicServiceShortUrl = true;
315 freeInstallManager_->HandleOnFreeInstallFail(recordId, freeInstallInfo, resultCode, isAsync);
316 EXPECT_EQ(freeInstallInfo.isPreStartMissionCalled, false);
317 }
318
319 /**
320 * @tc.number: HandleOnFreeInstallFail_003
321 * @tc.name: HandleOnFreeInstallFail
322 * @tc.desc: Test HandleOnFreeInstallFail.
323 */
324 HWTEST_F(FreeInstallTest, FreeInstall_HandleOnFreeInstallFail_003, TestSize.Level1)
325 {
326 auto abilityMs_ = std::make_shared<AbilityManagerService>();
327 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs_);
328 Want want;
329 ElementName element("", "com.example.aplication", "MainAbility");
330 want.SetElement(element);
331 int32_t recordId = 100;
332 int resultCode = 0;
333 want.SetParam(Want::PARAM_RESV_START_TIME, std::string("0"));
334 FreeInstallInfo freeInstallInfo;
335 freeInstallInfo.want = want;
336 bool isAsync = true;
337 freeInstallInfo.isOpenAtomicServiceShortUrl = true;
338 freeInstallInfo.startOptions = std::make_shared<StartOptions>();
339 EXPECT_NE(freeInstallInfo.startOptions, nullptr);
340 freeInstallInfo.startOptions->requestId_ = "1234567890";
341 freeInstallManager_->HandleOnFreeInstallFail(recordId, freeInstallInfo, resultCode, isAsync);
342 EXPECT_EQ(freeInstallInfo.isPreStartMissionCalled, false);
343 }
344
345 /**
346 * @tc.number: HandleOnFreeInstallFail_004
347 * @tc.name: HandleOnFreeInstallFail
348 * @tc.desc: Test HandleOnFreeInstallFail.
349 */
350 HWTEST_F(FreeInstallTest, FreeInstall_HandleOnFreeInstallFail_004, TestSize.Level1)
351 {
352 TAG_LOGI(AAFwkTag::TEST, "FreeInstall_HandleOnFreeInstallFail_004 start");
353 auto abilityMs_ = std::make_shared<AbilityManagerService>();
354 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs_);
355 Want want;
356 ElementName element("", "com.example.aplication", "MainAbility");
357 want.SetElement(element);
358 int32_t recordId = 100;
359 int resultCode = 0;
360 want.SetParam(Want::PARAM_RESV_START_TIME, std::string("0"));
361 FreeInstallInfo freeInstallInfo;
362 freeInstallInfo.want = want;
363 bool isAsync = true;
364 freeInstallInfo.isOpenAtomicServiceShortUrl = true;
365 freeInstallInfo.startOptions = std::make_shared<StartOptions>();
366 EXPECT_NE(freeInstallInfo.startOptions, nullptr);
367 freeInstallInfo.startOptions->requestId_ = "1234567890";
368 freeInstallInfo.callerToken = sptr<IRemoteObject>(new (std::nothrow) MockAbilityToken());
369 freeInstallManager_->HandleOnFreeInstallFail(recordId, freeInstallInfo, resultCode, isAsync);
370 EXPECT_EQ(freeInstallInfo.isPreStartMissionCalled, false);
371 TAG_LOGI(AAFwkTag::TEST, "FreeInstall_HandleOnFreeInstallFail_004 start");
372 }
373
374 /**
375 * @tc.number: StartAbilityByFreeInstall_001
376 * @tc.name: StartAbilityByFreeInstall
377 * @tc.desc: Test StartAbilityByFreeInstall.
378 */
379 HWTEST_F(FreeInstallTest, FreeInstall_StartAbilityByFreeInstall_001, TestSize.Level1)
380 {
381 auto abilityMs_ = std::make_shared<AbilityManagerService>();
382 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs_);
383 Want want;
384 ElementName element("", "com.test.demo", "MainAbility");
385 want.SetElement(element);
386 FreeInstallInfo freeInstallInfo;
387 std::string bundleName = "com.test.demo";
388 std::string abilityName = "MainAbility";
389 std::string startTime = "2024-7-17 00:00:00";
390 std::shared_ptr<FreeInstallParams> param = std::make_shared<FreeInstallParams>();
391 freeInstallInfo.startOptions = param->startOptions;
392 want.SetParam(Want::PARAM_RESV_START_TIME, startTime);
393 freeInstallInfo.want = want;
394 freeInstallManager_->StartAbilityByFreeInstall(freeInstallInfo, bundleName, abilityName, startTime);
395 freeInstallInfo.startOptions = nullptr;
396 freeInstallManager_->StartAbilityByFreeInstall(freeInstallInfo, bundleName, abilityName, startTime);
397 EXPECT_EQ(freeInstallInfo.isPreStartMissionCalled, false);
398 }
399
400 /**
401 * @tc.number: StartAbilityByFreeInstall_002
402 * @tc.name: StartAbilityByFreeInstall
403 * @tc.desc: Test StartAbilityByFreeInstall.
404 */
405 HWTEST_F(FreeInstallTest, FreeInstall_StartAbilityByFreeInstall_002, TestSize.Level1)
406 {
407 auto abilityMs_ = std::make_shared<AbilityManagerService>();
408 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs_);
409 Want want;
410 ElementName element("", "", "");
411 want.SetElement(element);
412 FreeInstallInfo freeInstallInfo;
413 std::string bundleName = "com.test.demo";
414 std::string abilityName = "MainAbility";
415 std::string startTime = "2024-7-17 00:00:00";
416 want.SetParam(Want::PARAM_RESV_START_TIME, startTime);
417 freeInstallInfo.want = want;
418 freeInstallManager_->StartAbilityByFreeInstall(freeInstallInfo, bundleName, abilityName, startTime);
419 EXPECT_EQ(freeInstallInfo.isPreStartMissionCalled, false);
420 }
421
422 /**
423 * @tc.number: StartAbilityByPreInstall_001
424 * @tc.name: StartAbilityByPreInstall
425 * @tc.desc: Test StartAbilityByPreInstall.
426 */
427 HWTEST_F(FreeInstallTest, FreeInstall_StartAbilityByPreInstall_001, TestSize.Level1)
428 {
429 auto abilityMs_ = std::make_shared<AbilityManagerService>();
430 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs_);
431 Want want;
432 ElementName element("", "com.test.demo", "MainAbility");
433 want.SetElement(element);
434 FreeInstallInfo freeInstallInfo;
435 std::string bundleName = "com.test.demo";
436 std::string abilityName = "MainAbility";
437 std::string startTime = "2024-7-17 00:00:00";
438 std::shared_ptr<FreeInstallParams> param = std::make_shared<FreeInstallParams>();
439 freeInstallInfo.startOptions = param->startOptions;
440 int32_t recordId = 100;
441 want.SetParam(Want::PARAM_RESV_START_TIME, startTime);
442 freeInstallInfo.want = want;
443 freeInstallInfo.isStartUIAbilityBySCBCalled = true;
444 freeInstallInfo.isOpenAtomicServiceShortUrl = true;
445 freeInstallManager_->StartAbilityByPreInstall(recordId, freeInstallInfo, bundleName, abilityName, startTime);
446 freeInstallInfo.startOptions = nullptr;
447 freeInstallManager_->StartAbilityByPreInstall(recordId, freeInstallInfo, bundleName, abilityName, startTime);
448 EXPECT_EQ(freeInstallInfo.isPreStartMissionCalled, false);
449 }
450
451 /**
452 * @tc.number: StartAbilityByPreInstall_002
453 * @tc.name: StartAbilityByPreInstall
454 * @tc.desc: Test StartAbilityByPreInstall.
455 */
456 HWTEST_F(FreeInstallTest, FreeInstall_StartAbilityByPreInstall_002, TestSize.Level1)
457 {
458 auto abilityMs_ = std::make_shared<AbilityManagerService>();
459 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs_);
460 Want want;
461 ElementName element("", "", "");
462 want.SetElement(element);
463 int32_t recordId = 100;
464 FreeInstallInfo freeInstallInfo;
465 std::string bundleName = "com.test.demo";
466 std::string abilityName = "MainAbility";
467 std::string startTime = "2024-7-17 00:00:00";
468 want.SetParam(Want::PARAM_RESV_START_TIME, startTime);
469 freeInstallInfo.want = want;
470 freeInstallManager_->StartAbilityByPreInstall(recordId, freeInstallInfo, bundleName, abilityName, startTime);
471 EXPECT_EQ(freeInstallInfo.isPreStartMissionCalled, false);
472 }
473
474 /**
475 * @tc.number: SetSCBCallStatus_001
476 * @tc.name: SetSCBCallStatus
477 * @tc.desc: Test SetSCBCallStatus.
478 */
479 HWTEST_F(FreeInstallTest, FreeInstall_SetSCBCallStatus_001, TestSize.Level1)
480 {
481 auto abilityMs_ = std::make_shared<AbilityManagerService>();
482 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs_);
483 Want want;
484 ElementName element("", "com.test.demo", "MainAbility");
485 want.SetElement(element);
486 std::string bundleName = "com.test.demo";
487 std::string abilityName = "MainAbility";
488 std::string startTime = "2024-7-17 00:00:00";
489 want.SetParam(Want::PARAM_RESV_START_TIME, startTime);
490 const int32_t userId = 1;
491 const int requestCode = 0;
492 FreeInstallInfo info = freeInstallManager_->BuildFreeInstallInfo(want, userId, requestCode, nullptr);
493 {
494 std::lock_guard<ffrt::mutex> lock(freeInstallManager_->freeInstallListLock_);
495 freeInstallManager_->freeInstallList_.push_back(info);
496 }
497 bool scbCallStatus = true;
498 freeInstallManager_->SetSCBCallStatus(bundleName, abilityName, startTime, scbCallStatus);
499 EXPECT_EQ(info.isStartUIAbilityBySCBCalled, false);
500 }
501
502 /**
503 * @tc.number: SetPreStartMissionCallStatus_001
504 * @tc.name: SetPreStartMissionCallStatus
505 * @tc.desc: Test SetPreStartMissionCallStatus.
506 */
507 HWTEST_F(FreeInstallTest, FreeInstall_SetPreStartMissionCallStatus_001, TestSize.Level1)
508 {
509 auto abilityMs_ = std::make_shared<AbilityManagerService>();
510 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs_);
511 Want want;
512 ElementName element("", "com.test.demo", "MainAbility");
513 want.SetElement(element);
514 std::string bundleName = "com.test.demo";
515 std::string abilityName = "MainAbility";
516 std::string startTime = "2024-7-17 00:00:00";
517 want.SetParam(Want::PARAM_RESV_START_TIME, startTime);
518 const int32_t userId = 1;
519 const int requestCode = 0;
520 FreeInstallInfo info = freeInstallManager_->BuildFreeInstallInfo(want, userId, requestCode, nullptr);
521 {
522 std::lock_guard<ffrt::mutex> lock(freeInstallManager_->freeInstallListLock_);
523 freeInstallManager_->freeInstallList_.push_back(info);
524 }
525 bool preStartMissionCallStatus = true;
526 freeInstallManager_->SetPreStartMissionCallStatus(bundleName, abilityName, startTime, preStartMissionCallStatus);
527 EXPECT_EQ(info.isPreStartMissionCalled, false);
528 }
529 } // namespace AppExecFwk
530 } // namespace OHOS