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