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 <cstddef>
17 #include <cstdio>
18 #include <fcntl.h>
19 #include <gmock/gmock.h>
20 #include <gtest/gtest.h>
21 #include <message_parcel.h>
22 #include <sys/stat.h>
23 #include <sys/types.h>
24
25 #include "b_error/b_error.h"
26 #include "b_session_restore.h"
27 #include "refbase.h"
28 #include "service_reverse.h"
29 #include "test_manager.h"
30 #include "unique_fd.h"
31
32 namespace OHOS::FileManagement::Backup {
33 using namespace std;
34 using namespace testing;
35
36 namespace {
37 const string BUNDLE_NAME = "com.example.app2backup";
38 const string FILE_NAME = "1.tar";
39 } // namespace
40
41 class ServiceReverseTest : public testing::Test {
42 public:
SetUpTestCase(void)43 static void SetUpTestCase(void) {};
TearDownTestCase()44 static void TearDownTestCase() {};
SetUp()45 void SetUp() override {};
46 void TearDown() override;
47
48 void Init(IServiceReverse::Scenario scenario, int nType = 0);
49 void IncrementalInit(IServiceReverse::Scenario scenario, int nType = 0);
50 sptr<ServiceReverse> service_ = nullptr;
51 };
52
OnFileReadyTest(const BFileInfo & fileInfo,UniqueFd fd)53 static void OnFileReadyTest(const BFileInfo &fileInfo, UniqueFd fd)
54 {
55 EXPECT_EQ(fileInfo.owner, BUNDLE_NAME);
56 EXPECT_EQ(fileInfo.fileName, FILE_NAME);
57 GTEST_LOG_(INFO) << "ServiceReverseTest-OnFileReadyTest SUCCESS";
58 }
59
OnBundleStartedTest(ErrCode err,const BundleName name)60 static void OnBundleStartedTest(ErrCode err, const BundleName name)
61 {
62 EXPECT_EQ(name, BUNDLE_NAME);
63 GTEST_LOG_(INFO) << "ServiceReverseTest-OnBundleStartedTest SUCCESS";
64 }
65
OnBundleFinishedTest(ErrCode err,const BundleName name)66 static void OnBundleFinishedTest(ErrCode err, const BundleName name)
67 {
68 EXPECT_EQ(name, BUNDLE_NAME);
69 GTEST_LOG_(INFO) << "ServiceReverseTest-OnBundleFinishedTest SUCCESS";
70 }
71
OnAllBundlesFinishedTest(ErrCode err)72 static void OnAllBundlesFinishedTest(ErrCode err)
73 {
74 EXPECT_EQ(err, BError(BError::Codes::OK));
75 GTEST_LOG_(INFO) << "ServiceReverseTest-OnAllBundlesFinishedTest SUCCESS";
76 }
77
OnBackupServiceDiedTest()78 static void OnBackupServiceDiedTest() {}
79
OnResultReportTest(std::string bundleName,std::string result)80 static void OnResultReportTest(std::string bundleName, std::string result)
81 {
82 EXPECT_EQ(result, "result_report");
83 EXPECT_EQ(bundleName, "com.example.app2backup");
84 GTEST_LOG_(INFO) << "ServiceReverseTest-OnResultReportTest SUCCESS";
85 }
86
TearDown()87 void ServiceReverseTest::TearDown()
88 {
89 service_ = nullptr;
90 }
91
Init(IServiceReverse::Scenario scenario,int nType)92 void ServiceReverseTest::Init(IServiceReverse::Scenario scenario, int nType)
93 {
94 if (scenario == IServiceReverse::Scenario::BACKUP) {
95 if (nType) {
96 service_ = new ServiceReverse(BSessionBackup::Callbacks {.onFileReady = nullptr,
97 .onBundleStarted = nullptr,
98 .onBundleFinished = nullptr,
99 .onAllBundlesFinished = nullptr,
100 .onResultReport = nullptr,
101 .onBackupServiceDied = nullptr});
102 } else {
103 service_ = new ServiceReverse(BSessionBackup::Callbacks {
104 .onFileReady = bind(OnFileReadyTest, placeholders::_1, placeholders::_2),
105 .onBundleStarted = bind(OnBundleStartedTest, placeholders::_1, placeholders::_2),
106 .onBundleFinished = bind(OnBundleFinishedTest, placeholders::_1, placeholders::_2),
107 .onAllBundlesFinished = bind(OnAllBundlesFinishedTest, placeholders::_1),
108 .onResultReport = bind(OnResultReportTest, placeholders::_1, placeholders::_2),
109 .onBackupServiceDied = bind(OnBackupServiceDiedTest)});
110 }
111 } else {
112 if (nType) {
113 service_ = new ServiceReverse(BSessionRestore::Callbacks {.onFileReady = nullptr,
114 .onBundleStarted = nullptr,
115 .onBundleFinished = nullptr,
116 .onAllBundlesFinished = nullptr,
117 .onResultReport = nullptr,
118 .onBackupServiceDied = nullptr});
119 } else {
120 service_ = new ServiceReverse(BSessionRestore::Callbacks {
121 .onFileReady = bind(OnFileReadyTest, placeholders::_1, placeholders::_2),
122 .onBundleStarted = bind(OnBundleStartedTest, placeholders::_1, placeholders::_2),
123 .onBundleFinished = bind(OnBundleFinishedTest, placeholders::_1, placeholders::_2),
124 .onAllBundlesFinished = bind(OnAllBundlesFinishedTest, placeholders::_1),
125 .onResultReport = bind(OnResultReportTest, placeholders::_1, placeholders::_2),
126 .onBackupServiceDied = bind(OnBackupServiceDiedTest)});
127 }
128 }
129 }
130
IncrementalInit(IServiceReverse::Scenario scenario,int nType)131 void ServiceReverseTest::IncrementalInit(IServiceReverse::Scenario scenario, int nType)
132 {
133 if (scenario == IServiceReverse::Scenario::BACKUP) {
134 if (nType) {
135 service_ = new ServiceReverse(BIncrementalBackupSession::Callbacks {.onFileReady = nullptr,
136 .onBundleStarted = nullptr,
137 .onBundleFinished = nullptr,
138 .onAllBundlesFinished = nullptr,
139 .onResultReport = nullptr,
140 .onBackupServiceDied = nullptr});
141 } else {
142 service_ = new ServiceReverse(BIncrementalBackupSession::Callbacks {
143 .onFileReady = bind(OnFileReadyTest, placeholders::_1, placeholders::_2),
144 .onBundleStarted = bind(OnBundleStartedTest, placeholders::_1, placeholders::_2),
145 .onBundleFinished = bind(OnBundleFinishedTest, placeholders::_1, placeholders::_2),
146 .onAllBundlesFinished = bind(OnAllBundlesFinishedTest, placeholders::_1),
147 .onResultReport = bind(OnResultReportTest, placeholders::_1, placeholders::_2),
148 .onBackupServiceDied = bind(OnBackupServiceDiedTest)});
149 }
150 } else {
151 if (nType) {
152 service_ = new ServiceReverse(BIncrementalRestoreSession::Callbacks {.onFileReady = nullptr,
153 .onBundleStarted = nullptr,
154 .onBundleFinished = nullptr,
155 .onAllBundlesFinished = nullptr,
156 .onBackupServiceDied = nullptr});
157 } else {
158 service_ = new ServiceReverse(BIncrementalRestoreSession::Callbacks {
159 .onFileReady = bind(OnFileReadyTest, placeholders::_1, placeholders::_2),
160 .onBundleStarted = bind(OnBundleStartedTest, placeholders::_1, placeholders::_2),
161 .onBundleFinished = bind(OnBundleFinishedTest, placeholders::_1, placeholders::_2),
162 .onAllBundlesFinished = bind(OnAllBundlesFinishedTest, placeholders::_1),
163 .onResultReport = bind(OnResultReportTest, placeholders::_1, placeholders::_2),
164 .onBackupServiceDied = bind(OnBackupServiceDiedTest)});
165 }
166 }
167 }
168
169 /**
170 * @tc.number: SUB_backup_ServiceReverse_BackupOnFileReady_0100
171 * @tc.name: SUB_backup_ServiceReverse_BackupOnFileReady_0100
172 * @tc.desc: 测试 BackupOnFileReady 接口
173 * @tc.size: MEDIUM
174 * @tc.type: FUNC
175 * @tc.level Level 1
176 * @tc.require: I6F3GV
177 */
178 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_BackupOnFileReady_0100, testing::ext::TestSize.Level1)
179 {
180 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_BackupOnFileReady_0100";
181 try {
182 Init(IServiceReverse::Scenario::BACKUP);
183 if (service_ == nullptr) {
184 GTEST_LOG_(INFO) <<
185 "SUB_backup_ServiceReverse_BackupOnFileReady_0100 service_ == nullptr";
186 return;
187 }
188 service_->BackupOnFileReady(BUNDLE_NAME, FILE_NAME, -1, 0);
189 service_->RestoreOnFileReady(BUNDLE_NAME, FILE_NAME, -1, 0);
190 } catch (...) {
191 EXPECT_TRUE(false);
192 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by BackupOnFileReady.";
193 }
194 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_BackupOnFileReady_0100";
195 }
196
197 /**
198 * @tc.number: SUB_backup_ServiceReverse_BackupOnFileReady_0101
199 * @tc.name: SUB_backup_ServiceReverse_BackupOnFileReady_0101
200 * @tc.desc: 测试 BackupOnFileReady 接口
201 * @tc.size: MEDIUM
202 * @tc.type: FUNC
203 * @tc.level Level 1
204 * @tc.require: I6F3GV
205 */
206 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_BackupOnFileReady_0101, testing::ext::TestSize.Level1)
207 {
208 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_BackupOnFileReady_0101";
209 try {
210 Init(IServiceReverse::Scenario::RESTORE);
211 if (service_ == nullptr) {
212 GTEST_LOG_(INFO) <<
213 "SUB_backup_ServiceReverse_BackupOnFileReady_0101 service_ == nullptr";
214 return;
215 }
216 service_->BackupOnFileReady(BUNDLE_NAME, FILE_NAME, -1, 0);
217 } catch (...) {
218 EXPECT_TRUE(false);
219 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by BackupOnFileReady.";
220 }
221 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_BackupOnFileReady_0101";
222 }
223
224 /**
225 * @tc.number: SUB_backup_ServiceReverse_BackupOnFileReady_0102
226 * @tc.name: SUB_backup_ServiceReverse_BackupOnFileReady_0102
227 * @tc.desc: 测试 BackupOnFileReady 接口
228 * @tc.size: MEDIUM
229 * @tc.type: FUNC
230 * @tc.level Level 1
231 * @tc.require: I6F3GV
232 */
233 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_BackupOnFileReady_0102, testing::ext::TestSize.Level1)
234 {
235 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_BackupOnFileReady_0102";
236 try {
237 Init(IServiceReverse::Scenario::BACKUP, 1);
238 if (service_ == nullptr) {
239 GTEST_LOG_(INFO) <<
240 "SUB_backup_ServiceReverse_BackupOnFileReady_0102 service_ == nullptr";
241 return;
242 }
243 service_->BackupOnFileReady(BUNDLE_NAME, FILE_NAME, -1, 0);
244 } catch (...) {
245 EXPECT_TRUE(false);
246 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by BackupOnFileReady.";
247 }
248 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_BackupOnFileReady_0102";
249 }
250
251 /**
252 * @tc.number: SUB_backup_ServiceReverse_BackupOnBundleStarted_0100
253 * @tc.name: SUB_backup_ServiceReverse_BackupOnBundleStarted_0100
254 * @tc.desc: 测试 BackupOnBundleStarted 接口
255 * @tc.size: MEDIUM
256 * @tc.type: FUNC
257 * @tc.level Level 1
258 * @tc.require: I6F3GV
259 */
260 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_BackupOnBundleStarted_0100, testing::ext::TestSize.Level1)
261 {
262 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_BackupOnBundleStarted_0100";
263 try {
264 Init(IServiceReverse::Scenario::BACKUP);
265 if (service_ == nullptr) {
266 GTEST_LOG_(INFO) <<
267 "SUB_backup_ServiceReverse_BackupOnBundleStarted_0100 service_ == nullptr";
268 return;
269 }
270 service_->BackupOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME);
271 service_->RestoreOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME);
272 } catch (...) {
273 EXPECT_TRUE(false);
274 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by BackupOnBundleStarted.";
275 }
276 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_BackupOnBundleStarted_0100";
277 }
278
279 /**
280 * @tc.number: SUB_backup_ServiceReverse_BackupOnBundleStarted_0101
281 * @tc.name: SUB_backup_ServiceReverse_BackupOnBundleStarted_0101
282 * @tc.desc: 测试 BackupOnBundleStarted 接口
283 * @tc.size: MEDIUM
284 * @tc.type: FUNC
285 * @tc.level Level 1
286 * @tc.require: I6F3GV
287 */
288 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_BackupOnBundleStarted_0101, testing::ext::TestSize.Level1)
289 {
290 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_BackupOnBundleStarted_0101";
291 try {
292 Init(IServiceReverse::Scenario::RESTORE);
293 if (service_ == nullptr) {
294 GTEST_LOG_(INFO) <<
295 "SUB_backup_ServiceReverse_BackupOnBundleStarted_0101 service_ == nullptr";
296 return;
297 }
298 service_->BackupOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME);
299 } catch (...) {
300 EXPECT_TRUE(false);
301 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by BackupOnBundleStarted.";
302 }
303 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_BackupOnBundleStarted_0101";
304 }
305
306 /**
307 * @tc.number: SUB_backup_ServiceReverse_BackupOnBundleStarted_0102
308 * @tc.name: SUB_backup_ServiceReverse_BackupOnBundleStarted_0102
309 * @tc.desc: 测试 BackupOnBundleStarted 接口
310 * @tc.size: MEDIUM
311 * @tc.type: FUNC
312 * @tc.level Level 1
313 * @tc.require: I6F3GV
314 */
315 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_BackupOnBundleStarted_0102, testing::ext::TestSize.Level1)
316 {
317 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_BackupOnBundleStarted_0102";
318 try {
319 Init(IServiceReverse::Scenario::BACKUP, 1);
320 if (service_ == nullptr) {
321 GTEST_LOG_(INFO) <<
322 "SUB_backup_ServiceReverse_BackupOnBundleStarted_0102 service_ == nullptr";
323 return;
324 }
325 service_->BackupOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME);
326 } catch (...) {
327 EXPECT_TRUE(false);
328 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by BackupOnBundleStarted.";
329 }
330 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_BackupOnBundleStarted_0102";
331 }
332
333 /**
334 * @tc.number: SUB_backup_ServiceReverse_BackupOnBundleFinished_0100
335 * @tc.name: SUB_backup_ServiceReverse_BackupOnBundleFinished_0100
336 * @tc.desc: 测试 BackupOnBundleFinished 接口
337 * @tc.size: MEDIUM
338 * @tc.type: FUNC
339 * @tc.level Level 1
340 * @tc.require: I6F3GV
341 */
342 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_BackupOnBundleFinished_0100, testing::ext::TestSize.Level1)
343 {
344 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_BackupOnBundleFinished_0100";
345 try {
346 Init(IServiceReverse::Scenario::BACKUP);
347 if (service_ == nullptr) {
348 GTEST_LOG_(INFO) <<
349 "SUB_backup_ServiceReverse_BackupOnBundleFinished_0100 service_ == nullptr";
350 return;
351 }
352 service_->BackupOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME);
353 service_->RestoreOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME);
354 } catch (...) {
355 EXPECT_TRUE(false);
356 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by BackupOnBundleFinished.";
357 }
358 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_BackupOnBundleFinished_0100";
359 }
360
361 /**
362 * @tc.number: SUB_backup_ServiceReverse_BackupOnBundleFinished_0101
363 * @tc.name: SUB_backup_ServiceReverse_BackupOnBundleFinished_0101
364 * @tc.desc: 测试 BackupOnBundleFinished 接口
365 * @tc.size: MEDIUM
366 * @tc.type: FUNC
367 * @tc.level Level 1
368 * @tc.require: I6F3GV
369 */
370 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_BackupOnBundleFinished_0101, testing::ext::TestSize.Level1)
371 {
372 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_BackupOnBundleFinished_0101";
373 try {
374 Init(IServiceReverse::Scenario::RESTORE);
375 if (service_ == nullptr) {
376 GTEST_LOG_(INFO) <<
377 "SUB_backup_ServiceReverse_BackupOnBundleFinished_0101 service_ == nullptr";
378 return;
379 }
380 service_->BackupOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME);
381 } catch (...) {
382 EXPECT_TRUE(false);
383 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by BackupOnBundleFinished.";
384 }
385 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_BackupOnBundleFinished_0101";
386 }
387
388 /**
389 * @tc.number: SUB_backup_ServiceReverse_BackupOnBundleFinished_0102
390 * @tc.name: SUB_backup_ServiceReverse_BackupOnBundleFinished_0102
391 * @tc.desc: 测试 BackupOnBundleFinished 接口
392 * @tc.size: MEDIUM
393 * @tc.type: FUNC
394 * @tc.level Level 1
395 * @tc.require: I6F3GV
396 */
397 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_BackupOnBundleFinished_0102, testing::ext::TestSize.Level1)
398 {
399 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_BackupOnBundleFinished_0102";
400 try {
401 Init(IServiceReverse::Scenario::BACKUP, 1);
402 if (service_ == nullptr) {
403 GTEST_LOG_(INFO) <<
404 "SUB_backup_ServiceReverse_BackupOnBundleFinished_0102 service_ == nullptr";
405 return;
406 }
407 service_->BackupOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME);
408 } catch (...) {
409 EXPECT_TRUE(false);
410 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by BackupOnBundleFinished.";
411 }
412 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_BackupOnBundleFinished_0102";
413 }
414
415 /**
416 * @tc.number: SUB_backup_ServiceReverse_BackupOnAllBundlesFinished_0100
417 * @tc.name: SUB_backup_ServiceReverse_BackupOnAllBundlesFinished_0100
418 * @tc.desc: 测试 BackupOnAllBundlesFinished 接口
419 * @tc.size: MEDIUM
420 * @tc.type: FUNC
421 * @tc.level Level 1
422 * @tc.require: I6F3GV
423 */
424 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_BackupOnAllBundlesFinished_0100, testing::ext::TestSize.Level1)
425 {
426 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_BackupOnAllBundlesFinished_0100";
427 try {
428 Init(IServiceReverse::Scenario::BACKUP);
429 if (service_ == nullptr) {
430 GTEST_LOG_(INFO) <<
431 "SUB_backup_ServiceReverse_BackupOnAllBundlesFinished_0100 service_ == nullptr";
432 return;
433 }
434 service_->BackupOnAllBundlesFinished(BError(BError::Codes::OK));
435 service_->RestoreOnAllBundlesFinished(BError(BError::Codes::OK));
436 } catch (...) {
437 EXPECT_TRUE(false);
438 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by BackupOnAllBundlesFinished.";
439 }
440 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_BackupOnAllBundlesFinished_0100";
441 }
442
443 /**
444 * @tc.number: SUB_backup_ServiceReverse_BackupOnAllBundlesFinished_0101
445 * @tc.name: SUB_backup_ServiceReverse_BackupOnAllBundlesFinished_0101
446 * @tc.desc: 测试 BackupOnAllBundlesFinished 接口
447 * @tc.size: MEDIUM
448 * @tc.type: FUNC
449 * @tc.level Level 1
450 * @tc.require: I6F3GV
451 */
452 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_BackupOnAllBundlesFinished_0101, testing::ext::TestSize.Level1)
453 {
454 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_BackupOnAllBundlesFinished_0101";
455 try {
456 Init(IServiceReverse::Scenario::RESTORE);
457 if (service_ == nullptr) {
458 GTEST_LOG_(INFO) <<
459 "SUB_backup_ServiceReverse_BackupOnAllBundlesFinished_0101 service_ == nullptr";
460 return;
461 }
462 service_->BackupOnAllBundlesFinished(BError(BError::Codes::OK));
463 } catch (...) {
464 EXPECT_TRUE(false);
465 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by BackupOnAllBundlesFinished.";
466 }
467 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_BackupOnAllBundlesFinished_0101";
468 }
469
470 /**
471 * @tc.number: SUB_backup_ServiceReverse_BackupOnAllBundlesFinished_0102
472 * @tc.name: SUB_backup_ServiceReverse_BackupOnAllBundlesFinished_0102
473 * @tc.desc: 测试 BackupOnAllBundlesFinished 接口
474 * @tc.size: MEDIUM
475 * @tc.type: FUNC
476 * @tc.level Level 1
477 * @tc.require: I6F3GV
478 */
479 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_BackupOnAllBundlesFinished_0102, testing::ext::TestSize.Level1)
480 {
481 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_BackupOnAllBundlesFinished_0102";
482 try {
483 Init(IServiceReverse::Scenario::BACKUP, 1);
484 if (service_ == nullptr) {
485 GTEST_LOG_(INFO) <<
486 "SUB_backup_ServiceReverse_BackupOnAllBundlesFinished_0102 service_ == nullptr";
487 return;
488 }
489 service_->BackupOnAllBundlesFinished(BError(BError::Codes::OK));
490 } catch (...) {
491 EXPECT_TRUE(false);
492 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by BackupOnAllBundlesFinished.";
493 }
494 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_BackupOnAllBundlesFinished_0102";
495 }
496
497 /**
498 * @tc.number: SUB_backup_ServiceReverse_RestoreOnFileReady_0100
499 * @tc.name: SUB_backup_ServiceReverse_RestoreOnFileReady_0100
500 * @tc.desc: 测试 RestoreOnFileReady 接口
501 * @tc.size: MEDIUM
502 * @tc.type: FUNC
503 * @tc.level Level 1
504 * @tc.require: I6F3GV
505 */
506 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_RestoreOnFileReady_0100, testing::ext::TestSize.Level1)
507 {
508 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_RestoreOnFileReady_0100";
509 try {
510 Init(IServiceReverse::Scenario::RESTORE);
511 if (service_ == nullptr) {
512 GTEST_LOG_(INFO) <<
513 "SUB_backup_ServiceReverse_RestoreOnFileReady_0100 service_ == nullptr";
514 return;
515 }
516 service_->RestoreOnFileReady(BUNDLE_NAME, FILE_NAME, -1, 0);
517 service_->BackupOnFileReady(BUNDLE_NAME, FILE_NAME, -1, 0);
518 } catch (...) {
519 EXPECT_TRUE(false);
520 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by RestoreOnFileReady.";
521 }
522 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_RestoreOnFileReady_0100";
523 }
524
525 /**
526 * @tc.number: SUB_backup_ServiceReverse_RestoreOnFileReady_0101
527 * @tc.name: SUB_backup_ServiceReverse_RestoreOnFileReady_0101
528 * @tc.desc: 测试 RestoreOnFileReady 接口
529 * @tc.size: MEDIUM
530 * @tc.type: FUNC
531 * @tc.level Level 1
532 * @tc.require: I6F3GV
533 */
534 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_RestoreOnFileReady_0101, testing::ext::TestSize.Level1)
535 {
536 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_RestoreOnFileReady_0101";
537 try {
538 Init(IServiceReverse::Scenario::BACKUP);
539 if (service_ == nullptr) {
540 GTEST_LOG_(INFO) <<
541 "SUB_backup_ServiceReverse_RestoreOnFileReady_0101 service_ == nullptr";
542 return;
543 }
544 service_->RestoreOnFileReady(BUNDLE_NAME, FILE_NAME, -1, 0);
545 } catch (...) {
546 EXPECT_TRUE(false);
547 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by RestoreOnFileReady.";
548 }
549 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_RestoreOnFileReady_0101";
550 }
551
552 /**
553 * @tc.number: SUB_backup_ServiceReverse_RestoreOnFileReady_0102
554 * @tc.name: SUB_backup_ServiceReverse_RestoreOnFileReady_0102
555 * @tc.desc: 测试 RestoreOnFileReady 接口
556 * @tc.size: MEDIUM
557 * @tc.type: FUNC
558 * @tc.level Level 1
559 * @tc.require: I6F3GV
560 */
561 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_RestoreOnFileReady_0102, testing::ext::TestSize.Level1)
562 {
563 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_RestoreOnFileReady_0102";
564 try {
565 Init(IServiceReverse::Scenario::RESTORE, 1);
566 if (service_ == nullptr) {
567 GTEST_LOG_(INFO) <<
568 "SUB_backup_ServiceReverse_RestoreOnFileReady_0102 service_ == nullptr";
569 return;
570 }
571 service_->RestoreOnFileReady(BUNDLE_NAME, FILE_NAME, -1, 0);
572 } catch (...) {
573 EXPECT_TRUE(false);
574 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by RestoreOnFileReady.";
575 }
576 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_RestoreOnFileReady_0102";
577 }
578
579 /**
580 * @tc.number: SUB_backup_ServiceReverse_RestoreOnBundleStarted_0100
581 * @tc.name: SUB_backup_ServiceReverse_RestoreOnBundleStarted_0100
582 * @tc.desc: 测试 RestoreOnBundleStarted 接口
583 * @tc.size: MEDIUM
584 * @tc.type: FUNC
585 * @tc.level Level 1
586 * @tc.require: I6F3GV
587 */
588 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_RestoreOnBundleStarted_0100, testing::ext::TestSize.Level1)
589 {
590 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_RestoreOnBundleStarted_0100";
591 try {
592 Init(IServiceReverse::Scenario::RESTORE);
593 if (service_ == nullptr) {
594 GTEST_LOG_(INFO) <<
595 "SUB_backup_ServiceReverse_RestoreOnBundleStarted_0100 service_ == nullptr";
596 return;
597 }
598 service_->RestoreOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME);
599 service_->BackupOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME);
600 } catch (...) {
601 EXPECT_TRUE(false);
602 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by RestoreOnBundleStarted.";
603 }
604 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_RestoreOnBundleStarted_0100";
605 }
606
607 /**
608 * @tc.number: SUB_backup_ServiceReverse_RestoreOnBundleStarted_0101
609 * @tc.name: SUB_backup_ServiceReverse_RestoreOnBundleStarted_0101
610 * @tc.desc: 测试 RestoreOnBundleStarted 接口
611 * @tc.size: MEDIUM
612 * @tc.type: FUNC
613 * @tc.level Level 1
614 * @tc.require: I6F3GV
615 */
616 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_RestoreOnBundleStarted_0101, testing::ext::TestSize.Level1)
617 {
618 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_RestoreOnBundleStarted_0101";
619 try {
620 Init(IServiceReverse::Scenario::BACKUP);
621 if (service_ == nullptr) {
622 GTEST_LOG_(INFO) <<
623 "SUB_backup_ServiceReverse_RestoreOnBundleStarted_0101 service_ == nullptr";
624 return;
625 }
626 service_->RestoreOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME);
627 } catch (...) {
628 EXPECT_TRUE(false);
629 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by RestoreOnBundleStarted.";
630 }
631 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_RestoreOnBundleStarted_0101";
632 }
633
634 /**
635 * @tc.number: SUB_backup_ServiceReverse_RestoreOnBundleStarted_0102
636 * @tc.name: SUB_backup_ServiceReverse_RestoreOnBundleStarted_0102
637 * @tc.desc: 测试 RestoreOnBundleStarted 接口
638 * @tc.size: MEDIUM
639 * @tc.type: FUNC
640 * @tc.level Level 1
641 * @tc.require: I6F3GV
642 */
643 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_RestoreOnBundleStarted_0102, testing::ext::TestSize.Level1)
644 {
645 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_RestoreOnBundleStarted_0102";
646 try {
647 Init(IServiceReverse::Scenario::RESTORE, 1);
648 if (service_ == nullptr) {
649 GTEST_LOG_(INFO) <<
650 "SUB_backup_ServiceReverse_RestoreOnBundleStarted_0102 service_ == nullptr";
651 return;
652 }
653 service_->RestoreOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME);
654 } catch (...) {
655 EXPECT_TRUE(false);
656 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by RestoreOnBundleStarted.";
657 }
658 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_RestoreOnBundleStarted_0102";
659 }
660
661 /**
662 * @tc.number: SUB_backup_ServiceReverse_RestoreOnBundleFinished_0100
663 * @tc.name: SUB_backup_ServiceReverse_RestoreOnBundleFinished_0100
664 * @tc.desc: 测试 RestoreOnBundleFinished 接口
665 * @tc.size: MEDIUM
666 * @tc.type: FUNC
667 * @tc.level Level 1
668 * @tc.require: I6F3GV
669 */
670 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_RestoreOnBundleFinished_0100, testing::ext::TestSize.Level1)
671 {
672 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_RestoreOnBundleFinished_0100";
673 try {
674 Init(IServiceReverse::Scenario::RESTORE);
675 if (service_ == nullptr) {
676 GTEST_LOG_(INFO) <<
677 "SUB_backup_ServiceReverse_RestoreOnBundleFinished_0100 service_ == nullptr";
678 return;
679 }
680 service_->RestoreOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME);
681 service_->BackupOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME);
682 } catch (...) {
683 EXPECT_TRUE(false);
684 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by RestoreOnBundleFinished.";
685 }
686 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_RestoreOnBundleFinished_0100";
687 }
688
689 /**
690 * @tc.number: SUB_backup_ServiceReverse_RestoreOnBundleFinished_0101
691 * @tc.name: SUB_backup_ServiceReverse_RestoreOnBundleFinished_0101
692 * @tc.desc: 测试 RestoreOnBundleFinished 接口
693 * @tc.size: MEDIUM
694 * @tc.type: FUNC
695 * @tc.level Level 1
696 * @tc.require: I6F3GV
697 */
698 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_RestoreOnBundleFinished_0101, testing::ext::TestSize.Level1)
699 {
700 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_RestoreOnBundleFinished_0101";
701 try {
702 Init(IServiceReverse::Scenario::BACKUP);
703 if (service_ == nullptr) {
704 GTEST_LOG_(INFO) <<
705 "SUB_backup_ServiceReverse_RestoreOnBundleFinished_0101 service_ == nullptr";
706 return;
707 }
708 service_->RestoreOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME);
709 } catch (...) {
710 EXPECT_TRUE(false);
711 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by RestoreOnBundleFinished.";
712 }
713 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_RestoreOnBundleFinished_0101";
714 }
715
716 /**
717 * @tc.number: SUB_backup_ServiceReverse_RestoreOnBundleFinished_0102
718 * @tc.name: SUB_backup_ServiceReverse_RestoreOnBundleFinished_0102
719 * @tc.desc: 测试 RestoreOnBundleFinished 接口
720 * @tc.size: MEDIUM
721 * @tc.type: FUNC
722 * @tc.level Level 1
723 * @tc.require: I6F3GV
724 */
725 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_RestoreOnBundleFinished_0102, testing::ext::TestSize.Level1)
726 {
727 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_RestoreOnBundleFinished_0102";
728 try {
729 Init(IServiceReverse::Scenario::RESTORE, 1);
730 if (service_ == nullptr) {
731 GTEST_LOG_(INFO) <<
732 "SUB_backup_ServiceReverse_RestoreOnBundleFinished_0102 service_ == nullptr";
733 return;
734 }
735 service_->RestoreOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME);
736 } catch (...) {
737 EXPECT_TRUE(false);
738 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by RestoreOnBundleFinished.";
739 }
740 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_RestoreOnBundleFinished_0102";
741 }
742
743 /**
744 * @tc.number: SUB_backup_ServiceReverse_RestoreOnAllBundlesFinished_0100
745 * @tc.name: SUB_backup_ServiceReverse_RestoreOnAllBundlesFinished_0100
746 * @tc.desc: 测试 RestoreOnAllBundlesFinished 接口
747 * @tc.size: MEDIUM
748 * @tc.type: FUNC
749 * @tc.level Level 1
750 * @tc.require: I6F3GV
751 */
752 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_RestoreOnAllBundlesFinished_0100, testing::ext::TestSize.Level1)
753 {
754 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_RestoreOnAllBundlesFinished_0100";
755 try {
756 Init(IServiceReverse::Scenario::RESTORE);
757 if (service_ == nullptr) {
758 GTEST_LOG_(INFO) <<
759 "SUB_backup_ServiceReverse_RestoreOnAllBundlesFinished_0100 service_ == nullptr";
760 return;
761 }
762 service_->RestoreOnAllBundlesFinished(BError(BError::Codes::OK));
763 service_->BackupOnAllBundlesFinished(BError(BError::Codes::OK));
764 } catch (...) {
765 EXPECT_TRUE(false);
766 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by RestoreOnAllBundlesFinished.";
767 }
768 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_RestoreOnAllBundlesFinished_0100";
769 }
770
771 /**
772 * @tc.number: SUB_backup_ServiceReverse_RestoreOnAllBundlesFinished_0101
773 * @tc.name: SUB_backup_ServiceReverse_RestoreOnAllBundlesFinished_0101
774 * @tc.desc: 测试 RestoreOnAllBundlesFinished 接口
775 * @tc.size: MEDIUM
776 * @tc.type: FUNC
777 * @tc.level Level 1
778 * @tc.require: I6F3GV
779 */
780 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_RestoreOnAllBundlesFinished_0101, testing::ext::TestSize.Level1)
781 {
782 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_RestoreOnAllBundlesFinished_0101";
783 try {
784 Init(IServiceReverse::Scenario::BACKUP);
785 if (service_ == nullptr) {
786 GTEST_LOG_(INFO) <<
787 "SUB_backup_ServiceReverse_RestoreOnAllBundlesFinished_0101 service_ == nullptr";
788 return;
789 }
790 service_->RestoreOnAllBundlesFinished(BError(BError::Codes::OK));
791 } catch (...) {
792 EXPECT_TRUE(false);
793 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by RestoreOnAllBundlesFinished.";
794 }
795 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_RestoreOnAllBundlesFinished_0101";
796 }
797
798 /**
799 * @tc.number: SUB_backup_ServiceReverse_RestoreOnAllBundlesFinished_0102
800 * @tc.name: SUB_backup_ServiceReverse_RestoreOnAllBundlesFinished_0102
801 * @tc.desc: 测试 RestoreOnAllBundlesFinished 接口
802 * @tc.size: MEDIUM
803 * @tc.type: FUNC
804 * @tc.level Level 1
805 * @tc.require: I6F3GV
806 */
807 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_RestoreOnAllBundlesFinished_0102, testing::ext::TestSize.Level1)
808 {
809 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_RestoreOnAllBundlesFinished_0102";
810 try {
811 Init(IServiceReverse::Scenario::RESTORE, 1);
812 if (service_ == nullptr) {
813 GTEST_LOG_(INFO) <<
814 "SUB_backup_ServiceReverse_RestoreOnAllBundlesFinished_0102 service_ == nullptr";
815 return;
816 }
817 service_->RestoreOnAllBundlesFinished(BError(BError::Codes::OK));
818 } catch (...) {
819 EXPECT_TRUE(false);
820 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by RestoreOnAllBundlesFinished.";
821 }
822 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_RestoreOnAllBundlesFinished_0102";
823 }
824
825 /**
826 * @tc.number: SUB_backup_ServiceReverse_BackupOnProcessInfo_0100
827 * @tc.name: SUB_backup_ServiceReverse_BackupOnProcessInfo_0100
828 * @tc.desc: 测试 BackupOnProcessInfo 接口
829 * @tc.size: MEDIUM
830 * @tc.type: FUNC
831 * @tc.level Level 1
832 * @tc.require: I6F3GV
833 */
834 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_BackupOnProcessInfo_0100, testing::ext::TestSize.Level1)
835 {
836 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_BackupOnProcessInfo_0100";
837 try {
838 Init(IServiceReverse::Scenario::BACKUP);
839 if (service_ == nullptr) {
840 GTEST_LOG_(INFO) <<
841 "SUB_backup_ServiceReverse_BackupOnProcessInfo_0100 service_ == nullptr";
842 return;
843 }
844 std::string bundleName = BUNDLE_NAME;
845 std::string processInfo = "{\"timeInfo\": \"\", \"resultInfo\": \"\"}";
846 service_->BackupOnProcessInfo(bundleName, processInfo);
847 service_->RestoreOnProcessInfo(bundleName, processInfo);
848 } catch (...) {
849 EXPECT_TRUE(false);
850 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by BackupOnProcessInfo.";
851 }
852 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_BackupOnProcessInfo_0100";
853 }
854
855 /**
856 * @tc.number: SUB_backup_ServiceReverse_BackupOnProcessInfo_0101
857 * @tc.name: SUB_backup_ServiceReverse_BackupOnProcessInfo_0101
858 * @tc.desc: 测试 BackupOnProcessInfo 接口
859 * @tc.size: MEDIUM
860 * @tc.type: FUNC
861 * @tc.level Level 1
862 * @tc.require: I6F3GV
863 */
864 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_BackupOnProcessInfo_0101, testing::ext::TestSize.Level1)
865 {
866 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_BackupOnProcessInfo_0101";
867 try {
868 Init(IServiceReverse::Scenario::RESTORE);
869 if (service_ == nullptr) {
870 GTEST_LOG_(INFO) <<
871 "SUB_backup_ServiceReverse_BackupOnProcessInfo_0101 service_ == nullptr";
872 return;
873 }
874 std::string bundleName = BUNDLE_NAME;
875 std::string processInfo = "{\"timeInfo\": \"\", \"resultInfo\": \"\"}";
876 service_->BackupOnProcessInfo(bundleName, processInfo);
877 } catch (...) {
878 EXPECT_TRUE(false);
879 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by BackupOnProcessInfo.";
880 }
881 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_BackupOnProcessInfo_0101";
882 }
883
884 /**
885 * @tc.number: SUB_backup_ServiceReverse_BackupOnProcessInfo_0102
886 * @tc.name: SUB_backup_ServiceReverse_BackupOnProcessInfo_0102
887 * @tc.desc: 测试 BackupOnProcessInfo 接口
888 * @tc.size: MEDIUM
889 * @tc.type: FUNC
890 * @tc.level Level 1
891 * @tc.require: I6F3GV
892 */
893 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_BackupOnProcessInfo_0102, testing::ext::TestSize.Level1)
894 {
895 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_BackupOnProcessInfo_0102";
896 try {
897 Init(IServiceReverse::Scenario::BACKUP, 1);
898 if (service_ == nullptr) {
899 GTEST_LOG_(INFO) <<
900 "SUB_backup_ServiceReverse_BackupOnProcessInfo_0102 service_ == nullptr";
901 return;
902 }
903 std::string bundleName = BUNDLE_NAME;
904 std::string processInfo = "{\"timeInfo\": \"\", \"resultInfo\": \"\"}";
905 service_->BackupOnProcessInfo(bundleName, processInfo);
906 } catch (...) {
907 EXPECT_TRUE(false);
908 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by BackupOnProcessInfo.";
909 }
910 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_BackupOnProcessInfo_0102";
911 }
912
913 /**
914 * @tc.number: SUB_backup_ServiceReverse_0200
915 * @tc.name: SUB_backup_ServiceReverse_0200
916 * @tc.desc: 测试分支
917 * @tc.size: MEDIUM
918 * @tc.type: FUNC
919 * @tc.level Level 1
920 * @tc.require: I6F3GV
921 */
922 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_0200, testing::ext::TestSize.Level1)
923 {
924 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_0200";
925 try {
926 Init(IServiceReverse::Scenario::RESTORE, 1);
927 if (service_ == nullptr) {
928 GTEST_LOG_(INFO) <<
929 "SUB_backup_ServiceReverse_0200 service_ == nullptr";
930 return;
931 }
932 service_->RestoreOnFileReady(BUNDLE_NAME, FILE_NAME, -1, 0);
933 service_->RestoreOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME);
934 service_->RestoreOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME);
935 service_->RestoreOnAllBundlesFinished(BError(BError::Codes::OK));
936 } catch (...) {
937 EXPECT_TRUE(false);
938 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred.";
939 }
940 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_0200";
941 }
942
943 /**
944 * @tc.number: SUB_backup_ServiceReverse_0201
945 * @tc.name: SUB_backup_ServiceReverse_0201
946 * @tc.desc: 测试分支
947 * @tc.size: MEDIUM
948 * @tc.type: FUNC
949 * @tc.level Level 1
950 * @tc.require: I6F3GV
951 */
952 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_0201, testing::ext::TestSize.Level1)
953 {
954 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_0201";
955 try {
956 Init(IServiceReverse::Scenario::RESTORE, 0);
957 if (service_ == nullptr) {
958 GTEST_LOG_(INFO) <<
959 "SUB_backup_ServiceReverse_0201 service_ == nullptr";
960 return;
961 }
962 service_->RestoreOnFileReady(BUNDLE_NAME, FILE_NAME, -1, 0);
963 service_->RestoreOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME);
964 service_->RestoreOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME);
965 service_->RestoreOnAllBundlesFinished(BError(BError::Codes::OK));
966 } catch (...) {
967 EXPECT_TRUE(false);
968 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred.";
969 }
970 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_0201";
971 }
972
973 /**
974 * @tc.number: SUB_backup_ServiceReverse_0300
975 * @tc.name: SUB_backup_ServiceReverse_0300
976 * @tc.desc: 测试分支
977 * @tc.size: MEDIUM
978 * @tc.type: FUNC
979 * @tc.level Level 1
980 * @tc.require: I6F3GV
981 */
982 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_0300, testing::ext::TestSize.Level1)
983 {
984 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_0300";
985 try {
986 Init(IServiceReverse::Scenario::BACKUP, 1);
987 if (service_ == nullptr) {
988 GTEST_LOG_(INFO) <<
989 "SUB_backup_ServiceReverse_0300 service_ == nullptr";
990 return;
991 }
992 service_->BackupOnFileReady(BUNDLE_NAME, FILE_NAME, -1, 0);
993 service_->BackupOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME);
994 service_->BackupOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME);
995 service_->BackupOnAllBundlesFinished(BError(BError::Codes::OK));
996 } catch (...) {
997 EXPECT_TRUE(false);
998 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred.";
999 }
1000 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_0300";
1001 }
1002
1003 /**
1004 * @tc.number: SUB_backup_ServiceReverse_0301
1005 * @tc.name: SUB_backup_ServiceReverse_0301
1006 * @tc.desc: 测试分支
1007 * @tc.size: MEDIUM
1008 * @tc.type: FUNC
1009 * @tc.level Level 1
1010 * @tc.require: I6F3GV
1011 */
1012 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_0301, testing::ext::TestSize.Level1)
1013 {
1014 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_0301";
1015 try {
1016 Init(IServiceReverse::Scenario::BACKUP, 0);
1017 if (service_ == nullptr) {
1018 GTEST_LOG_(INFO) <<
1019 "SUB_backup_ServiceReverse_0301 service_ == nullptr";
1020 return;
1021 }
1022 service_->BackupOnFileReady(BUNDLE_NAME, FILE_NAME, -1, 0);
1023 service_->BackupOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME);
1024 service_->BackupOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME);
1025 service_->BackupOnAllBundlesFinished(BError(BError::Codes::OK));
1026 } catch (...) {
1027 EXPECT_TRUE(false);
1028 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred.";
1029 }
1030 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_0301";
1031 }
1032
1033 /**
1034 * @tc.number: SUB_backup_ServiceReverse_IncrementalBackupOnFileReady_0100
1035 * @tc.name: SUB_backup_ServiceReverse_IncrementalBackupOnFileReady_0100
1036 * @tc.desc: 测试 IncrementalBackupOnFileReady 接口
1037 * @tc.size: MEDIUM
1038 * @tc.type: FUNC
1039 * @tc.level Level 1
1040 * @tc.require: I9116W
1041 */
1042 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_IncrementalBackupOnFileReady_0100, testing::ext::TestSize.Level1)
1043 {
1044 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalBackupOnFileReady_0100";
1045 try {
1046 IncrementalInit(IServiceReverse::Scenario::BACKUP);
1047 if (service_ == nullptr) {
1048 GTEST_LOG_(INFO) <<
1049 "SUB_backup_ServiceReverse_IncrementalBackupOnFileReady_0100 service_ == nullptr";
1050 return;
1051 }
1052 service_->IncrementalBackupOnFileReady(BUNDLE_NAME, FILE_NAME, -1, -1, 0);
1053 service_->IncrementalRestoreOnFileReady(BUNDLE_NAME, FILE_NAME, -1, -1, 0);
1054 } catch (...) {
1055 EXPECT_TRUE(false);
1056 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by RestoreOnAllBundlesFinished.";
1057 }
1058 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_IncrementalBackupOnFileReady_0100";
1059 }
1060
1061 /**
1062 * @tc.number: SUB_backup_ServiceReverse_IncrementalBackupOnFileReady_0101
1063 * @tc.name: SUB_backup_ServiceReverse_IncrementalBackupOnFileReady_0101
1064 * @tc.desc: 测试 IncrementalBackupOnFileReady 接口
1065 * @tc.size: MEDIUM
1066 * @tc.type: FUNC
1067 * @tc.level Level 1
1068 * @tc.require: I9116W
1069 */
1070 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_IncrementalBackupOnFileReady_0101, testing::ext::TestSize.Level1)
1071 {
1072 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalBackupOnFileReady_0101";
1073 try {
1074 IncrementalInit(IServiceReverse::Scenario::RESTORE);
1075 if (service_ == nullptr) {
1076 GTEST_LOG_(INFO) <<
1077 "SUB_backup_ServiceReverse_IncrementalBackupOnFileReady_0101 service_ == nullptr";
1078 return;
1079 }
1080 service_->IncrementalBackupOnFileReady(BUNDLE_NAME, FILE_NAME, -1, -1, 0);
1081
1082 IncrementalInit(IServiceReverse::Scenario::BACKUP, 1);
1083 service_->IncrementalBackupOnFileReady(BUNDLE_NAME, FILE_NAME, -1, -1, 0);
1084 } catch (...) {
1085 EXPECT_TRUE(false);
1086 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by IncrementalBackupOnFileReady.";
1087 }
1088 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_IncrementalBackupOnFileReady_0101";
1089 }
1090
1091 /**
1092 * @tc.number: SUB_backup_ServiceReverse_IncrementalBackupOnBundleStarted_0100
1093 * @tc.name: SUB_backup_ServiceReverse_IncrementalBackupOnBundleStarted_0100
1094 * @tc.desc: 测试 IncrementalBackupOnBundleStarted 接口
1095 * @tc.size: MEDIUM
1096 * @tc.type: FUNC
1097 * @tc.level Level 1
1098 * @tc.require: I9116W
1099 */
1100 HWTEST_F(ServiceReverseTest,
1101 SUB_backup_ServiceReverse_IncrementalBackupOnBundleStarted_0100,
1102 testing::ext::TestSize.Level1)
1103 {
1104 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalBackupOnBundleStarted_0100";
1105 try {
1106 IncrementalInit(IServiceReverse::Scenario::BACKUP);
1107 if (service_ == nullptr) {
1108 GTEST_LOG_(INFO) <<
1109 "SUB_backup_ServiceReverse_IncrementalBackupOnBundleStarted_0100 service_ == nullptr";
1110 return;
1111 }
1112 service_->IncrementalBackupOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME);
1113 service_->IncrementalRestoreOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME);
1114 } catch (...) {
1115 EXPECT_TRUE(false);
1116 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by IncrementalBackupOnBundleStarted.";
1117 }
1118 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_IncrementalBackupOnBundleStarted_0100";
1119 }
1120
1121 /**
1122 * @tc.number: SUB_backup_ServiceReverse_IncrementalBackupOnBundleStarted_0101
1123 * @tc.name: SUB_backup_ServiceReverse_IncrementalBackupOnBundleStarted_0101
1124 * @tc.desc: 测试 IncrementalBackupOnBundleStarted 接口
1125 * @tc.size: MEDIUM
1126 * @tc.type: FUNC
1127 * @tc.level Level 1
1128 * @tc.require: I9116W
1129 */
1130 HWTEST_F(ServiceReverseTest,
1131 SUB_backup_ServiceReverse_IncrementalBackupOnBundleStarted_0101,
1132 testing::ext::TestSize.Level1)
1133 {
1134 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalBackupOnBundleStarted_0101";
1135 try {
1136 IncrementalInit(IServiceReverse::Scenario::RESTORE);
1137 if (service_ == nullptr) {
1138 GTEST_LOG_(INFO) <<
1139 "SUB_backup_ServiceReverse_IncrementalBackupOnBundleStarted_0101 service_ == nullptr";
1140 return;
1141 }
1142 service_->IncrementalBackupOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME);
1143
1144 IncrementalInit(IServiceReverse::Scenario::BACKUP, 1);
1145 service_->IncrementalBackupOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME);
1146 } catch (...) {
1147 EXPECT_TRUE(false);
1148 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by IncrementalBackupOnBundleStarted.";
1149 }
1150 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_IncrementalBackupOnBundleStarted_0101";
1151 }
1152
1153 /**
1154 * @tc.number: SUB_backup_ServiceReverse_IncrementalBackupOnBundleFinished_0100
1155 * @tc.name: SUB_backup_ServiceReverse_IncrementalBackupOnBundleFinished_0100
1156 * @tc.desc: 测试 IncrementalBackupOnBundleFinished 接口
1157 * @tc.size: MEDIUM
1158 * @tc.type: FUNC
1159 * @tc.level Level 1
1160 * @tc.require: I9116W
1161 */
1162 HWTEST_F(ServiceReverseTest,
1163 SUB_backup_ServiceReverse_IncrementalBackupOnBundleFinished_0100,
1164 testing::ext::TestSize.Level1)
1165 {
1166 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalBackupOnBundleFinished_0100";
1167 try {
1168 IncrementalInit(IServiceReverse::Scenario::BACKUP);
1169 if (service_ == nullptr) {
1170 GTEST_LOG_(INFO) <<
1171 "SUB_backup_ServiceReverse_IncrementalBackupOnBundleFinished_0100 service_ == nullptr";
1172 return;
1173 }
1174 service_->IncrementalBackupOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME);
1175 service_->IncrementalRestoreOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME);
1176 } catch (...) {
1177 EXPECT_TRUE(false);
1178 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by IncrementalBackupOnBundleFinished.";
1179 }
1180 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_IncrementalBackupOnBundleFinished_0100";
1181 }
1182
1183 /**
1184 * @tc.number: SUB_backup_ServiceReverse_IncrementalBackupOnBundleFinished_0101
1185 * @tc.name: SUB_backup_ServiceReverse_IncrementalBackupOnBundleFinished_0101
1186 * @tc.desc: 测试 IncrementalBackupOnBundleFinished 接口
1187 * @tc.size: MEDIUM
1188 * @tc.type: FUNC
1189 * @tc.level Level 1
1190 * @tc.require: I9116W
1191 */
1192 HWTEST_F(ServiceReverseTest,
1193 SUB_backup_ServiceReverse_IncrementalBackupOnBundleFinished_0101,
1194 testing::ext::TestSize.Level1)
1195 {
1196 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalBackupOnBundleFinished_0101";
1197 try {
1198 IncrementalInit(IServiceReverse::Scenario::RESTORE);
1199 if (service_ == nullptr) {
1200 GTEST_LOG_(INFO) <<
1201 "SUB_backup_ServiceReverse_IncrementalBackupOnBundleFinished_0101 service_ == nullptr";
1202 return;
1203 }
1204 service_->IncrementalBackupOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME);
1205
1206 IncrementalInit(IServiceReverse::Scenario::BACKUP, 1);
1207 service_->IncrementalBackupOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME);
1208 } catch (...) {
1209 EXPECT_TRUE(false);
1210 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by IncrementalBackupOnBundleFinished.";
1211 }
1212 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_IncrementalBackupOnBundleFinished_0101";
1213 }
1214
1215 /**
1216 * @tc.number: SUB_backup_ServiceReverse_IncrementalBackupOnAllBundlesFinished_0100
1217 * @tc.name: SUB_backup_ServiceReverse_IncrementalBackupOnAllBundlesFinished_0100
1218 * @tc.desc: 测试 IncrementalBackupOnAllBundlesFinished 接口
1219 * @tc.size: MEDIUM
1220 * @tc.type: FUNC
1221 * @tc.level Level 1
1222 * @tc.require: I9116W
1223 */
1224 HWTEST_F(ServiceReverseTest,
1225 SUB_backup_ServiceReverse_IncrementalBackupOnAllBundlesFinished_0100,
1226 testing::ext::TestSize.Level1)
1227 {
1228 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalBackupOnAllBundlesFinished_0100";
1229 try {
1230 IncrementalInit(IServiceReverse::Scenario::BACKUP);
1231 if (service_ == nullptr) {
1232 GTEST_LOG_(INFO) <<
1233 "SUB_backup_ServiceReverse_IncrementalBackupOnAllBundlesFinished_0100 service_ == nullptr";
1234 return;
1235 }
1236 service_->IncrementalBackupOnAllBundlesFinished(BError(BError::Codes::OK));
1237 service_->IncrementalRestoreOnAllBundlesFinished(BError(BError::Codes::OK));
1238 } catch (...) {
1239 EXPECT_TRUE(false);
1240 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by IncrementalBackupOnAllBundlesFinished.";
1241 }
1242 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_IncrementalBackupOnAllBundlesFinished_0100";
1243 }
1244
1245 /**
1246 * @tc.number: SUB_backup_ServiceReverse_IncrementalBackupOnAllBundlesFinished_0101
1247 * @tc.name: SUB_backup_ServiceReverse_IncrementalBackupOnAllBundlesFinished_0101
1248 * @tc.desc: 测试 IncrementalBackupOnAllBundlesFinished 接口
1249 * @tc.size: MEDIUM
1250 * @tc.type: FUNC
1251 * @tc.level Level 1
1252 * @tc.require: I9116W
1253 */
1254 HWTEST_F(ServiceReverseTest,
1255 SUB_backup_ServiceReverse_IncrementalBackupOnAllBundlesFinished_0101,
1256 testing::ext::TestSize.Level1)
1257 {
1258 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalBackupOnAllBundlesFinished_0101";
1259 try {
1260 IncrementalInit(IServiceReverse::Scenario::RESTORE);
1261 if (service_ == nullptr) {
1262 GTEST_LOG_(INFO) <<
1263 "SUB_backup_ServiceReverse_IncrementalBackupOnAllBundlesFinished_0101 service_ == nullptr";
1264 return;
1265 }
1266 service_->IncrementalBackupOnAllBundlesFinished(BError(BError::Codes::OK));
1267
1268 IncrementalInit(IServiceReverse::Scenario::BACKUP, 1);
1269 service_->IncrementalBackupOnAllBundlesFinished(BError(BError::Codes::OK));
1270 } catch (...) {
1271 EXPECT_TRUE(false);
1272 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by IncrementalBackupOnAllBundlesFinished.";
1273 }
1274 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_IncrementalBackupOnAllBundlesFinished_0101";
1275 }
1276
1277 /**
1278 * @tc.number: SUB_backup_ServiceReverse_IncrementalRestoreOnFileReady_0100
1279 * @tc.name: SUB_backup_ServiceReverse_IncrementalRestoreOnFileReady_0100
1280 * @tc.desc: 测试 IncrementalRestoreOnFileReady 接口
1281 * @tc.size: MEDIUM
1282 * @tc.type: FUNC
1283 * @tc.level Level 1
1284 * @tc.require: I9116W
1285 */
1286 HWTEST_F(ServiceReverseTest,
1287 SUB_backup_ServiceReverse_IncrementalRestoreOnFileReady_0100,
1288 testing::ext::TestSize.Level1)
1289 {
1290 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalRestoreOnFileReady_0100";
1291 try {
1292 IncrementalInit(IServiceReverse::Scenario::RESTORE);
1293 if (service_ == nullptr) {
1294 GTEST_LOG_(INFO) <<
1295 "SUB_backup_ServiceReverse_IncrementalRestoreOnFileReady_0100 service_ == nullptr";
1296 return;
1297 }
1298 service_->IncrementalRestoreOnFileReady(BUNDLE_NAME, FILE_NAME, -1, -1, 0);
1299 service_->IncrementalBackupOnFileReady(BUNDLE_NAME, FILE_NAME, -1, -1, 0);
1300 } catch (...) {
1301 EXPECT_TRUE(false);
1302 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by IncrementalRestoreOnFileReady.";
1303 }
1304 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_IncrementalRestoreOnFileReady_0100";
1305 }
1306
1307 /**
1308 * @tc.number: SUB_backup_ServiceReverse_IncrementalRestoreOnFileReady_0101
1309 * @tc.name: SUB_backup_ServiceReverse_IncrementalRestoreOnFileReady_0101
1310 * @tc.desc: 测试 IncrementalRestoreOnFileReady 接口
1311 * @tc.size: MEDIUM
1312 * @tc.type: FUNC
1313 * @tc.level Level 1
1314 * @tc.require: I9116W
1315 */
1316 HWTEST_F(ServiceReverseTest,
1317 SUB_backup_ServiceReverse_IncrementalRestoreOnFileReady_0101,
1318 testing::ext::TestSize.Level1)
1319 {
1320 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalRestoreOnFileReady_0101";
1321 try {
1322 IncrementalInit(IServiceReverse::Scenario::BACKUP);
1323 if (service_ == nullptr) {
1324 GTEST_LOG_(INFO) <<
1325 "SUB_backup_ServiceReverse_IncrementalRestoreOnFileReady_0101 service_ == nullptr";
1326 return;
1327 }
1328 service_->IncrementalRestoreOnFileReady(BUNDLE_NAME, FILE_NAME, -1, -1, 0);
1329
1330 IncrementalInit(IServiceReverse::Scenario::RESTORE, 1);
1331 service_->IncrementalRestoreOnFileReady(BUNDLE_NAME, FILE_NAME, -1, -1, 0);
1332 } catch (...) {
1333 EXPECT_TRUE(false);
1334 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by IncrementalRestoreOnFileReady.";
1335 }
1336 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_IncrementalRestoreOnFileReady_0101";
1337 }
1338
1339 /**
1340 * @tc.number: SUB_backup_ServiceReverse_IncrementalRestoreOnBundleStarted_0100
1341 * @tc.name: SUB_backup_ServiceReverse_IncrementalRestoreOnBundleStarted_0100
1342 * @tc.desc: 测试 IncrementalRestoreOnBundleStarted 接口
1343 * @tc.size: MEDIUM
1344 * @tc.type: FUNC
1345 * @tc.level Level 1
1346 * @tc.require: I9116W
1347 */
1348 HWTEST_F(ServiceReverseTest,
1349 SUB_backup_ServiceReverse_IncrementalRestoreOnBundleStarted_0100,
1350 testing::ext::TestSize.Level1)
1351 {
1352 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalRestoreOnBundleStarted_0100";
1353 try {
1354 IncrementalInit(IServiceReverse::Scenario::RESTORE);
1355 if (service_ == nullptr) {
1356 GTEST_LOG_(INFO) <<
1357 "SUB_backup_ServiceReverse_IncrementalRestoreOnBundleStarted_0100 service_ == nullptr";
1358 return;
1359 }
1360 service_->IncrementalRestoreOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME);
1361 service_->IncrementalBackupOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME);
1362 } catch (...) {
1363 EXPECT_TRUE(false);
1364 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by IncrementalRestoreOnBundleStarted.";
1365 }
1366 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_IncrementalRestoreOnBundleStarted_0100";
1367 }
1368
1369 /**
1370 * @tc.number: SUB_backup_ServiceReverse_IncrementalRestoreOnBundleStarted_0101
1371 * @tc.name: SUB_backup_ServiceReverse_IncrementalRestoreOnBundleStarted_0101
1372 * @tc.desc: 测试 IncrementalRestoreOnBundleStarted 接口
1373 * @tc.size: MEDIUM
1374 * @tc.type: FUNC
1375 * @tc.level Level 1
1376 * @tc.require: I9116W
1377 */
1378 HWTEST_F(ServiceReverseTest,
1379 SUB_backup_ServiceReverse_IncrementalRestoreOnBundleStarted_0101,
1380 testing::ext::TestSize.Level1)
1381 {
1382 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalRestoreOnBundleStarted_0101";
1383 try {
1384 IncrementalInit(IServiceReverse::Scenario::BACKUP);
1385 if (service_ == nullptr) {
1386 GTEST_LOG_(INFO) <<
1387 "SUB_backup_ServiceReverse_IncrementalRestoreOnBundleStarted_0101 service_ == nullptr";
1388 return;
1389 }
1390 service_->IncrementalRestoreOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME);
1391
1392 IncrementalInit(IServiceReverse::Scenario::RESTORE, 1);
1393 service_->IncrementalRestoreOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME);
1394 } catch (...) {
1395 EXPECT_TRUE(false);
1396 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by IncrementalRestoreOnBundleStarted.";
1397 }
1398 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_IncrementalRestoreOnBundleStarted_0101";
1399 }
1400
1401 /**
1402 * @tc.number: SUB_backup_ServiceReverse_IncrementalRestoreOnBundleFinished_0100
1403 * @tc.name: SUB_backup_ServiceReverse_IncrementalRestoreOnBundleFinished_0100
1404 * @tc.desc: 测试 IncrementalRestoreOnBundleFinished 接口
1405 * @tc.size: MEDIUM
1406 * @tc.type: FUNC
1407 * @tc.level Level 1
1408 * @tc.require: I9116W
1409 */
1410 HWTEST_F(ServiceReverseTest,
1411 SUB_backup_ServiceReverse_IncrementalRestoreOnBundleFinished_0100,
1412 testing::ext::TestSize.Level1)
1413 {
1414 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalRestoreOnBundleFinished_0100";
1415 try {
1416 IncrementalInit(IServiceReverse::Scenario::RESTORE);
1417 if (service_ == nullptr) {
1418 GTEST_LOG_(INFO) <<
1419 "SUB_backup_ServiceReverse_IncrementalRestoreOnBundleFinished_0100 service_ == nullptr";
1420 return;
1421 }
1422 service_->IncrementalRestoreOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME);
1423 service_->IncrementalBackupOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME);
1424 } catch (...) {
1425 EXPECT_TRUE(false);
1426 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by IncrementalRestoreOnBundleFinished.";
1427 }
1428 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_IncrementalRestoreOnBundleFinished_0100";
1429 }
1430
1431 /**
1432 * @tc.number: SUB_backup_ServiceReverse_IncrementalRestoreOnBundleFinished_0101
1433 * @tc.name: SUB_backup_ServiceReverse_IncrementalRestoreOnBundleFinished_0101
1434 * @tc.desc: 测试 IncrementalRestoreOnBundleFinished 接口
1435 * @tc.size: MEDIUM
1436 * @tc.type: FUNC
1437 * @tc.level Level 1
1438 * @tc.require: I9116W
1439 */
1440 HWTEST_F(ServiceReverseTest,
1441 SUB_backup_ServiceReverse_IncrementalRestoreOnBundleFinished_0101,
1442 testing::ext::TestSize.Level1)
1443 {
1444 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalRestoreOnBundleFinished_0101";
1445 try {
1446 IncrementalInit(IServiceReverse::Scenario::BACKUP);
1447 if (service_ == nullptr) {
1448 GTEST_LOG_(INFO) <<
1449 "SUB_backup_ServiceReverse_IncrementalRestoreOnBundleFinished_0101 service_ == nullptr";
1450 return;
1451 }
1452 service_->IncrementalRestoreOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME);
1453
1454 IncrementalInit(IServiceReverse::Scenario::RESTORE, 1);
1455 service_->IncrementalRestoreOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME);
1456 } catch (...) {
1457 EXPECT_TRUE(false);
1458 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by IncrementalRestoreOnBundleFinished.";
1459 }
1460 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_IncrementalRestoreOnBundleFinished_0101";
1461 }
1462
1463 /**
1464 * @tc.number: SUB_backup_ServiceReverse_IncrementalRestoreOnAllBundlesFinished_0100
1465 * @tc.name: SUB_backup_ServiceReverse_IncrementalRestoreOnAllBundlesFinished_0100
1466 * @tc.desc: 测试 IncrementalRestoreOnAllBundlesFinished 接口
1467 * @tc.size: MEDIUM
1468 * @tc.type: FUNC
1469 * @tc.level Level 1
1470 * @tc.require: I9116W
1471 */
1472 HWTEST_F(ServiceReverseTest,
1473 SUB_backup_ServiceReverse_IncrementalRestoreOnAllBundlesFinished_0100,
1474 testing::ext::TestSize.Level1)
1475 {
1476 GTEST_LOG_(INFO)
1477 << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalRestoreOnAllBundlesFinished_0100";
1478 try {
1479 IncrementalInit(IServiceReverse::Scenario::RESTORE);
1480 if (service_ == nullptr) {
1481 GTEST_LOG_(INFO) <<
1482 "SUB_backup_ServiceReverse_IncrementalRestoreOnAllBundlesFinished_0100 service_ == nullptr";
1483 return;
1484 }
1485 service_->IncrementalRestoreOnAllBundlesFinished(BError(BError::Codes::OK));
1486 service_->IncrementalBackupOnAllBundlesFinished(BError(BError::Codes::OK));
1487 } catch (...) {
1488 EXPECT_TRUE(false);
1489 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by IncrementalRestoreOnAllBundlesFinished.";
1490 }
1491 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_IncrementalRestoreOnAllBundlesFinished_0100";
1492 }
1493
1494 /**
1495 * @tc.number: SUB_backup_ServiceReverse_IncrementalRestoreOnAllBundlesFinished_0101
1496 * @tc.name: SUB_backup_ServiceReverse_IncrementalRestoreOnAllBundlesFinished_0101
1497 * @tc.desc: 测试 IncrementalRestoreOnAllBundlesFinished 接口
1498 * @tc.size: MEDIUM
1499 * @tc.type: FUNC
1500 * @tc.level Level 1
1501 * @tc.require: I9116W
1502 */
1503 HWTEST_F(ServiceReverseTest,
1504 SUB_backup_ServiceReverse_IncrementalRestoreOnAllBundlesFinished_0101,
1505 testing::ext::TestSize.Level1)
1506 {
1507 GTEST_LOG_(INFO)
1508 << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalRestoreOnAllBundlesFinished_0101";
1509 try {
1510 IncrementalInit(IServiceReverse::Scenario::BACKUP);
1511 if (service_ == nullptr) {
1512 GTEST_LOG_(INFO) <<
1513 "SUB_backup_ServiceReverse_IncrementalRestoreOnAllBundlesFinished_0101 service_ == nullptr";
1514 return;
1515 }
1516 service_->IncrementalRestoreOnAllBundlesFinished(BError(BError::Codes::OK));
1517
1518 IncrementalInit(IServiceReverse::Scenario::RESTORE, 1);
1519 service_->IncrementalRestoreOnAllBundlesFinished(BError(BError::Codes::OK));
1520 } catch (...) {
1521 EXPECT_TRUE(false);
1522 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by IncrementalRestoreOnAllBundlesFinished.";
1523 }
1524 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_IncrementalRestoreOnAllBundlesFinished_0101";
1525 }
1526
1527 /**
1528 * @tc.number: SUB_backup_ServiceReverse_RestoreOnResultReport_0100
1529 * @tc.name: SUB_backup_ServiceReverse_RestoreOnResultReport_0100
1530 * @tc.desc: 测试 RestoreOnResultReport 接口
1531 * @tc.size: MEDIUM
1532 * @tc.type: FUNC
1533 * @tc.level Level 1
1534 * @tc.require: I6F3GV
1535 */
1536 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_RestoreOnResultReport_0100, testing::ext::TestSize.Level1)
1537 {
1538 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_RestoreOnResultReport_0100";
1539 try {
1540 Init(IServiceReverse::Scenario::RESTORE);
1541 if (service_ == nullptr) {
1542 GTEST_LOG_(INFO) << "SUB_backup_ServiceReverse_RestoreOnResultReport_0100 service_ == nullptr";
1543 return;
1544 }
1545 std::string resultReport = "result_report";
1546 std::string bundleName = BUNDLE_NAME;
1547 service_->RestoreOnResultReport(resultReport, bundleName);
1548 } catch (...) {
1549 EXPECT_TRUE(false);
1550 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by RestoreOnResultReport.";
1551 }
1552 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_RestoreOnResultReport_0100";
1553 }
1554
1555 /**
1556 * @tc.number: SUB_backup_ServiceReverse_RestoreOnResultReport_0101
1557 * @tc.name: SUB_backup_ServiceReverse_RestoreOnResultReport_0101
1558 * @tc.desc: 测试 RestoreOnResultReport 接口
1559 * @tc.size: MEDIUM
1560 * @tc.type: FUNC
1561 * @tc.level Level 1
1562 * @tc.require: I6F3GV
1563 */
1564 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_RestoreOnResultReport_0101, testing::ext::TestSize.Level1)
1565 {
1566 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_RestoreOnResultReport_0101";
1567 try {
1568 Init(IServiceReverse::Scenario::RESTORE, 1);
1569 if (service_ == nullptr) {
1570 GTEST_LOG_(INFO) << "SUB_backup_ServiceReverse_RestoreOnResultReport_0101 service_ == nullptr";
1571 return;
1572 }
1573 std::string resultReport = "result_report";
1574 std::string bundleName = BUNDLE_NAME;
1575 service_->RestoreOnResultReport(resultReport, bundleName);
1576 } catch (...) {
1577 EXPECT_TRUE(false);
1578 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by RestoreOnResultReport.";
1579 }
1580 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_RestoreOnResultReport_0101";
1581 }
1582
1583 /**
1584 * @tc.number: SUB_backup_ServiceReverse_IncrementalRestoreOnResultReport_0100
1585 * @tc.name: SUB_backup_ServiceReverse_IncrementalRestoreOnResultReport_0100
1586 * @tc.desc: 测试 IncrementalRestoreOnResultReport 接口
1587 * @tc.size: MEDIUM
1588 * @tc.type: FUNC
1589 * @tc.level Level 1
1590 * @tc.require: I6F3GV
1591 */
1592 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_IncrementalRestoreOnResultReport_0100,
1593 testing::ext::TestSize.Level1)
1594 {
1595 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalRestoreOnResultReport_0100";
1596 try {
1597 IncrementalInit(IServiceReverse::Scenario::RESTORE);
1598 if (service_ == nullptr) {
1599 GTEST_LOG_(INFO) << "SUB_backup_ServiceReverse_IncrementalRestoreOnResultReport_0100 service_ == nullptr";
1600 return;
1601 }
1602 std::string resultReport = "result_report";
1603 std::string bundleName = BUNDLE_NAME;
1604 service_->IncrementalRestoreOnResultReport(resultReport, bundleName);
1605 } catch (...) {
1606 EXPECT_TRUE(false);
1607 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by IncrementalRestoreOnResultReport.";
1608 }
1609 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_IncrementalRestoreOnResultReport_0100";
1610 }
1611
1612 /**
1613 * @tc.number: SUB_backup_ServiceReverse_IncrementalRestoreOnResultReport_0101
1614 * @tc.name: SUB_backup_ServiceReverse_IncrementalRestoreOnResultReport_0101
1615 * @tc.desc: 测试 IncrementalRestoreOnResultReport 接口
1616 * @tc.size: MEDIUM
1617 * @tc.type: FUNC
1618 * @tc.level Level 1
1619 * @tc.require: I6F3GV
1620 */
1621 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_IncrementalRestoreOnResultReport_0101,
1622 testing::ext::TestSize.Level1)
1623 {
1624 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalRestoreOnResultReport_0101";
1625 try {
1626 IncrementalInit(IServiceReverse::Scenario::RESTORE, 1);
1627 if (service_ == nullptr) {
1628 GTEST_LOG_(INFO) << "SUB_backup_ServiceReverse_IncrementalRestoreOnResultReport_0101 service_ == nullptr";
1629 return;
1630 }
1631 std::string resultReport = "result_report";
1632 std::string bundleName = BUNDLE_NAME;
1633 service_->IncrementalRestoreOnResultReport(resultReport, bundleName);
1634 } catch (...) {
1635 EXPECT_TRUE(false);
1636 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by IncrementalRestoreOnResultReport.";
1637 }
1638 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_IncrementalRestoreOnResultReport_0101";
1639 }
1640
1641 /**
1642 * @tc.number: SUB_backup_ServiceReverse_BackupOnResultReport_0100
1643 * @tc.name: SUB_backup_ServiceReverse_BackupOnResultReport_0100
1644 * @tc.desc: 测试 BackupOnResultReport 接口
1645 * @tc.size: MEDIUM
1646 * @tc.type: FUNC
1647 * @tc.level Level 1
1648 * @tc.require: I6F3GV
1649 */
1650 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_BackupOnResultReport_0100, testing::ext::TestSize.Level1)
1651 {
1652 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_BackupOnResultReport_0100";
1653 try {
1654 Init(IServiceReverse::Scenario::BACKUP);
1655 std::string resultReport = "result_report";
1656 std::string bundleName = BUNDLE_NAME;
1657 if (service_ == nullptr) {
1658 GTEST_LOG_(INFO) << "SUB_backup_ServiceReverse_BackupOnResultReport_0100 service_ == nullptr";
1659 return;
1660 }
1661 service_->BackupOnResultReport(resultReport, bundleName);
1662 } catch (...) {
1663 EXPECT_TRUE(false);
1664 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by BackupOnResultReport.";
1665 }
1666 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_BackupOnResultReport_0100";
1667 }
1668
1669 /**
1670 * @tc.number: SUB_backup_ServiceReverse_BackupOnResultReport_0101
1671 * @tc.name: SUB_backup_ServiceReverse_BackupOnResultReport_0101
1672 * @tc.desc: 测试 BackupOnResultReport 接口
1673 * @tc.size: MEDIUM
1674 * @tc.type: FUNC
1675 * @tc.level Level 1
1676 * @tc.require: I6F3GV
1677 */
1678 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_BackupOnResultReport_0101, testing::ext::TestSize.Level1)
1679 {
1680 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_BackupOnResultReport_0101";
1681 try {
1682 Init(IServiceReverse::Scenario::BACKUP, 1);
1683 std::string resultReport = "result_report";
1684 std::string bundleName = BUNDLE_NAME;
1685 if (service_ == nullptr) {
1686 GTEST_LOG_(INFO) << "SUB_backup_ServiceReverse_BackupOnResultReport_0101 service_ == nullptr";
1687 return;
1688 }
1689 service_->BackupOnResultReport(resultReport, bundleName);
1690 } catch (...) {
1691 EXPECT_TRUE(false);
1692 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by BackupOnResultReport.";
1693 }
1694 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_BackupOnResultReport_0101";
1695 }
1696
1697 /**
1698 * @tc.number: SUB_backup_ServiceReverse_IncrementalBackupOnResultReport_0100
1699 * @tc.name: SUB_backup_ServiceReverse_IncrementalBackupOnResultReport_0100
1700 * @tc.desc: 测试 IncrementalBackupOnResultReport 接口
1701 * @tc.size: MEDIUM
1702 * @tc.type: FUNC
1703 * @tc.level Level 1
1704 * @tc.require: I6F3GV
1705 */
1706 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_IncrementalBackupOnResultReport_0100,
1707 testing::ext::TestSize.Level1)
1708 {
1709 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalBackupOnResultReport_0100";
1710 try {
1711 IncrementalInit(IServiceReverse::Scenario::BACKUP);
1712 std::string resultReport = "result_report";
1713 std::string bundleName = BUNDLE_NAME;
1714 if (service_ == nullptr) {
1715 GTEST_LOG_(INFO) << "SUB_backup_ServiceReverse_IncrementalBackupOnResultReport_0100 service_ == nullptr";
1716 return;
1717 }
1718 service_->IncrementalBackupOnResultReport(resultReport, bundleName);
1719 } catch (...) {
1720 EXPECT_TRUE(false);
1721 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by IncrementalBackupOnResultReport.";
1722 }
1723 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_IncrementalBackupOnResultReport_0100";
1724 }
1725
1726 /**
1727 * @tc.number: SUB_backup_ServiceReverse_IncrementalBackupOnResultReport_0101
1728 * @tc.name: SUB_backup_ServiceReverse_IncrementalBackupOnResultReport_0101
1729 * @tc.desc: 测试 IncrementalBackupOnResultReport 接口
1730 * @tc.size: MEDIUM
1731 * @tc.type: FUNC
1732 * @tc.level Level 1
1733 * @tc.require: I6F3GV
1734 */
1735 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_IncrementalBackupOnResultReport_0101,
1736 testing::ext::TestSize.Level1)
1737 {
1738 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalBackupOnResultReport_0101";
1739 try {
1740 IncrementalInit(IServiceReverse::Scenario::BACKUP, 1);
1741 std::string resultReport = "result_report";
1742 std::string bundleName = BUNDLE_NAME;
1743 if (service_ == nullptr) {
1744 GTEST_LOG_(INFO) << "SUB_backup_ServiceReverse_IncrementalBackupOnResultReport_0101 service_ == nullptr";
1745 return;
1746 }
1747 service_->IncrementalBackupOnResultReport(resultReport, bundleName);
1748 } catch (...) {
1749 EXPECT_TRUE(false);
1750 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by IncrementalBackupOnResultReport.";
1751 }
1752 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_IncrementalBackupOnResultReport_0101";
1753 }
1754
1755 /**
1756 * @tc.number: SUB_backup_ServiceReverse_BackupOnScanningInfo_0100
1757 * @tc.name: SUB_backup_ServiceReverse_BackupOnScanningInfo_0100
1758 * @tc.desc: 测试 BackupOnScanningInfo 接口
1759 * @tc.size: MEDIUM
1760 * @tc.type: FUNC
1761 * @tc.level Level 1
1762 * @tc.require: I6F3GV
1763 */
1764 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_BackupOnScanningInfo_0100, testing::ext::TestSize.Level1)
1765 {
1766 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_BackupOnScanningInfo_0100";
1767 try {
1768 Init(IServiceReverse::Scenario::BACKUP);
1769 if (service_ == nullptr) {
1770 GTEST_LOG_(INFO) <<
1771 "SUB_backup_ServiceReverse_BackupOnScanningInfo_0100 service_ == nullptr";
1772 return;
1773 }
1774 std::string scannedInfo = "";
1775 service_->BackupOnScanningInfo(scannedInfo);
1776 } catch (...) {
1777 EXPECT_TRUE(false);
1778 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by BackupOnScanningInfo.";
1779 }
1780 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_BackupOnScanningInfo_0100";
1781 }
1782
1783 /**
1784 * @tc.number: SUB_backup_ServiceReverse_BackupOnScanningInfo_0101
1785 * @tc.name: SUB_backup_ServiceReverse_BackupOnScanningInfo_0101
1786 * @tc.desc: 测试 BackupOnScanningInfo 接口
1787 * @tc.size: MEDIUM
1788 * @tc.type: FUNC
1789 * @tc.level Level 1
1790 * @tc.require: I6F3GV
1791 */
1792 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_BackupOnScanningInfo_0101, testing::ext::TestSize.Level1)
1793 {
1794 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_BackupOnScanningInfo_0101";
1795 try {
1796 Init(IServiceReverse::Scenario::RESTORE);
1797 if (service_ == nullptr) {
1798 GTEST_LOG_(INFO) <<
1799 "SUB_backup_ServiceReverse_BackupOnScanningInfo_0101 service_ == nullptr";
1800 return;
1801 }
1802 std::string scannedInfo = "";
1803 service_->BackupOnScanningInfo(scannedInfo);
1804 } catch (...) {
1805 EXPECT_TRUE(false);
1806 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by BackupOnScanningInfo.";
1807 }
1808 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_BackupOnScanningInfo_0101";
1809 }
1810
1811 /**
1812 * @tc.number: SUB_backup_ServiceReverse_IncrementalBackupOnScanningInfo_0100
1813 * @tc.name: SUB_backup_ServiceReverse_IncrementalBackupOnScanningInfo_0100
1814 * @tc.desc: 测试 IncrementalBackupOnScanningInfo 接口
1815 * @tc.size: MEDIUM
1816 * @tc.type: FUNC
1817 * @tc.level Level 1
1818 * @tc.require: I6F3GV
1819 */
1820 HWTEST_F(ServiceReverseTest,
1821 SUB_backup_ServiceReverse_IncrementalBackupOnScanningInfo_0100, testing::ext::TestSize.Level1)
1822 {
1823 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalBackupOnScanningInfo_0100";
1824 try {
1825 Init(IServiceReverse::Scenario::RESTORE);
1826 if (service_ == nullptr) {
1827 GTEST_LOG_(INFO) <<
1828 "SUB_backup_ServiceReverse_IncrementalBackupOnScanningInfo_0100 service_ == nullptr";
1829 return;
1830 }
1831 std::string scannedInfo = "";
1832 service_->BackupOnScanningInfo(scannedInfo);
1833 } catch (...) {
1834 EXPECT_TRUE(false);
1835 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by BackupOnScanningInfo.";
1836 }
1837 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_IncrementalBackupOnScanningInfo_0100";
1838 }
1839
1840 /**
1841 * @tc.number: SUB_backup_ServiceReverse_IncrementalBackupOnScanningInfo_0101
1842 * @tc.name: SUB_backup_ServiceReverse_IncrementalBackupOnScanningInfo_0101
1843 * @tc.desc: 测试 IncrementalBackupOnScanningInfo 接口
1844 * @tc.size: MEDIUM
1845 * @tc.type: FUNC
1846 * @tc.level Level 1
1847 * @tc.require: I6F3GV
1848 */
1849 HWTEST_F(ServiceReverseTest,
1850 SUB_backup_ServiceReverse_IncrementalBackupOnScanningInfo_0101, testing::ext::TestSize.Level1)
1851 {
1852 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalBackupOnScanningInfo_0101";
1853 try {
1854 Init(IServiceReverse::Scenario::BACKUP);
1855 if (service_ == nullptr) {
1856 GTEST_LOG_(INFO) <<
1857 "SUB_backup_ServiceReverse_IncrementalBackupOnScanningInfo_0101 service_ == nullptr";
1858 return;
1859 }
1860 std::string scannedInfo = "";
1861 service_->BackupOnScanningInfo(scannedInfo);
1862 } catch (...) {
1863 EXPECT_TRUE(false);
1864 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by BackupOnScanningInfo.";
1865 }
1866 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_IncrementalBackupOnScanningInfo_0101";
1867 }
1868 } // namespace OHOS::FileManagement::Backup