1 /*
2 * Copyright (c) 2022-2024 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 <cstdio>
17 #include <gtest/gtest.h>
18 #include <string>
19
20 #include "b_error/b_error.h"
21 #include "b_json/b_json_entity_ext_manage.h"
22 #include "ext_extension_mock.h"
23 #include "file_ex.h"
24 #include "module_ipc/service.h"
25 #include "module_ipc/svc_session_manager.h"
26 #include "service_reverse_mock.h"
27 #include "test_manager.h"
28
29 namespace OHOS::FileManagement::Backup {
30 using namespace testing;
31 using namespace std;
32
33 namespace {
34 const string BUNDLE_NAME = "com.example.app2backup";
35 const string MANAGE_JSON = "manage.json";
36 const string FILE_NAME = "1.tar";
37 constexpr int32_t SERVICE_ID = 5203;
38 constexpr int32_t CLIENT_TOKEN_ID = 100;
39 } // namespace
40
41 class SvcSessionManagerTest : public testing::Test {
42 public:
43 static void SetUpTestCase(void);
44 static void TearDownTestCase(void);
SetUp()45 void SetUp() override {};
TearDown()46 void TearDown() override {};
47 void Init(IServiceReverse::Scenario scenario);
48
49 static inline sptr<SvcSessionManager> sessionManagerPtr_ = nullptr;
50 static inline sptr<ServiceReverseMock> remote_ = nullptr;
51 static inline sptr<Service> servicePtr_ = nullptr;
52 };
53
SetUpTestCase(void)54 void SvcSessionManagerTest::SetUpTestCase(void)
55 {
56 GTEST_LOG_(INFO) << "SetUpTestCase enter";
57 remote_ = sptr(new ServiceReverseMock());
58 servicePtr_ = sptr(new Service(SERVICE_ID));
59 sessionManagerPtr_ = sptr<SvcSessionManager>(new SvcSessionManager(wptr(servicePtr_)));
60 }
61
TearDownTestCase(void)62 void SvcSessionManagerTest::TearDownTestCase(void)
63 {
64 GTEST_LOG_(INFO) << "TearDownTestCase enter";
65 sessionManagerPtr_ = nullptr;
66 servicePtr_ = nullptr;
67 remote_ = nullptr;
68 }
69
Init(IServiceReverse::Scenario scenario)70 void SvcSessionManagerTest::Init(IServiceReverse::Scenario scenario)
71 {
72 vector<string> bundleNames;
73 vector<string> failedBundles;
74 map<string, BackupExtInfo> backupExtNameMap;
75 bundleNames.emplace_back(BUNDLE_NAME);
76 EXPECT_TRUE(sessionManagerPtr_ != nullptr);
77 sessionManagerPtr_->Active(
78 {.clientToken = CLIENT_TOKEN_ID, .scenario = scenario, .backupExtNameMap = {}, .clientProxy = remote_});
79 sessionManagerPtr_->IsOnAllBundlesFinished();
80 sessionManagerPtr_->AppendBundles(bundleNames, failedBundles);
81 sessionManagerPtr_->Finish();
82 sessionManagerPtr_->IsOnAllBundlesFinished();
83 }
84
85 /**
86 * @tc.number: SUB_backup_sa_session_VerifyCallerAndScenario_0100
87 * @tc.name: SUB_backup_sa_session_VerifyCallerAndScenario_0100
88 * @tc.desc: 测试 VerifyCallerAndScenario 是否是有效的
89 * @tc.size: MEDIUM
90 * @tc.type: FUNC
91 * @tc.level Level 1
92 * @tc.require: I6F3GV
93 */
94 HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_VerifyCallerAndScenario_0100, testing::ext::TestSize.Level1)
95 {
96 GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_VerifyCallerAndScenario_0100";
97 try {
98 EXPECT_TRUE(sessionManagerPtr_ != nullptr);
99 sessionManagerPtr_->impl_.scenario = IServiceReverse::Scenario::BACKUP;
100 ErrCode ret = sessionManagerPtr_->VerifyCallerAndScenario(CLIENT_TOKEN_ID,
101 IServiceReverse::Scenario::RESTORE);
102 EXPECT_TRUE(ret == BError(BError::Codes::SDK_MIXED_SCENARIO).GetCode());
103
104 sessionManagerPtr_->impl_.scenario = IServiceReverse::Scenario::BACKUP;
105 sessionManagerPtr_->impl_.clientToken = 0;
106 ret = sessionManagerPtr_->VerifyCallerAndScenario(CLIENT_TOKEN_ID, IServiceReverse::Scenario::BACKUP);
107 EXPECT_TRUE(ret == BError(BError::Codes::SA_REFUSED_ACT).GetCode());
108
109 sessionManagerPtr_->impl_.scenario = IServiceReverse::Scenario::BACKUP;
110 sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID;
111 ret = sessionManagerPtr_->VerifyCallerAndScenario(CLIENT_TOKEN_ID, IServiceReverse::Scenario::BACKUP);
112 EXPECT_TRUE(ret == ERR_OK);
113 } catch (...) {
114 EXPECT_TRUE(false);
115 GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by VerifyCallerAndScenario.";
116 }
117 GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_VerifyCallerAndScenario_0100";
118 }
119
120 /**
121 * @tc.number: SUB_backup_sa_session_Active_0100
122 * @tc.name: SUB_backup_sa_session_Active_0100
123 * @tc.desc: 测试 Active
124 * @tc.size: MEDIUM
125 * @tc.type: FUNC
126 * @tc.level Level 1
127 * @tc.require: I6F3GV
128 */
129 HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_Active_0100, testing::ext::TestSize.Level1)
130 {
131 GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_Active_0100";
132 try {
133 SvcSessionManager::Impl newImpl;
134 EXPECT_TRUE(sessionManagerPtr_ != nullptr);
135 sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID;
136 auto res = sessionManagerPtr_->Active(newImpl);
137 EXPECT_EQ(res, BError(BError::Codes::SA_SESSION_CONFLICT).GetCode());
138
139 sessionManagerPtr_->impl_.clientToken = 0;
140 res = sessionManagerPtr_->Active(newImpl);
141 EXPECT_EQ(res, BError(BError::Codes::SA_INVAL_ARG).GetCode());
142
143 newImpl.clientToken = CLIENT_TOKEN_ID;
144 newImpl.scenario = IServiceReverse::Scenario::UNDEFINED;
145 sessionManagerPtr_->impl_.clientToken = 0;
146 res = sessionManagerPtr_->Active(newImpl);
147 EXPECT_EQ(res, BError(BError::Codes::SA_INVAL_ARG).GetCode());
148
149 newImpl.clientToken = CLIENT_TOKEN_ID;
150 newImpl.scenario = IServiceReverse::Scenario::BACKUP;
151 newImpl.clientProxy = nullptr;
152 sessionManagerPtr_->impl_.clientToken = 0;
153 res = sessionManagerPtr_->Active(newImpl);
154 EXPECT_EQ(res, BError(BError::Codes::SA_INVAL_ARG).GetCode());
155 } catch (...) {
156 EXPECT_TRUE(false);
157 GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by Active.";
158 }
159 GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_Active_0100";
160 }
161
162 /**
163 * @tc.number: SUB_backup_sa_session_Deactive_0100
164 * @tc.name: SUB_backup_sa_session_Deactive_0100
165 * @tc.desc: 测试 Deactive
166 * @tc.size: MEDIUM
167 * @tc.type: FUNC
168 * @tc.level Level 1
169 * @tc.require: I6F3GV
170 */
171 HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_Deactive_0100, testing::ext::TestSize.Level1)
172 {
173 GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_Deactive_0100";
174 try {
175 wptr<IRemoteObject> remoteInAction = nullptr;
176 EXPECT_TRUE(sessionManagerPtr_ != nullptr);
177 sessionManagerPtr_->impl_.clientToken = 0;
178 ErrCode ret = sessionManagerPtr_->Deactive(remoteInAction, false);
179 EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode());
180
181 sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID;
182 sessionManagerPtr_->impl_.clientProxy = nullptr;
183 ret = sessionManagerPtr_->Deactive(remoteInAction, false);
184 EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode());
185
186 sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID;
187 sessionManagerPtr_->impl_.clientProxy = remote_;
188 ret = sessionManagerPtr_->Deactive(remoteInAction, false);
189 EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode());
190
191 sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID;
192 sessionManagerPtr_->impl_.clientProxy = remote_;
193 ret = sessionManagerPtr_->Deactive(remoteInAction, true);
194 EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode());
195 } catch (...) {
196 EXPECT_TRUE(false);
197 GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by Deactive.";
198 }
199 GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_Deactive_0100";
200 }
201
202 /**
203 * @tc.number: SUB_backup_sa_session_VerifyBundleName_0100
204 * @tc.name: SUB_backup_sa_session_VerifyBundleName_0100
205 * @tc.desc: 测试 VerifyBundleName 检验调用者给定的bundleName是否是有效的
206 * @tc.size: MEDIUM
207 * @tc.type: FUNC
208 * @tc.level Level 1
209 * @tc.require: I6F3GV
210 */
211 HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_VerifyBundleName_0100, testing::ext::TestSize.Level1)
212 {
213 GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_VerifyBundleName_0100";
214 try {
215 string bundleName = BUNDLE_NAME;
216 EXPECT_TRUE(sessionManagerPtr_ != nullptr);
217 sessionManagerPtr_->impl_.clientToken = 0;
218 ErrCode ret = sessionManagerPtr_->VerifyBundleName(bundleName);
219 EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode());
220
221 sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID;
222 sessionManagerPtr_->impl_.backupExtNameMap.clear();
223 ret = sessionManagerPtr_->VerifyBundleName(bundleName);
224 EXPECT_EQ(ret, BError(BError::Codes::SA_REFUSED_ACT).GetCode());
225
226 sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID;
227 sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {};
228 ret = sessionManagerPtr_->VerifyBundleName(bundleName);
229 EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode());
230 } catch (...) {
231 EXPECT_TRUE(false);
232 GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by VerifyBundleName.";
233 }
234 GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_VerifyBundleName_0100";
235 }
236
237 /**
238 * @tc.number: SUB_backup_sa_session_GetServiceReverseProxy_0100
239 * @tc.name: SUB_backup_sa_session_GetServiceReverseProxy_0100
240 * @tc.desc: 测试 GetServiceReverseProxy
241 * @tc.size: MEDIUM
242 * @tc.type: FUNC
243 * @tc.level Level 1
244 * @tc.require: I6F3GV
245 */
246 HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetServiceReverseProxy_0100, testing::ext::TestSize.Level1)
247 {
248 GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_GetServiceReverseProxy_0100";
249 try {
250 try {
251 EXPECT_TRUE(sessionManagerPtr_ != nullptr);
252 sessionManagerPtr_->impl_.clientProxy = nullptr;
253 sessionManagerPtr_->GetServiceReverseProxy();
254 EXPECT_TRUE(false);
255 } catch (BError &err) {
256 EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_REFUSED_ACT);
257 }
258
259 sessionManagerPtr_->impl_.clientProxy = remote_;
260 auto proxy = sessionManagerPtr_->GetServiceReverseProxy();
261 EXPECT_EQ(reinterpret_cast<long long>(proxy.GetRefPtr()),
262 reinterpret_cast<long long>(sessionManagerPtr_->impl_.clientProxy.GetRefPtr()));
263 } catch (...) {
264 EXPECT_TRUE(false);
265 GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by GetServiceReverseProxy.";
266 }
267 GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_GetServiceReverseProxy_0100";
268 }
269
270 /**
271 * @tc.number: SUB_backup_sa_session_getscenario_0100
272 * @tc.name: SUB_backup_sa_session_getscenario_0100
273 * @tc.desc: 测试 GetScenario 接口
274 * @tc.size: MEDIUM
275 * @tc.type: FUNC
276 * @tc.level Level 1
277 * @tc.require: I6F3GV
278 */
279 HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_getscenario_0100, testing::ext::TestSize.Level1)
280 {
281 GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_getscenario_0100";
282 try {
283 EXPECT_TRUE(sessionManagerPtr_ != nullptr);
284 sessionManagerPtr_->impl_.clientToken = 0;
285 IServiceReverse::Scenario scenario = sessionManagerPtr_->GetScenario();
286 EXPECT_TRUE(scenario == IServiceReverse::Scenario::UNDEFINED);
287
288 sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID;
289 scenario = sessionManagerPtr_->GetScenario();
290 EXPECT_TRUE(scenario == IServiceReverse::Scenario::UNDEFINED);
291 } catch (...) {
292 EXPECT_TRUE(false);
293 GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by getscenario.";
294 }
295 GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_getscenario_0100";
296 }
297
298 /**
299 * @tc.number: SUB_backup_sa_session_onBundlefileready_0100
300 * @tc.name: SUB_backup_sa_session_onBundlefileready_0100
301 * @tc.desc: 测试 OnBundleFileReady 接口 restore流程
302 * @tc.size: MEDIUM
303 * @tc.type: FUNC
304 * @tc.level Level 1
305 * @tc.require: I6F3GV
306 */
307 HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_onBundlefileready_0100, testing::ext::TestSize.Level1)
308 {
309 GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_onBundlefileready_0100";
310 EXPECT_TRUE(sessionManagerPtr_ != nullptr);
311 sessionManagerPtr_->impl_.clientToken = 0;
312 bool fileReady = sessionManagerPtr_->OnBundleFileReady(BUNDLE_NAME);
313 EXPECT_FALSE(fileReady);
314
315 sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID;
316 sessionManagerPtr_->impl_.backupExtNameMap.clear();
317 fileReady = sessionManagerPtr_->OnBundleFileReady(BUNDLE_NAME);
318 EXPECT_FALSE(fileReady);
319
320 sessionManagerPtr_->impl_.backupExtNameMap.clear();
321 sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID;
322 sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {};
323 sessionManagerPtr_->impl_.scenario = IServiceReverse::Scenario::RESTORE;
324 fileReady = sessionManagerPtr_->OnBundleFileReady(BUNDLE_NAME);
325 EXPECT_TRUE(fileReady);
326
327 sessionManagerPtr_->impl_.backupExtNameMap.clear();
328 sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID;
329 sessionManagerPtr_->impl_.backupExtNameMap["123"] = {};
330 sessionManagerPtr_->impl_.scenario = IServiceReverse::Scenario::BACKUP;
331 fileReady = sessionManagerPtr_->OnBundleFileReady("123");
332 EXPECT_TRUE(fileReady);
333
334 sessionManagerPtr_->impl_.backupExtNameMap.clear();
335 sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID;
336 sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {};
337 sessionManagerPtr_->impl_.scenario = IServiceReverse::Scenario::UNDEFINED;
338 fileReady = sessionManagerPtr_->OnBundleFileReady(BUNDLE_NAME);
339 EXPECT_FALSE(fileReady);
340 GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_onBundlefileready_0100";
341 }
342
343 /**
344 * @tc.number: SUB_backup_sa_session_onBundlefileready_0101
345 * @tc.name: SUB_backup_sa_session_onBundlefileready_0101
346 * @tc.desc: 测试 OnBundleFileReady 接口 restore流程
347 * @tc.size: MEDIUM
348 * @tc.type: FUNC
349 * @tc.level Level 1
350 * @tc.require: I6F3GV
351 */
352 HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_onBundlefileready_0101, testing::ext::TestSize.Level1)
353 {
354 GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_onBundlefileready_0101";
355 EXPECT_TRUE(sessionManagerPtr_ != nullptr);
356 sessionManagerPtr_->impl_.backupExtNameMap.clear();
357 sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID;
358 sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {};
359 sessionManagerPtr_->impl_.scenario = IServiceReverse::Scenario::BACKUP;
360 bool fileReady = sessionManagerPtr_->OnBundleFileReady(BUNDLE_NAME, "");
361 EXPECT_FALSE(fileReady);
362
363 sessionManagerPtr_->impl_.backupExtNameMap.clear();
364 sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID;
365 sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {};
366 sessionManagerPtr_->impl_.scenario = IServiceReverse::Scenario::BACKUP;
367 fileReady = sessionManagerPtr_->OnBundleFileReady(BUNDLE_NAME, "test");
368 EXPECT_FALSE(fileReady);
369
370 sessionManagerPtr_->impl_.backupExtNameMap.clear();
371 sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID;
372 sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {};
373 sessionManagerPtr_->impl_.scenario = IServiceReverse::Scenario::BACKUP;
374 fileReady = sessionManagerPtr_->OnBundleFileReady(BUNDLE_NAME, string(BConstants::EXT_BACKUP_MANAGE));
375 EXPECT_FALSE(fileReady);
376
377 BackupExtInfo info;
378 info.receExtManageJson = true;
379 sessionManagerPtr_->impl_.backupExtNameMap.clear();
380 sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID;
381 sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = info;
382 fileReady = sessionManagerPtr_->OnBundleFileReady(BUNDLE_NAME, "");
383 EXPECT_TRUE(fileReady);
384 GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_onBundlefileready_0101";
385 }
386
387 /**
388 * @tc.number: SUB_backup_sa_session_OnBundleExtManageInfo_0100
389 * @tc.name: SUB_backup_sa_session_OnBundleExtManageInfo_0100
390 * @tc.desc: 测试 OnBundleExtManageInfo
391 * @tc.size: MEDIUM
392 * @tc.type: FUNC
393 * @tc.level Level 1
394 * @tc.require: I6F3GV
395 */
396 HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_OnBundleExtManageInfo_0100, testing::ext::TestSize.Level1)
397 {
398 GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_OnBundleExtManageInfo_0100";
399 EXPECT_TRUE(sessionManagerPtr_ != nullptr);
400 sessionManagerPtr_->impl_.clientToken = 0;
401 auto ret = sessionManagerPtr_->OnBundleExtManageInfo(BUNDLE_NAME, UniqueFd(-1));
402 EXPECT_TRUE(move(ret) == -1);
403
404 sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID;
405 sessionManagerPtr_->impl_.scenario = IServiceReverse::Scenario::RESTORE;
406 ret = sessionManagerPtr_->OnBundleExtManageInfo(BUNDLE_NAME, UniqueFd(-1));
407 EXPECT_TRUE(move(ret) == -1);
408
409 TestManager tm("SvcSessionManagerTest_GetFd_0100");
410 string filePath = tm.GetRootDirCurTest().append(MANAGE_JSON);
411 SaveStringToFile(filePath, R"({"fileName" : "1.tar"})");
412 UniqueFd fd(open(filePath.data(), O_RDWR | O_CREAT, S_IRUSR | S_IWUSR));
413 sessionManagerPtr_->OnBundleExtManageInfo(BUNDLE_NAME, move(fd));
414 bool fileReady = sessionManagerPtr_->OnBundleFileReady(BUNDLE_NAME);
415 EXPECT_TRUE(fileReady);
416 fileReady = sessionManagerPtr_->OnBundleFileReady(BUNDLE_NAME, FILE_NAME);
417 EXPECT_TRUE(fileReady);
418 fileReady = sessionManagerPtr_->OnBundleFileReady(BUNDLE_NAME, MANAGE_JSON);
419 EXPECT_TRUE(fileReady);
420 fileReady = sessionManagerPtr_->OnBundleFileReady(BUNDLE_NAME, FILE_NAME);
421 EXPECT_TRUE(fileReady);
422 GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_OnBundleExtManageInfo_0100";
423 }
424
425 /**
426 * @tc.number: SUB_backup_sa_session_GetBackupAbilityExt_0100
427 * @tc.name: SUB_backup_sa_session_GetBackupAbilityExt_0100
428 * @tc.desc: 测试 GetBackupAbilityExt 接口
429 * @tc.size: MEDIUM
430 * @tc.type: FUNC
431 * @tc.level Level 1
432 * @tc.require: I6F3GV
433 */
434 HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetBackupAbilityExt_0100, testing::ext::TestSize.Level1)
435 {
436 GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_GetBackupAbilityExt_0100";
437 try {
438 EXPECT_TRUE(sessionManagerPtr_ != nullptr);
439 sessionManagerPtr_->reversePtr_ = nullptr;
440 auto ret = sessionManagerPtr_->GetBackupAbilityExt(BUNDLE_NAME);
441 ret->callDied_("", false);
442 ret->callConnected_("");
443 EXPECT_TRUE(true);
444
445 sessionManagerPtr_->reversePtr_ = servicePtr_;
446 ret = sessionManagerPtr_->GetBackupAbilityExt(BUNDLE_NAME);
447 ret->callDied_("", false);
448 ret->callConnected_("");
449 EXPECT_TRUE(true);
450 } catch (...) {
451 EXPECT_TRUE(false);
452 GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by GetBackupAbilityExt.";
453 }
454 GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_GetBackupAbilityExt_0100";
455 }
456
457 /**
458 * @tc.number: SUB_backup_sa_session_GetBackupSAExt_0100
459 * @tc.name: SUB_backup_sa_session_GetBackupSAExt_0100
460 * @tc.desc: 测试 GetBackupSAExt 接口
461 * @tc.size: MEDIUM
462 * @tc.type: FUNC
463 * @tc.level Level 1
464 * @tc.require: I6F3GV
465 */
466 HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetBackupSAExt_0100, testing::ext::TestSize.Level1)
467 {
468 GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_GetBackupSAExt_0100";
469 try {
470 EXPECT_TRUE(sessionManagerPtr_ != nullptr);
471 sessionManagerPtr_->reversePtr_ = nullptr;
472 auto ret = sessionManagerPtr_->GetBackupSAExt(BUNDLE_NAME);
473 ret->callDied_("");
474 ret->callConnected_("");
475 ret->callBackup_("", 0, "", BError(BError::Codes::OK));
476 ret->callRestore_("", "", BError(BError::Codes::OK));
477 EXPECT_TRUE(true);
478
479 sessionManagerPtr_->reversePtr_ = servicePtr_;
480 ret = sessionManagerPtr_->GetBackupSAExt(BUNDLE_NAME);
481 ret->callDied_("");
482 ret->callConnected_("");
483 ret->callBackup_("", 0, "", BError(BError::Codes::OK));
484 ret->callRestore_("", "", BError(BError::Codes::OK));
485 EXPECT_TRUE(true);
486 } catch (...) {
487 EXPECT_TRUE(false);
488 GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by GetBackupSAExt.";
489 }
490 GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_GetBackupSAExt_0100";
491 }
492
493 /**
494 * @tc.number: SUB_backup_sa_session_InitClient_0100
495 * @tc.name: SUB_backup_sa_session_InitClient_0100
496 * @tc.desc: 测试 InitClient 接口
497 * @tc.size: MEDIUM
498 * @tc.type: FUNC
499 * @tc.level Level 1
500 * @tc.require: I6F3GV
501 */
502 HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_InitClient_0100, testing::ext::TestSize.Level1)
503 {
504 GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_InitClient_0100";
505 try {
506 SvcSessionManager::Impl newImpl;
507 newImpl.clientProxy = nullptr;
508 EXPECT_TRUE(sessionManagerPtr_ != nullptr);
509 ErrCode ret = sessionManagerPtr_->InitClient(newImpl);
510 EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode());
511
512 newImpl.clientProxy = remote_;
513 ret = sessionManagerPtr_->InitClient(newImpl);
514 EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode());
515 } catch (...) {
516 EXPECT_TRUE(false);
517 GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by InitClient.";
518 }
519 GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_InitClient_0100";
520 }
521
522 /**
523 * @tc.number: SUB_backup_sa_session_GetExtFileNameRequest_0100
524 * @tc.name: SUB_backup_sa_session_GetExtFileNameRequest_0100
525 * @tc.desc: 测试 GetExtFileNameRequest 获取暂存真实文件请求
526 * @tc.size: MEDIUM
527 * @tc.type: FUNC
528 * @tc.level Level 1
529 * @tc.require: I6F3GV
530 */
531 HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetExtFileNameRequest_0100, testing::ext::TestSize.Level1)
532 {
533 GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_GetExtFileNameRequest_0100";
534 try {
535 EXPECT_TRUE(sessionManagerPtr_ != nullptr);
536 sessionManagerPtr_->impl_.clientToken = 0;
537 sessionManagerPtr_->SetExtFileNameRequest(BUNDLE_NAME, FILE_NAME);
538 EXPECT_TRUE(true);
539
540 sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID;
541 sessionManagerPtr_->impl_.backupExtNameMap.clear();
542 sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {};
543 sessionManagerPtr_->SetExtFileNameRequest(BUNDLE_NAME, FILE_NAME);
544 EXPECT_EQ(sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME].fileNameInfo.size(), 1);
545 EXPECT_EQ(*(sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME].fileNameInfo.begin()), FILE_NAME);
546 } catch (...) {
547 EXPECT_TRUE(false);
548 GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by GetExtFileNameRequest.";
549 }
550 GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_GetExtFileNameRequest_0100";
551 }
552
553 /**
554 * @tc.number: SUB_backup_sa_session_GetExtFileNameRequest_0101
555 * @tc.name: SUB_backup_sa_session_GetExtFileNameRequest_0101
556 * @tc.desc: 测试 GetExtFileNameRequest 获取暂存真实文件请求
557 * @tc.size: MEDIUM
558 * @tc.type: FUNC
559 * @tc.level Level 1
560 * @tc.require: I6F3GV
561 */
562 HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetExtFileNameRequest_0101, testing::ext::TestSize.Level1)
563 {
564 GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_GetExtFileNameRequest_0101";
565 EXPECT_TRUE(sessionManagerPtr_ != nullptr);
566 sessionManagerPtr_->impl_.clientToken = 0;
567 auto fileNameSet = sessionManagerPtr_->GetExtFileNameRequest(BUNDLE_NAME);
568 EXPECT_TRUE(fileNameSet.empty());
569 GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_GetExtFileNameRequest_0101";
570 }
571
572 /**
573 * @tc.number: SUB_backup_sa_session_GetExtFileNameRequest_0102
574 * @tc.name: SUB_backup_sa_session_GetExtFileNameRequest_0102
575 * @tc.desc: 测试 GetExtFileNameRequest 获取暂存真实文件请求
576 * @tc.size: MEDIUM
577 * @tc.type: FUNC
578 * @tc.level Level 1
579 * @tc.require: I6F3GV
580 */
581 HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetExtFileNameRequest_0102, testing::ext::TestSize.Level1)
582 {
583 GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_GetExtFileNameRequest_0102";
584 EXPECT_TRUE(sessionManagerPtr_ != nullptr);
585 sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID;
586 sessionManagerPtr_->impl_.scenario = IServiceReverse::Scenario::UNDEFINED;
587 auto fileNameSet = sessionManagerPtr_->GetExtFileNameRequest(BUNDLE_NAME);
588 EXPECT_TRUE(fileNameSet.empty());
589 GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_GetExtFileNameRequest_0102";
590 }
591
592 /**
593 * @tc.number: SUB_backup_sa_session_GetExtFileNameRequest_0103
594 * @tc.name: SUB_backup_sa_session_GetExtFileNameRequest_0103
595 * @tc.desc: 测试 GetExtFileNameRequest 获取暂存真实文件请求
596 * @tc.size: MEDIUM
597 * @tc.type: FUNC
598 * @tc.level Level 1
599 * @tc.require: I6F3GV
600 */
601 HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetExtFileNameRequest_0103, testing::ext::TestSize.Level1)
602 {
603 GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_GetExtFileNameRequest_0103";
604 EXPECT_TRUE(sessionManagerPtr_ != nullptr);
605 sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID;
606 sessionManagerPtr_->impl_.scenario = IServiceReverse::Scenario::RESTORE;
607 auto fileNameSet = sessionManagerPtr_->GetExtFileNameRequest(BUNDLE_NAME);
608 EXPECT_FALSE(fileNameSet.empty());
609 GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_GetExtFileNameRequest_0103";
610 }
611
612 /**
613 * @tc.number: SUB_backup_sa_session_GetExtConnection_0100
614 * @tc.name: SUB_backup_sa_session_GetExtConnection_0100
615 * @tc.desc: 测试 GetExtConnection 接口
616 * @tc.size: MEDIUM
617 * @tc.type: FUNC
618 * @tc.level Level 1
619 * @tc.require: I6F3GV
620 */
621 HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetExtConnection_0100, testing::ext::TestSize.Level1)
622 {
623 GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_GetExtConnection_0100";
624 EXPECT_TRUE(sessionManagerPtr_ != nullptr);
625 sessionManagerPtr_->impl_.clientToken = 0;
626 auto connection = sessionManagerPtr_->GetExtConnection(BUNDLE_NAME);
627 EXPECT_TRUE(connection == nullptr);
628
629 sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID;
630 sessionManagerPtr_->impl_.backupExtNameMap.clear();
631 connection = sessionManagerPtr_->GetExtConnection(BUNDLE_NAME);
632 EXPECT_TRUE(connection == nullptr);
633
634 sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID;
635 sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {};
636 connection = sessionManagerPtr_->GetExtConnection(BUNDLE_NAME);
637 EXPECT_TRUE(connection == nullptr);
638
639 BackupExtInfo info;
640 info.backUpConnection = sptr(new SvcBackupConnection(nullptr, nullptr, BUNDLE_NAME));
641 sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID;
642 sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = info;
643 connection = sessionManagerPtr_->GetExtConnection(BUNDLE_NAME);
644 EXPECT_EQ(reinterpret_cast<long long>(connection.GetRefPtr()),
645 reinterpret_cast<long long>(info.backUpConnection.GetRefPtr()));
646 GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_GetExtConnection_0100";
647 }
648
649 /**
650 * @tc.number: SUB_backup_sa_session_GetSAExtConnection_0100
651 * @tc.name: SUB_backup_sa_session_GetSAExtConnection_0100
652 * @tc.desc: 测试 GetSAExtConnection 接口
653 * @tc.size: MEDIUM
654 * @tc.type: FUNC
655 * @tc.level Level 1
656 * @tc.require: I6F3GV
657 */
658 HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetSAExtConnection_0100, testing::ext::TestSize.Level1)
659 {
660 GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_GetSAExtConnection_0100";
661 EXPECT_TRUE(sessionManagerPtr_ != nullptr);
662 sessionManagerPtr_->impl_.clientToken = 0;
663 auto tempConnPtr = sessionManagerPtr_->GetSAExtConnection(BUNDLE_NAME);
664 auto backupConnPtr = tempConnPtr.lock();
665 EXPECT_TRUE(backupConnPtr == nullptr);
666
667 sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID;
668 sessionManagerPtr_->impl_.backupExtNameMap.clear();
669 tempConnPtr = sessionManagerPtr_->GetSAExtConnection(BUNDLE_NAME);
670 backupConnPtr = tempConnPtr.lock();
671 EXPECT_TRUE(backupConnPtr == nullptr);
672
673 sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID;
674 sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {};
675 tempConnPtr = sessionManagerPtr_->GetSAExtConnection(BUNDLE_NAME);
676 backupConnPtr = tempConnPtr.lock();
677 EXPECT_TRUE(backupConnPtr == nullptr);
678
679 BackupExtInfo info;
680 info.saBackupConnection = make_shared<SABackupConnection>(nullptr, nullptr, nullptr, nullptr);
681 sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID;
682 sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = info;
683 auto ret = sessionManagerPtr_->GetSAExtConnection(BUNDLE_NAME).lock();
684 EXPECT_EQ(reinterpret_cast<long long>(ret.get()), reinterpret_cast<long long>(info.saBackupConnection.get()));
685 GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_GetSAExtConnection_0100";
686 }
687
688 /**
689 * @tc.number: SUB_backup_sa_session_DumpInfo_0100
690 * @tc.name: SUB_backup_sa_session_DumpInfo_0100
691 * @tc.desc: 测试 DumpInfo 接口
692 * @tc.size: MEDIUM
693 * @tc.type: FUNC
694 * @tc.level Level 1
695 * @tc.require: I6F3GV
696 */
697 HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_DumpInfo_0100, testing::ext::TestSize.Level1)
698 {
699 GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_DumpInfo_0100";
700 try {
701 TestManager tm("SvcSessionManagerTest_GetFd_0100");
702 string fileUri = tm.GetRootDirCurTest().append(FILE_NAME);
703 UniqueFd fd(open(fileUri.data(), O_RDONLY | O_CREAT, S_IRUSR | S_IWUSR));
704 EXPECT_TRUE(sessionManagerPtr_ != nullptr);
705 sessionManagerPtr_->DumpInfo(fd, {});
706 } catch (...) {
707 EXPECT_TRUE(false);
708 GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by DumpInfo.";
709 }
710 GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_DumpInfo_0100";
711 }
712
713 /**
714 * @tc.number: SUB_backup_sa_session_GetSchedBundleName_0100
715 * @tc.name: SUB_backup_sa_session_GetSchedBundleName_0100
716 * @tc.desc: 测试 GetSchedBundleName 调度器获取所需要的调度信息
717 * @tc.size: MEDIUM
718 * @tc.type: FUNC
719 * @tc.level Level 1
720 * @tc.require: I6F3GV
721 */
722 HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetSchedBundleName_0100, testing::ext::TestSize.Level1)
723 {
724 GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_GetSchedBundleName_0100";
725 try {
726 string bundleName;
727 EXPECT_TRUE(sessionManagerPtr_ != nullptr);
728 sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID;
729 sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {};
730 sessionManagerPtr_->SetIsReadyLaunch(BUNDLE_NAME);
731 bool condition = sessionManagerPtr_->GetSchedBundleName(bundleName);
732 EXPECT_EQ(bundleName, BUNDLE_NAME);
733 EXPECT_TRUE(condition);
734 GTEST_LOG_(INFO) << "SvcSessionManagerTest-GetSchedBundleName Branches";
735 sessionManagerPtr_->SetServiceSchedAction(BUNDLE_NAME, BConstants::ServiceSchedAction::START);
736 condition = sessionManagerPtr_->GetSchedBundleName(bundleName);
737 EXPECT_FALSE(condition);
738 sessionManagerPtr_->SetServiceSchedAction(BUNDLE_NAME, BConstants::ServiceSchedAction::START);
739 sessionManagerPtr_->SetServiceSchedAction(BUNDLE_NAME, BConstants::ServiceSchedAction::START);
740 sessionManagerPtr_->SetServiceSchedAction(BUNDLE_NAME, BConstants::ServiceSchedAction::START);
741 condition = sessionManagerPtr_->GetSchedBundleName(bundleName);
742 EXPECT_FALSE(condition);
743 sessionManagerPtr_->SetServiceSchedAction(BUNDLE_NAME, BConstants::ServiceSchedAction::WAIT);
744 } catch (...) {
745 EXPECT_TRUE(false);
746 GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by GetSchedBundleName.";
747 }
748 GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_GetSchedBundleName_0100";
749 }
750
751 /**
752 * @tc.number: SUB_backup_sa_session_GetServiceSchedAction_0100
753 * @tc.name: SUB_backup_sa_session_GetServiceSchedAction_0100
754 * @tc.desc: 测试 GetServiceSchedAction 获取状态
755 * @tc.size: MEDIUM
756 * @tc.type: FUNC
757 * @tc.level Level 1
758 * @tc.require: I6F3GV
759 */
760 HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetServiceSchedAction_0100, testing::ext::TestSize.Level1)
761 {
762 GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_GetServiceSchedAction_0100";
763 try {
764 EXPECT_TRUE(sessionManagerPtr_ != nullptr);
765 auto action = sessionManagerPtr_->GetServiceSchedAction(BUNDLE_NAME);
766 EXPECT_EQ(action, BConstants::ServiceSchedAction::WAIT);
767
768 sessionManagerPtr_->SetServiceSchedAction(BUNDLE_NAME, BConstants::ServiceSchedAction::START);
769 action = sessionManagerPtr_->GetServiceSchedAction(BUNDLE_NAME);
770 EXPECT_EQ(action, BConstants::ServiceSchedAction::START);
771 GTEST_LOG_(INFO) << "SvcSessionManagerTest-SetServiceSchedAction Branches";
772 sessionManagerPtr_->SetServiceSchedAction(BUNDLE_NAME, BConstants::ServiceSchedAction::FINISH);
773 } catch (...) {
774 EXPECT_TRUE(false);
775 GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by GetServiceSchedAction.";
776 }
777 GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_GetServiceSchedAction_0100";
778 }
779
780 /**
781 * @tc.number: SUB_backup_sa_session_GetServiceSchedAction_0102
782 * @tc.name: SUB_backup_sa_session_GetServiceSchedAction_0102
783 * @tc.desc: 测试 GetServiceSchedAction 获取状态
784 * @tc.size: MEDIUM
785 * @tc.type: FUNC
786 * @tc.level Level 1
787 * @tc.require: I6F3GV
788 */
789 HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetServiceSchedAction_0102, testing::ext::TestSize.Level1)
790 {
791 GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_GetServiceSchedAction_0102";
792 try {
793 EXPECT_TRUE(sessionManagerPtr_ != nullptr);
794 auto action = sessionManagerPtr_->GetServiceSchedAction(BUNDLE_NAME);
795 EXPECT_NE(action, BConstants::ServiceSchedAction::WAIT);
796
797 SvcSessionManager::Impl impl_;
798 impl_.clientToken = 0;
799 sessionManagerPtr_->SetServiceSchedAction(BUNDLE_NAME, BConstants::ServiceSchedAction::START);
800 action = sessionManagerPtr_->GetServiceSchedAction(BUNDLE_NAME);
801 EXPECT_EQ(action, BConstants::ServiceSchedAction::START);
802 GTEST_LOG_(INFO) << "SvcSessionManagerTest-SetServiceSchedAction Branches";
803 sessionManagerPtr_->SetServiceSchedAction(BUNDLE_NAME, BConstants::ServiceSchedAction::FINISH);
804 } catch (...) {
805 EXPECT_TRUE(false);
806 GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by GetServiceSchedAction.";
807 }
808 GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_GetServiceSchedAction_0102";
809 }
810
811 /**
812 * @tc.number: SUB_backup_sa_session_GetServiceSchedAction_0103
813 * @tc.name: SUB_backup_sa_session_GetServiceSchedAction_0103
814 * @tc.desc: 测试 GetServiceSchedAction 获取状态
815 * @tc.size: MEDIUM
816 * @tc.type: FUNC
817 * @tc.level Level 1
818 * @tc.require: I6F3GV
819 */
820 HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetServiceSchedAction_0103, testing::ext::TestSize.Level1)
821 {
822 GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_GetServiceSchedAction_0103";
823 string bundleName = "";
824 EXPECT_TRUE(sessionManagerPtr_ != nullptr);
825 auto action = sessionManagerPtr_->GetServiceSchedAction(bundleName);
826 EXPECT_EQ(action, BConstants::ServiceSchedAction::UNKNOWN);
827
828 EXPECT_THROW(sessionManagerPtr_->SetServiceSchedAction(bundleName, BConstants::ServiceSchedAction::START), BError);
829 action = sessionManagerPtr_->GetServiceSchedAction(bundleName);
830 EXPECT_EQ(action, BConstants::ServiceSchedAction::UNKNOWN);
831
832 sessionManagerPtr_->impl_.clientToken = 0;
833 action = sessionManagerPtr_->GetServiceSchedAction(bundleName);
834 EXPECT_TRUE(action == BConstants::ServiceSchedAction::UNKNOWN);
835
836 sessionManagerPtr_->impl_.clientToken = 0;
837 EXPECT_THROW(sessionManagerPtr_->SetServiceSchedAction(bundleName, BConstants::ServiceSchedAction::START), BError);
838 EXPECT_TRUE(true);
839 GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_GetServiceSchedAction_0103";
840 }
841
842 /**
843 * @tc.number: SUB_backup_sa_session_GetBackupExtName_0100
844 * @tc.name: SUB_backup_sa_session_GetBackupExtName_0100
845 * @tc.desc: 测试 GetBackupExtName 接口
846 * @tc.size: MEDIUM
847 * @tc.type: FUNC
848 * @tc.level Level 1
849 * @tc.require: I6F3GV
850 */
851 HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetBackupExtName_0100, testing::ext::TestSize.Level1)
852 {
853 GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_GetBackupExtName_0100";
854 try {
855 EXPECT_TRUE(sessionManagerPtr_ != nullptr);
856 sessionManagerPtr_->SetBackupExtName(BUNDLE_NAME, BUNDLE_NAME);
857 string extName = sessionManagerPtr_->GetBackupExtName(BUNDLE_NAME);
858 EXPECT_EQ(extName, "");
859 } catch (...) {
860 EXPECT_TRUE(false);
861 GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by GetBackupExtName.";
862 }
863 GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_GetBackupExtName_0100";
864 }
865
866 /**
867 * @tc.number: SUB_backup_sa_session_GetBackupExtName_0101
868 * @tc.name: SUB_backup_sa_session_GetBackupExtName_0101
869 * @tc.desc: 测试 GetBackupExtName 接口
870 * @tc.size: MEDIUM
871 * @tc.type: FUNC
872 * @tc.level Level 1
873 * @tc.require: I6F3GV
874 */
875 HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetBackupExtName_0101, testing::ext::TestSize.Level1)
876 {
877 GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_GetBackupExtName_0101";
878 string bundleName = "";
879 EXPECT_TRUE(sessionManagerPtr_ != nullptr);
880 sessionManagerPtr_->impl_.clientToken = 0;
881 sessionManagerPtr_->SetBackupExtName(bundleName, bundleName);
882 EXPECT_TRUE(true);
883
884 sessionManagerPtr_->impl_.clientToken = 0;
885 auto backupExtName = sessionManagerPtr_->GetBackupExtName(bundleName);
886 EXPECT_EQ(backupExtName, "");
887
888 sessionManagerPtr_->SetBackupExtName(bundleName, bundleName);
889 string extName = sessionManagerPtr_->GetBackupExtName(bundleName);
890 EXPECT_EQ(extName, "");
891 GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_GetBackupExtName_0101";
892 }
893
894 /**
895 * @tc.number: SUB_backup_sa_session_SetBackupExtInfo_0100
896 * @tc.name: SUB_backup_sa_session_SetBackupExtInfo_0100
897 * @tc.desc: 测试 SetBackupExtInfo 接口
898 * @tc.size: MEDIUM
899 * @tc.type: FUNC
900 * @tc.level Level 1
901 * @tc.require: I6F3GV
902 */
903 HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_SetBackupExtInfo_0100, testing::ext::TestSize.Level1)
904 {
905 GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_SetBackupExtInfo_0100";
906 string bundleName = BUNDLE_NAME;
907 string extInfo = "test";
908 EXPECT_TRUE(sessionManagerPtr_ != nullptr);
909 sessionManagerPtr_->impl_.clientToken = 0;
910 sessionManagerPtr_->SetBackupExtInfo(bundleName, extInfo);
911 EXPECT_TRUE(true);
912
913 sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID;
914 sessionManagerPtr_->impl_.backupExtNameMap.clear();
915 sessionManagerPtr_->impl_.backupExtNameMap[bundleName] = {};
916 sessionManagerPtr_->SetBackupExtInfo(bundleName, extInfo);
917 EXPECT_EQ(sessionManagerPtr_->impl_.backupExtNameMap.size(), 1);
918 GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_SetBackupExtInfo_0100";
919 }
920
921 /**
922 * @tc.number: SUB_backup_sa_session_GetBackupExtInfo_0100
923 * @tc.name: SUB_backup_sa_session_GetBackupExtInfo_0100
924 * @tc.desc: 测试 GetBackupExtInfo 接口
925 * @tc.size: MEDIUM
926 * @tc.type: FUNC
927 * @tc.level Level 1
928 * @tc.require: I6F3GV
929 */
930 HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetBackupExtInfo_0100, testing::ext::TestSize.Level1)
931 {
932 GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_GetBackupExtInfo_0100";
933 string bundleName = BUNDLE_NAME;
934 string extInfo = "test";
935 EXPECT_TRUE(sessionManagerPtr_ != nullptr);
936 sessionManagerPtr_->impl_.clientToken = 0;
937 auto extInfoRet = sessionManagerPtr_->GetBackupExtInfo(bundleName);
938 EXPECT_EQ(extInfoRet, "");
939
940 BackupExtInfo info;
941 info.extInfo = "test";
942 sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID;
943 sessionManagerPtr_->impl_.backupExtNameMap.clear();
944 sessionManagerPtr_->impl_.backupExtNameMap[bundleName] = info;
945 auto ret = sessionManagerPtr_->GetBackupExtInfo(bundleName);
946 EXPECT_EQ(ret, "test");
947 GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_GetBackupExtInfo_0100";
948 }
949
950 /**
951 * @tc.number: SUB_backup_sa_session_AppendBundles_0100
952 * @tc.name: SUB_backup_sa_session_AppendBundles_0100
953 * @tc.desc: 测试 AppendBundles 接口
954 * @tc.size: MEDIUM
955 * @tc.type: FUNC
956 * @tc.level Level 1
957 * @tc.require: I6F3GV
958 */
959 HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_AppendBundles_0100, testing::ext::TestSize.Level1)
960 {
961 GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_AppendBundles_0100";
962 try {
963 vector<BundleName> bundleNames;
964 vector<string> failedBundles;
965 EXPECT_TRUE(sessionManagerPtr_ != nullptr);
966 sessionManagerPtr_->impl_.clientToken = 0;
967 sessionManagerPtr_->AppendBundles(bundleNames, failedBundles);
968 EXPECT_TRUE(true);
969
970 bundleNames.clear();
971 bundleNames.emplace_back("app1");
972 sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID;
973 sessionManagerPtr_->impl_.backupExtNameMap.clear();
974 sessionManagerPtr_->AppendBundles(bundleNames, failedBundles);
975 EXPECT_EQ(sessionManagerPtr_->impl_.backupExtNameMap.size(), 1);
976
977 bundleNames.clear();
978 bundleNames.emplace_back("123");
979 sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID;
980 sessionManagerPtr_->impl_.backupExtNameMap.clear();
981 sessionManagerPtr_->AppendBundles(bundleNames, failedBundles);
982 EXPECT_EQ(sessionManagerPtr_->impl_.backupExtNameMap.size(), 1);
983 } catch (...) {
984 EXPECT_FALSE(false);
985 GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by AppendBundles.";
986 }
987 GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_AppendBundles_0100";
988 }
989
990 /**
991 * @tc.number: SUB_backup_sa_session_NeedToUnloadService_0100
992 * @tc.name: SUB_backup_sa_session_NeedToUnloadService_0100
993 * @tc.desc: 测试 NeedToUnloadService 接口
994 * @tc.size: MEDIUM
995 * @tc.type: FUNC
996 * @tc.level Level 1
997 * @tc.require: I6VA38
998 */
999 HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_NeedToUnloadService_0100, testing::ext::TestSize.Level1)
1000 {
1001 GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_NeedToUnloadService_0100";
1002 try {
1003
1004 EXPECT_TRUE(sessionManagerPtr_ != nullptr);
1005 sessionManagerPtr_->impl_.restoreDataType = RestoreTypeEnum::RESTORE_DATA_READDY;
1006 auto ret = sessionManagerPtr_->NeedToUnloadService();
1007 EXPECT_FALSE(ret);
1008
1009 sessionManagerPtr_->impl_.backupExtNameMap.clear();
1010 sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {};
1011 sessionManagerPtr_->impl_.restoreDataType = RestoreTypeEnum::RESTORE_DATA_WAIT_SEND;
1012 sessionManagerPtr_->impl_.scenario = IServiceReverse::Scenario::RESTORE;
1013 ret = sessionManagerPtr_->NeedToUnloadService();
1014 EXPECT_FALSE(ret);
1015
1016 sessionManagerPtr_->impl_.backupExtNameMap.clear();
1017 sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {};
1018 sessionManagerPtr_->impl_.restoreDataType = RestoreTypeEnum::RESTORE_DATA_WAIT_SEND;
1019 sessionManagerPtr_->impl_.scenario = IServiceReverse::Scenario::BACKUP;
1020 ret = sessionManagerPtr_->NeedToUnloadService();
1021 EXPECT_FALSE(ret);
1022 } catch (...) {
1023 EXPECT_TRUE(false);
1024 GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by NeedToUnloadService.";
1025 }
1026 GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_NeedToUnloadService_0100";
1027 }
1028
1029 /**
1030 * @tc.number: SUB_backup_sa_session_removeextinfo_0100
1031 * @tc.name: SUB_backup_sa_session_removeextinfo_0100
1032 * @tc.desc: 测试 RemoveExtInfo 移除bundleName是否是有效的
1033 * @tc.size: MEDIUM
1034 * @tc.type: FUNC
1035 * @tc.level Level 1
1036 * @tc.require: I6F3GV
1037 */
1038 HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_removeextinfo_0100, testing::ext::TestSize.Level1)
1039 {
1040 GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_removeextinfo_0100";
1041 try {
1042 EXPECT_TRUE(sessionManagerPtr_ != nullptr);
1043 sessionManagerPtr_->impl_.backupExtNameMap.clear();
1044 sessionManagerPtr_->RemoveExtInfo(BUNDLE_NAME);
1045 EXPECT_EQ(sessionManagerPtr_->impl_.backupExtNameMap.size(), 0);
1046
1047 sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {};
1048 sessionManagerPtr_->RemoveExtInfo(BUNDLE_NAME);
1049 EXPECT_EQ(sessionManagerPtr_->impl_.backupExtNameMap.size(), 0);
1050
1051 sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {};
1052 sessionManagerPtr_->extConnectNum_ = 0;
1053 sessionManagerPtr_->RemoveExtInfo(BUNDLE_NAME);
1054 EXPECT_EQ(sessionManagerPtr_->extConnectNum_, 0);
1055
1056 sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {};
1057 sessionManagerPtr_->extConnectNum_ = 1;
1058 sessionManagerPtr_->RemoveExtInfo(BUNDLE_NAME);
1059 EXPECT_EQ(sessionManagerPtr_->extConnectNum_, 0);
1060 } catch (...) {
1061 EXPECT_TRUE(false);
1062 GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by RemoveExtInfo.";
1063 }
1064 GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_removeextinfo_0100";
1065 }
1066
1067 /**
1068 * @tc.number: SUB_backup_sa_session_OnBundleFileReady_0200
1069 * @tc.name: SUB_backup_sa_session_OnBundleFileReady_0200
1070 * @tc.desc: 测试 OnBundleFileReady
1071 * @tc.size: MEDIUM
1072 * @tc.type: FUNC
1073 * @tc.level Level 1
1074 * @tc.require: I6F3GV
1075 */
1076 HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_OnBundleFileReady_0200, testing::ext::TestSize.Level1)
1077 {
1078 GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_OnBundleFileReady_0200";
1079 try {
1080 EXPECT_TRUE(sessionManagerPtr_ != nullptr);
1081 sessionManagerPtr_->Deactive(nullptr, true);
1082 Init(IServiceReverse::Scenario::BACKUP);
1083 bool fileReady = sessionManagerPtr_->OnBundleFileReady(BUNDLE_NAME, MANAGE_JSON);
1084 EXPECT_FALSE(fileReady);
1085 fileReady = sessionManagerPtr_->OnBundleFileReady(BUNDLE_NAME, FILE_NAME);
1086 EXPECT_FALSE(fileReady);
1087 fileReady = sessionManagerPtr_->OnBundleFileReady(BUNDLE_NAME, FILE_NAME);
1088 EXPECT_FALSE(fileReady);
1089 } catch (...) {
1090 EXPECT_TRUE(false);
1091 GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by OnBundleFileReady.";
1092 }
1093 GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_OnBundleFileReady_0200";
1094 }
1095
1096 /**
1097 * @tc.number: SUB_backup_sa_session_SetSessionUserId_0100
1098 * @tc.name: SUB_backup_sa_session_SetSessionUserId_0100
1099 * @tc.desc: 测试 SetSessionUserId
1100 * @tc.size: MEDIUM
1101 * @tc.type: FUNC
1102 * @tc.level Level 1
1103 * @tc.require: I8ZIMJ
1104 */
1105 HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_SetSessionUserId_0100, testing::ext::TestSize.Level1)
1106 {
1107 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_backup_sa_session_SetSessionUserId_0100";
1108 try {
1109 int32_t userId = 1;
1110 EXPECT_TRUE(sessionManagerPtr_ != nullptr);
1111 sessionManagerPtr_->SetSessionUserId(userId);
1112 } catch (...) {
1113 EXPECT_TRUE(false);
1114 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by SetSessionUserId.";
1115 }
1116 GTEST_LOG_(INFO) << "ServiceTest-end SUB_backup_sa_session_SetSessionUserId_0100";
1117 }
1118
1119 /**
1120 * @tc.number: SUB_backup_sa_session_GetSessionUserId_0100
1121 * @tc.name: SUB_backup_sa_session_GetSessionUserId_0100
1122 * @tc.desc: 测试 GetSessionUserId
1123 * @tc.size: MEDIUM
1124 * @tc.type: FUNC
1125 * @tc.level Level 1
1126 * @tc.require: I8ZIMJ
1127 */
1128 HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetSessionUserId_0100, testing::ext::TestSize.Level1)
1129 {
1130 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_backup_sa_session_GetSessionUserId_0100";
1131 try {
1132 EXPECT_TRUE(sessionManagerPtr_ != nullptr);
1133 sessionManagerPtr_->GetSessionUserId();
1134 } catch (...) {
1135 EXPECT_TRUE(false);
1136 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by GetSessionUserId.";
1137 }
1138 GTEST_LOG_(INFO) << "ServiceTest-end SUB_backup_sa_session_GetSessionUserId_0100";
1139 }
1140
1141 /**
1142 * @tc.number: SUB_backup_sa_session_SetOldBackupVersion_0100
1143 * @tc.name: SUB_backup_sa_session_SetOldBackupVersion_0100
1144 * @tc.desc: 测试 SetSessionUserId
1145 * @tc.size: MEDIUM
1146 * @tc.type: FUNC
1147 * @tc.level Level 1
1148 * @tc.require: I8ZIMJ
1149 */
1150 HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_SetOldBackupVersion_0100, testing::ext::TestSize.Level1)
1151 {
1152 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_backup_sa_session_SetOldBackupVersion_0100";
1153 try {
1154 std::string backupVersion = "16.0";
1155 EXPECT_TRUE(sessionManagerPtr_ != nullptr);
1156 sessionManagerPtr_->SetOldBackupVersion(backupVersion);
1157 EXPECT_EQ(sessionManagerPtr_->impl_.oldBackupVersion, backupVersion);
1158 } catch (...) {
1159 EXPECT_TRUE(false);
1160 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by SetOldBackupVersion.";
1161 }
1162 GTEST_LOG_(INFO) << "ServiceTest-end SUB_backup_sa_session_SetOldBackupVersion_0100";
1163 }
1164
1165 /**
1166 * @tc.number: SUB_backup_sa_session_GetOldBackupVersion_0100
1167 * @tc.name: SUB_backup_sa_session_GetOldBackupVersion_0100
1168 * @tc.desc: 测试 GetSessionUserId
1169 * @tc.size: MEDIUM
1170 * @tc.type: FUNC
1171 * @tc.level Level 1
1172 * @tc.require: I8ZIMJ
1173 */
1174 HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetOldBackupVersion_0100, testing::ext::TestSize.Level1)
1175 {
1176 GTEST_LOG_(INFO) << "ServiceTest-begin SUB_backup_sa_session_GetOldBackupVersion_0100";
1177 try {
1178 EXPECT_TRUE(sessionManagerPtr_ != nullptr);
1179 sessionManagerPtr_->GetOldBackupVersion();
1180 EXPECT_TRUE(true);
1181
1182 sessionManagerPtr_->impl_.oldBackupVersion = "16.0";
1183 EXPECT_EQ(sessionManagerPtr_->GetOldBackupVersion(), "16.0");
1184 EXPECT_TRUE(true);
1185 } catch (...) {
1186 EXPECT_TRUE(false);
1187 GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by GetOldBackupVersion.";
1188 }
1189 GTEST_LOG_(INFO) << "ServiceTest-end SUB_backup_sa_session_GetOldBackupVersion_0100";
1190 }
1191
1192 /**
1193 * @tc.number: SUB_backup_sa_session_SetBundleRestoreType_0100
1194 * @tc.name: SUB_backup_sa_session_SetBundleRestoreType_0100
1195 * @tc.desc: 测试 SetBundleRestoreType 接口
1196 * @tc.size: MEDIUM
1197 * @tc.type: FUNC
1198 * @tc.level Level 1
1199 * @tc.require: I6VA38
1200 */
1201 HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_SetBundleRestoreType_0100, testing::ext::TestSize.Level1)
1202 {
1203 GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_SetBundleRestoreType_0100";
1204 EXPECT_TRUE(sessionManagerPtr_ != nullptr);
1205 sessionManagerPtr_->impl_.clientToken = 0;
1206 sessionManagerPtr_->SetBundleRestoreType(BUNDLE_NAME, RESTORE_DATA_READDY);
1207 EXPECT_TRUE(true);
1208
1209 sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID;
1210 sessionManagerPtr_->impl_.backupExtNameMap.clear();
1211 sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {};
1212 sessionManagerPtr_->SetBundleRestoreType(BUNDLE_NAME, RESTORE_DATA_READDY);
1213 EXPECT_EQ(sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME].restoreType, RESTORE_DATA_READDY);
1214 GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_SetBundleRestoreType_0100";
1215 }
1216
1217 /**
1218 * @tc.number: SUB_backup_sa_session_GetBundleRestoreType_0100
1219 * @tc.name: SUB_backup_sa_session_GetBundleRestoreType_0100
1220 * @tc.desc: 测试 GetBundleRestoreType 接口
1221 * @tc.size: MEDIUM
1222 * @tc.type: FUNC
1223 * @tc.level Level 1
1224 * @tc.require: I6VA38
1225 */
1226 HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetBundleRestoreType_0100, testing::ext::TestSize.Level1)
1227 {
1228 GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_GetBundleRestoreType_0100";
1229 EXPECT_TRUE(sessionManagerPtr_ != nullptr);
1230 sessionManagerPtr_->impl_.clientToken = 0;
1231 auto restoreType = sessionManagerPtr_->GetBundleRestoreType(BUNDLE_NAME);
1232 EXPECT_TRUE(restoreType == RestoreTypeEnum::RESTORE_DATA_WAIT_SEND);
1233
1234 sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID;
1235 sessionManagerPtr_->impl_.backupExtNameMap.clear();
1236 sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {};
1237 restoreType = sessionManagerPtr_->GetBundleRestoreType(BUNDLE_NAME);
1238 EXPECT_TRUE(restoreType == RestoreTypeEnum::RESTORE_DATA_WAIT_SEND);
1239 EXPECT_TRUE(true);
1240 GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_GetBundleRestoreType_0100";
1241 }
1242
1243 /**
1244 * @tc.number: SUB_backup_sa_session_SetBundleVersionCode_0100
1245 * @tc.name: SUB_backup_sa_session_SetBundleVersionCode_0100
1246 * @tc.desc: 测试 SetBundleVersionCode 接口
1247 * @tc.size: MEDIUM
1248 * @tc.type: FUNC
1249 * @tc.level Level 1
1250 * @tc.require: I6VA38
1251 */
1252 HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_SetBundleVersionCode_0100, testing::ext::TestSize.Level1)
1253 {
1254 GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_SetBundleVersionCode_0100";
1255 EXPECT_TRUE(sessionManagerPtr_ != nullptr);
1256 sessionManagerPtr_->impl_.clientToken = 0;
1257 sessionManagerPtr_->SetBundleVersionCode(BUNDLE_NAME, 0);
1258 EXPECT_TRUE(true);
1259
1260 sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID;
1261 sessionManagerPtr_->impl_.backupExtNameMap.clear();
1262 sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {};
1263 sessionManagerPtr_->SetBundleVersionCode(BUNDLE_NAME, 0);
1264 EXPECT_EQ(sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME].versionCode, 0);
1265 GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_SetBundleVersionCode_0100";
1266 }
1267
1268 /**
1269 * @tc.number: SUB_backup_sa_session_GetBundleVersionCode_0100
1270 * @tc.name: SUB_backup_sa_session_GetBundleVersionCode_0100
1271 * @tc.desc: 测试 GetBundleVersionCode 接口
1272 * @tc.size: MEDIUM
1273 * @tc.type: FUNC
1274 * @tc.level Level 1
1275 * @tc.require: I6VA38
1276 */
1277 HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetBundleVersionCode_0100, testing::ext::TestSize.Level1)
1278 {
1279 GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_GetBundleVersionCode_0100";
1280 EXPECT_TRUE(sessionManagerPtr_ != nullptr);
1281 sessionManagerPtr_->impl_.clientToken = 0;
1282 auto versionCode = sessionManagerPtr_->GetBundleVersionCode(BUNDLE_NAME);
1283 EXPECT_TRUE(versionCode == 0);
1284
1285 sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID;
1286 sessionManagerPtr_->impl_.backupExtNameMap.clear();
1287 sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {};
1288 sessionManagerPtr_->GetBundleVersionCode(BUNDLE_NAME);
1289 EXPECT_TRUE(true);
1290 GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_GetBundleVersionCode_0100";
1291 }
1292
1293 /**
1294 * @tc.number: SUB_backup_sa_session_SetBundleVersionName_0100
1295 * @tc.name: SUB_backup_sa_session_SetBundleVersionName_0100
1296 * @tc.desc: 测试 SetBundleVersionName 接口
1297 * @tc.size: MEDIUM
1298 * @tc.type: FUNC
1299 * @tc.level Level 1
1300 * @tc.require: I6VA38
1301 */
1302 HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_SetBundleVersionName_0100, testing::ext::TestSize.Level1)
1303 {
1304 GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_SetBundleVersionName_0100";
1305 try {
1306 EXPECT_TRUE(sessionManagerPtr_ != nullptr);
1307 sessionManagerPtr_->impl_.clientToken = 0;
1308 sessionManagerPtr_->SetBundleVersionName(BUNDLE_NAME, "1.0.0");
1309 EXPECT_TRUE(true);
1310
1311 sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID;
1312 sessionManagerPtr_->impl_.backupExtNameMap.clear();
1313 sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {};
1314 sessionManagerPtr_->SetBundleVersionName(BUNDLE_NAME, "1.0.0");
1315 EXPECT_TRUE(true);
1316 } catch (...) {
1317 EXPECT_TRUE(false);
1318 GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by SetBundleVersionName.";
1319 }
1320 GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_SetBundleVersionName_0100";
1321 }
1322
1323 /**
1324 * @tc.number: SUB_backup_sa_session_GetBundleVersionName_0100
1325 * @tc.name: SUB_backup_sa_session_GetBundleVersionName_0100
1326 * @tc.desc: 测试 GetBundleVersionName 接口
1327 * @tc.size: MEDIUM
1328 * @tc.type: FUNC
1329 * @tc.level Level 1
1330 * @tc.require: I6VA38
1331 */
1332 HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetBundleVersionName_0100, testing::ext::TestSize.Level1)
1333 {
1334 GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_GetBundleVersionName_0100";
1335 EXPECT_TRUE(sessionManagerPtr_ != nullptr);
1336 sessionManagerPtr_->impl_.clientToken = 0;
1337 auto versionStr = sessionManagerPtr_->GetBundleVersionName(BUNDLE_NAME);
1338 EXPECT_EQ(versionStr, "");
1339
1340 sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID;
1341 sessionManagerPtr_->impl_.backupExtNameMap.clear();
1342 sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {};
1343 versionStr = sessionManagerPtr_->GetBundleVersionName(BUNDLE_NAME);
1344 EXPECT_EQ(versionStr, "");
1345 GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_GetBundleVersionName_0100";
1346 }
1347
1348 /**
1349 * @tc.number: SUB_backup_sa_session_SetBundleUserId_0100
1350 * @tc.name: SUB_backup_sa_session_SetBundleUserId_0100
1351 * @tc.desc: 测试 SetBundleUserId 接口
1352 * @tc.size: MEDIUM
1353 * @tc.type: FUNC
1354 * @tc.level Level 1
1355 * @tc.require: I6VA38
1356 */
1357 HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_SetBundleUserId_0100, testing::ext::TestSize.Level1)
1358 {
1359 GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_SetBundleUserId_0100";
1360 try {
1361 int32_t userId = 100;
1362 sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID;
1363 sessionManagerPtr_->impl_.backupExtNameMap.clear();
1364 sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {};
1365 sessionManagerPtr_->SetBundleUserId(BUNDLE_NAME, userId);
1366 EXPECT_TRUE(true);
1367 } catch (...) {
1368 EXPECT_TRUE(false);
1369 GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by SetBundleUserId.";
1370 }
1371 GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_SetBundleUserId_0100";
1372 }
1373
1374 /**
1375 * @tc.number: SUB_backup_sa_session_GetBundleUserId_0100
1376 * @tc.name: SUB_backup_sa_session_GetBundleUserId_0100
1377 * @tc.desc: 测试 GetBundleUserId 接口
1378 * @tc.size: MEDIUM
1379 * @tc.type: FUNC
1380 * @tc.level Level 1
1381 * @tc.require: I6VA38
1382 */
1383 HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetBundleUserId_0100, testing::ext::TestSize.Level1)
1384 {
1385 GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_GetBundleUserId_0100";
1386 try {
1387 sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID;
1388 sessionManagerPtr_->impl_.backupExtNameMap.clear();
1389 sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {};
1390 auto result = sessionManagerPtr_->GetBundleUserId(BUNDLE_NAME);
1391 EXPECT_EQ(result, BConstants::DEFAULT_USER_ID);
1392 } catch (...) {
1393 EXPECT_TRUE(false);
1394 GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by GetBundleUserId.";
1395 }
1396 GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_GetBundleUserId_0100";
1397 }
1398
1399 /**
1400 * @tc.number: SUB_backup_sa_session_Start_0100
1401 * @tc.name: SUB_backup_sa_session_Start_0100
1402 * @tc.desc: 测试 Start
1403 * @tc.size: MEDIUM
1404 * @tc.type: FUNC
1405 * @tc.level Level 1
1406 * @tc.require: I6F3GV
1407 */
1408 HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_Start_0100, testing::ext::TestSize.Level1)
1409 {
1410 GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_Start_0100";
1411 try {
1412 EXPECT_TRUE(sessionManagerPtr_ != nullptr);
1413 sessionManagerPtr_->impl_.clientToken = 0;
1414 ErrCode ret = sessionManagerPtr_->Start();
1415 EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode());
1416
1417 sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID;
1418 ret = sessionManagerPtr_->Start();
1419 EXPECT_TRUE(sessionManagerPtr_->impl_.isBackupStart);
1420 } catch (...) {
1421 EXPECT_TRUE(false);
1422 GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by Start.";
1423 }
1424 GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_Start_0100";
1425 }
1426
1427 /**
1428 * @tc.number: SUB_backup_sa_session_Finish_0100
1429 * @tc.name: SUB_backup_sa_session_Finish_0100
1430 * @tc.desc: 测试 Finish
1431 * @tc.size: MEDIUM
1432 * @tc.type: FUNC
1433 * @tc.level Level 1
1434 * @tc.require: I6F3GV
1435 */
1436 HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_Finish_0100, testing::ext::TestSize.Level1)
1437 {
1438 GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_Finish_0100";
1439 try {
1440 EXPECT_TRUE(sessionManagerPtr_ != nullptr);
1441 sessionManagerPtr_->impl_.clientToken = 0;
1442 ErrCode ret = sessionManagerPtr_->Finish();
1443 EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode());
1444
1445 sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID;
1446 ret = sessionManagerPtr_->Finish();
1447 EXPECT_TRUE(sessionManagerPtr_->impl_.isAppendFinish);
1448 } catch (...) {
1449 EXPECT_TRUE(false);
1450 GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by Finish.";
1451 }
1452 GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_Finish_0100";
1453 }
1454
1455 /**
1456 * @tc.number: SUB_backup_sa_session_IsOnAllBundlesFinished_0100
1457 * @tc.name: SUB_backup_sa_session_IsOnAllBundlesFinished_0100
1458 * @tc.desc: 测试 IsOnAllBundlesFinished
1459 * @tc.size: MEDIUM
1460 * @tc.type: FUNC
1461 * @tc.level Level 1
1462 * @tc.require: I6F3GV
1463 */
1464 HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_IsOnAllBundlesFinished_0100, testing::ext::TestSize.Level1)
1465 {
1466 GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_IsOnAllBundlesFinished_0100";
1467 EXPECT_TRUE(sessionManagerPtr_ != nullptr);
1468 sessionManagerPtr_->impl_.clientToken = 0;
1469 bool ret = sessionManagerPtr_->IsOnAllBundlesFinished();
1470 EXPECT_FALSE(ret);
1471
1472 sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID;
1473 sessionManagerPtr_->impl_.scenario = IServiceReverse::Scenario::RESTORE;
1474 ret = sessionManagerPtr_->IsOnAllBundlesFinished();
1475 EXPECT_FALSE(ret);
1476
1477 sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID;
1478 sessionManagerPtr_->impl_.scenario = IServiceReverse::Scenario::UNDEFINED;
1479 ret = sessionManagerPtr_->IsOnAllBundlesFinished();
1480 EXPECT_FALSE(ret);
1481 GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_IsOnAllBundlesFinished_0100";
1482 }
1483
1484 /**
1485 * @tc.number: SUB_backup_sa_session_IsOnOnStartSched_0100
1486 * @tc.name: SUB_backup_sa_session_IsOnOnStartSched_0100
1487 * @tc.desc: 测试 IsOnOnStartSched
1488 * @tc.size: MEDIUM
1489 * @tc.type: FUNC
1490 * @tc.level Level 1
1491 * @tc.require: I6F3GV
1492 */
1493 HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_IsOnOnStartSched_0100, testing::ext::TestSize.Level1)
1494 {
1495 GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_IsOnOnStartSched_0100";
1496 try {
1497 EXPECT_TRUE(sessionManagerPtr_ != nullptr);
1498 sessionManagerPtr_->impl_.clientToken = 0;
1499 auto ret = sessionManagerPtr_->IsOnOnStartSched();
1500 EXPECT_FALSE(ret);
1501
1502 sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID;
1503 sessionManagerPtr_->impl_.isBackupStart = false;
1504 ret = sessionManagerPtr_->IsOnOnStartSched();
1505
1506 sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID;
1507 sessionManagerPtr_->impl_.isBackupStart = true;
1508 sessionManagerPtr_->impl_.backupExtNameMap.clear();
1509 ret = sessionManagerPtr_->IsOnOnStartSched();
1510 EXPECT_FALSE(ret);
1511
1512 sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID;
1513 sessionManagerPtr_->impl_.isBackupStart = true;
1514 sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {};
1515 ret = sessionManagerPtr_->IsOnOnStartSched();
1516 EXPECT_TRUE(ret);
1517 } catch (...) {
1518 EXPECT_TRUE(false);
1519 GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by IsOnOnStartSched.";
1520 }
1521 GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_IsOnOnStartSched_0100";
1522 }
1523
1524 /**
1525 * @tc.number: SUB_backup_sa_session_SetBundleDataSize_0100
1526 * @tc.name: SUB_backup_sa_session_SetBundleDataSize_0100
1527 * @tc.desc: 测试 SetBundleDataSize
1528 * @tc.size: MEDIUM
1529 * @tc.type: FUNC
1530 * @tc.level Level 1
1531 * @tc.require: I6F3GV
1532 */
1533 HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_SetBundleDataSize_0100, testing::ext::TestSize.Level1)
1534 {
1535 GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_SetBundleDataSize_0100";
1536 try {
1537 EXPECT_TRUE(sessionManagerPtr_ != nullptr);
1538 sessionManagerPtr_->impl_.clientToken = 0;
1539 sessionManagerPtr_->SetBundleDataSize(BUNDLE_NAME, 0);
1540 EXPECT_TRUE(true);
1541
1542 sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID;
1543 sessionManagerPtr_->impl_.backupExtNameMap.clear();
1544 sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {};
1545 sessionManagerPtr_->SetBundleDataSize(BUNDLE_NAME, 0);
1546 EXPECT_TRUE(true);
1547 } catch (...) {
1548 EXPECT_TRUE(false);
1549 GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by SetBundleDataSize.";
1550 }
1551 GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_SetBundleDataSize_0100";
1552 }
1553
1554 /**
1555 * @tc.number: SUB_backup_sa_session_StartFwkTimer_0100
1556 * @tc.name: SUB_backup_sa_session_StartFwkTimer_0100
1557 * @tc.desc: 测试 StartFwkTimer
1558 * @tc.size: MEDIUM
1559 * @tc.type: FUNC
1560 * @tc.level Level 1
1561 * @tc.require: I6F3GV
1562 */
1563 HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_StartFwkTimer_0100, testing::ext::TestSize.Level1)
1564 {
1565 GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_StartFwkTimer_0100";
1566 try {
__anona1685dff0202() 1567 auto callback = []() -> void {};
1568 EXPECT_TRUE(sessionManagerPtr_ != nullptr);
1569 sessionManagerPtr_->impl_.clientToken = 0;
1570 auto ret = sessionManagerPtr_->StartFwkTimer(BUNDLE_NAME, callback);
1571 EXPECT_FALSE(ret);
1572
1573 BackupExtInfo info;
1574 info.fwkTimerStatus = false;
1575 sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID;
1576 sessionManagerPtr_->impl_.backupExtNameMap.clear();
1577 sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = info;
1578 ret = sessionManagerPtr_->StartFwkTimer(BUNDLE_NAME, callback);
1579 EXPECT_TRUE(ret);
1580 ret = sessionManagerPtr_->StopFwkTimer(BUNDLE_NAME);
1581 EXPECT_TRUE(ret);
1582
1583 info.fwkTimerStatus = true;
1584 sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID;
1585 sessionManagerPtr_->impl_.backupExtNameMap.clear();
1586 sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = info;
1587 ret = sessionManagerPtr_->StartFwkTimer(BUNDLE_NAME, callback);
1588 EXPECT_FALSE(ret);
1589 ret = sessionManagerPtr_->StopFwkTimer(BUNDLE_NAME);
1590 EXPECT_TRUE(ret);
1591 } catch (...) {
1592 EXPECT_TRUE(false);
1593 GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by StartFwkTimer.";
1594 }
1595 GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_StartFwkTimer_0100";
1596 }
1597
1598 /**
1599 * @tc.number: SUB_backup_sa_session_UpdateTimer_0100
1600 * @tc.name: SUB_backup_sa_session_UpdateTimer_0100
1601 * @tc.desc: 测试 UpdateTimer
1602 * @tc.size: MEDIUM
1603 * @tc.type: FUNC
1604 * @tc.level Level 1
1605 * @tc.require: I6F3GV
1606 */
1607 HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_UpdateTimer_0100, testing::ext::TestSize.Level1)
1608 {
1609 GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_UpdateTimer_0100";
1610 try {
__anona1685dff0302() 1611 auto callback = []() -> void {};
1612 EXPECT_TRUE(sessionManagerPtr_ != nullptr);
1613 sessionManagerPtr_->impl_.clientToken = 0;
1614 auto ret = sessionManagerPtr_->UpdateTimer(BUNDLE_NAME, BConstants::DEFAULT_TIMEOUT, callback);
1615 EXPECT_FALSE(ret);
1616
1617 sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID;
1618 sessionManagerPtr_->impl_.backupExtNameMap.clear();
1619 EXPECT_FALSE(ret);
1620
1621 BackupExtInfo info;
1622 info.extTimerStatus = false;
1623 sessionManagerPtr_->impl_.backupExtNameMap.clear();
1624 sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = info;
1625 ret = sessionManagerPtr_->UpdateTimer(BUNDLE_NAME, BConstants::DEFAULT_TIMEOUT, callback);
1626 EXPECT_TRUE(ret);
1627
1628 info.extTimerStatus = true;
1629 sessionManagerPtr_->impl_.backupExtNameMap.clear();
1630 sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = info;
1631 ret = sessionManagerPtr_->UpdateTimer(BUNDLE_NAME, BConstants::DEFAULT_TIMEOUT, callback);
1632 EXPECT_TRUE(ret);
1633 } catch (...) {
1634 EXPECT_TRUE(false);
1635 GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by UpdateTimer.";
1636 }
1637 GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_UpdateTimer_0100";
1638 }
1639
1640 /**
1641 * @tc.number: SUB_backup_sa_session_StopFwkTimer_0100
1642 * @tc.name: SUB_backup_sa_session_StopFwkTimer_0100
1643 * @tc.desc: 测试 StopFwkTimer
1644 * @tc.size: MEDIUM
1645 * @tc.type: FUNC
1646 * @tc.level Level 1
1647 * @tc.require: I6F3GV
1648 */
1649 HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_StopFwkTimer_0100, testing::ext::TestSize.Level1)
1650 {
1651 GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_StopFwkTimer_0100";
1652 try {
1653 EXPECT_TRUE(sessionManagerPtr_ != nullptr);
1654 sessionManagerPtr_->impl_.clientToken = 0;
1655 auto ret = sessionManagerPtr_->StopFwkTimer(BUNDLE_NAME);
1656 EXPECT_FALSE(ret);
1657
1658 BackupExtInfo info;
1659 info.fwkTimerStatus = false;
1660 sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID;
1661 sessionManagerPtr_->impl_.backupExtNameMap.clear();
1662 sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = info;
1663 ret = sessionManagerPtr_->StopFwkTimer(BUNDLE_NAME);
1664 EXPECT_TRUE(ret);
1665
1666 info.fwkTimerStatus = true;
1667 sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID;
1668 sessionManagerPtr_->impl_.backupExtNameMap.clear();
1669 sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = info;
1670 ret = sessionManagerPtr_->StopFwkTimer(BUNDLE_NAME);
1671 EXPECT_TRUE(ret);
1672 } catch (...) {
1673 EXPECT_TRUE(false);
1674 GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by StopFwkTimer.";
1675 }
1676 GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_StopFwkTimer_0100";
1677 }
1678
1679 /**
1680 * @tc.number: SUB_backup_sa_session_ClearSessionData_0100
1681 * @tc.name: SUB_backup_sa_session_ClearSessionData_0100
1682 * @tc.desc: 测试 ClearSessionData
1683 * @tc.size: MEDIUM
1684 * @tc.type: FUNC
1685 * @tc.level Level 1
1686 * @tc.require: I6F3GV
1687 */
1688 HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_ClearSessionData_0100, testing::ext::TestSize.Level1)
1689 {
1690 GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_ClearSessionData_0100";
1691 try {
1692 BackupExtInfo info;
1693 info.fwkTimerStatus = true;
1694 info.schedAction = BConstants::ServiceSchedAction::RUNNING;
1695 info.backUpConnection = sptr(new SvcBackupConnection(nullptr, nullptr, BUNDLE_NAME));
1696 EXPECT_TRUE(sessionManagerPtr_ != nullptr);
1697 sessionManagerPtr_->impl_.backupExtNameMap.clear();
1698 sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = info;
1699 sessionManagerPtr_->ClearSessionData();
1700 EXPECT_TRUE(true);
1701
1702 info.fwkTimerStatus = false;
1703 info.schedAction = BConstants::ServiceSchedAction::WAIT;
1704 sessionManagerPtr_->impl_.backupExtNameMap.clear();
1705 sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = info;
1706 sessionManagerPtr_->ClearSessionData();
1707 EXPECT_TRUE(true);
1708 } catch (...) {
1709 EXPECT_TRUE(false);
1710 GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by ClearSessionData.";
1711 }
1712 GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_ClearSessionData_0100";
1713 }
1714
1715 /**
1716 * @tc.number: SUB_backup_sa_session_GetIsIncrementalBackup_0100
1717 * @tc.name: SUB_backup_sa_session_GetIsIncrementalBackup_0100
1718 * @tc.desc: 测试 GetIsIncrementalBackup
1719 * @tc.size: MEDIUM
1720 * @tc.type: FUNC
1721 * @tc.level Level 1
1722 * @tc.require: I6F3GV
1723 */
1724 HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetIsIncrementalBackup_0100, testing::ext::TestSize.Level1)
1725 {
1726 GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_GetIsIncrementalBackup_0100";
1727 EXPECT_TRUE(sessionManagerPtr_ != nullptr);
1728 sessionManagerPtr_->impl_.clientToken = 0;
1729 bool ret = sessionManagerPtr_->GetIsIncrementalBackup();
1730 EXPECT_FALSE(ret);
1731
1732 sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID;
1733 ret = sessionManagerPtr_->GetIsIncrementalBackup();
1734 EXPECT_FALSE(ret);
1735 GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_GetIsIncrementalBackup_0100";
1736 }
1737
1738 /**
1739 * @tc.number: SUB_backup_sa_session_SetIncrementalData_0100
1740 * @tc.name: SUB_backup_sa_session_SetIncrementalData_0100
1741 * @tc.desc: 测试 SetIncrementalData
1742 * @tc.size: MEDIUM
1743 * @tc.type: FUNC
1744 * @tc.level Level 1
1745 * @tc.require: I6F3GV
1746 */
1747 HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_SetIncrementalData_0100, testing::ext::TestSize.Level1)
1748 {
1749 GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_SetIncrementalData_0100";
1750 try {
1751 BIncrementalData incrementalData;
1752 EXPECT_TRUE(sessionManagerPtr_ != nullptr);
1753 sessionManagerPtr_->impl_.clientToken = 0;
1754 sessionManagerPtr_->SetIncrementalData(incrementalData);
1755 EXPECT_TRUE(true);
1756
1757 incrementalData.bundleName = BUNDLE_NAME;
1758 sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID;
1759 sessionManagerPtr_->impl_.backupExtNameMap.clear();
1760 sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {};
1761 sessionManagerPtr_->SetIncrementalData(incrementalData);
1762 EXPECT_TRUE(true);
1763 } catch (...) {
1764 EXPECT_TRUE(false);
1765 GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by SetIncrementalData.";
1766 }
1767 GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_SetIncrementalData_0100";
1768 }
1769
1770 /**
1771 * @tc.number: SUB_backup_sa_session_GetIncrementalManifestFd_0100
1772 * @tc.name: SUB_backup_sa_session_GetIncrementalManifestFd_0100
1773 * @tc.desc: 测试 GetIncrementalManifestFd
1774 * @tc.size: MEDIUM
1775 * @tc.type: FUNC
1776 * @tc.level Level 1
1777 * @tc.require: I6F3GV
1778 */
1779 HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetIncrementalManifestFd_0100, testing::ext::TestSize.Level1)
1780 {
1781 GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_GetIncrementalManifestFd_0100";
1782 EXPECT_TRUE(sessionManagerPtr_ != nullptr);
1783 sessionManagerPtr_->impl_.clientToken = 0;
1784 auto ret = sessionManagerPtr_->GetIncrementalManifestFd(BUNDLE_NAME);
1785 EXPECT_TRUE(ret == -1);
1786
1787 sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID;
1788 sessionManagerPtr_->impl_.backupExtNameMap.clear();
1789 sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {};
1790 ret = sessionManagerPtr_->GetIncrementalManifestFd(BUNDLE_NAME);
1791 EXPECT_TRUE(ret == 0);
1792 GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_GetIncrementalManifestFd_0100";
1793 }
1794
1795 /**
1796 * @tc.number: SUB_backup_sa_session_StartExtTimer_0100
1797 * @tc.name: SUB_backup_sa_session_StartExtTimer_0100
1798 * @tc.desc: 测试 StartExtTimer 接口
1799 * @tc.size: MEDIUM
1800 * @tc.type: FUNC
1801 * @tc.level Level 1
1802 * @tc.require: I6F3GV
1803 */
1804 HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_StartExtTimer_0100, testing::ext::TestSize.Level1)
1805 {
1806 GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_StartExtTimer_0100";
1807 try {
1808 EXPECT_TRUE(sessionManagerPtr_ != nullptr);
__anona1685dff0402() 1809 auto callback = []() -> void {};
1810 sessionManagerPtr_->impl_.clientToken = 0;
1811 bool ret = sessionManagerPtr_->StartExtTimer(BUNDLE_NAME, callback);
1812 EXPECT_FALSE(ret);
1813
1814 BackupExtInfo info;
1815 info.extTimerStatus = false;
1816 sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID;
1817 sessionManagerPtr_->impl_.backupExtNameMap.clear();
1818 sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = info;
1819 ret = sessionManagerPtr_->StartExtTimer(BUNDLE_NAME, callback);
1820 EXPECT_TRUE(ret);
1821 ret = sessionManagerPtr_->StopExtTimer(BUNDLE_NAME);
1822 EXPECT_TRUE(ret);
1823
1824 info.extTimerStatus = true;
1825 sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID;
1826 sessionManagerPtr_->impl_.backupExtNameMap.clear();
1827 sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = info;
1828 ret = sessionManagerPtr_->StartExtTimer(BUNDLE_NAME, callback);
1829 EXPECT_FALSE(ret);
1830 ret = sessionManagerPtr_->StopExtTimer(BUNDLE_NAME);
1831 EXPECT_TRUE(ret);
1832 } catch (...) {
1833 EXPECT_TRUE(false);
1834 GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by StartExtTimer.";
1835 }
1836 GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_StartExtTimer_0100";
1837 }
1838
1839 /**
1840 * @tc.number: SUB_backup_sa_session_StopExtTimer_0100
1841 * @tc.name: SUB_backup_sa_session_StopExtTimer_0100
1842 * @tc.desc: 测试 StopExtTimer 接口
1843 * @tc.size: MEDIUM
1844 * @tc.type: FUNC
1845 * @tc.level Level 1
1846 * @tc.require: I6F3GV
1847 */
1848 HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_StopExtTimer_0100, testing::ext::TestSize.Level1)
1849 {
1850 GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_StopExtTimer_0100";
1851 try {
1852 EXPECT_TRUE(sessionManagerPtr_ != nullptr);
1853 sessionManagerPtr_->impl_.clientToken = 0;
1854 bool ret = sessionManagerPtr_->StopExtTimer(BUNDLE_NAME);
1855 EXPECT_FALSE(ret);
1856
1857 BackupExtInfo info;
1858 info.extTimerStatus = false;
1859 sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID;
1860 sessionManagerPtr_->impl_.backupExtNameMap.clear();
1861 sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = info;
1862 ret = sessionManagerPtr_->StopExtTimer(BUNDLE_NAME);
1863 EXPECT_TRUE(ret);
1864
1865 info.extTimerStatus = true;
1866 sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID;
1867 sessionManagerPtr_->impl_.backupExtNameMap.clear();
1868 sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = info;
1869 ret = sessionManagerPtr_->StopExtTimer(BUNDLE_NAME);
1870 EXPECT_TRUE(ret);
1871 } catch (...) {
1872 EXPECT_TRUE(false);
1873 GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by StopExtTimer.";
1874 }
1875 GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_StopExtTimer_0100";
1876 }
1877
1878 /**
1879 * @tc.number: SUB_backup_sa_session_SetClearDataFlag_0100
1880 * @tc.name: SUB_backup_sa_session_SetClearDataFlag_0100
1881 * @tc.desc: 测试 SetClearDataFlag
1882 * @tc.size: MEDIUM
1883 * @tc.type: FUNC
1884 * @tc.level Level 1
1885 * @tc.require: I6F3GV
1886 */
1887 HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_SetClearDataFlag_0100, testing::ext::TestSize.Level1)
1888 {
1889 GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_SetClearDataFlag_0100";
1890 try {
1891 EXPECT_TRUE(sessionManagerPtr_ != nullptr);
1892 sessionManagerPtr_->impl_.clientToken = 0;
1893 sessionManagerPtr_->SetClearDataFlag(BUNDLE_NAME, false);
1894 EXPECT_TRUE(true);
1895
1896 sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID;
1897 sessionManagerPtr_->impl_.backupExtNameMap.clear();
1898 sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {};
1899 sessionManagerPtr_->SetClearDataFlag(BUNDLE_NAME, false);
1900 EXPECT_EQ(sessionManagerPtr_->GetClearDataFlag(BUNDLE_NAME), false);
1901
1902 sessionManagerPtr_->SetClearDataFlag(BUNDLE_NAME, true);
1903 EXPECT_EQ(sessionManagerPtr_->GetClearDataFlag(BUNDLE_NAME), true);
1904 } catch (...) {
1905 EXPECT_TRUE(false);
1906 GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by SetClearDataFlag.";
1907 }
1908 GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_SetClearDataFlag_0100";
1909 }
1910
1911 /**
1912 * @tc.number: SUB_backup_sa_session_GetClearDataFlag_0100
1913 * @tc.name: SUB_backup_sa_session_GetClearDataFlag_0100
1914 * @tc.desc: 测试 GetClearDataFlag
1915 * @tc.size: MEDIUM
1916 * @tc.type: FUNC
1917 * @tc.level Level 1
1918 * @tc.require: I6F3GV
1919 */
1920 HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetClearDataFlag_0100, testing::ext::TestSize.Level1)
1921 {
1922 GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_GetClearDataFlag_0100";
1923 try {
1924 EXPECT_TRUE(sessionManagerPtr_ != nullptr);
1925 sessionManagerPtr_->impl_.clientToken = 0;
1926 auto ret = sessionManagerPtr_->GetClearDataFlag(BUNDLE_NAME);
1927 EXPECT_TRUE(ret);
1928
1929 sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID;
1930 sessionManagerPtr_->impl_.backupExtNameMap.clear();
1931 sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {};
1932 sessionManagerPtr_->SetClearDataFlag(BUNDLE_NAME, false);
1933 EXPECT_EQ(sessionManagerPtr_->GetClearDataFlag(BUNDLE_NAME), false);
1934
1935 sessionManagerPtr_->SetClearDataFlag(BUNDLE_NAME, true);
1936 EXPECT_EQ(sessionManagerPtr_->GetClearDataFlag(BUNDLE_NAME), true);
1937 } catch (...) {
1938 EXPECT_TRUE(false);
1939 GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by GetClearDataFlag.";
1940 }
1941 GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_GetClearDataFlag_0100";
1942 }
1943
1944 /**
1945 * @tc.number: SUB_backup_sa_session_SetPublishFlag_0100
1946 * @tc.name: SUB_backup_sa_session_SetPublishFlag_0100
1947 * @tc.desc: 测试 SetPublishFlag
1948 * @tc.size: MEDIUM
1949 * @tc.type: FUNC
1950 * @tc.level Level 1
1951 * @tc.require: I6F3GV
1952 */
1953 HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_SetPublishFlag_0100, testing::ext::TestSize.Level1)
1954 {
1955 GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_SetPublishFlag_0100";
1956 try {
1957 EXPECT_TRUE(sessionManagerPtr_ != nullptr);
1958 sessionManagerPtr_->impl_.clientToken = 0;
1959 sessionManagerPtr_->SetPublishFlag(BUNDLE_NAME);
1960 EXPECT_TRUE(true);
1961
1962 sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID;
1963 sessionManagerPtr_->impl_.backupExtNameMap.clear();
1964 sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {};
1965 sessionManagerPtr_->SetPublishFlag(BUNDLE_NAME);
1966 EXPECT_TRUE(true);
1967 } catch (...) {
1968 EXPECT_TRUE(false);
1969 GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by SetPublishFlag.";
1970 }
1971 GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_SetPublishFlag_0100";
1972 }
1973
1974 /**
1975 * @tc.number: SUB_backup_sa_session_SetImplRestoreType_0100
1976 * @tc.name: SUB_backup_sa_session_SetImplRestoreType_0100
1977 * @tc.desc: 测试 SetImplRestoreType
1978 * @tc.size: MEDIUM
1979 * @tc.type: FUNC
1980 * @tc.level Level 1
1981 * @tc.require: I6F3GV
1982 */
1983 HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_SetImplRestoreType_0100, testing::ext::TestSize.Level1)
1984 {
1985 GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_SetImplRestoreType_0100";
1986 try {
1987 sessionManagerPtr_->SetImplRestoreType(RESTORE_DATA_WAIT_SEND);
1988 bool isValid = sessionManagerPtr_->ValidRestoreDataType(RESTORE_DATA_READDY);
1989 EXPECT_EQ(isValid, false);
1990 isValid = sessionManagerPtr_->ValidRestoreDataType(RESTORE_DATA_WAIT_SEND);
1991 EXPECT_EQ(isValid, true);
1992 EXPECT_TRUE(true);
1993 } catch (...) {
1994 EXPECT_TRUE(false);
1995 GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by SetImplRestoreType.";
1996 }
1997 GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_SetImplRestoreType_0100";
1998 }
1999
2000 /**
2001 * @tc.number: SUB_backup_sa_session_Exception_0100
2002 * @tc.name: SUB_backup_sa_session_Exception_0100
2003 * @tc.desc: 测试 Exception
2004 * @tc.size: MEDIUM
2005 * @tc.type: FUNC
2006 * @tc.level Level 1
2007 * @tc.require: I6F3GV
2008 */
2009 HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_Exception_0100, testing::ext::TestSize.Level1)
2010 {
2011 GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_Exception_0100";
2012 try {
2013 EXPECT_TRUE(sessionManagerPtr_ != nullptr);
2014 sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID;
2015 sessionManagerPtr_->impl_.backupExtNameMap.clear();
2016
2017 sessionManagerPtr_->SetExtFileNameRequest(BUNDLE_NAME, "");
2018 EXPECT_TRUE(true);
2019
2020 sessionManagerPtr_->impl_.scenario = IServiceReverse::Scenario::RESTORE;
2021 std::set<std::string> fileSet = sessionManagerPtr_->GetExtFileNameRequest(BUNDLE_NAME);
2022 EXPECT_TRUE(fileSet.empty());
2023
2024 sessionManagerPtr_->SetBackupExtName(BUNDLE_NAME, "");
2025 EXPECT_TRUE(true);
2026
2027 std::string extName = sessionManagerPtr_->GetBackupExtName(BUNDLE_NAME);
2028 EXPECT_TRUE(extName.empty());
2029
2030 sessionManagerPtr_->SetBackupExtInfo(BUNDLE_NAME, "");
2031 EXPECT_TRUE(true);
2032
2033 std::string extInfo = sessionManagerPtr_->GetBackupExtInfo(BUNDLE_NAME);
2034 EXPECT_TRUE(extInfo.empty());
2035
2036 sessionManagerPtr_->SetBundleUserId(BUNDLE_NAME, 0);
2037 EXPECT_TRUE(true);
2038
2039 int32_t id = sessionManagerPtr_->GetBundleUserId(BUNDLE_NAME);
2040 EXPECT_EQ(id, sessionManagerPtr_->GetSessionUserId());
2041 } catch (...) {
2042 EXPECT_TRUE(false);
2043 GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by Exception.";
2044 }
2045 GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_Exception_0100";
2046 }
2047
2048 /**
2049 * @tc.number: SUB_backup_sa_session_Exception_0200
2050 * @tc.name: SUB_backup_sa_session_Exception_0200
2051 * @tc.desc: 测试 Exception
2052 * @tc.size: MEDIUM
2053 * @tc.type: FUNC
2054 * @tc.level Level 1
2055 * @tc.require: I6F3GV
2056 */
2057 HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_Exception_0200, testing::ext::TestSize.Level1)
2058 {
2059 GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_Exception_0200";
2060 try {
2061 EXPECT_TRUE(sessionManagerPtr_ != nullptr);
2062 sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID;
2063 sessionManagerPtr_->impl_.backupExtNameMap.clear();
2064
2065 sessionManagerPtr_->SetBundleRestoreType(BUNDLE_NAME, RestoreTypeEnum::RESTORE_DATA_WAIT_SEND);
2066 EXPECT_TRUE(true);
2067
2068 RestoreTypeEnum restoreType = sessionManagerPtr_->GetBundleRestoreType(BUNDLE_NAME);
2069 EXPECT_EQ(restoreType, RestoreTypeEnum::RESTORE_DATA_WAIT_SEND);
2070
2071 sessionManagerPtr_->SetBundleVersionCode(BUNDLE_NAME, 0);
2072 EXPECT_TRUE(true);
2073
2074 int64_t versionCode = sessionManagerPtr_->GetBundleVersionCode(BUNDLE_NAME);
2075 EXPECT_EQ(versionCode, 0);
2076
2077 sessionManagerPtr_->SetBundleVersionName(BUNDLE_NAME, "");
2078 EXPECT_TRUE(true);
2079
2080 std::string versionName = sessionManagerPtr_->GetBundleVersionName(BUNDLE_NAME);
2081 EXPECT_TRUE(versionName.empty());
2082
2083 sessionManagerPtr_->SetClearDataFlag(BUNDLE_NAME, true);
2084 EXPECT_TRUE(true);
2085
2086 bool flag = sessionManagerPtr_->GetClearDataFlag(BUNDLE_NAME);
2087 EXPECT_TRUE(flag);
2088 } catch (...) {
2089 EXPECT_TRUE(false);
2090 GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by Exception.";
2091 }
2092 GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_Exception_0200";
2093 }
2094 #include "svc_session_manager_ex_test.cpp"
2095 } // namespace OHOS::FileManagement::Backup