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
18 #define private public
19 #include "ability_manager_service.h"
20 #include "task_handler_wrap.h"
21 #undef private
22
23 #include "ability_record.h"
24 #include "sa_mgr_client.h"
25
26 using namespace testing::ext;
27 using namespace OHOS::AAFwk;
28
29 namespace OHOS {
30 namespace AppExecFwk {
31 namespace {
32 const int BUNDLE_MGR_SERVICE_SYS_ABILITY_ID = 401;
33 const int VALID_RECORD_ID = 1;
34 const int INVALID_RECORD_ID = -1;
35 constexpr const char* KEY_REQUEST_ID = "com.ohos.param.requestId";
36 }
37 class FreeInstallTest : public testing::Test {
38 public:
FreeInstallTest()39 FreeInstallTest()
40 {}
~FreeInstallTest()41 ~FreeInstallTest()
42 {}
43 static void SetUpTestCase(void);
44 static void TearDownTestCase(void);
45 void SetUp();
46 void TearDown();
47 sptr<Token> MockToken();
48 std::shared_ptr<FreeInstallManager> freeInstallManager_ = nullptr;
49 };
50
SetUpTestCase(void)51 void FreeInstallTest::SetUpTestCase(void) {}
52
TearDownTestCase(void)53 void FreeInstallTest::TearDownTestCase(void) {}
54
SetUp(void)55 void FreeInstallTest::SetUp(void) {}
56
TearDown(void)57 void FreeInstallTest::TearDown(void)
58 {}
59
MockToken()60 sptr<Token> FreeInstallTest::MockToken()
61 {
62 sptr<Token> token = nullptr;
63 AbilityRequest abilityRequest;
64 abilityRequest.appInfo.bundleName = "com.test.demo";
65 abilityRequest.abilityInfo.name = "MainAbility";
66 abilityRequest.abilityInfo.type = AbilityType::PAGE;
67 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
68 if (!abilityRecord) {
69 return nullptr;
70 }
71 return abilityRecord->GetToken();
72 }
73
74 /**
75 * @tc.number: FreeInstall_StartFreeInstall_001
76 * @tc.name: StartFreeInstall
77 * @tc.desc: Test StartFreeInstall when callback is success.
78 */
79 HWTEST_F(FreeInstallTest, FreeInstall_StartFreeInstall_001, TestSize.Level1)
80 {
81 auto abilityMs_ = std::make_shared<AbilityManagerService>();
82 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs_);
83 Want want;
84 ElementName element("", "com.test.demo", "MainAbility");
85 want.SetElement(element);
86 const int32_t userId = 100;
87 const int requestCode = 0;
88 want.SetParam(Want::PARAM_RESV_START_TIME, std::string("0"));
89 // mock callerToken
90 const sptr<IRemoteObject> callerToken = MockToken();
91 int res = 0;
92
93 usleep(100000); // 100000 means us.
94 // from freeInstallManager_->freeInstallList_ find startInstallTime
95 for (auto it = freeInstallManager_->freeInstallList_.begin(); it != freeInstallManager_->freeInstallList_.end();) {
96 std::string bundleName = (*it).want.GetElement().GetBundleName();
97 std::string abilityName = (*it).want.GetElement().GetAbilityName();
98 if (want.GetElement().GetBundleName().compare(bundleName) != 0 ||
99 want.GetElement().GetAbilityName().compare(abilityName) != 0) {
100 want.SetParam(Want::PARAM_RESV_START_TIME, (*it).want.GetStringParam(Want::PARAM_RESV_START_TIME));
101 break;
102 }
103 }
104 freeInstallManager_->OnInstallFinished(-1, 0, want, userId, false);
105
106 EXPECT_TRUE(freeInstallManager_ != nullptr);
107 }
108
109 /**
110 * @tc.number: FreeInstall_StartFreeInstall_002
111 * @tc.name: StartFreeInstall
112 * @tc.desc: Test StartFreeInstall when token is nullptr.
113 */
114 HWTEST_F(FreeInstallTest, FreeInstall_StartFreeInstall_002, TestSize.Level1)
115 {
116 auto abilityMs_ = std::make_shared<AbilityManagerService>();
117 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs_);
118 Want want;
119 ElementName element("", "com.test.demo", "MainAbility");
120 want.SetElement(element);
121 const int32_t userId = 100; // 100 means userId
122 const int requestCode = 0;
123 // token is nullptr, IsTopAbility failed
124 const sptr<IRemoteObject> callerToken = nullptr;
125 // NotTopAbility
126 freeInstallManager_->StartFreeInstall(want, userId, requestCode, callerToken);
127 EXPECT_TRUE(freeInstallManager_ != nullptr);
128 }
129
130 /**
131 * @tc.number: FreeInstall_StartFreeInstall_003
132 * @tc.name: StartFreeInstall
133 * @tc.desc: Test StartFreeInstall when callback is failed.
134 */
135 HWTEST_F(FreeInstallTest, FreeInstall_StartFreeInstall_003, TestSize.Level1)
136 {
137 auto abilityMs_ = std::make_shared<AbilityManagerService>();
138 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs_);
139 Want want;
140 ElementName element("", "com.test.demo", "MainAbility");
141 want.SetElement(element);
142 const int32_t userId = 1;
143 const int requestCode = 0;
144 // mock callerToken
145 const sptr<IRemoteObject> callerToken = MockToken();
146 int res = 0;
147
148 usleep(100000); // 100000 means us.
149 // from freeInstallManager_->freeInstallList_ find startInstallTime
150 for (auto it = freeInstallManager_->freeInstallList_.begin(); it != freeInstallManager_->freeInstallList_.end();) {
151 std::string bundleName = (*it).want.GetElement().GetBundleName();
152 std::string abilityName = (*it).want.GetElement().GetAbilityName();
153 if (want.GetElement().GetBundleName().compare(bundleName) != 0 ||
154 want.GetElement().GetAbilityName().compare(abilityName) != 0) {
155 want.SetParam(Want::PARAM_RESV_START_TIME, (*it).want.GetStringParam(Want::PARAM_RESV_START_TIME));
156 break;
157 }
158 }
159 freeInstallManager_->OnInstallFinished(-1, 1, want, userId, false);
160
161 EXPECT_TRUE(freeInstallManager_ != nullptr);
162 }
163
164 /**
165 * @tc.number: FreeInstall_OnInstallFinished_001
166 * @tc.name: OnInstallFinished
167 * @tc.desc: Test OnInstallFinished succeed.
168 */
169 HWTEST_F(FreeInstallTest, FreeInstall_OnInstallFinished_001, TestSize.Level1)
170 {
171 auto abilityMs_ = std::make_shared<AbilityManagerService>();
172 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs_);
173 Want want;
174 ElementName element("", "com.test.demo", "MainAbility");
175 want.SetElement(element);
176 const int32_t userId = 1;
177 const int requestCode = 0;
178 want.SetParam(Want::PARAM_RESV_START_TIME, std::string("0"));
179
180 FreeInstallInfo info = freeInstallManager_->BuildFreeInstallInfo(want, userId, requestCode, nullptr);
181 freeInstallManager_->freeInstallList_.resize(0);
182 freeInstallManager_->freeInstallList_.emplace_back(info);
183 freeInstallManager_->OnInstallFinished(-1, 0, want, userId, false);
184
185 for (auto it = freeInstallManager_->freeInstallList_.begin();
186 it != freeInstallManager_->freeInstallList_.end(); it++) {
187 std::string bundleName = (*it).want.GetElement().GetBundleName();
188 std::string abilityName = (*it).want.GetElement().GetAbilityName();
189 std::string startTime = (*it).want.GetStringParam(Want::PARAM_RESV_START_TIME);
190 if (want.GetElement().GetBundleName().compare(bundleName) == 0 &&
191 want.GetElement().GetAbilityName().compare(abilityName) == 0 &&
192 want.GetStringParam(Want::PARAM_RESV_START_TIME).compare(startTime) == 0) {
193 EXPECT_EQ((*it).promise->get_future().get(), 0);
194 }
195 }
196 }
197
198 /**
199 * @tc.number: FreeInstall_OnInstallFinished_002
200 * @tc.name: OnInstallFinished
201 * @tc.desc: Test OnInstallFinished failed.
202 */
203 HWTEST_F(FreeInstallTest, FreeInstall_OnInstallFinished_002, TestSize.Level1)
204 {
205 auto abilityMs_ = std::make_shared<AbilityManagerService>();
206 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs_);
207 Want want;
208 ElementName element("", "com.test.demo", "MainAbility");
209 want.SetElement(element);
210 const int32_t userId = 1;
211 const int requestCode = 0;
212 want.SetParam(Want::PARAM_RESV_START_TIME, std::string("0"));
213
214 FreeInstallInfo info = freeInstallManager_->BuildFreeInstallInfo(want, userId, requestCode, nullptr);
215 freeInstallManager_->freeInstallList_.resize(0);
216 freeInstallManager_->freeInstallList_.emplace_back(info);
217 freeInstallManager_->OnInstallFinished(-1, 1, want, userId, false);
218
219 for (auto it = freeInstallManager_->freeInstallList_.begin();
220 it != freeInstallManager_->freeInstallList_.end(); it++) {
221 std::string bundleName = (*it).want.GetElement().GetBundleName();
222 std::string abilityName = (*it).want.GetElement().GetAbilityName();
223 std::string startTime = (*it).want.GetStringParam(Want::PARAM_RESV_START_TIME);
224 if (want.GetElement().GetBundleName().compare(bundleName) == 0 &&
225 want.GetElement().GetAbilityName().compare(abilityName) == 0 &&
226 want.GetStringParam(Want::PARAM_RESV_START_TIME).compare(startTime) == 0) {
227 EXPECT_EQ((*it).promise->get_future().get(), 1);
228 }
229 }
230 }
231
232 /**
233 * @tc.number: FreeInstall_OnInstallFinished_003
234 * @tc.name: OnInstallFinished
235 * @tc.desc: Test OnInstallFinished failed.
236 */
237 HWTEST_F(FreeInstallTest, FreeInstall_OnInstallFinished_003, TestSize.Level1)
238 {
239 auto abilityMs_ = std::make_shared<AbilityManagerService>();
240 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs_);
241 Want want;
242 ElementName element("", "com.test.demo", "MainAbility");
243 want.SetElement(element);
244 want.SetParam(Want::PARAM_RESV_START_TIME, std::string("0"));
245 const int32_t userId = 1;
246 const int requestCode = 0;
247
248 FreeInstallInfo info = freeInstallManager_->BuildFreeInstallInfo(want, userId, requestCode, nullptr);
249 info.isInstalled = true;
250 freeInstallManager_->freeInstallList_.resize(0);
251 info.promise.reset();
252 freeInstallManager_->freeInstallList_.emplace_back(info);
253 freeInstallManager_->OnInstallFinished(-1, 0, want, userId, false);
254
255 int size = freeInstallManager_->freeInstallList_.size();
256 EXPECT_EQ(size, 1);
257 }
258
259 /**
260 * @tc.number: FreeInstall_FreeInstallAbilityFromRemote_001
261 * @tc.name: FreeInstallAbilityFromRemote
262 * @tc.desc: Test FreeInstallAbilityFromRemote.
263 */
264 HWTEST_F(FreeInstallTest, FreeInstall_FreeInstallAbilityFromRemote_001, TestSize.Level1)
265 {
266 auto abilityMs_ = std::make_shared<AbilityManagerService>();
267 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs_);
268 Want want;
269 ElementName element("", "com.test.demo", "MainAbility");
270 want.SetElement(element);
271 const int32_t userId = 1;
272 const int requestCode = 0;
273
274 int res = freeInstallManager_->FreeInstallAbilityFromRemote(want, nullptr, userId, requestCode);
275 EXPECT_EQ(res, 22);
276 }
277
278 /**
279 * @tc.number: FreeInstall_OnRemoteInstallFinished_001
280 * @tc.name: OnRemoteInstallFinished
281 * @tc.desc: Test OnRemoteInstallFinished.
282 */
283 HWTEST_F(FreeInstallTest, FreeInstall_OnRemoteInstallFinished_001, TestSize.Level1)
284 {
285 auto abilityMs_ = std::make_shared<AbilityManagerService>();
286 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs_);
287 Want want;
288 ElementName element("", "com.test.demo", "MainAbility");
289 want.SetElement(element);
290 const int32_t userId = 1;
291 const int requestCode = 0;
292 want.SetParam(Want::PARAM_RESV_START_TIME, std::string("0"));
293
294 FreeInstallInfo info = freeInstallManager_->BuildFreeInstallInfo(want, userId, requestCode, nullptr);
295 freeInstallManager_->freeInstallList_.resize(0);
296 freeInstallManager_->freeInstallList_.emplace_back(info);
297 freeInstallManager_->OnRemoteInstallFinished(-1, 0, want, userId);
298
299 for (auto it = freeInstallManager_->freeInstallList_.begin();
300 it != freeInstallManager_->freeInstallList_.end(); it++) {
301 std::string bundleName = (*it).want.GetElement().GetBundleName();
302 std::string abilityName = (*it).want.GetElement().GetAbilityName();
303 std::string startTime = (*it).want.GetStringParam(Want::PARAM_RESV_START_TIME);
304 if (want.GetElement().GetBundleName().compare(bundleName) == 0 &&
305 want.GetElement().GetAbilityName().compare(abilityName) == 0 &&
306 want.GetStringParam(Want::PARAM_RESV_START_TIME).compare(startTime) == 0) {
307 EXPECT_EQ((*it).promise->get_future().get(), 0);
308 }
309 }
310 }
311
312 /**
313 * @tc.number: FreeInstall_ConnectFreeInstall_001
314 * @tc.name: ConnectFreeInstall
315 * @tc.desc: Test ConnectFreeInstall.
316 */
317 HWTEST_F(FreeInstallTest, FreeInstall_ConnectFreeInstall_001, TestSize.Level1)
318 {
319 auto abilityMs_ = std::make_shared<AbilityManagerService>();
320 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs_);
321 Want want;
322 ElementName element("", "com.test.demo", "MainAbility");
323 want.SetElement(element);
324 const int32_t userId = 1;
325
326 int res = freeInstallManager_->ConnectFreeInstall(want, userId, nullptr, "");
327 EXPECT_NE(res, 0);
328 }
329
330
331 /**
332 * @tc.number: FreeInstall_UpdateElementName_001
333 * @tc.name: UpdateElementName
334 * @tc.desc: Test UpdateElementName.
335 */
336 HWTEST_F(FreeInstallTest, FreeInstall_UpdateElementName_001, TestSize.Level1)
337 {
338 auto abilityMs_ = std::make_shared<AbilityManagerService>();
339 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs_);
340 Want want;
341 const int32_t userId = 1;
342 freeInstallManager_->UpdateElementName(want, userId);
343 freeInstallManager_->GetTimeStamp();
344 EXPECT_TRUE(freeInstallManager_ != nullptr);
345 }
346
347 /**
348 * @tc.number: FreeInstall_AddFreeInstallObserver_001
349 * @tc.name: AddFreeInstallObserver
350 * @tc.desc: Test AddFreeInstallObserver.
351 */
352 HWTEST_F(FreeInstallTest, FreeInstall_AddFreeInstallObserver_001, TestSize.Level1)
353 {
354 auto abilityMs_ = std::make_shared<AbilityManagerService>();
355 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs_);
356
357 auto ret = freeInstallManager_->AddFreeInstallObserver(nullptr, nullptr);
358 EXPECT_EQ(CHECK_PERMISSION_FAILED, ret);
359 }
360
361 /**
362 * @tc.number: FreeInstall_SetSCBCallStatus_001
363 * @tc.name: SetSCBCallStatus
364 * @tc.desc: Test SetSCBCallStatus.
365 */
366 HWTEST_F(FreeInstallTest, FreeInstall_SetSCBCallStatus_001, TestSize.Level1)
367 {
368 auto abilityMs_ = std::make_shared<AbilityManagerService>();
369 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs_);
370
371 freeInstallManager_->SetSCBCallStatus("com.ix.hiservcie", "ServiceAbility", "2024-7-17 00:00:00", false);
372 FreeInstallInfo freeInstallInfo;
373 freeInstallManager_->GetFreeInstallTaskInfo("com.ix.hiservcie", "ServiceAbility",
374 "2024-7-17 00:00:00", freeInstallInfo);
375 EXPECT_EQ(freeInstallInfo.isStartUIAbilityBySCBCalled, false);
376 }
377
378 /**
379 * @tc.number: FreeInstall_SetPreStartMissionCallStatus_001
380 * @tc.name: SetPreStartMissionCallStatus
381 * @tc.desc: Test SetPreStartMissionCallStatus.
382 */
383 HWTEST_F(FreeInstallTest, FreeInstall_SetPreStartMissionCallStatus_001, TestSize.Level1)
384 {
385 auto abilityMs_ = std::make_shared<AbilityManagerService>();
386 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs_);
387
388 freeInstallManager_->SetPreStartMissionCallStatus("com.ix.hiservcie", "ServiceAbility",
389 "2024-7-17 00:00:00", false);
390 FreeInstallInfo freeInstallInfo;
391 freeInstallManager_->GetFreeInstallTaskInfo("com.ix.hiservcie", "ServiceAbility",
392 "2024-7-17 00:00:00", freeInstallInfo);
393 EXPECT_EQ(freeInstallInfo.isPreStartMissionCalled, false);
394 }
395
396 /**
397 * @tc.number: FreeInstall_SetFreeInstallTaskSessionId_001
398 * @tc.name: SetFreeInstallTaskSessionId
399 * @tc.desc: Test SetFreeInstallTaskSessionId.
400 */
401 HWTEST_F(FreeInstallTest, FreeInstall_SetFreeInstallTaskSessionId_001, TestSize.Level1)
402 {
403 auto abilityMs_ = std::make_shared<AbilityManagerService>();
404 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs_);
405
406 Want want;
407 ElementName element("", "com.ix.hiservcie", "ServiceAbility");
408 want.SetElement(element);
409
410 std::string startTime = "2024-7-17 00:00:00";
411 want.SetParam(Want::PARAM_RESV_START_TIME, startTime);
412 const int32_t userId = 1;
413 const int requestCode = 0;
414 // mock callerToken
415 const sptr<IRemoteObject> callerToken = MockToken();
416 FreeInstallInfo info = freeInstallManager_->BuildFreeInstallInfo(want, userId, requestCode, callerToken);
417 {
418 std::lock_guard<ffrt::mutex> lock(freeInstallManager_->freeInstallListLock_);
419 freeInstallManager_->freeInstallList_.push_back(info);
420 }
421
422 freeInstallManager_->SetFreeInstallTaskSessionId("com.ix.hiservcie", "ServiceAbility",
423 "2024-7-17 00:00:00", "sessionId");
424 FreeInstallInfo freeInstallInfo;
425 bool ret = freeInstallManager_->GetFreeInstallTaskInfo("sessionId", freeInstallInfo);
426 EXPECT_EQ(true, ret);
427
428 freeInstallManager_->RemoveFreeInstallInfo("com.ix.hiservcie", "ServiceAbility", "2024-7-17 00:00:00");
429 ret = freeInstallManager_->GetFreeInstallTaskInfo("com.ix.hiservcie", "ServiceAbility",
430 "2024-7-17 00:00:00", freeInstallInfo);
431 EXPECT_EQ(false, ret);
432 freeInstallManager_->OnInstallFinished(-1, 1, want, userId, false);
433 }
434
435 /**
436 * @tc.number: FreeInstall_VerifyStartFreeInstallPermission_001
437 * @tc.name: VerifyStartFreeInstallPermission
438 * @tc.desc: Test VerifyStartFreeInstallPermission.
439 */
440 HWTEST_F(FreeInstallTest, FreeInstall_VerifyStartFreeInstallPermission_001, TestSize.Level1)
441 {
442 auto abilityMs_ = std::make_shared<AbilityManagerService>();
443 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs_);
444
445 const sptr<IRemoteObject> callerToken = MockToken();
446 freeInstallManager_->VerifyStartFreeInstallPermission(callerToken);
447 freeInstallManager_->GetRecordIdByToken(callerToken);
448 EXPECT_TRUE(freeInstallManager_ != nullptr);
449 }
450
451 /**
452 * @tc.number: FreeInstall_SetAppRunningState_001
453 * @tc.name: SetAppRunningState
454 * @tc.desc: Test SetAppRunningState.
455 */
456 HWTEST_F(FreeInstallTest, FreeInstall_SetAppRunningState_001, TestSize.Level1)
457 {
458 auto abilityMs_ = std::make_shared<AbilityManagerService>();
459 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs_);
460
461 Want want;
462 freeInstallManager_->SetAppRunningState(want);
463 EXPECT_TRUE(freeInstallManager_ != nullptr);
464 }
465
466 /**
467 * @tc.number: FreeInstall_PostUpgradeAtomicServiceTask_001
468 * @tc.name: PostUpgradeAtomicServiceTask
469 * @tc.desc: Test PostUpgradeAtomicServiceTask.
470 */
471 HWTEST_F(FreeInstallTest, FreeInstall_PostUpgradeAtomicServiceTask_001, TestSize.Level1)
472 {
473 auto abilityMs_ = std::make_shared<AbilityManagerService>();
474 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs_);
475
476 Want want;
477 ElementName element("", "com.test.demo", "MainAbility");
478 want.SetElement(element);
479 const int32_t userId = 100;
480 int resultCode = 0;
481 freeInstallManager_->PostUpgradeAtomicServiceTask(resultCode, want, userId);
482 EXPECT_TRUE(freeInstallManager_ != nullptr);
483 }
484
485 /**
486 * @tc.number: FreeInstall_StartAbilityByOriginalWant_001
487 * @tc.name: StartAbilityByOriginalWant
488 * @tc.desc: Test StartAbilityByOriginalWant.
489 */
490 HWTEST_F(FreeInstallTest, FreeInstall_StartAbilityByOriginalWant_001, TestSize.Level1)
491 {
492 auto abilityMs_ = std::make_shared<AbilityManagerService>();
493 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs_);
494
495 FreeInstallInfo freeInstallInfo;
496 freeInstallManager_->StartAbilityByOriginalWant(freeInstallInfo, "2024-07-17 00:00:00");
497 EXPECT_TRUE(freeInstallManager_ != nullptr);
498 }
499
500 /**
501 * @tc.number: FreeInstall_StartAbilityByConvertedWant_001
502 * @tc.name: StartAbilityByConvertedWant
503 * @tc.desc: Test StartAbilityByConvertedWant.
504 */
505 HWTEST_F(FreeInstallTest, FreeInstall_StartAbilityByConvertedWant_001, TestSize.Level1)
506 {
507 auto abilityMs_ = std::make_shared<AbilityManagerService>();
508 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs_);
509
510 FreeInstallInfo freeInstallInfo;
511 freeInstallManager_->StartAbilityByConvertedWant(freeInstallInfo, "2024-07-17 00:00:00");
512 EXPECT_TRUE(freeInstallManager_ != nullptr);
513 }
514
515 /**
516 * @tc.number: IsTopAbility_001
517 * @tc.name: IsTopAbility
518 * @tc.desc: Test IsTopAbility.
519 */
520 HWTEST_F(FreeInstallTest, FreeInstall_IsTopAbility_001, TestSize.Level1)
521 {
522 auto abilityMs = std::make_shared<AbilityManagerService>();
523 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs);
524 EXPECT_NE(freeInstallManager_, nullptr);
525 sptr<IRemoteObject> callerToken = nullptr;
526 bool result = freeInstallManager_->IsTopAbility(callerToken);
527 EXPECT_FALSE(result);
528 }
529
530 /**
531 * @tc.number: FreeInstall_StartRemoteFreeInstall_001
532 * @tc.name: StartRemoteFreeInstall
533 * @tc.desc: Test StartRemoteFreeInstall.
534 */
535 HWTEST_F(FreeInstallTest, FreeInstall_StartRemoteFreeInstall_001, TestSize.Level1)
536 {
537 auto abilityMs = std::make_shared<AbilityManagerService>();
538 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs);
539 Want want;
540 want.SetParam(Want::PARAM_RESV_FOR_RESULT, true);
541 AbilityRequest abilityRequest;
542 abilityRequest.appInfo.bundleName = "com.test.demo";
543 abilityRequest.abilityInfo.name = "MainAbility";
544 abilityRequest.abilityInfo.type = AbilityType::PAGE;
545 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
546 abilityRecord->missionId_ = -1;
547 sptr<IRemoteObject> callerToken = nullptr;
548 int result = freeInstallManager_->StartRemoteFreeInstall(want, 0, 0, callerToken);
549 EXPECT_EQ(result, ERR_INVALID_VALUE);
550 }
551
552 /**
553 * @tc.number: FreeInstall_AddFreeInstallObserver_002
554 * @tc.name: AddFreeInstallObserver
555 * @tc.desc: Test StartRemoteFreeInstall.
556 */
557 HWTEST_F(FreeInstallTest, FreeInstall_AddFreeInstallObserver_002, TestSize.Level1)
558 {
559 auto abilityMs = std::make_shared<AbilityManagerService>();
560 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs);
561 AbilityRequest abilityRequest;
562 abilityRequest.appInfo.bundleName = "com.test.demo";
563 abilityRequest.abilityInfo.name = "MainAbility";
564 abilityRequest.abilityInfo.type = AbilityType::PAGE;
565 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
566 abilityRecord->missionId_ = -1;
567 sptr<IRemoteObject> callerToken = abilityRecord->GetToken();
568 int result = freeInstallManager_->AddFreeInstallObserver(callerToken, nullptr);
569 EXPECT_EQ(result, ERR_INVALID_VALUE);
570 }
571
572 /**
573 * @tc.number: FreeInstall_GetRecordIdByToken_001
574 * @tc.name: GetRecordIdByToken
575 * @tc.desc: Test StartRemoteFreeInstall.
576 */
577 HWTEST_F(FreeInstallTest, FreeInstall_GetRecordIdByToken_001, TestSize.Level1)
578 {
579 auto abilityMs = std::make_shared<AbilityManagerService>();
580 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs);
581 EXPECT_NE(freeInstallManager_, nullptr);
582 AbilityRequest abilityRequest;
583 abilityRequest.appInfo.bundleName = "com.test.demo";
584 abilityRequest.abilityInfo.name = "MainAbility";
585 abilityRequest.abilityInfo.type = AbilityType::PAGE;
586 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
587 abilityRecord->recordId_ = VALID_RECORD_ID;
588 sptr<IRemoteObject> callerToken = abilityRecord->GetToken();
589 int32_t result = freeInstallManager_->GetRecordIdByToken(callerToken);
590 EXPECT_EQ(result, VALID_RECORD_ID);
591 }
592
593 /**
594 * @tc.number: FreeInstall_GetRecordIdByToken_002
595 * @tc.name: GetRecordIdByToken
596 * @tc.desc: Test StartRemoteFreeInstall.
597 */
598 HWTEST_F(FreeInstallTest, FreeInstall_GetRecordIdByToken_002, TestSize.Level1)
599 {
600 auto abilityMs = std::make_shared<AbilityManagerService>();
601 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs);
602 EXPECT_NE(freeInstallManager_, nullptr);
603 sptr<IRemoteObject> callerToken = nullptr;
604 int32_t result = freeInstallManager_->GetRecordIdByToken(callerToken);
605 EXPECT_EQ(result, INVALID_RECORD_ID);
606 }
607
608 /**
609 * @tc.number: FreeInstall_BuildFreeInstallInfo_002
610 * @tc.name: BuildFreeInstallInfo
611 * @tc.desc: Test BuildFreeInstallInfo.
612 */
613 HWTEST_F(FreeInstallTest, FreeInstall_BuildFreeInstallInfo_002, TestSize.Level1)
614 {
615 auto abilityMs_ = std::make_shared<AbilityManagerService>();
616 freeInstallManager_ = std::make_shared<FreeInstallManager>(abilityMs_);
617 Want want;
618 ElementName element("", "com.test.demo", "MainAbility");
619 want.SetElement(element);
620 const int32_t userId = 1;
621 const int requestCode = 0;
622 want.SetParam(Want::PARAM_RESV_START_TIME, std::string("0"));
623 auto param = std::make_shared<FreeInstallParams>();
624 AAFwk::StartOptions startOptions;
625 startOptions.requestId_ = "test";
626 param->startOptions = std::make_shared<AAFwk::StartOptions>(startOptions);
627
628 FreeInstallInfo info = freeInstallManager_->BuildFreeInstallInfo(want, userId, requestCode, nullptr, param);
629 EXPECT_EQ(info.want.GetStringParam(KEY_REQUEST_ID), "test");
630 }
631 } // namespace AppExecFwk
632 } // namespace OHOS