1 /*
2 * Copyright (c) 2022-2023 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_recovery.h"
20 #undef private
21 #include "ability_info.h"
22 #include "app_recovery_parcel_allocator.h"
23 #include "event_handler.h"
24 #include "int_wrapper.h"
25 #include "mock_ability.h"
26 #include "mock_ability_token.h"
27 #include "mock_app_ability.h"
28 #include "recovery_param.h"
29 #include "ui_ability.h"
30 #include "want.h"
31 #include "want_params.h"
32
33 using namespace testing::ext;
34 namespace OHOS {
35 namespace AppExecFwk {
36 class AbilityRecoveryUnitTest : public testing::Test {
37 public:
38 static void SetUpTestCase();
39 static void TearDownTestCase();
40 void SetUp();
41 void TearDown();
42 std::shared_ptr<AbilityRecovery> abilityRecovery_ = std::make_shared<AbilityRecovery>();
43 std::shared_ptr<AbilityRuntime::UIAbility> ability_ = std::make_shared<AbilityRuntime::UIAbility>();
44 std::shared_ptr<AbilityRuntime::UIAbility> mockAbility_ = std::make_shared<MockAbility>();
45 std::shared_ptr<AbilityRuntime::UIAbility> mockAbility2_ = std::make_shared<MockAppAbility>();
46 std::shared_ptr<AppExecFwk::AbilityInfo> abilityInfo_ = std::make_shared<AbilityInfo>();
47 std::shared_ptr<AppExecFwk::ApplicationInfo> applicationInfo_ = std::make_shared<ApplicationInfo>();
48 sptr<IRemoteObject> token_ = new MockAbilityToken();
49 Want want_;
50 };
51
SetUpTestCase()52 void AbilityRecoveryUnitTest::SetUpTestCase()
53 {
54 }
55
TearDownTestCase()56 void AbilityRecoveryUnitTest::TearDownTestCase()
57 {}
58
SetUp()59 void AbilityRecoveryUnitTest::SetUp()
60 {
61 abilityRecovery_->isEnable_ = false;
62 abilityRecovery_->restartFlag_ = 0;
63 abilityRecovery_->saveOccasion_ = 0;
64 abilityRecovery_->saveMode_ = 0;
65 abilityRecovery_->hasLoaded_ = false;
66 abilityRecovery_->abilityInfo_ = abilityInfo_;
67 abilityRecovery_->jsAbilityPtr_ = 0;
68 }
69
TearDown()70 void AbilityRecoveryUnitTest::TearDown()
71 {
72 }
73
74 /**
75 * @tc.name: GetRestartFlag_001
76 * @tc.desc: Test GetRestartFlag
77 * @tc.type: FUNC
78 * @tc.require: I5UL6H
79 */
80 HWTEST_F(AbilityRecoveryUnitTest, GetRestartFlag_001, TestSize.Level1)
81 {
82 EXPECT_EQ(abilityRecovery_->GetRestartFlag(), 0);
83 abilityRecovery_->restartFlag_ = RestartFlag::ALWAYS_RESTART;
84 EXPECT_EQ(abilityRecovery_->GetRestartFlag(), RestartFlag::ALWAYS_RESTART);
85 }
86
87 /**
88 * @tc.name: GetSaveOccasionFlag_001
89 * @tc.desc: Test GetSaveOccasionFlag
90 * @tc.type: FUNC
91 * @tc.require: I5UL6H
92 */
93 HWTEST_F(AbilityRecoveryUnitTest, GetSaveOccasionFlag_001, TestSize.Level1)
94 {
95 EXPECT_EQ(abilityRecovery_->GetSaveOccasionFlag(), 0);
96 abilityRecovery_->saveOccasion_ = SaveOccasionFlag::SAVE_WHEN_ERROR;
97 EXPECT_EQ(abilityRecovery_->GetSaveOccasionFlag(), SaveOccasionFlag::SAVE_WHEN_ERROR);
98 }
99 /**
100 * @tc.name: GetSaveModeFlag_001
101 * @tc.desc: Test GetSaveModeFlag
102 * @tc.type: FUNC
103 * @tc.require: I5UL6H
104 */
105 HWTEST_F(AbilityRecoveryUnitTest, GetSaveModeFlag_001, TestSize.Level1)
106 {
107 EXPECT_EQ(abilityRecovery_->GetSaveModeFlag(), 0);
108 abilityRecovery_->saveMode_ = SaveModeFlag::SAVE_WITH_FILE;
109 EXPECT_EQ(abilityRecovery_->GetSaveModeFlag(), SaveModeFlag::SAVE_WITH_FILE);
110 }
111
112 /**
113 * @tc.name: EnableAbilityRecovery_001
114 * @tc.desc: EnableAbilityRecovery with config, check the enable flag is set as expected.
115 * @tc.type: FUNC
116 * @tc.require: I5UL6H
117 */
118 HWTEST_F(AbilityRecoveryUnitTest, EnableAbilityRecovery_001, TestSize.Level1)
119 {
120 EXPECT_FALSE(abilityRecovery_->isEnable_);
121 abilityRecovery_->EnableAbilityRecovery(true, RestartFlag::ALWAYS_RESTART, SaveOccasionFlag::SAVE_WHEN_ERROR,
122 SaveModeFlag::SAVE_WITH_FILE);
123 EXPECT_TRUE(abilityRecovery_->isEnable_);
124 }
125
126 /**
127 * @tc.name: EnableAbilityRecovery_002
128 * @tc.desc: EnableAbilityRecovery with config, check the config is set as expected.
129 * @tc.type: FUNC
130 * @tc.require: I5UL6H
131 */
132 HWTEST_F(AbilityRecoveryUnitTest, EnableAbilityRecovery_002, TestSize.Level1)
133 {
134 abilityRecovery_->EnableAbilityRecovery(true, RestartFlag::ALWAYS_RESTART, SaveOccasionFlag::SAVE_WHEN_ERROR,
135 SaveModeFlag::SAVE_WITH_FILE);
136 EXPECT_EQ(RestartFlag::ALWAYS_RESTART, abilityRecovery_->GetRestartFlag());
137 EXPECT_EQ(SaveOccasionFlag::SAVE_WHEN_ERROR, abilityRecovery_->GetSaveOccasionFlag());
138 EXPECT_EQ(SaveModeFlag::SAVE_WITH_FILE, abilityRecovery_->GetSaveModeFlag());
139 }
140
141 /**
142 * @tc.name: EnableAbilityRecovery_003
143 * @tc.desc: EnableAppRecovery with config, check the config is set as expected.
144 * @tc.type: FUNC
145 * @tc.require: I5UL6H
146 */
147 HWTEST_F(AbilityRecoveryUnitTest, EnableAbilityRecovery_003, TestSize.Level1)
148 {
149 abilityRecovery_->EnableAbilityRecovery(true, RestartFlag::NO_RESTART, SaveOccasionFlag::SAVE_ALL,
150 SaveModeFlag::SAVE_WITH_SHARED_MEMORY);
151 EXPECT_EQ(RestartFlag::NO_RESTART, abilityRecovery_->GetRestartFlag());
152 EXPECT_EQ(SaveOccasionFlag::SAVE_ALL, abilityRecovery_->GetSaveOccasionFlag());
153 EXPECT_EQ(SaveModeFlag::SAVE_WITH_SHARED_MEMORY, abilityRecovery_->GetSaveModeFlag());
154 }
155
156 /**
157 * @tc.name: InitAbilityInfo_001
158 * @tc.desc: Test InitAbilityInfo
159 * @tc.type: FUNC
160 * @tc.require: I5UL6H
161 */
162 HWTEST_F(AbilityRecoveryUnitTest, InitAbilityInfo_001, TestSize.Level1)
163 {
164 EXPECT_TRUE(abilityRecovery_->InitAbilityInfo(ability_, abilityInfo_, token_));
165 }
166
167 /**
168 * @tc.name: IsSaveAbilityState_001
169 * @tc.desc: Test IsSaveAbilityState when state is not support save.
170 * @tc.type: FUNC
171 * @tc.require: I5UL6H
172 */
173 HWTEST_F(AbilityRecoveryUnitTest, IsSaveAbilityState_001, TestSize.Level1)
174 {
175 abilityRecovery_->EnableAbilityRecovery(true, RestartFlag::ALWAYS_RESTART, SaveOccasionFlag::SAVE_WHEN_ERROR,
176 SaveModeFlag::SAVE_WITH_FILE);
177 EXPECT_FALSE(abilityRecovery_->IsSaveAbilityState(StateReason::LIFECYCLE));
178 }
179
180 /**
181 * @tc.name: IsSaveAbilityState_002
182 * @tc.desc: Test IsSaveAbilityState when state is not support save.
183 * @tc.type: FUNC
184 * @tc.require: I5UL6H
185 */
186 HWTEST_F(AbilityRecoveryUnitTest, IsSaveAbilityState_002, TestSize.Level1)
187 {
188 abilityRecovery_->EnableAbilityRecovery(true, RestartFlag::ALWAYS_RESTART, SaveOccasionFlag::SAVE_WHEN_BACKGROUND,
189 SaveModeFlag::SAVE_WITH_FILE);
190 EXPECT_FALSE(abilityRecovery_->IsSaveAbilityState(StateReason::CPP_CRASH));
191 EXPECT_FALSE(abilityRecovery_->IsSaveAbilityState(StateReason::JS_ERROR));
192 EXPECT_FALSE(abilityRecovery_->IsSaveAbilityState(StateReason::APP_FREEZE));
193 }
194
195 /**
196 * @tc.name: IsSaveAbilityState_003
197 * @tc.desc: Test IsSaveAbilityState when state is support save.
198 * @tc.type: FUNC
199 * @tc.require: I5UL6H
200 */
201 HWTEST_F(AbilityRecoveryUnitTest, IsSaveAbilityState_003, TestSize.Level1)
202 {
203 abilityRecovery_->EnableAbilityRecovery(true, RestartFlag::ALWAYS_RESTART, SaveOccasionFlag::SAVE_WHEN_BACKGROUND,
204 SaveModeFlag::SAVE_WITH_FILE);
205 EXPECT_TRUE(abilityRecovery_->IsSaveAbilityState(StateReason::DEVELOPER_REQUEST));
206 EXPECT_TRUE(abilityRecovery_->IsSaveAbilityState(StateReason::LIFECYCLE));
207 }
208
209 /**
210 * @tc.name: IsSaveAbilityState_004
211 * @tc.desc: Test IsSaveAbilityState when state is support save.
212 * @tc.type: FUNC
213 * @tc.require: I5UL6H
214 */
215 HWTEST_F(AbilityRecoveryUnitTest, IsSaveAbilityState_004, TestSize.Level1)
216 {
217 abilityRecovery_->EnableAbilityRecovery(true, RestartFlag::ALWAYS_RESTART, SaveOccasionFlag::SAVE_WHEN_ERROR,
218 SaveModeFlag::SAVE_WITH_FILE);
219 EXPECT_TRUE(abilityRecovery_->IsSaveAbilityState(StateReason::CPP_CRASH));
220 EXPECT_TRUE(abilityRecovery_->IsSaveAbilityState(StateReason::JS_ERROR));
221 EXPECT_TRUE(abilityRecovery_->IsSaveAbilityState(StateReason::APP_FREEZE));
222 }
223
224 /**
225 * @tc.name: ScheduleSaveAbilityState_001
226 * @tc.desc: Test ScheduleSaveAbilityState when enableFlag is false.
227 * @tc.type: FUNC
228 * @tc.require: I5UL6H
229 */
230 HWTEST_F(AbilityRecoveryUnitTest, ScheduleSaveAbilityState_001, TestSize.Level1)
231 {
232 EXPECT_FALSE(abilityRecovery_->ScheduleSaveAbilityState(StateReason::DEVELOPER_REQUEST));
233 }
234
235 /**
236 * @tc.name: ScheduleSaveAbilityState_002
237 * @tc.desc: Test ScheduleSaveAbilityState when StateReason is not support save.
238 * @tc.type: FUNC
239 * @tc.require: I5UL6H
240 */
241 HWTEST_F(AbilityRecoveryUnitTest, ScheduleSaveAbilityState_002, TestSize.Level1)
242 {
243 abilityRecovery_->EnableAbilityRecovery(true, RestartFlag::ALWAYS_RESTART, SaveOccasionFlag::SAVE_WHEN_ERROR,
244 SaveModeFlag::SAVE_WITH_FILE);
245 EXPECT_FALSE(abilityRecovery_->ScheduleSaveAbilityState(StateReason::LIFECYCLE));
246 abilityRecovery_->missionId_ = 1;
247 EXPECT_FALSE(!abilityRecovery_->isEnable_);
248 EXPECT_TRUE(abilityRecovery_->missionId_ > 0);
249 abilityRecovery_->saveOccasion_ = 0x0010;
250 EXPECT_TRUE((abilityRecovery_->saveOccasion_ & SaveOccasionFlag::SAVE_WHEN_ERROR) == 0);
251 EXPECT_FALSE(abilityRecovery_->ScheduleSaveAbilityState(StateReason::APP_FREEZE));
252 }
253
254 /**
255 * @tc.name: SaveAbilityState_001
256 * @tc.desc: Test SaveAbilityState when ability is nullptr.
257 * @tc.type: FUNC
258 * @tc.require: I5UL6H
259 */
260 HWTEST_F(AbilityRecoveryUnitTest, SaveAbilityState_001, TestSize.Level1)
261 {
262 abilityRecovery_->ability_.reset();
263 EXPECT_FALSE(abilityRecovery_->SaveAbilityState(StateReason::LIFECYCLE));
264 }
265
266 /**
267 * @tc.name: SaveAbilityState_002
268 * @tc.desc: Test SaveAbilityState when saveResult is not support save.
269 * @tc.type: FUNC
270 * @tc.require: I5UL6H
271 */
272 HWTEST_F(AbilityRecoveryUnitTest, SaveAbilityState_002, TestSize.Level1)
273 {
274 abilityRecovery_->ability_ = mockAbility2_;
275 EXPECT_TRUE(abilityRecovery_->SaveAbilityState(StateReason::LIFECYCLE));
276 }
277
278 /**
279 * @tc.name: SaveAbilityState_003
280 * @tc.desc: Test SaveAbilityState when pageStack is empty or not.
281 * @tc.type: FUNC
282 * @tc.require: I5UL6H
283 */
284 HWTEST_F(AbilityRecoveryUnitTest, SaveAbilityState_003, TestSize.Level1)
285 {
286 abilityRecovery_->ability_ = ability_;
287 EXPECT_TRUE(abilityRecovery_->SaveAbilityState(StateReason::LIFECYCLE));
288 abilityRecovery_->ability_ = mockAbility_;
289 EXPECT_TRUE(abilityRecovery_->SaveAbilityState(StateReason::LIFECYCLE));
290 }
291
292 /**
293 * @tc.name: SaveAbilityState_004
294 * @tc.desc: Test SaveAbilityState when SaveModeFlag is SAVE_WITH_FILE or SAVE_WITH_SHARED_MEMORY.
295 * @tc.type: FUNC
296 * @tc.require: I5UL6H
297 */
298 HWTEST_F(AbilityRecoveryUnitTest, SaveAbilityState_004, TestSize.Level1)
299 {
300 abilityRecovery_->EnableAbilityRecovery(true, RestartFlag::ALWAYS_RESTART, SaveOccasionFlag::SAVE_WHEN_ERROR,
301 SaveModeFlag::SAVE_WITH_FILE);
302 abilityRecovery_->ability_ = mockAbility_;
303 EXPECT_TRUE(abilityRecovery_->SaveAbilityState(StateReason::LIFECYCLE));
304 abilityRecovery_->EnableAbilityRecovery(true, RestartFlag::ALWAYS_RESTART, SaveOccasionFlag::SAVE_WHEN_ERROR,
305 SaveModeFlag::SAVE_WITH_SHARED_MEMORY);
306 EXPECT_TRUE(abilityRecovery_->SaveAbilityState(StateReason::LIFECYCLE));
307 }
308
309 /**
310 * @tc.name: ScheduleRecoverAbility_001
311 * @tc.desc: Test ScheduleRecoverAbility when enableFlag is false.
312 * @tc.type: FUNC
313 * @tc.require: I5UL6H
314 */
315 HWTEST_F(AbilityRecoveryUnitTest, ScheduleRecoverAbility_001, TestSize.Level1)
316 {
317 EXPECT_FALSE(abilityRecovery_->ScheduleRecoverAbility(StateReason::DEVELOPER_REQUEST));
318 }
319
320 /**
321 * @tc.name: ScheduleRecoverAbility_002
322 * @tc.desc: Test ScheduleRecoverAbility when token is nullptr.
323 * @tc.type: FUNC
324 * @tc.require: I5UL6H
325 */
326 HWTEST_F(AbilityRecoveryUnitTest, ScheduleRecoverAbility_002, TestSize.Level1)
327 {
328 abilityRecovery_->EnableAbilityRecovery(true, RestartFlag::ALWAYS_RESTART, SaveOccasionFlag::SAVE_WHEN_ERROR,
329 SaveModeFlag::SAVE_WITH_FILE);
330 token_ = nullptr;
331 EXPECT_FALSE(abilityRecovery_->ScheduleRecoverAbility(StateReason::DEVELOPER_REQUEST));
332 }
333
334 /**
335 * @tc.name: ScheduleRecoverAbility_003
336 * @tc.desc: Test ScheduleRecoverAbility check the ret as expected.
337 * @tc.type: FUNC
338 * @tc.require: I5UL6H
339 */
340 HWTEST_F(AbilityRecoveryUnitTest, ScheduleRecoverAbility_003, TestSize.Level1)
341 {
342 abilityRecovery_->EnableAbilityRecovery(true, RestartFlag::ALWAYS_RESTART, SaveOccasionFlag::SAVE_WHEN_ERROR,
343 SaveModeFlag::SAVE_WITH_FILE);
344 token_ = new MockAbilityToken();
345 abilityRecovery_->token_ = token_;
346 EXPECT_TRUE(abilityRecovery_->ScheduleRecoverAbility(StateReason::DEVELOPER_REQUEST));
347 }
348
349 /**
350 * @tc.name: ScheduleRestoreAbilityState_001
351 * @tc.desc: Test ScheduleRestoreAbilityState when enableFlag is false.
352 * @tc.type: FUNC
353 * @tc.require: I5UL6H
354 */
355 HWTEST_F(AbilityRecoveryUnitTest, ScheduleRestoreAbilityState_001, TestSize.Level1)
356 {
357 EXPECT_FALSE(abilityRecovery_->ScheduleRestoreAbilityState(StateReason::DEVELOPER_REQUEST, want_));
358 }
359
360 /**
361 * @tc.name: ScheduleRestoreAbilityState_002
362 * @tc.desc: Test ScheduleRestoreAbilityState when StateReason is not support save.
363 * @tc.type: FUNC
364 * @tc.require: I5UL6H
365 */
366 HWTEST_F(AbilityRecoveryUnitTest, ScheduleRestoreAbilityState_002, TestSize.Level1)
367 {
368 abilityRecovery_->EnableAbilityRecovery(true, RestartFlag::ALWAYS_RESTART, SaveOccasionFlag::SAVE_WHEN_ERROR,
369 SaveModeFlag::SAVE_WITH_FILE);
370 EXPECT_FALSE(abilityRecovery_->ScheduleRestoreAbilityState(StateReason::LIFECYCLE, want_));
371 }
372
373 /**
374 * @tc.name: ScheduleRestoreAbilityState_003
375 * @tc.desc: Test ScheduleRestoreAbilityState when no saved state.
376 * @tc.type: FUNC
377 * @tc.require: I5UL6H
378 */
379 HWTEST_F(AbilityRecoveryUnitTest, ScheduleRestoreAbilityState_003, TestSize.Level1)
380 {
381 abilityRecovery_->EnableAbilityRecovery(true, RestartFlag::ALWAYS_RESTART, SaveOccasionFlag::SAVE_WHEN_ERROR,
382 SaveModeFlag::SAVE_WITH_FILE);
383 abilityRecovery_->abilityInfo_.reset();
384 EXPECT_FALSE(abilityRecovery_->ScheduleRestoreAbilityState(StateReason::CPP_CRASH, want_));
385 }
386
387 /**
388 * @tc.name: ScheduleRestoreAbilityState_004
389 * @tc.desc: Test ScheduleRestoreAbilityState check the ret as expected.
390 * @tc.require: I5UL6H
391 */
392 HWTEST_F(AbilityRecoveryUnitTest, ScheduleRestoreAbilityState_004, TestSize.Level1)
393 {
394 abilityRecovery_->EnableAbilityRecovery(true, RestartFlag::ALWAYS_RESTART, SaveOccasionFlag::SAVE_WHEN_ERROR,
395 SaveModeFlag::SAVE_WITH_SHARED_MEMORY);
396 abilityRecovery_->hasTryLoad_ = true;
397 abilityRecovery_->hasLoaded_ = true;
398 EXPECT_TRUE(abilityRecovery_->ScheduleRestoreAbilityState(StateReason::CPP_CRASH, want_));
399 }
400
401 /**
402 * @tc.name: LoadSavedState_001
403 * @tc.desc: Test LoadSavedState when abilityInfo is nullptr.
404 * @tc.type: FUNC
405 * @tc.require: I5UL6H
406 */
407 HWTEST_F(AbilityRecoveryUnitTest, LoadSavedState_001, TestSize.Level1)
408 {
409 abilityRecovery_->abilityInfo_.reset();
410 EXPECT_FALSE(abilityRecovery_->LoadSavedState(StateReason::DEVELOPER_REQUEST));
411 }
412
413 /**
414 * @tc.name: LoadSavedState_002
415 * @tc.desc: Test LoadSavedState when load twice.
416 * @tc.type: FUNC
417 * @tc.require: I5UL6H
418 */
419 HWTEST_F(AbilityRecoveryUnitTest, LoadSavedState_002, TestSize.Level1)
420 {
421 abilityRecovery_->hasTryLoad_ = true;
422 EXPECT_FALSE(abilityRecovery_->LoadSavedState(StateReason::DEVELOPER_REQUEST));
423 }
424
425 /**
426 * @tc.name: LoadSavedState_003
427 * @tc.desc: Test LoadSavedState when hasTryLoad is false.
428 * @tc.type: FUNC
429 * @tc.require: I5UL6H
430 */
431 HWTEST_F(AbilityRecoveryUnitTest, LoadSavedState_003, TestSize.Level1)
432 {
433 abilityRecovery_->hasTryLoad_ = false;
434 EXPECT_FALSE(abilityRecovery_->LoadSavedState(StateReason::DEVELOPER_REQUEST));
435 }
436
437 /**
438 * @tc.name: GetSavedPageStack_001
439 * @tc.desc: Test GetSavedPageStack when no saved state.
440 * @tc.type: FUNC
441 * @tc.require: I5UL6H
442 */
443 HWTEST_F(AbilityRecoveryUnitTest, GetSavedPageStack_001, TestSize.Level1)
444 {
445 abilityRecovery_->hasTryLoad_ = true;
446 abilityRecovery_->EnableAbilityRecovery(true, RestartFlag::ALWAYS_RESTART, SaveOccasionFlag::SAVE_WHEN_ERROR,
447 SaveModeFlag::SAVE_WITH_SHARED_MEMORY);
448 EXPECT_EQ(abilityRecovery_->GetSavedPageStack(StateReason::DEVELOPER_REQUEST), "");
449 }
450
451 /**
452 * @tc.name: GetSavedPageStack_002
453 * @tc.desc: Test GetSavedPageStack when pageStack is empty.
454 * @tc.type: FUNC
455 * @tc.require: I5UL6H
456 */
457 HWTEST_F(AbilityRecoveryUnitTest, GetSavedPageStack_002, TestSize.Level1)
458 {
459 abilityRecovery_->hasTryLoad_ = true;
460 abilityRecovery_->hasLoaded_ = true;
461 abilityRecovery_->EnableAbilityRecovery(true, RestartFlag::ALWAYS_RESTART, SaveOccasionFlag::SAVE_WHEN_ERROR,
462 SaveModeFlag::SAVE_WITH_SHARED_MEMORY);
463 EXPECT_EQ(abilityRecovery_->GetSavedPageStack(StateReason::DEVELOPER_REQUEST), "");
464 }
465
466 /**
467 * @tc.name: GetSavedPageStack_003
468 * @tc.desc: Test GetSavedPageStack check the ret as expected.
469 * @tc.type: FUNC
470 * @tc.require: I5UL6H
471 */
472 HWTEST_F(AbilityRecoveryUnitTest, GetSavedPageStack_003, TestSize.Level1)
473 {
474 abilityRecovery_->hasTryLoad_ = true;
475 abilityRecovery_->hasLoaded_ = true;
476 abilityRecovery_->pageStack_ = "test";
477 abilityRecovery_->EnableAbilityRecovery(true, RestartFlag::ALWAYS_RESTART, SaveOccasionFlag::SAVE_WHEN_ERROR,
478 SaveModeFlag::SAVE_WITH_SHARED_MEMORY);
479 EXPECT_EQ(abilityRecovery_->GetSavedPageStack(StateReason::DEVELOPER_REQUEST), "test");
480 }
481
482 /**
483 * @tc.name: GetToken_001
484 * @tc.desc: Test GetToken check the ret as expected.
485 * @tc.type: FUNC
486 * @tc.require: I5UL6H
487 */
488 HWTEST_F(AbilityRecoveryUnitTest, GetToken_001, TestSize.Level1)
489 {
490 EXPECT_EQ(abilityRecovery_->GetToken(), abilityRecovery_->token_);
491 }
492
493 /**
494 * @tc.name: PersistAppState_001
495 * @tc.desc: Test PersistAppState when abilityInfo is nullptr.
496 * @tc.type: FUNC
497 * @tc.require: I5Z7LE
498 */
499 HWTEST_F(AbilityRecoveryUnitTest, PersistAppState_001, TestSize.Level1)
500 {
501 abilityRecovery_->abilityInfo_.reset();
502 EXPECT_FALSE(abilityRecovery_->PersistState());
503 }
504
505 /**
506 * @tc.name: PersistAppState_002
507 * @tc.desc: Test PersistAppState check the ret as expected.
508 * @tc.type: FUNC
509 * @tc.require: I5Z7LE
510 */
511 HWTEST_F(AbilityRecoveryUnitTest, PersistAppState_002, TestSize.Level1)
512 {
513 abilityRecovery_->abilityInfo_ = abilityInfo_;
514 abilityRecovery_->missionId_ = 1;
515 EXPECT_TRUE(abilityRecovery_->PersistState());
516 abilityRecovery_->params_ = want_.GetParams();
517 int32_t natValue32 = 0;
518 abilityRecovery_->params_.SetParam("test", AAFwk::Integer::Box(natValue32));
519 EXPECT_TRUE(abilityRecovery_->PersistState());
520 }
521
522 /**
523 * @tc.name: PersistAppState_003
524 * @tc.desc: add testcase.
525 * @tc.type: FUNC
526 * @tc.require: I5Z7LE
527 */
528 HWTEST_F(AbilityRecoveryUnitTest, PersistAppState_003, TestSize.Level1)
529 {
530 abilityRecovery_->abilityInfo_ = abilityInfo_;
531 abilityRecovery_->missionId_ = -1;
532 EXPECT_FALSE(abilityRecovery_->PersistState());
533 }
534
535 /**
536 * @tc.name: IsSameAbility_001
537 * @tc.desc: Test IsSameAbility when not set SetJsAbility.
538 * @tc.type: FUNC
539 * @tc.require: I5Z7LE
540 */
541 HWTEST_F(AbilityRecoveryUnitTest, IsSameAbility_001, TestSize.Level1)
542 {
543 uintptr_t jsAbility = reinterpret_cast<uintptr_t>(mockAbility_.get());
544 EXPECT_FALSE(abilityRecovery_->IsSameAbility(jsAbility));
545 }
546
547 /**
548 * @tc.name: IsSameAbility_002
549 * @tc.desc: Test IsSameAbility after set SetJsAbility.
550 * @tc.type: FUNC
551 * @tc.require: I5Z7LE
552 */
553 HWTEST_F(AbilityRecoveryUnitTest, IsSameAbility_002, TestSize.Level1)
554 {
555 uintptr_t jsAbility = reinterpret_cast<uintptr_t>(mockAbility_.get());
556 abilityRecovery_->SetJsAbility(jsAbility);
557 EXPECT_TRUE(abilityRecovery_->IsSameAbility(jsAbility));
558 }
559
560 /**
561 * @tc.name: Test AppRecoveryAllocator
562 * @tc.desc: Test AppRecoveryAllocator
563 * @tc.type: Bugfix
564 * @tc.require: I6ZDY2
565 */
566 HWTEST_F(AbilityRecoveryUnitTest, TestAppRecoveryAllocator_001, TestSize.Level1)
567 {
568 AppRecoveryParcelAllocator allocator;
569 allocator.Dealloc(nullptr);
570 EXPECT_EQ(allocator.Alloc(0), nullptr);
571 EXPECT_EQ(allocator.Realloc(nullptr, 0), nullptr);
572 }
573
574 /**
575 * @tc.name: Test ReadSerializeDataFromFile
576 * @tc.desc: add testcase
577 * @tc.type: Bugfix
578 */
579 HWTEST_F(AbilityRecoveryUnitTest, TestReadSerializeDataFromFile_001, TestSize.Level1)
580 {
581 int32_t savedStateId = 0;
582 AAFwk::WantParams wantParams;
583 EXPECT_TRUE(!abilityRecovery_->ReadSerializeDataFromFile(savedStateId, wantParams));
584 }
585
586 /**
587 * @tc.name: Test LoadSavedState
588 * @tc.desc: add testcase
589 * @tc.type: Bugfix
590 */
591 HWTEST_F(AbilityRecoveryUnitTest, TestLoadSavedState_001, TestSize.Level1)
592 {
593 abilityRecovery_->hasLoaded_ = false;
594 abilityRecovery_->missionId_ = 10;
595 EXPECT_TRUE(!abilityRecovery_->LoadSavedState(StateReason::DEVELOPER_REQUEST));
596 }
597
598 /**
599 * @tc.name: Test IsOnForeground
600 * @tc.desc: add testcase
601 * @tc.type: Bugfix
602 */
603 HWTEST_F(AbilityRecoveryUnitTest, IsOnForeground_001, TestSize.Level1)
604 {
605 bool ret = abilityRecovery_->IsOnForeground();
606 EXPECT_EQ(ret, false);
607
608 std::shared_ptr<AbilityRuntime::UIAbility> ability =
609 std::make_shared<AbilityRuntime::UIAbility>();
610 abilityRecovery_->ability_ = ability;
611 ret = abilityRecovery_->IsOnForeground();
612 EXPECT_EQ(ret, false);
613
614 ability->abilityLifecycleExecutor_ =
615 std::make_shared<AppExecFwk::AbilityLifecycleExecutor>();
616 ability->abilityLifecycleExecutor_->state_ =
617 AbilityLifecycleExecutor::LifecycleState::FOREGROUND_NEW;
618 abilityRecovery_->ability_ = ability;
619 ret = abilityRecovery_->IsOnForeground();
620 EXPECT_EQ(ret, true);
621 }
622
623 /**
624 * @tc.name: SaveStateCallback_001
625 * @tc.desc: Test SaveStateCallback when enableFlag is false.
626 * @tc.type: FUNC
627 * @tc.require: I5UL6H
628 */
629 HWTEST_F(AbilityRecoveryUnitTest, SaveStateCallback_001, TestSize.Level1)
630 {
631 AppExecFwk::OnSaveStateResult result;
632 result.status = AppExecFwk::OnSaveResult::CONTINUATION_REJECT;
633 abilityRecovery_->ability_ = mockAbility_;
634 abilityRecovery_->SaveStateCallback(result);
635 EXPECT_NE(abilityRecovery_->ability_.lock(), nullptr);
636 result.status = AppExecFwk::OnSaveResult::ALL_AGREE;
637 abilityRecovery_->SaveStateCallback(result);
638 EXPECT_NE(abilityRecovery_->ability_.lock(), nullptr);
639 }
640 } // namespace AppExecFwk
641 } // namespace OHOS
642