1 /*
2 * Copyright (c) 2024-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 #define private public
19 #include "app_preloader.h"
20 #undef private
21 #include "ability_manager_errors.h"
22 #include "hilog_tag_wrapper.h"
23
24 using namespace testing;
25 using namespace testing::ext;
26
27 namespace OHOS {
28 namespace AppExecFwk {
29 class AppPreloaderTest : public testing::Test {
30 public:
31 void SetUp();
32 void TearDown();
33
34 protected:
35 std::shared_ptr<RemoteClientManager> remoteClientManager_ = nullptr;
36 };
37
SetUp()38 void AppPreloaderTest::SetUp()
39 {
40 remoteClientManager_ = std::make_shared<RemoteClientManager>();
41 auto bundleMgrHelper = std::make_shared<BundleMgrHelper>();
42 remoteClientManager_->SetBundleManagerHelper(bundleMgrHelper);
43 }
44
TearDown()45 void AppPreloaderTest::TearDown()
46 {}
47
48 /**
49 * @tc.number: AppPreloaderTest_GeneratePreloadRequest_0100
50 * @tc.desc: Test GeneratePreloadRequest works
51 * @tc.type: FUNC
52 * @tc.Function: GeneratePreloadRequest
53 * @tc.SubFunction: NA
54 * @tc.EnvConditions: NA
55 */
56 HWTEST_F(AppPreloaderTest, AppPreloaderTest_GeneratePreloadRequest_0100, TestSize.Level2)
57 {
58 TAG_LOGD(AAFwkTag::TEST, "AppPreloaderTest_GeneratePreloadRequest_0100 start.");
59 auto manager = std::make_shared<AppPreloader>(remoteClientManager_);
60 EXPECT_NE(manager, nullptr);
61
62 std::string bundleName = "com.acts.preloadtest";
63 int32_t userId = 100;
64 int32_t appIndex = 0;
65 PreloadRequest request;
66 auto ret = manager->GeneratePreloadRequest(bundleName, userId, appIndex, request);
67 EXPECT_EQ(ret, ERR_OK);
68 }
69
70 /**
71 * @tc.number: AppPreloaderTest_GeneratePreloadRequest_0200
72 * @tc.desc: Test GeneratePreloadRequest works
73 * @tc.type: FUNC
74 * @tc.Function: GeneratePreloadRequest
75 * @tc.SubFunction: NA
76 * @tc.EnvConditions: NA
77 */
78 HWTEST_F(AppPreloaderTest, AppPreloaderTest_GeneratePreloadRequest_0200, TestSize.Level2)
79 {
80 TAG_LOGD(AAFwkTag::TEST, "AppPreloaderTest_GeneratePreloadRequest_0200 start.");
81 auto manager = std::make_shared<AppPreloader>(remoteClientManager_);
82 EXPECT_NE(manager, nullptr);
83
84 std::string bundleName = "com.acts.preloadtest";
85 int32_t userId = 1;
86 int32_t appIndex = 0;
87 PreloadRequest request;
88 auto ret = manager->GeneratePreloadRequest(bundleName, userId, appIndex, request);
89 EXPECT_EQ(ret, ERR_OK);
90 }
91
92 /**
93 * @tc.number: AppPreloaderTest_GeneratePreloadRequest_0300
94 * @tc.desc: Test GeneratePreloadRequest works
95 * @tc.type: FUNC
96 * @tc.Function: GeneratePreloadRequest
97 * @tc.SubFunction: NA
98 * @tc.EnvConditions: NA
99 */
100 HWTEST_F(AppPreloaderTest, AppPreloaderTest_GeneratePreloadRequest_0300, TestSize.Level2)
101 {
102 TAG_LOGD(AAFwkTag::TEST, "AppPreloaderTest_GeneratePreloadRequest_0300 start.");
103 auto manager = std::make_shared<AppPreloader>(remoteClientManager_);
104 EXPECT_NE(manager, nullptr);
105
106 std::string bundleName = "com.acts.preloadtest";
107 int32_t userId = 0;
108 int32_t appIndex = 0;
109 PreloadRequest request;
110 auto ret = manager->GeneratePreloadRequest(bundleName, userId, appIndex, request);
111 EXPECT_EQ(ret, ERR_OK);
112 }
113
114 /**
115 * @tc.number: AppPreloaderTest_GeneratePreloadRequest_0400
116 * @tc.desc: Test GeneratePreloadRequest works
117 * @tc.type: FUNC
118 * @tc.Function: GeneratePreloadRequest
119 * @tc.SubFunction: NA
120 * @tc.EnvConditions: NA
121 */
122 HWTEST_F(AppPreloaderTest, AppPreloaderTest_GeneratePreloadRequest_0400, TestSize.Level2)
123 {
124 TAG_LOGD(AAFwkTag::TEST, "AppPreloaderTest_GeneratePreloadRequest_0400 start.");
125 auto manager = std::make_shared<AppPreloader>(remoteClientManager_);
126 EXPECT_NE(manager, nullptr);
127
128 std::string bundleName = "com.acts.preloadtest";
129 int32_t userId = -1;
130 int32_t appIndex = 0;
131 PreloadRequest request;
132 auto ret = manager->GeneratePreloadRequest(bundleName, userId, appIndex, request);
133 EXPECT_EQ(ret, ERR_OK);
134 }
135
136 /**
137 * @tc.number: AppPreloaderTest_GeneratePreloadRequest_0500
138 * @tc.desc: Test GeneratePreloadRequest works
139 * @tc.type: FUNC
140 * @tc.Function: GeneratePreloadRequest
141 * @tc.SubFunction: NA
142 * @tc.EnvConditions: NA
143 */
144 HWTEST_F(AppPreloaderTest, AppPreloaderTest_GeneratePreloadRequest_0500, TestSize.Level2)
145 {
146 TAG_LOGD(AAFwkTag::TEST, "AppPreloaderTest_GeneratePreloadRequest_0500 start.");
147 auto manager = std::make_shared<AppPreloader>(remoteClientManager_);
148 EXPECT_NE(manager, nullptr);
149
150 std::string bundleName = "com.acts.preloadtest";
151 int32_t userId = 100;
152 int32_t appIndex = 1;
153 PreloadRequest request;
154 auto ret = manager->GeneratePreloadRequest(bundleName, userId, appIndex, request);
155 EXPECT_EQ(ret, ERR_OK);
156 }
157
158 /**
159 * @tc.number: AppPreloaderTest_GeneratePreloadRequest_0500
160 * @tc.desc: Test GeneratePreloadRequest works
161 * @tc.type: FUNC
162 * @tc.Function: GeneratePreloadRequest
163 * @tc.SubFunction: NA
164 * @tc.EnvConditions: NA
165 */
166 HWTEST_F(AppPreloaderTest, AppPreloaderTest_GeneratePreloadRequest_0600, TestSize.Level2)
167 {
168 TAG_LOGD(AAFwkTag::TEST, "AppPreloaderTest_GeneratePreloadRequest_0600 start.");
169 auto manager = std::make_shared<AppPreloader>(remoteClientManager_);
170 EXPECT_NE(manager, nullptr);
171
172 std::string bundleName = "com.acts.preloadtest";
173 int32_t userId = 1;
174 int32_t appIndex = 1;
175 PreloadRequest request;
176 auto ret = manager->GeneratePreloadRequest(bundleName, userId, appIndex, request);
177 EXPECT_EQ(ret, ERR_OK);
178 }
179
180 /**
181 * @tc.number: AppPreloaderTest_GeneratePreloadRequest_0700
182 * @tc.desc: Test GeneratePreloadRequest works
183 * @tc.type: FUNC
184 * @tc.Function: GeneratePreloadRequest
185 * @tc.SubFunction: NA
186 * @tc.EnvConditions: NA
187 */
188 HWTEST_F(AppPreloaderTest, AppPreloaderTest_GeneratePreloadRequest_0700, TestSize.Level2)
189 {
190 TAG_LOGD(AAFwkTag::TEST, "AppPreloaderTest_GeneratePreloadRequest_0700 start.");
191 auto manager = std::make_shared<AppPreloader>(remoteClientManager_);
192 EXPECT_NE(manager, nullptr);
193
194 std::string bundleName = "com.acts.preloadtest";
195 int32_t userId = 0;
196 int32_t appIndex = 1;
197 PreloadRequest request;
198 auto ret = manager->GeneratePreloadRequest(bundleName, userId, appIndex, request);
199 EXPECT_EQ(ret, ERR_OK);
200 }
201
202 /**
203 * @tc.number: AppPreloaderTest_GeneratePreloadRequest_0800
204 * @tc.desc: Test GeneratePreloadRequest works
205 * @tc.type: FUNC
206 * @tc.Function: GeneratePreloadRequest
207 * @tc.SubFunction: NA
208 * @tc.EnvConditions: NA
209 */
210 HWTEST_F(AppPreloaderTest, AppPreloaderTest_GeneratePreloadRequest_0800, TestSize.Level2)
211 {
212 TAG_LOGD(AAFwkTag::TEST, "AppPreloaderTest_GeneratePreloadRequest_0800 start.");
213 auto manager = std::make_shared<AppPreloader>(remoteClientManager_);
214 EXPECT_NE(manager, nullptr);
215
216 std::string bundleName = "com.acts.preloadtest";
217 int32_t userId = 0;
218 int32_t appIndex = -1;
219 PreloadRequest request;
220 auto ret = manager->GeneratePreloadRequest(bundleName, userId, appIndex, request);
221 EXPECT_EQ(ret, ERR_OK);
222 }
223
224 /**
225 * @tc.number: AppPreloaderTest_GeneratePreloadRequest_0900
226 * @tc.desc: Test GeneratePreloadRequest works
227 * @tc.type: FUNC
228 * @tc.Function: GeneratePreloadRequest
229 * @tc.SubFunction: NA
230 * @tc.EnvConditions: NA
231 */
232 HWTEST_F(AppPreloaderTest, AppPreloaderTest_GeneratePreloadRequest_0900, TestSize.Level2)
233 {
234 TAG_LOGI(AAFwkTag::TEST, "AppPreloaderTest_GeneratePreloadRequest_0900 start.");
235 auto manager = std::make_shared<AppPreloader>(remoteClientManager_);
236 EXPECT_NE(manager, nullptr);
237
238 std::string bundleName = "com.acts.preloadtest";
239 int32_t userId = UidCheckCode::UID_CHECK_NOT_ENTRY_HAP_MODULE_INFO;
240 int32_t appIndex = 0;
241 PreloadRequest request;
242 request.preloadMode = PreloadMode::PRELOAD_BY_PHASE;
243 auto ret = manager->GeneratePreloadRequest(bundleName, userId, appIndex, request);
244 EXPECT_EQ(ret, AAFwk::ERR_PRELOAD_NOT_ENTRY_MODULE);
245 TAG_LOGI(AAFwkTag::TEST, "AppPreloaderTest_GeneratePreloadRequest_0900 ned.");
246 }
247
248 /**
249 * @tc.number: AppPreloaderTest_GeneratePreloadRequest_1000
250 * @tc.desc: Test GeneratePreloadRequest works
251 * @tc.type: FUNC
252 * @tc.Function: GeneratePreloadRequest
253 * @tc.SubFunction: NA
254 * @tc.EnvConditions: NA
255 */
256 HWTEST_F(AppPreloaderTest, AppPreloaderTest_GeneratePreloadRequest_1000, TestSize.Level2)
257 {
258 TAG_LOGI(AAFwkTag::TEST, "AppPreloaderTest_GeneratePreloadRequest_1000 start.");
259 auto manager = std::make_shared<AppPreloader>(remoteClientManager_);
260 EXPECT_NE(manager, nullptr);
261
262 std::string bundleName = "com.acts.preloadtest";
263 int32_t userId = 100;
264 int32_t appIndex = 0;
265 PreloadRequest request;
266 request.preloadMode = PreloadMode::PRELOAD_BY_PHASE;
267 auto ret = manager->GeneratePreloadRequest(bundleName, userId, appIndex, request);
268 EXPECT_EQ(ret, ERR_OK);
269 TAG_LOGI(AAFwkTag::TEST, "AppPreloaderTest_GeneratePreloadRequest_1000 ned.");
270 }
271
272 /**
273 * @tc.number: AppPreloaderTest_PreCheck_0100
274 * @tc.desc: Test PreCheck works
275 * @tc.type: FUNC
276 * @tc.Function: GeneratePreloadRequest
277 * @tc.SubFunction: NA
278 * @tc.EnvConditions: NA
279 */
280 HWTEST_F(AppPreloaderTest, AppPreloaderTest_PreCheck_0100, TestSize.Level2)
281 {
282 TAG_LOGD(AAFwkTag::TEST, "AppPreloaderTest_PreCheck_0100 start.");
283 auto manager = std::make_shared<AppPreloader>(remoteClientManager_);
284 EXPECT_NE(manager, nullptr);
285
286 std::string bundleName = "com.acts.testxxxx";
287 auto ret = manager->PreCheck(bundleName, PreloadMode::PRE_MAKE);
288 EXPECT_EQ(ret, true);
289 }
290
291 /**
292 * @tc.number: AppPreloaderTest_PreCheck_0200
293 * @tc.desc: Test PreCheck works
294 * @tc.type: FUNC
295 * @tc.Function: GeneratePreloadRequest
296 * @tc.SubFunction: NA
297 * @tc.EnvConditions: NA
298 */
299 HWTEST_F(AppPreloaderTest, AppPreloaderTest_PreCheck_0200, TestSize.Level2)
300 {
301 TAG_LOGD(AAFwkTag::TEST, "AppPreloaderTest_PreCheck_0200 start.");
302 auto manager = std::make_shared<AppPreloader>(remoteClientManager_);
303 EXPECT_NE(manager, nullptr);
304
305 std::string bundleName = "";
306 auto ret = manager->PreCheck(bundleName, PreloadMode::PRE_MAKE);
307 EXPECT_EQ(ret, true);
308 }
309
310 /**
311 * @tc.number: AppPreloaderTest_PreCheck_0300
312 * @tc.desc: Test PreCheck works
313 * @tc.type: FUNC
314 * @tc.Function: GeneratePreloadRequest
315 * @tc.SubFunction: NA
316 * @tc.EnvConditions: NA
317 */
318 HWTEST_F(AppPreloaderTest, AppPreloaderTest_PreCheck_0300, TestSize.Level2)
319 {
320 TAG_LOGD(AAFwkTag::TEST, "AppPreloaderTest_PreCheck_0300 start.");
321 auto manager = std::make_shared<AppPreloader>(remoteClientManager_);
322 EXPECT_NE(manager, nullptr);
323
324 std::string bundleName = "com.acts.testxxxx";
325 auto ret = manager->PreCheck(bundleName, PreloadMode::PRESS_DOWN);
326 EXPECT_EQ(ret, false);
327 }
328
329 /**
330 * @tc.number: AppPreloaderTest_PreCheck_0400
331 * @tc.desc: Test PreCheck works
332 * @tc.type: FUNC
333 * @tc.Function: GeneratePreloadRequest
334 * @tc.SubFunction: NA
335 * @tc.EnvConditions: NA
336 */
337 HWTEST_F(AppPreloaderTest, AppPreloaderTest_PreCheck_0400, TestSize.Level2)
338 {
339 TAG_LOGD(AAFwkTag::TEST, "AppPreloaderTest_PreCheck_0400 start.");
340 auto manager = std::make_shared<AppPreloader>(remoteClientManager_);
341 EXPECT_NE(manager, nullptr);
342
343 std::string bundleName = "com.acts.testxxxx";
344 auto ret = manager->PreCheck(bundleName, PreloadMode::PRESS_DOWN);
345 EXPECT_EQ(ret, false);
346 }
347
348 /**
349 * @tc.number: AppPreloaderTest_PreCheck_0500
350 * @tc.desc: Test PreCheck works
351 * @tc.type: FUNC
352 * @tc.Function: GeneratePreloadRequest
353 * @tc.SubFunction: NA
354 * @tc.EnvConditions: NA
355 */
356 HWTEST_F(AppPreloaderTest, AppPreloaderTest_PreCheck_0500, TestSize.Level2)
357 {
358 TAG_LOGI(AAFwkTag::TEST, "AppPreloaderTest_PreCheck_0500 start.");
359 auto manager = std::make_shared<AppPreloader>(remoteClientManager_);
360 EXPECT_NE(manager, nullptr);
361
362 std::string bundleName = "com.acts.testxxxx";
363 auto ret = manager->PreCheck(bundleName, PreloadMode::PRELOAD_BY_PHASE);
364 EXPECT_EQ(ret, true);
365 TAG_LOGI(AAFwkTag::TEST, "AppPreloaderTest_PreCheck_0500 end.");
366 }
367
368 /**
369 * @tc.number: AppPreloaderTest_GetLaunchWant_0100
370 * @tc.desc: Test GetLaunchWant works
371 * @tc.type: FUNC
372 * @tc.Function: GetLaunchWant
373 * @tc.SubFunction: NA
374 * @tc.EnvConditions: NA
375 */
376 HWTEST_F(AppPreloaderTest, AppPreloaderTest_GetLaunchWant_0100, TestSize.Level2)
377 {
378 TAG_LOGD(AAFwkTag::TEST, "AppPreloaderTest_GetLaunchWant_0100 start.");
379 auto manager = std::make_shared<AppPreloader>(remoteClientManager_);
380 EXPECT_NE(manager, nullptr);
381
382 std::string bundleName = "com.acts.preloadtest";
383 int32_t userId = -2;
384 int32_t appIndex = 0;
385 PreloadRequest request;
386 auto ret = manager->GeneratePreloadRequest(bundleName, userId, appIndex, request);
387 EXPECT_EQ(ret, AAFwk::ERR_TARGET_BUNDLE_NOT_EXIST);
388 }
389
390 /**
391 * @tc.number: AppPreloaderTest_GetLaunchWant_0200
392 * @tc.desc: Test GetLaunchWant works
393 * @tc.type: FUNC
394 * @tc.Function: GetLaunchWant
395 * @tc.SubFunction: NA
396 * @tc.EnvConditions: NA
397 */
398 HWTEST_F(AppPreloaderTest, AppPreloaderTest_GetLaunchWant_0200, TestSize.Level2)
399 {
400 TAG_LOGD(AAFwkTag::TEST, "AppPreloaderTest_GetLaunchWant_0200 start.");
401 auto manager = std::make_shared<AppPreloader>(remoteClientManager_);
402 EXPECT_NE(manager, nullptr);
403
404 manager->remoteClientManager_ = nullptr;
405 std::string bundleName = "com.acts.preloadtest";
406 int32_t userId = -2;
407 Want want;
408 auto ret = manager->GetLaunchWant(bundleName, userId, want);
409 manager->remoteClientManager_ = remoteClientManager_;
410 EXPECT_FALSE(ret);
411 }
412
413 /**
414 * @tc.number: AppPreloaderTest_GetLaunchAbilityInfo_0100
415 * @tc.desc: Test GetLaunchAbilityInfo works
416 * @tc.type: FUNC
417 * @tc.Function: GetLaunchAbilityInfo
418 * @tc.SubFunction: NA
419 * @tc.EnvConditions: NA
420 */
421 HWTEST_F(AppPreloaderTest, AppPreloaderTest_GetLaunchAbilityInfo_0100, TestSize.Level2)
422 {
423 TAG_LOGD(AAFwkTag::TEST, "AppPreloaderTest_GetLaunchAbilityInfo_0100 start.");
424 auto manager = std::make_shared<AppPreloader>(remoteClientManager_);
425 EXPECT_NE(manager, nullptr);
426
427 manager->remoteClientManager_ = nullptr;
428 Want want;
429 int32_t userId = -2;
430 AbilityInfo abilityInfo;
431 auto ret = manager->GetLaunchAbilityInfo(want, userId, abilityInfo);
432 manager->remoteClientManager_ = remoteClientManager_;
433 EXPECT_FALSE(ret);
434 }
435
436 /**
437 * @tc.number: AppPreloaderTest_GetLaunchAbilityInfo_0200
438 * @tc.desc: Test GetLaunchAbilityInfo works
439 * @tc.type: FUNC
440 * @tc.Function: GetLaunchAbilityInfo
441 * @tc.SubFunction: NA
442 * @tc.EnvConditions: NA
443 */
444 HWTEST_F(AppPreloaderTest, AppPreloaderTest_GetLaunchAbilityInfo_0200, TestSize.Level2)
445 {
446 TAG_LOGD(AAFwkTag::TEST, "AppPreloaderTest_GetLaunchAbilityInfo_0200 start.");
447 auto manager = std::make_shared<AppPreloader>(remoteClientManager_);
448 EXPECT_NE(manager, nullptr);
449
450 std::string bundleName = "com.acts.preloadtest";
451 int32_t userId = -3;
452 int32_t appIndex = 0;
453 PreloadRequest request;
454 auto ret = manager->GeneratePreloadRequest(bundleName, userId, appIndex, request);
455 EXPECT_EQ(ret, AAFwk::ERR_GET_LAUNCH_ABILITY_INFO_FAILED);
456 }
457
458 /**
459 * @tc.number: AppPreloaderTest_CheckPreloadConditions_0100
460 * @tc.desc: Test CheckPreloadConditions works
461 * @tc.type: FUNC
462 * @tc.Function: CheckPreloadConditions
463 * @tc.SubFunction: NA
464 * @tc.EnvConditions: NA
465 */
466 HWTEST_F(AppPreloaderTest, AppPreloaderTest_CheckPreloadConditions_0100, TestSize.Level2)
467 {
468 TAG_LOGD(AAFwkTag::TEST, "AppPreloaderTest_CheckPreloadConditions_0100 start.");
469 auto manager = std::make_shared<AppPreloader>(remoteClientManager_);
470 EXPECT_NE(manager, nullptr);
471
472 std::string bundleName = "com.acts.preloadtest";
473 int32_t userId = -5;
474 int32_t appIndex = 0;
475 PreloadRequest request;
476 auto ret = manager->GeneratePreloadRequest(bundleName, userId, appIndex, request);
477 EXPECT_EQ(ret, AAFwk::ERR_CHECK_PRELOAD_CONDITIONS_FAILED);
478 }
479
480 /**
481 * @tc.number: AppPreloaderTest_CheckPreloadConditions_0200
482 * @tc.desc: Test CheckPreloadConditions works
483 * @tc.type: FUNC
484 * @tc.Function: CheckPreloadConditions
485 * @tc.SubFunction: NA
486 * @tc.EnvConditions: NA
487 */
488 HWTEST_F(AppPreloaderTest, AppPreloaderTest_CheckPreloadConditions_0200, TestSize.Level2)
489 {
490 TAG_LOGD(AAFwkTag::TEST, "AppPreloaderTest_CheckPreloadConditions_0200 start.");
491 auto manager = std::make_shared<AppPreloader>(remoteClientManager_);
492 EXPECT_NE(manager, nullptr);
493
494 std::string bundleName = "com.acts.preloadtest";
495 int32_t userId = -6;
496 int32_t appIndex = 0;
497 PreloadRequest request;
498 auto ret = manager->GeneratePreloadRequest(bundleName, userId, appIndex, request);
499 EXPECT_EQ(ret, AAFwk::ERR_CHECK_PRELOAD_CONDITIONS_FAILED);
500 }
501
502 /**
503 * @tc.number: AppPreloaderTest_CheckPreloadConditions_0300
504 * @tc.desc: Test CheckPreloadConditions works
505 * @tc.type: FUNC
506 * @tc.Function: CheckPreloadConditions
507 * @tc.SubFunction: NA
508 * @tc.EnvConditions: NA
509 */
510 HWTEST_F(AppPreloaderTest, AppPreloaderTest_CheckPreloadConditions_0300, TestSize.Level2)
511 {
512 TAG_LOGD(AAFwkTag::TEST, "AppPreloaderTest_CheckPreloadConditions_0300 start.");
513 auto manager = std::make_shared<AppPreloader>(remoteClientManager_);
514 EXPECT_NE(manager, nullptr);
515
516 std::string bundleName = "com.acts.preloadtest";
517 int32_t userId = -7;
518 int32_t appIndex = 0;
519 PreloadRequest request;
520 auto ret = manager->GeneratePreloadRequest(bundleName, userId, appIndex, request);
521 EXPECT_EQ(ret, AAFwk::ERR_CHECK_PRELOAD_CONDITIONS_FAILED);
522 }
523
524 /**
525 * @tc.number: AppPreloaderTest_GetBundleAndHapInfo_0100
526 * @tc.desc: Test GetBundleAndHapInfo works
527 * @tc.type: FUNC
528 * @tc.Function: GetBundleAndHapInfo
529 * @tc.SubFunction: NA
530 * @tc.EnvConditions: NA
531 */
532 HWTEST_F(AppPreloaderTest, AppPreloaderTest_GetBundleAndHapInfo_0100, TestSize.Level2)
533 {
534 TAG_LOGD(AAFwkTag::TEST, "AppPreloaderTest_GetBundleAndHapInfo_0100 start.");
535 auto manager = std::make_shared<AppPreloader>(remoteClientManager_);
536 EXPECT_NE(manager, nullptr);
537
538 std::string bundleName = "com.acts.preloadtest";
539 int32_t userId = -9;
540 int32_t appIndex = 0;
541 PreloadRequest request;
542 auto ret = manager->GeneratePreloadRequest(bundleName, userId, appIndex, request);
543 EXPECT_EQ(ret, AAFwk::GET_BUNDLE_INFO_FAILED);
544 }
545
546 /**
547 * @tc.number: AppPreloaderTest_GetBundleAndHapInfo_0200
548 * @tc.desc: Test GetBundleAndHapInfo works
549 * @tc.type: FUNC
550 * @tc.Function: GetBundleAndHapInfo
551 * @tc.SubFunction: NA
552 * @tc.EnvConditions: NA
553 */
554 HWTEST_F(AppPreloaderTest, AppPreloaderTest_GetBundleAndHapInfo_0200, TestSize.Level2)
555 {
556 TAG_LOGD(AAFwkTag::TEST, "AppPreloaderTest_GetBundleAndHapInfo_0200 start.");
557 auto manager = std::make_shared<AppPreloader>(remoteClientManager_);
558 EXPECT_NE(manager, nullptr);
559
560 std::string bundleName = "com.acts.preloadtest";
561 int32_t userId = -10;
562 int32_t appIndex = 0;
563 PreloadRequest request;
564 auto ret = manager->GeneratePreloadRequest(bundleName, userId, appIndex, request);
565 EXPECT_EQ(ret, AAFwk::GET_BUNDLE_INFO_FAILED);
566 }
567
568 /**
569 * @tc.number: AppPreloaderTest_GetBundleAndHapInfo_0300
570 * @tc.desc: Test GetBundleAndHapInfo works
571 * @tc.type: FUNC
572 * @tc.Function: GetBundleAndHapInfo
573 * @tc.SubFunction: NA
574 * @tc.EnvConditions: NA
575 */
576 HWTEST_F(AppPreloaderTest, AppPreloaderTest_GetBundleAndHapInfo_0300, TestSize.Level2)
577 {
578 TAG_LOGD(AAFwkTag::TEST, "AppPreloaderTest_GetBundleAndHapInfo_0300 start.");
579 auto manager = std::make_shared<AppPreloader>(remoteClientManager_);
580 EXPECT_NE(manager, nullptr);
581
582 manager->remoteClientManager_ = nullptr;
583 std::string bundleName = "com.acts.preloadtest";
584 int32_t userId = -2;
585 AbilityInfo abilityInfo;
586 BundleInfo bundleInfo;
587 HapModuleInfo hapModuleInfo;
588 auto ret = manager->GetBundleAndHapInfo(bundleName, userId, abilityInfo, bundleInfo, hapModuleInfo);
589 manager->remoteClientManager_ = remoteClientManager_;
590 EXPECT_FALSE(ret);
591 }
592
593 /**
594 * @tc.number: AppPreloaderTest_GetBundleManagerHelper_0100
595 * @tc.desc: Test GetBundleManagerHelper works
596 * @tc.type: FUNC
597 * @tc.Function: GetBundleManagerHelper
598 * @tc.SubFunction: NA
599 * @tc.EnvConditions: NA
600 */
601 HWTEST_F(AppPreloaderTest, AppPreloaderTest_GetBundleManagerHelper_0100, TestSize.Level2)
602 {
603 TAG_LOGD(AAFwkTag::TEST, "AppPreloaderTest_GetBundleManagerHelper_0100 start.");
604 auto manager = std::make_shared<AppPreloader>(remoteClientManager_);
605 EXPECT_NE(manager, nullptr);
606 manager->remoteClientManager_ = nullptr;
607 auto ret = manager->GetBundleManagerHelper();
608 manager->remoteClientManager_ = remoteClientManager_;
609 EXPECT_EQ(ret, nullptr);
610 }
611 } // namespace AppExecFwk
612 } // namespace OHOS
613