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