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_recovery.h"
20 #undef private
21 #include "ability.h"
22 #include "ability_info.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 "want.h"
30 #include "want_params.h"
31
32 using namespace testing::ext;
33 namespace OHOS {
34 namespace AppExecFwk {
35 class AbilityRecoveryUnitTest : public testing::Test {
36 public:
37 static void SetUpTestCase();
38 static void TearDownTestCase();
39 void SetUp();
40 void TearDown();
41 std::shared_ptr<AbilityRecovery> abilityRecovery_ = std::make_shared<AbilityRecovery>();
42 std::shared_ptr<AppExecFwk::Ability> ability_ = std::make_shared<Ability>();
43 std::shared_ptr<AppExecFwk::Ability> mockAbility_ = std::make_shared<MockAbility>();
44 std::shared_ptr<AppExecFwk::Ability> mockAbility2_ = std::make_shared<MockAppAbility>();
45 std::shared_ptr<AppExecFwk::AbilityInfo> abilityInfo_ = std::make_shared<AbilityInfo>();
46 std::shared_ptr<AppExecFwk::ApplicationInfo> applicationInfo_ = std::make_shared<ApplicationInfo>();
47 sptr<IRemoteObject> token_ = new MockAbilityToken();
48 Want want_;
49 };
50
SetUpTestCase()51 void AbilityRecoveryUnitTest::SetUpTestCase()
52 {
53 }
54
TearDownTestCase()55 void AbilityRecoveryUnitTest::TearDownTestCase()
56 {}
57
SetUp()58 void AbilityRecoveryUnitTest::SetUp()
59 {
60 abilityRecovery_->isEnable_ = false;
61 abilityRecovery_->restartFlag_ = 0;
62 abilityRecovery_->saveOccasion_ = 0;
63 abilityRecovery_->saveMode_ = 0;
64 abilityRecovery_->hasLoaded_ = false;
65 abilityRecovery_->abilityInfo_ = abilityInfo_;
66 }
67
TearDown()68 void AbilityRecoveryUnitTest::TearDown()
69 {
70 }
71
72 /**
73 * @tc.name: GetRestartFlag_001
74 * @tc.desc: Test GetRestartFlag
75 * @tc.type: FUNC
76 * @tc.require: I5UL6H
77 */
78 HWTEST_F(AbilityRecoveryUnitTest, GetRestartFlag_001, TestSize.Level1)
79 {
80 EXPECT_EQ(abilityRecovery_->GetRestartFlag(), 0);
81 abilityRecovery_->restartFlag_ = RestartFlag::ALWAYS_RESTART;
82 EXPECT_EQ(abilityRecovery_->GetRestartFlag(), RestartFlag::ALWAYS_RESTART);
83 }
84
85 /**
86 * @tc.name: GetSaveOccasionFlag_001
87 * @tc.desc: Test GetSaveOccasionFlag
88 * @tc.type: FUNC
89 * @tc.require: I5UL6H
90 */
91 HWTEST_F(AbilityRecoveryUnitTest, GetSaveOccasionFlag_001, TestSize.Level1)
92 {
93 EXPECT_EQ(abilityRecovery_->GetSaveOccasionFlag(), 0);
94 abilityRecovery_->saveOccasion_ = SaveOccasionFlag::SAVE_WHEN_ERROR;
95 EXPECT_EQ(abilityRecovery_->GetSaveOccasionFlag(), SaveOccasionFlag::SAVE_WHEN_ERROR);
96 }
97 /**
98 * @tc.name: GetSaveModeFlag_001
99 * @tc.desc: Test GetSaveModeFlag
100 * @tc.type: FUNC
101 * @tc.require: I5UL6H
102 */
103 HWTEST_F(AbilityRecoveryUnitTest, GetSaveModeFlag_001, TestSize.Level1)
104 {
105 EXPECT_EQ(abilityRecovery_->GetSaveModeFlag(), 0);
106 abilityRecovery_->saveMode_ = SaveModeFlag::SAVE_WITH_FILE;
107 EXPECT_EQ(abilityRecovery_->GetSaveModeFlag(), SaveModeFlag::SAVE_WITH_FILE);
108 }
109
110 /**
111 * @tc.name: EnableAbilityRecovery_001
112 * @tc.desc: EnableAbilityRecovery with config, check the enable flag is set as expected.
113 * @tc.type: FUNC
114 * @tc.require: I5UL6H
115 */
116 HWTEST_F(AbilityRecoveryUnitTest, EnableAbilityRecovery_001, TestSize.Level1)
117 {
118 EXPECT_FALSE(abilityRecovery_->isEnable_);
119 abilityRecovery_->EnableAbilityRecovery(RestartFlag::ALWAYS_RESTART, SaveOccasionFlag::SAVE_WHEN_ERROR,
120 SaveModeFlag::SAVE_WITH_FILE);
121 EXPECT_TRUE(abilityRecovery_->isEnable_);
122 }
123
124 /**
125 * @tc.name: EnableAbilityRecovery_002
126 * @tc.desc: EnableAbilityRecovery with config, check the config is set as expected.
127 * @tc.type: FUNC
128 * @tc.require: I5UL6H
129 */
130 HWTEST_F(AbilityRecoveryUnitTest, EnableAbilityRecovery_002, TestSize.Level1)
131 {
132 abilityRecovery_->EnableAbilityRecovery(RestartFlag::ALWAYS_RESTART, SaveOccasionFlag::SAVE_WHEN_ERROR,
133 SaveModeFlag::SAVE_WITH_FILE);
134 EXPECT_EQ(RestartFlag::ALWAYS_RESTART, abilityRecovery_->GetRestartFlag());
135 EXPECT_EQ(SaveOccasionFlag::SAVE_WHEN_ERROR, abilityRecovery_->GetSaveOccasionFlag());
136 EXPECT_EQ(SaveModeFlag::SAVE_WITH_FILE, abilityRecovery_->GetSaveModeFlag());
137 }
138
139 /**
140 * @tc.name: EnableAbilityRecovery_003
141 * @tc.desc: EnableAppRecovery with config, check the config is set as expected.
142 * @tc.type: FUNC
143 * @tc.require: I5UL6H
144 */
145 HWTEST_F(AbilityRecoveryUnitTest, EnableAbilityRecovery_003, TestSize.Level1)
146 {
147 abilityRecovery_->EnableAbilityRecovery(RestartFlag::NO_RESTART, SaveOccasionFlag::SAVE_ALL,
148 SaveModeFlag::SAVE_WITH_SHARED_MEMORY);
149 EXPECT_EQ(RestartFlag::NO_RESTART, abilityRecovery_->GetRestartFlag());
150 EXPECT_EQ(SaveOccasionFlag::SAVE_ALL, abilityRecovery_->GetSaveOccasionFlag());
151 EXPECT_EQ(SaveModeFlag::SAVE_WITH_SHARED_MEMORY, abilityRecovery_->GetSaveModeFlag());
152 }
153
154 /**
155 * @tc.name: InitAbilityInfo_001
156 * @tc.desc: Test InitAbilityInfo
157 * @tc.type: FUNC
158 * @tc.require: I5UL6H
159 */
160 HWTEST_F(AbilityRecoveryUnitTest, InitAbilityInfo_001, TestSize.Level1)
161 {
162 EXPECT_TRUE(abilityRecovery_->InitAbilityInfo(ability_, abilityInfo_, token_));
163 }
164
165 /**
166 * @tc.name: IsSaveAbilityState_001
167 * @tc.desc: Test IsSaveAbilityState when state is not support save.
168 * @tc.type: FUNC
169 * @tc.require: I5UL6H
170 */
171 HWTEST_F(AbilityRecoveryUnitTest, IsSaveAbilityState_001, TestSize.Level1)
172 {
173 abilityRecovery_->EnableAbilityRecovery(RestartFlag::ALWAYS_RESTART, SaveOccasionFlag::SAVE_WHEN_ERROR,
174 SaveModeFlag::SAVE_WITH_FILE);
175 EXPECT_FALSE(abilityRecovery_->IsSaveAbilityState(StateReason::LIFECYCLE));
176 }
177
178 /**
179 * @tc.name: IsSaveAbilityState_002
180 * @tc.desc: Test IsSaveAbilityState when state is not support save.
181 * @tc.type: FUNC
182 * @tc.require: I5UL6H
183 */
184 HWTEST_F(AbilityRecoveryUnitTest, IsSaveAbilityState_002, TestSize.Level1)
185 {
186 abilityRecovery_->EnableAbilityRecovery(RestartFlag::ALWAYS_RESTART, SaveOccasionFlag::SAVE_WHEN_BACKGROUND,
187 SaveModeFlag::SAVE_WITH_FILE);
188 EXPECT_FALSE(abilityRecovery_->IsSaveAbilityState(StateReason::CPP_CRASH));
189 EXPECT_FALSE(abilityRecovery_->IsSaveAbilityState(StateReason::JS_ERROR));
190 EXPECT_FALSE(abilityRecovery_->IsSaveAbilityState(StateReason::APP_FREEZE));
191 }
192
193 /**
194 * @tc.name: IsSaveAbilityState_003
195 * @tc.desc: Test IsSaveAbilityState when state is support save.
196 * @tc.type: FUNC
197 * @tc.require: I5UL6H
198 */
199 HWTEST_F(AbilityRecoveryUnitTest, IsSaveAbilityState_003, TestSize.Level1)
200 {
201 abilityRecovery_->EnableAbilityRecovery(RestartFlag::ALWAYS_RESTART, SaveOccasionFlag::SAVE_WHEN_BACKGROUND,
202 SaveModeFlag::SAVE_WITH_FILE);
203 EXPECT_TRUE(abilityRecovery_->IsSaveAbilityState(StateReason::DEVELOPER_REQUEST));
204 EXPECT_TRUE(abilityRecovery_->IsSaveAbilityState(StateReason::LIFECYCLE));
205 }
206
207 /**
208 * @tc.name: IsSaveAbilityState_004
209 * @tc.desc: Test IsSaveAbilityState when state is support save.
210 * @tc.type: FUNC
211 * @tc.require: I5UL6H
212 */
213 HWTEST_F(AbilityRecoveryUnitTest, IsSaveAbilityState_004, TestSize.Level1)
214 {
215 abilityRecovery_->EnableAbilityRecovery(RestartFlag::ALWAYS_RESTART, SaveOccasionFlag::SAVE_WHEN_ERROR,
216 SaveModeFlag::SAVE_WITH_FILE);
217 EXPECT_TRUE(abilityRecovery_->IsSaveAbilityState(StateReason::CPP_CRASH));
218 EXPECT_TRUE(abilityRecovery_->IsSaveAbilityState(StateReason::JS_ERROR));
219 EXPECT_TRUE(abilityRecovery_->IsSaveAbilityState(StateReason::APP_FREEZE));
220 }
221
222 /**
223 * @tc.name: ScheduleSaveAbilityState_001
224 * @tc.desc: Test ScheduleSaveAbilityState when enableFlag is false.
225 * @tc.type: FUNC
226 * @tc.require: I5UL6H
227 */
228 HWTEST_F(AbilityRecoveryUnitTest, ScheduleSaveAbilityState_001, TestSize.Level1)
229 {
230 EXPECT_FALSE(abilityRecovery_->ScheduleSaveAbilityState(StateReason::DEVELOPER_REQUEST));
231 }
232
233 /**
234 * @tc.name: ScheduleSaveAbilityState_002
235 * @tc.desc: Test ScheduleSaveAbilityState when StateReason is not support save.
236 * @tc.type: FUNC
237 * @tc.require: I5UL6H
238 */
239 HWTEST_F(AbilityRecoveryUnitTest, ScheduleSaveAbilityState_002, TestSize.Level1)
240 {
241 abilityRecovery_->EnableAbilityRecovery(RestartFlag::ALWAYS_RESTART, SaveOccasionFlag::SAVE_WHEN_ERROR,
242 SaveModeFlag::SAVE_WITH_FILE);
243 EXPECT_FALSE(abilityRecovery_->ScheduleSaveAbilityState(StateReason::LIFECYCLE));
244 }
245
246 /**
247 * @tc.name: SaveAbilityState_001
248 * @tc.desc: Test SaveAbilityState when ability is nullptr.
249 * @tc.type: FUNC
250 * @tc.require: I5UL6H
251 */
252 HWTEST_F(AbilityRecoveryUnitTest, SaveAbilityState_001, TestSize.Level1)
253 {
254 abilityRecovery_->ability_.reset();
255 EXPECT_FALSE(abilityRecovery_->SaveAbilityState());
256 }
257
258 /**
259 * @tc.name: SaveAbilityState_002
260 * @tc.desc: Test SaveAbilityState when saveResult is not support save.
261 * @tc.type: FUNC
262 * @tc.require: I5UL6H
263 */
264 HWTEST_F(AbilityRecoveryUnitTest, SaveAbilityState_002, TestSize.Level1)
265 {
266 abilityRecovery_->ability_ = mockAbility2_;
267 EXPECT_FALSE(abilityRecovery_->SaveAbilityState());
268 }
269
270 /**
271 * @tc.name: SaveAbilityState_003
272 * @tc.desc: Test SaveAbilityState when pageStack is empty or not.
273 * @tc.type: FUNC
274 * @tc.require: I5UL6H
275 */
276 HWTEST_F(AbilityRecoveryUnitTest, SaveAbilityState_003, TestSize.Level1)
277 {
278 abilityRecovery_->ability_ = ability_;
279 EXPECT_TRUE(abilityRecovery_->SaveAbilityState());
280 abilityRecovery_->ability_ = mockAbility_;
281 EXPECT_TRUE(abilityRecovery_->SaveAbilityState());
282 }
283
284 /**
285 * @tc.name: SaveAbilityState_004
286 * @tc.desc: Test SaveAbilityState when SaveModeFlag is SAVE_WITH_FILE or SAVE_WITH_SHARED_MEMORY.
287 * @tc.type: FUNC
288 * @tc.require: I5UL6H
289 */
290 HWTEST_F(AbilityRecoveryUnitTest, SaveAbilityState_004, TestSize.Level1)
291 {
292 abilityRecovery_->EnableAbilityRecovery(RestartFlag::ALWAYS_RESTART, SaveOccasionFlag::SAVE_WHEN_ERROR,
293 SaveModeFlag::SAVE_WITH_FILE);
294 abilityRecovery_->ability_ = mockAbility_;
295 EXPECT_TRUE(abilityRecovery_->SaveAbilityState());
296 abilityRecovery_->EnableAbilityRecovery(RestartFlag::ALWAYS_RESTART, SaveOccasionFlag::SAVE_WHEN_ERROR,
297 SaveModeFlag::SAVE_WITH_SHARED_MEMORY);
298 EXPECT_TRUE(abilityRecovery_->SaveAbilityState());
299 }
300
301 /**
302 * @tc.name: ScheduleRecoverAbility_001
303 * @tc.desc: Test ScheduleRecoverAbility when enableFlag is false.
304 * @tc.type: FUNC
305 * @tc.require: I5UL6H
306 */
307 HWTEST_F(AbilityRecoveryUnitTest, ScheduleRecoverAbility_001, TestSize.Level1)
308 {
309 EXPECT_FALSE(abilityRecovery_->ScheduleRecoverAbility(StateReason::DEVELOPER_REQUEST));
310 }
311
312 /**
313 * @tc.name: ScheduleRecoverAbility_002
314 * @tc.desc: Test ScheduleRecoverAbility when token is nullptr.
315 * @tc.type: FUNC
316 * @tc.require: I5UL6H
317 */
318 HWTEST_F(AbilityRecoveryUnitTest, ScheduleRecoverAbility_002, TestSize.Level1)
319 {
320 abilityRecovery_->EnableAbilityRecovery(RestartFlag::ALWAYS_RESTART, SaveOccasionFlag::SAVE_WHEN_ERROR,
321 SaveModeFlag::SAVE_WITH_FILE);
322 token_ = nullptr;
323 EXPECT_FALSE(abilityRecovery_->ScheduleRecoverAbility(StateReason::DEVELOPER_REQUEST));
324 }
325
326 /**
327 * @tc.name: ScheduleRecoverAbility_003
328 * @tc.desc: Test ScheduleRecoverAbility check the ret as expected.
329 * @tc.type: FUNC
330 * @tc.require: I5UL6H
331 */
332 HWTEST_F(AbilityRecoveryUnitTest, ScheduleRecoverAbility_003, TestSize.Level1)
333 {
334 abilityRecovery_->EnableAbilityRecovery(RestartFlag::ALWAYS_RESTART, SaveOccasionFlag::SAVE_WHEN_ERROR,
335 SaveModeFlag::SAVE_WITH_FILE);
336 token_ = new MockAbilityToken();
337 abilityRecovery_->token_ = token_;
338 EXPECT_TRUE(abilityRecovery_->ScheduleRecoverAbility(StateReason::DEVELOPER_REQUEST));
339 }
340
341 /**
342 * @tc.name: ScheduleRestoreAbilityState_001
343 * @tc.desc: Test ScheduleRestoreAbilityState when enableFlag is false.
344 * @tc.type: FUNC
345 * @tc.require: I5UL6H
346 */
347 HWTEST_F(AbilityRecoveryUnitTest, ScheduleRestoreAbilityState_001, TestSize.Level1)
348 {
349 EXPECT_FALSE(abilityRecovery_->ScheduleRestoreAbilityState(StateReason::DEVELOPER_REQUEST, want_));
350 }
351
352 /**
353 * @tc.name: ScheduleRestoreAbilityState_002
354 * @tc.desc: Test ScheduleRestoreAbilityState when StateReason is not support save.
355 * @tc.type: FUNC
356 * @tc.require: I5UL6H
357 */
358 HWTEST_F(AbilityRecoveryUnitTest, ScheduleRestoreAbilityState_002, TestSize.Level1)
359 {
360 abilityRecovery_->EnableAbilityRecovery(RestartFlag::ALWAYS_RESTART, SaveOccasionFlag::SAVE_WHEN_ERROR,
361 SaveModeFlag::SAVE_WITH_FILE);
362 EXPECT_FALSE(abilityRecovery_->ScheduleRestoreAbilityState(StateReason::LIFECYCLE, want_));
363 }
364
365 /**
366 * @tc.name: ScheduleRestoreAbilityState_003
367 * @tc.desc: Test ScheduleRestoreAbilityState when no saved state.
368 * @tc.type: FUNC
369 * @tc.require: I5UL6H
370 */
371 HWTEST_F(AbilityRecoveryUnitTest, ScheduleRestoreAbilityState_003, TestSize.Level1)
372 {
373 abilityRecovery_->EnableAbilityRecovery(RestartFlag::ALWAYS_RESTART, SaveOccasionFlag::SAVE_WHEN_ERROR,
374 SaveModeFlag::SAVE_WITH_FILE);
375 abilityRecovery_->abilityInfo_.reset();
376 EXPECT_FALSE(abilityRecovery_->ScheduleRestoreAbilityState(StateReason::CPP_CRASH, want_));
377 }
378
379 /**
380 * @tc.name: ScheduleRestoreAbilityState_004
381 * @tc.desc: Test ScheduleRestoreAbilityState check the ret as expected.
382 * @tc.require: I5UL6H
383 */
384 HWTEST_F(AbilityRecoveryUnitTest, ScheduleRestoreAbilityState_004, TestSize.Level1)
385 {
386 abilityRecovery_->EnableAbilityRecovery(RestartFlag::ALWAYS_RESTART, SaveOccasionFlag::SAVE_WHEN_ERROR,
387 SaveModeFlag::SAVE_WITH_SHARED_MEMORY);
388 abilityRecovery_->hasTryLoad_ = true;
389 abilityRecovery_->hasLoaded_ = true;
390 EXPECT_TRUE(abilityRecovery_->ScheduleRestoreAbilityState(StateReason::CPP_CRASH, want_));
391 }
392
393 /**
394 * @tc.name: LoadSavedState_001
395 * @tc.desc: Test LoadSavedState when abilityInfo is nullptr.
396 * @tc.type: FUNC
397 * @tc.require: I5UL6H
398 */
399 HWTEST_F(AbilityRecoveryUnitTest, LoadSavedState_001, TestSize.Level1)
400 {
401 abilityRecovery_->abilityInfo_.reset();
402 EXPECT_FALSE(abilityRecovery_->LoadSavedState(StateReason::DEVELOPER_REQUEST));
403 }
404
405 /**
406 * @tc.name: LoadSavedState_002
407 * @tc.desc: Test LoadSavedState when load twice.
408 * @tc.type: FUNC
409 * @tc.require: I5UL6H
410 */
411 HWTEST_F(AbilityRecoveryUnitTest, LoadSavedState_002, TestSize.Level1)
412 {
413 abilityRecovery_->hasTryLoad_ = true;
414 EXPECT_FALSE(abilityRecovery_->LoadSavedState(StateReason::DEVELOPER_REQUEST));
415 }
416
417 /**
418 * @tc.name: LoadSavedState_003
419 * @tc.desc: Test LoadSavedState when hasTryLoad is false.
420 * @tc.type: FUNC
421 * @tc.require: I5UL6H
422 */
423 HWTEST_F(AbilityRecoveryUnitTest, LoadSavedState_003, TestSize.Level1)
424 {
425 abilityRecovery_->hasTryLoad_ = false;
426 EXPECT_FALSE(abilityRecovery_->LoadSavedState(StateReason::DEVELOPER_REQUEST));
427 }
428
429 /**
430 * @tc.name: GetSavedPageStack_001
431 * @tc.desc: Test GetSavedPageStack when no saved state.
432 * @tc.type: FUNC
433 * @tc.require: I5UL6H
434 */
435 HWTEST_F(AbilityRecoveryUnitTest, GetSavedPageStack_001, TestSize.Level1)
436 {
437 abilityRecovery_->hasTryLoad_ = true;
438 abilityRecovery_->EnableAbilityRecovery(RestartFlag::ALWAYS_RESTART, SaveOccasionFlag::SAVE_WHEN_ERROR,
439 SaveModeFlag::SAVE_WITH_SHARED_MEMORY);
440 EXPECT_EQ(abilityRecovery_->GetSavedPageStack(StateReason::DEVELOPER_REQUEST), "");
441 }
442
443 /**
444 * @tc.name: GetSavedPageStack_002
445 * @tc.desc: Test GetSavedPageStack when pageStack is empty.
446 * @tc.type: FUNC
447 * @tc.require: I5UL6H
448 */
449 HWTEST_F(AbilityRecoveryUnitTest, GetSavedPageStack_002, TestSize.Level1)
450 {
451 abilityRecovery_->hasTryLoad_ = true;
452 abilityRecovery_->hasLoaded_ = true;
453 abilityRecovery_->EnableAbilityRecovery(RestartFlag::ALWAYS_RESTART, SaveOccasionFlag::SAVE_WHEN_ERROR,
454 SaveModeFlag::SAVE_WITH_SHARED_MEMORY);
455 EXPECT_EQ(abilityRecovery_->GetSavedPageStack(StateReason::DEVELOPER_REQUEST), "");
456 }
457
458 /**
459 * @tc.name: GetSavedPageStack_003
460 * @tc.desc: Test GetSavedPageStack check the ret as expected.
461 * @tc.type: FUNC
462 * @tc.require: I5UL6H
463 */
464 HWTEST_F(AbilityRecoveryUnitTest, GetSavedPageStack_003, TestSize.Level1)
465 {
466 abilityRecovery_->hasTryLoad_ = true;
467 abilityRecovery_->hasLoaded_ = true;
468 abilityRecovery_->pageStack_ = "test";
469 abilityRecovery_->EnableAbilityRecovery(RestartFlag::ALWAYS_RESTART, SaveOccasionFlag::SAVE_WHEN_ERROR,
470 SaveModeFlag::SAVE_WITH_SHARED_MEMORY);
471 EXPECT_EQ(abilityRecovery_->GetSavedPageStack(StateReason::DEVELOPER_REQUEST), "test");
472 }
473
474 /**
475 * @tc.name: GetToken_001
476 * @tc.desc: Test GetToken check the ret as expected.
477 * @tc.type: FUNC
478 * @tc.require: I5UL6H
479 */
480 HWTEST_F(AbilityRecoveryUnitTest, GetToken_001, TestSize.Level1)
481 {
482 EXPECT_EQ(abilityRecovery_->GetToken(), abilityRecovery_->token_);
483 }
484
485 /**
486 * @tc.name: PersistAppState_001
487 * @tc.desc: Test PersistAppState when abilityInfo is nullptr.
488 * @tc.type: FUNC
489 * @tc.require: I5Z7LE
490 */
491 HWTEST_F(AbilityRecoveryUnitTest, PersistAppState_001, TestSize.Level1)
492 {
493 abilityRecovery_->abilityInfo_.reset();
494 EXPECT_FALSE(abilityRecovery_->PersistState());
495 }
496
497 /**
498 * @tc.name: PersistAppState_002
499 * @tc.desc: Test PersistAppState check the ret as expected.
500 * @tc.type: FUNC
501 * @tc.require: I5Z7LE
502 */
503 HWTEST_F(AbilityRecoveryUnitTest, PersistAppState_002, TestSize.Level1)
504 {
505 abilityRecovery_->abilityInfo_ = abilityInfo_;
506 EXPECT_TRUE(abilityRecovery_->PersistState());
507 abilityRecovery_->params_ = want_.GetParams();
508 int32_t natValue32 = 0;
509 abilityRecovery_->params_.SetParam("test", AAFwk::Integer::Box(natValue32));
510 EXPECT_TRUE(abilityRecovery_->PersistState());
511 }
512 } // namespace AppExecFwk
513 } // namespace OHOS
514