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 }
247 
248 /**
249  * @tc.name: SaveAbilityState_001
250  * @tc.desc: Test SaveAbilityState when ability is nullptr.
251  * @tc.type: FUNC
252  * @tc.require: I5UL6H
253  */
254 HWTEST_F(AbilityRecoveryUnitTest, SaveAbilityState_001, TestSize.Level1)
255 {
256     abilityRecovery_->ability_.reset();
257     EXPECT_FALSE(abilityRecovery_->SaveAbilityState());
258 }
259 
260 /**
261  * @tc.name: SaveAbilityState_002
262  * @tc.desc: Test SaveAbilityState when saveResult is not support save.
263  * @tc.type: FUNC
264  * @tc.require: I5UL6H
265  */
266 HWTEST_F(AbilityRecoveryUnitTest, SaveAbilityState_002, TestSize.Level1)
267 {
268     abilityRecovery_->ability_ = mockAbility2_;
269     EXPECT_FALSE(abilityRecovery_->SaveAbilityState());
270 }
271 
272 /**
273  * @tc.name: SaveAbilityState_003
274  * @tc.desc: Test SaveAbilityState when pageStack is empty or not.
275  * @tc.type: FUNC
276  * @tc.require: I5UL6H
277  */
278 HWTEST_F(AbilityRecoveryUnitTest, SaveAbilityState_003, TestSize.Level1)
279 {
280     abilityRecovery_->ability_ = ability_;
281     EXPECT_TRUE(abilityRecovery_->SaveAbilityState());
282     abilityRecovery_->ability_ = mockAbility_;
283     EXPECT_TRUE(abilityRecovery_->SaveAbilityState());
284 }
285 
286 /**
287  * @tc.name: SaveAbilityState_004
288  * @tc.desc: Test SaveAbilityState when SaveModeFlag is SAVE_WITH_FILE or SAVE_WITH_SHARED_MEMORY.
289  * @tc.type: FUNC
290  * @tc.require: I5UL6H
291  */
292 HWTEST_F(AbilityRecoveryUnitTest, SaveAbilityState_004, TestSize.Level1)
293 {
294     abilityRecovery_->EnableAbilityRecovery(true, RestartFlag::ALWAYS_RESTART, SaveOccasionFlag::SAVE_WHEN_ERROR,
295         SaveModeFlag::SAVE_WITH_FILE);
296     abilityRecovery_->ability_ = mockAbility_;
297     EXPECT_TRUE(abilityRecovery_->SaveAbilityState());
298     abilityRecovery_->EnableAbilityRecovery(true, RestartFlag::ALWAYS_RESTART, SaveOccasionFlag::SAVE_WHEN_ERROR,
299         SaveModeFlag::SAVE_WITH_SHARED_MEMORY);
300     EXPECT_TRUE(abilityRecovery_->SaveAbilityState());
301 }
302 
303 /**
304  * @tc.name: ScheduleRecoverAbility_001
305  * @tc.desc: Test ScheduleRecoverAbility when enableFlag is false.
306  * @tc.type: FUNC
307  * @tc.require: I5UL6H
308  */
309 HWTEST_F(AbilityRecoveryUnitTest, ScheduleRecoverAbility_001, TestSize.Level1)
310 {
311     EXPECT_FALSE(abilityRecovery_->ScheduleRecoverAbility(StateReason::DEVELOPER_REQUEST));
312 }
313 
314 /**
315  * @tc.name: ScheduleRecoverAbility_002
316  * @tc.desc: Test ScheduleRecoverAbility when token is nullptr.
317  * @tc.type: FUNC
318  * @tc.require: I5UL6H
319  */
320 HWTEST_F(AbilityRecoveryUnitTest, ScheduleRecoverAbility_002, TestSize.Level1)
321 {
322     abilityRecovery_->EnableAbilityRecovery(true, RestartFlag::ALWAYS_RESTART, SaveOccasionFlag::SAVE_WHEN_ERROR,
323         SaveModeFlag::SAVE_WITH_FILE);
324     token_ = nullptr;
325     EXPECT_FALSE(abilityRecovery_->ScheduleRecoverAbility(StateReason::DEVELOPER_REQUEST));
326 }
327 
328 /**
329  * @tc.name: ScheduleRecoverAbility_003
330  * @tc.desc: Test ScheduleRecoverAbility check the ret as expected.
331  * @tc.type: FUNC
332  * @tc.require: I5UL6H
333  */
334 HWTEST_F(AbilityRecoveryUnitTest, ScheduleRecoverAbility_003, TestSize.Level1)
335 {
336     abilityRecovery_->EnableAbilityRecovery(true, RestartFlag::ALWAYS_RESTART, SaveOccasionFlag::SAVE_WHEN_ERROR,
337         SaveModeFlag::SAVE_WITH_FILE);
338     token_ = new MockAbilityToken();
339     abilityRecovery_->token_ = token_;
340     EXPECT_TRUE(abilityRecovery_->ScheduleRecoverAbility(StateReason::DEVELOPER_REQUEST));
341 }
342 
343 /**
344  * @tc.name: ScheduleRestoreAbilityState_001
345  * @tc.desc: Test ScheduleRestoreAbilityState when enableFlag is false.
346  * @tc.type: FUNC
347  * @tc.require: I5UL6H
348  */
349 HWTEST_F(AbilityRecoveryUnitTest, ScheduleRestoreAbilityState_001, TestSize.Level1)
350 {
351     EXPECT_FALSE(abilityRecovery_->ScheduleRestoreAbilityState(StateReason::DEVELOPER_REQUEST, want_));
352 }
353 
354 /**
355  * @tc.name: ScheduleRestoreAbilityState_002
356  * @tc.desc: Test ScheduleRestoreAbilityState when StateReason is not support save.
357  * @tc.type: FUNC
358  * @tc.require: I5UL6H
359  */
360 HWTEST_F(AbilityRecoveryUnitTest, ScheduleRestoreAbilityState_002, TestSize.Level1)
361 {
362     abilityRecovery_->EnableAbilityRecovery(true, RestartFlag::ALWAYS_RESTART, SaveOccasionFlag::SAVE_WHEN_ERROR,
363         SaveModeFlag::SAVE_WITH_FILE);
364     EXPECT_FALSE(abilityRecovery_->ScheduleRestoreAbilityState(StateReason::LIFECYCLE, want_));
365 }
366 
367 /**
368  * @tc.name: ScheduleRestoreAbilityState_003
369  * @tc.desc: Test ScheduleRestoreAbilityState when no saved state.
370  * @tc.type: FUNC
371  * @tc.require: I5UL6H
372  */
373 HWTEST_F(AbilityRecoveryUnitTest, ScheduleRestoreAbilityState_003, TestSize.Level1)
374 {
375     abilityRecovery_->EnableAbilityRecovery(true, RestartFlag::ALWAYS_RESTART, SaveOccasionFlag::SAVE_WHEN_ERROR,
376         SaveModeFlag::SAVE_WITH_FILE);
377     abilityRecovery_->abilityInfo_.reset();
378     EXPECT_FALSE(abilityRecovery_->ScheduleRestoreAbilityState(StateReason::CPP_CRASH, want_));
379 }
380 
381 /**
382  * @tc.name: ScheduleRestoreAbilityState_004
383  * @tc.desc: Test ScheduleRestoreAbilityState check the ret as expected.
384  * @tc.require: I5UL6H
385  */
386 HWTEST_F(AbilityRecoveryUnitTest, ScheduleRestoreAbilityState_004, TestSize.Level1)
387 {
388     abilityRecovery_->EnableAbilityRecovery(true, RestartFlag::ALWAYS_RESTART, SaveOccasionFlag::SAVE_WHEN_ERROR,
389         SaveModeFlag::SAVE_WITH_SHARED_MEMORY);
390     abilityRecovery_->hasTryLoad_ = true;
391     abilityRecovery_->hasLoaded_ = true;
392     EXPECT_TRUE(abilityRecovery_->ScheduleRestoreAbilityState(StateReason::CPP_CRASH, want_));
393 }
394 
395 /**
396  * @tc.name: LoadSavedState_001
397  * @tc.desc: Test LoadSavedState when abilityInfo is nullptr.
398  * @tc.type: FUNC
399  * @tc.require: I5UL6H
400  */
401 HWTEST_F(AbilityRecoveryUnitTest, LoadSavedState_001, TestSize.Level1)
402 {
403     abilityRecovery_->abilityInfo_.reset();
404     EXPECT_FALSE(abilityRecovery_->LoadSavedState(StateReason::DEVELOPER_REQUEST));
405 }
406 
407 /**
408  * @tc.name: LoadSavedState_002
409  * @tc.desc: Test LoadSavedState when load twice.
410  * @tc.type: FUNC
411  * @tc.require: I5UL6H
412  */
413 HWTEST_F(AbilityRecoveryUnitTest, LoadSavedState_002, TestSize.Level1)
414 {
415     abilityRecovery_->hasTryLoad_ = true;
416     EXPECT_FALSE(abilityRecovery_->LoadSavedState(StateReason::DEVELOPER_REQUEST));
417 }
418 
419 /**
420  * @tc.name: LoadSavedState_003
421  * @tc.desc: Test LoadSavedState when hasTryLoad is false.
422  * @tc.type: FUNC
423  * @tc.require: I5UL6H
424  */
425 HWTEST_F(AbilityRecoveryUnitTest, LoadSavedState_003, TestSize.Level1)
426 {
427     abilityRecovery_->hasTryLoad_ = false;
428     EXPECT_FALSE(abilityRecovery_->LoadSavedState(StateReason::DEVELOPER_REQUEST));
429 }
430 
431 /**
432  * @tc.name: GetSavedPageStack_001
433  * @tc.desc: Test GetSavedPageStack when no saved state.
434  * @tc.type: FUNC
435  * @tc.require: I5UL6H
436  */
437 HWTEST_F(AbilityRecoveryUnitTest, GetSavedPageStack_001, TestSize.Level1)
438 {
439     abilityRecovery_->hasTryLoad_ = true;
440     abilityRecovery_->EnableAbilityRecovery(true, RestartFlag::ALWAYS_RESTART, SaveOccasionFlag::SAVE_WHEN_ERROR,
441         SaveModeFlag::SAVE_WITH_SHARED_MEMORY);
442     EXPECT_EQ(abilityRecovery_->GetSavedPageStack(StateReason::DEVELOPER_REQUEST), "");
443 }
444 
445 /**
446  * @tc.name: GetSavedPageStack_002
447  * @tc.desc: Test GetSavedPageStack when pageStack is empty.
448  * @tc.type: FUNC
449  * @tc.require: I5UL6H
450  */
451 HWTEST_F(AbilityRecoveryUnitTest, GetSavedPageStack_002, TestSize.Level1)
452 {
453     abilityRecovery_->hasTryLoad_ = true;
454     abilityRecovery_->hasLoaded_ = true;
455     abilityRecovery_->EnableAbilityRecovery(true, RestartFlag::ALWAYS_RESTART, SaveOccasionFlag::SAVE_WHEN_ERROR,
456         SaveModeFlag::SAVE_WITH_SHARED_MEMORY);
457     EXPECT_EQ(abilityRecovery_->GetSavedPageStack(StateReason::DEVELOPER_REQUEST), "");
458 }
459 
460 /**
461  * @tc.name: GetSavedPageStack_003
462  * @tc.desc: Test GetSavedPageStack check the ret as expected.
463  * @tc.type: FUNC
464  * @tc.require: I5UL6H
465  */
466 HWTEST_F(AbilityRecoveryUnitTest, GetSavedPageStack_003, TestSize.Level1)
467 {
468     abilityRecovery_->hasTryLoad_ = true;
469     abilityRecovery_->hasLoaded_ = true;
470     abilityRecovery_->pageStack_ = "test";
471     abilityRecovery_->EnableAbilityRecovery(true, RestartFlag::ALWAYS_RESTART, SaveOccasionFlag::SAVE_WHEN_ERROR,
472         SaveModeFlag::SAVE_WITH_SHARED_MEMORY);
473     EXPECT_EQ(abilityRecovery_->GetSavedPageStack(StateReason::DEVELOPER_REQUEST), "test");
474 }
475 
476 /**
477  * @tc.name: GetToken_001
478  * @tc.desc: Test GetToken check the ret as expected.
479  * @tc.type: FUNC
480  * @tc.require: I5UL6H
481  */
482 HWTEST_F(AbilityRecoveryUnitTest, GetToken_001, TestSize.Level1)
483 {
484     EXPECT_EQ(abilityRecovery_->GetToken(), abilityRecovery_->token_);
485 }
486 
487 /**
488  * @tc.name:  PersistAppState_001
489  * @tc.desc:  Test PersistAppState when abilityInfo is nullptr.
490  * @tc.type: FUNC
491  * @tc.require: I5Z7LE
492  */
493 HWTEST_F(AbilityRecoveryUnitTest, PersistAppState_001, TestSize.Level1)
494 {
495     abilityRecovery_->abilityInfo_.reset();
496     EXPECT_FALSE(abilityRecovery_->PersistState());
497 }
498 
499 /**
500  * @tc.name:  PersistAppState_002
501  * @tc.desc:  Test PersistAppState check the ret as expected.
502  * @tc.type: FUNC
503  * @tc.require: I5Z7LE
504  */
505 HWTEST_F(AbilityRecoveryUnitTest, PersistAppState_002, TestSize.Level1)
506 {
507     abilityRecovery_->abilityInfo_ = abilityInfo_;
508     abilityRecovery_->missionId_ = 1;
509     EXPECT_TRUE(abilityRecovery_->PersistState());
510     abilityRecovery_->params_ = want_.GetParams();
511     int32_t natValue32 = 0;
512     abilityRecovery_->params_.SetParam("test", AAFwk::Integer::Box(natValue32));
513     EXPECT_TRUE(abilityRecovery_->PersistState());
514 }
515 
516 /**
517  * @tc.name:  IsSameAbility_001
518  * @tc.desc:  Test IsSameAbility when not set SetJsAbility.
519  * @tc.type: FUNC
520  * @tc.require: I5Z7LE
521  */
522 HWTEST_F(AbilityRecoveryUnitTest, IsSameAbility_001, TestSize.Level1)
523 {
524     uintptr_t jsAbility = reinterpret_cast<uintptr_t>(mockAbility_.get());
525     EXPECT_FALSE(abilityRecovery_->IsSameAbility(jsAbility));
526 }
527 
528 /**
529  * @tc.name:  IsSameAbility_002
530  * @tc.desc:  Test IsSameAbility after set SetJsAbility.
531  * @tc.type: FUNC
532  * @tc.require: I5Z7LE
533  */
534 HWTEST_F(AbilityRecoveryUnitTest, IsSameAbility_002, TestSize.Level1)
535 {
536     uintptr_t jsAbility = reinterpret_cast<uintptr_t>(mockAbility_.get());
537     abilityRecovery_->SetJsAbility(jsAbility);
538     EXPECT_TRUE(abilityRecovery_->IsSameAbility(jsAbility));
539 }
540 
541 /**
542  * @tc.name:  Test AppRecoveryAllocator
543  * @tc.desc:  Test AppRecoveryAllocator
544  * @tc.type: Bugfix
545  * @tc.require: I6ZDY2
546  */
547 HWTEST_F(AbilityRecoveryUnitTest, TestAppRecoveryAllocator_001, TestSize.Level1)
548 {
549     AppRecoveryParcelAllocator allocator;
550     allocator.Dealloc(nullptr);
551     EXPECT_EQ(allocator.Alloc(0), nullptr);
552     EXPECT_EQ(allocator.Realloc(nullptr, 0), nullptr);
553 }
554 }  // namespace AppExecFwk
555 }  // namespace OHOS
556