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_0200
827  * @tc.name: SUB_backup_ServiceReverse_0200
828  * @tc.desc: 测试分支
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_0200, testing::ext::TestSize.Level1)
835 {
836     GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_0200";
837     try {
838         Init(IServiceReverse::Scenario::RESTORE, 1);
839         if (service_ == nullptr) {
840             GTEST_LOG_(INFO) <<
841                 "SUB_backup_ServiceReverse_0200 service_ == nullptr";
842             return;
843         }
844         service_->RestoreOnFileReady(BUNDLE_NAME, FILE_NAME, -1, 0);
845         service_->RestoreOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME);
846         service_->RestoreOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME);
847         service_->RestoreOnAllBundlesFinished(BError(BError::Codes::OK));
848     } catch (...) {
849         EXPECT_TRUE(false);
850         GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred.";
851     }
852     GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_0200";
853 }
854 
855 /**
856  * @tc.number: SUB_backup_ServiceReverse_0201
857  * @tc.name: SUB_backup_ServiceReverse_0201
858  * @tc.desc: 测试分支
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_0201, testing::ext::TestSize.Level1)
865 {
866     GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_0201";
867     try {
868         Init(IServiceReverse::Scenario::RESTORE, 0);
869         if (service_ == nullptr) {
870             GTEST_LOG_(INFO) <<
871                 "SUB_backup_ServiceReverse_0201 service_ == nullptr";
872             return;
873         }
874         service_->RestoreOnFileReady(BUNDLE_NAME, FILE_NAME, -1, 0);
875         service_->RestoreOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME);
876         service_->RestoreOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME);
877         service_->RestoreOnAllBundlesFinished(BError(BError::Codes::OK));
878     } catch (...) {
879         EXPECT_TRUE(false);
880         GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred.";
881     }
882     GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_0201";
883 }
884 
885 /**
886  * @tc.number: SUB_backup_ServiceReverse_0300
887  * @tc.name: SUB_backup_ServiceReverse_0300
888  * @tc.desc: 测试分支
889  * @tc.size: MEDIUM
890  * @tc.type: FUNC
891  * @tc.level Level 1
892  * @tc.require: I6F3GV
893  */
894 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_0300, testing::ext::TestSize.Level1)
895 {
896     GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_0300";
897     try {
898         Init(IServiceReverse::Scenario::BACKUP, 1);
899         if (service_ == nullptr) {
900             GTEST_LOG_(INFO) <<
901                 "SUB_backup_ServiceReverse_0300 service_ == nullptr";
902             return;
903         }
904         service_->BackupOnFileReady(BUNDLE_NAME, FILE_NAME, -1, 0);
905         service_->BackupOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME);
906         service_->BackupOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME);
907         service_->BackupOnAllBundlesFinished(BError(BError::Codes::OK));
908     } catch (...) {
909         EXPECT_TRUE(false);
910         GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred.";
911     }
912     GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_0300";
913 }
914 
915 /**
916  * @tc.number: SUB_backup_ServiceReverse_0301
917  * @tc.name: SUB_backup_ServiceReverse_0301
918  * @tc.desc: 测试分支
919  * @tc.size: MEDIUM
920  * @tc.type: FUNC
921  * @tc.level Level 1
922  * @tc.require: I6F3GV
923  */
924 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_0301, testing::ext::TestSize.Level1)
925 {
926     GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_0301";
927     try {
928         Init(IServiceReverse::Scenario::BACKUP, 0);
929         if (service_ == nullptr) {
930             GTEST_LOG_(INFO) <<
931                 "SUB_backup_ServiceReverse_0301 service_ == nullptr";
932             return;
933         }
934         service_->BackupOnFileReady(BUNDLE_NAME, FILE_NAME, -1, 0);
935         service_->BackupOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME);
936         service_->BackupOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME);
937         service_->BackupOnAllBundlesFinished(BError(BError::Codes::OK));
938     } catch (...) {
939         EXPECT_TRUE(false);
940         GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred.";
941     }
942     GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_0301";
943 }
944 
945 /**
946  * @tc.number: SUB_backup_ServiceReverse_IncrementalBackupOnFileReady_0100
947  * @tc.name: SUB_backup_ServiceReverse_IncrementalBackupOnFileReady_0100
948  * @tc.desc: 测试 IncrementalBackupOnFileReady 接口
949  * @tc.size: MEDIUM
950  * @tc.type: FUNC
951  * @tc.level Level 1
952  * @tc.require: I9116W
953  */
954 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_IncrementalBackupOnFileReady_0100, testing::ext::TestSize.Level1)
955 {
956     GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalBackupOnFileReady_0100";
957     try {
958         IncrementalInit(IServiceReverse::Scenario::BACKUP);
959         if (service_ == nullptr) {
960             GTEST_LOG_(INFO) <<
961                 "SUB_backup_ServiceReverse_IncrementalBackupOnFileReady_0100 service_ == nullptr";
962             return;
963         }
964         service_->IncrementalBackupOnFileReady(BUNDLE_NAME, FILE_NAME, -1, -1, 0);
965         service_->IncrementalRestoreOnFileReady(BUNDLE_NAME, FILE_NAME, -1, -1, 0);
966     } catch (...) {
967         EXPECT_TRUE(false);
968         GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by RestoreOnAllBundlesFinished.";
969     }
970     GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_IncrementalBackupOnFileReady_0100";
971 }
972 
973 /**
974  * @tc.number: SUB_backup_ServiceReverse_IncrementalBackupOnFileReady_0101
975  * @tc.name: SUB_backup_ServiceReverse_IncrementalBackupOnFileReady_0101
976  * @tc.desc: 测试 IncrementalBackupOnFileReady 接口
977  * @tc.size: MEDIUM
978  * @tc.type: FUNC
979  * @tc.level Level 1
980  * @tc.require: I9116W
981  */
982 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_IncrementalBackupOnFileReady_0101, testing::ext::TestSize.Level1)
983 {
984     GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalBackupOnFileReady_0101";
985     try {
986         IncrementalInit(IServiceReverse::Scenario::RESTORE);
987         if (service_ == nullptr) {
988             GTEST_LOG_(INFO) <<
989                 "SUB_backup_ServiceReverse_IncrementalBackupOnFileReady_0101 service_ == nullptr";
990             return;
991         }
992         service_->IncrementalBackupOnFileReady(BUNDLE_NAME, FILE_NAME, -1, -1, 0);
993 
994         IncrementalInit(IServiceReverse::Scenario::BACKUP, 1);
995         service_->IncrementalBackupOnFileReady(BUNDLE_NAME, FILE_NAME, -1, -1, 0);
996     } catch (...) {
997         EXPECT_TRUE(false);
998         GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by IncrementalBackupOnFileReady.";
999     }
1000     GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_IncrementalBackupOnFileReady_0101";
1001 }
1002 
1003 /**
1004  * @tc.number: SUB_backup_ServiceReverse_IncrementalBackupOnBundleStarted_0100
1005  * @tc.name: SUB_backup_ServiceReverse_IncrementalBackupOnBundleStarted_0100
1006  * @tc.desc: 测试 IncrementalBackupOnBundleStarted 接口
1007  * @tc.size: MEDIUM
1008  * @tc.type: FUNC
1009  * @tc.level Level 1
1010  * @tc.require: I9116W
1011  */
1012 HWTEST_F(ServiceReverseTest,
1013          SUB_backup_ServiceReverse_IncrementalBackupOnBundleStarted_0100,
1014          testing::ext::TestSize.Level1)
1015 {
1016     GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalBackupOnBundleStarted_0100";
1017     try {
1018         IncrementalInit(IServiceReverse::Scenario::BACKUP);
1019         if (service_ == nullptr) {
1020             GTEST_LOG_(INFO) <<
1021                 "SUB_backup_ServiceReverse_IncrementalBackupOnBundleStarted_0100 service_ == nullptr";
1022             return;
1023         }
1024         service_->IncrementalBackupOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME);
1025         service_->IncrementalRestoreOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME);
1026     } catch (...) {
1027         EXPECT_TRUE(false);
1028         GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by IncrementalBackupOnBundleStarted.";
1029     }
1030     GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_IncrementalBackupOnBundleStarted_0100";
1031 }
1032 
1033 /**
1034  * @tc.number: SUB_backup_ServiceReverse_IncrementalBackupOnBundleStarted_0101
1035  * @tc.name: SUB_backup_ServiceReverse_IncrementalBackupOnBundleStarted_0101
1036  * @tc.desc: 测试 IncrementalBackupOnBundleStarted 接口
1037  * @tc.size: MEDIUM
1038  * @tc.type: FUNC
1039  * @tc.level Level 1
1040  * @tc.require: I9116W
1041  */
1042 HWTEST_F(ServiceReverseTest,
1043          SUB_backup_ServiceReverse_IncrementalBackupOnBundleStarted_0101,
1044          testing::ext::TestSize.Level1)
1045 {
1046     GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalBackupOnBundleStarted_0101";
1047     try {
1048         IncrementalInit(IServiceReverse::Scenario::RESTORE);
1049         if (service_ == nullptr) {
1050             GTEST_LOG_(INFO) <<
1051                 "SUB_backup_ServiceReverse_IncrementalBackupOnBundleStarted_0101 service_ == nullptr";
1052             return;
1053         }
1054         service_->IncrementalBackupOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME);
1055 
1056         IncrementalInit(IServiceReverse::Scenario::BACKUP, 1);
1057         service_->IncrementalBackupOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME);
1058     } catch (...) {
1059         EXPECT_TRUE(false);
1060         GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by IncrementalBackupOnBundleStarted.";
1061     }
1062     GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_IncrementalBackupOnBundleStarted_0101";
1063 }
1064 
1065 /**
1066  * @tc.number: SUB_backup_ServiceReverse_IncrementalBackupOnBundleFinished_0100
1067  * @tc.name: SUB_backup_ServiceReverse_IncrementalBackupOnBundleFinished_0100
1068  * @tc.desc: 测试 IncrementalBackupOnBundleFinished 接口
1069  * @tc.size: MEDIUM
1070  * @tc.type: FUNC
1071  * @tc.level Level 1
1072  * @tc.require: I9116W
1073  */
1074 HWTEST_F(ServiceReverseTest,
1075          SUB_backup_ServiceReverse_IncrementalBackupOnBundleFinished_0100,
1076          testing::ext::TestSize.Level1)
1077 {
1078     GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalBackupOnBundleFinished_0100";
1079     try {
1080         IncrementalInit(IServiceReverse::Scenario::BACKUP);
1081         if (service_ == nullptr) {
1082             GTEST_LOG_(INFO) <<
1083                 "SUB_backup_ServiceReverse_IncrementalBackupOnBundleFinished_0100 service_ == nullptr";
1084             return;
1085         }
1086         service_->IncrementalBackupOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME);
1087         service_->IncrementalRestoreOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME);
1088     } catch (...) {
1089         EXPECT_TRUE(false);
1090         GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by IncrementalBackupOnBundleFinished.";
1091     }
1092     GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_IncrementalBackupOnBundleFinished_0100";
1093 }
1094 
1095 /**
1096  * @tc.number: SUB_backup_ServiceReverse_IncrementalBackupOnBundleFinished_0101
1097  * @tc.name: SUB_backup_ServiceReverse_IncrementalBackupOnBundleFinished_0101
1098  * @tc.desc: 测试 IncrementalBackupOnBundleFinished 接口
1099  * @tc.size: MEDIUM
1100  * @tc.type: FUNC
1101  * @tc.level Level 1
1102  * @tc.require: I9116W
1103  */
1104 HWTEST_F(ServiceReverseTest,
1105          SUB_backup_ServiceReverse_IncrementalBackupOnBundleFinished_0101,
1106          testing::ext::TestSize.Level1)
1107 {
1108     GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalBackupOnBundleFinished_0101";
1109     try {
1110         IncrementalInit(IServiceReverse::Scenario::RESTORE);
1111         if (service_ == nullptr) {
1112             GTEST_LOG_(INFO) <<
1113                 "SUB_backup_ServiceReverse_IncrementalBackupOnBundleFinished_0101 service_ == nullptr";
1114             return;
1115         }
1116         service_->IncrementalBackupOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME);
1117 
1118         IncrementalInit(IServiceReverse::Scenario::BACKUP, 1);
1119         service_->IncrementalBackupOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME);
1120     } catch (...) {
1121         EXPECT_TRUE(false);
1122         GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by IncrementalBackupOnBundleFinished.";
1123     }
1124     GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_IncrementalBackupOnBundleFinished_0101";
1125 }
1126 
1127 /**
1128  * @tc.number: SUB_backup_ServiceReverse_IncrementalBackupOnAllBundlesFinished_0100
1129  * @tc.name: SUB_backup_ServiceReverse_IncrementalBackupOnAllBundlesFinished_0100
1130  * @tc.desc: 测试 IncrementalBackupOnAllBundlesFinished 接口
1131  * @tc.size: MEDIUM
1132  * @tc.type: FUNC
1133  * @tc.level Level 1
1134  * @tc.require: I9116W
1135  */
1136 HWTEST_F(ServiceReverseTest,
1137          SUB_backup_ServiceReverse_IncrementalBackupOnAllBundlesFinished_0100,
1138          testing::ext::TestSize.Level1)
1139 {
1140     GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalBackupOnAllBundlesFinished_0100";
1141     try {
1142         IncrementalInit(IServiceReverse::Scenario::BACKUP);
1143         if (service_ == nullptr) {
1144             GTEST_LOG_(INFO) <<
1145                 "SUB_backup_ServiceReverse_IncrementalBackupOnAllBundlesFinished_0100 service_ == nullptr";
1146             return;
1147         }
1148         service_->IncrementalBackupOnAllBundlesFinished(BError(BError::Codes::OK));
1149         service_->IncrementalRestoreOnAllBundlesFinished(BError(BError::Codes::OK));
1150     } catch (...) {
1151         EXPECT_TRUE(false);
1152         GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by IncrementalBackupOnAllBundlesFinished.";
1153     }
1154     GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_IncrementalBackupOnAllBundlesFinished_0100";
1155 }
1156 
1157 /**
1158  * @tc.number: SUB_backup_ServiceReverse_IncrementalBackupOnAllBundlesFinished_0101
1159  * @tc.name: SUB_backup_ServiceReverse_IncrementalBackupOnAllBundlesFinished_0101
1160  * @tc.desc: 测试 IncrementalBackupOnAllBundlesFinished 接口
1161  * @tc.size: MEDIUM
1162  * @tc.type: FUNC
1163  * @tc.level Level 1
1164  * @tc.require: I9116W
1165  */
1166 HWTEST_F(ServiceReverseTest,
1167          SUB_backup_ServiceReverse_IncrementalBackupOnAllBundlesFinished_0101,
1168          testing::ext::TestSize.Level1)
1169 {
1170     GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalBackupOnAllBundlesFinished_0101";
1171     try {
1172         IncrementalInit(IServiceReverse::Scenario::RESTORE);
1173         if (service_ == nullptr) {
1174             GTEST_LOG_(INFO) <<
1175                 "SUB_backup_ServiceReverse_IncrementalBackupOnAllBundlesFinished_0101 service_ == nullptr";
1176             return;
1177         }
1178         service_->IncrementalBackupOnAllBundlesFinished(BError(BError::Codes::OK));
1179 
1180         IncrementalInit(IServiceReverse::Scenario::BACKUP, 1);
1181         service_->IncrementalBackupOnAllBundlesFinished(BError(BError::Codes::OK));
1182     } catch (...) {
1183         EXPECT_TRUE(false);
1184         GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by IncrementalBackupOnAllBundlesFinished.";
1185     }
1186     GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_IncrementalBackupOnAllBundlesFinished_0101";
1187 }
1188 
1189 /**
1190  * @tc.number: SUB_backup_ServiceReverse_IncrementalRestoreOnFileReady_0100
1191  * @tc.name: SUB_backup_ServiceReverse_IncrementalRestoreOnFileReady_0100
1192  * @tc.desc: 测试 IncrementalRestoreOnFileReady 接口
1193  * @tc.size: MEDIUM
1194  * @tc.type: FUNC
1195  * @tc.level Level 1
1196  * @tc.require: I9116W
1197  */
1198 HWTEST_F(ServiceReverseTest,
1199          SUB_backup_ServiceReverse_IncrementalRestoreOnFileReady_0100,
1200          testing::ext::TestSize.Level1)
1201 {
1202     GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalRestoreOnFileReady_0100";
1203     try {
1204         IncrementalInit(IServiceReverse::Scenario::RESTORE);
1205         if (service_ == nullptr) {
1206             GTEST_LOG_(INFO) <<
1207                 "SUB_backup_ServiceReverse_IncrementalRestoreOnFileReady_0100 service_ == nullptr";
1208             return;
1209         }
1210         service_->IncrementalRestoreOnFileReady(BUNDLE_NAME, FILE_NAME, -1, -1, 0);
1211         service_->IncrementalBackupOnFileReady(BUNDLE_NAME, FILE_NAME, -1, -1, 0);
1212     } catch (...) {
1213         EXPECT_TRUE(false);
1214         GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by IncrementalRestoreOnFileReady.";
1215     }
1216     GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_IncrementalRestoreOnFileReady_0100";
1217 }
1218 
1219 /**
1220  * @tc.number: SUB_backup_ServiceReverse_IncrementalRestoreOnFileReady_0101
1221  * @tc.name: SUB_backup_ServiceReverse_IncrementalRestoreOnFileReady_0101
1222  * @tc.desc: 测试 IncrementalRestoreOnFileReady 接口
1223  * @tc.size: MEDIUM
1224  * @tc.type: FUNC
1225  * @tc.level Level 1
1226  * @tc.require: I9116W
1227  */
1228 HWTEST_F(ServiceReverseTest,
1229          SUB_backup_ServiceReverse_IncrementalRestoreOnFileReady_0101,
1230          testing::ext::TestSize.Level1)
1231 {
1232     GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalRestoreOnFileReady_0101";
1233     try {
1234         IncrementalInit(IServiceReverse::Scenario::BACKUP);
1235         if (service_ == nullptr) {
1236             GTEST_LOG_(INFO) <<
1237                 "SUB_backup_ServiceReverse_IncrementalRestoreOnFileReady_0101 service_ == nullptr";
1238             return;
1239         }
1240         service_->IncrementalRestoreOnFileReady(BUNDLE_NAME, FILE_NAME, -1, -1, 0);
1241 
1242         IncrementalInit(IServiceReverse::Scenario::RESTORE, 1);
1243         service_->IncrementalRestoreOnFileReady(BUNDLE_NAME, FILE_NAME, -1, -1, 0);
1244     } catch (...) {
1245         EXPECT_TRUE(false);
1246         GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by IncrementalRestoreOnFileReady.";
1247     }
1248     GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_IncrementalRestoreOnFileReady_0101";
1249 }
1250 
1251 /**
1252  * @tc.number: SUB_backup_ServiceReverse_IncrementalRestoreOnBundleStarted_0100
1253  * @tc.name: SUB_backup_ServiceReverse_IncrementalRestoreOnBundleStarted_0100
1254  * @tc.desc: 测试 IncrementalRestoreOnBundleStarted 接口
1255  * @tc.size: MEDIUM
1256  * @tc.type: FUNC
1257  * @tc.level Level 1
1258  * @tc.require: I9116W
1259  */
1260 HWTEST_F(ServiceReverseTest,
1261          SUB_backup_ServiceReverse_IncrementalRestoreOnBundleStarted_0100,
1262          testing::ext::TestSize.Level1)
1263 {
1264     GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalRestoreOnBundleStarted_0100";
1265     try {
1266         IncrementalInit(IServiceReverse::Scenario::RESTORE);
1267         if (service_ == nullptr) {
1268             GTEST_LOG_(INFO) <<
1269                 "SUB_backup_ServiceReverse_IncrementalRestoreOnBundleStarted_0100 service_ == nullptr";
1270             return;
1271         }
1272         service_->IncrementalRestoreOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME);
1273         service_->IncrementalBackupOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME);
1274     } catch (...) {
1275         EXPECT_TRUE(false);
1276         GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by IncrementalRestoreOnBundleStarted.";
1277     }
1278     GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_IncrementalRestoreOnBundleStarted_0100";
1279 }
1280 
1281 /**
1282  * @tc.number: SUB_backup_ServiceReverse_IncrementalRestoreOnBundleStarted_0101
1283  * @tc.name: SUB_backup_ServiceReverse_IncrementalRestoreOnBundleStarted_0101
1284  * @tc.desc: 测试 IncrementalRestoreOnBundleStarted 接口
1285  * @tc.size: MEDIUM
1286  * @tc.type: FUNC
1287  * @tc.level Level 1
1288  * @tc.require: I9116W
1289  */
1290 HWTEST_F(ServiceReverseTest,
1291          SUB_backup_ServiceReverse_IncrementalRestoreOnBundleStarted_0101,
1292          testing::ext::TestSize.Level1)
1293 {
1294     GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalRestoreOnBundleStarted_0101";
1295     try {
1296         IncrementalInit(IServiceReverse::Scenario::BACKUP);
1297         if (service_ == nullptr) {
1298             GTEST_LOG_(INFO) <<
1299                 "SUB_backup_ServiceReverse_IncrementalRestoreOnBundleStarted_0101 service_ == nullptr";
1300             return;
1301         }
1302         service_->IncrementalRestoreOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME);
1303 
1304         IncrementalInit(IServiceReverse::Scenario::RESTORE, 1);
1305         service_->IncrementalRestoreOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME);
1306     } catch (...) {
1307         EXPECT_TRUE(false);
1308         GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by IncrementalRestoreOnBundleStarted.";
1309     }
1310     GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_IncrementalRestoreOnBundleStarted_0101";
1311 }
1312 
1313 /**
1314  * @tc.number: SUB_backup_ServiceReverse_IncrementalRestoreOnBundleFinished_0100
1315  * @tc.name: SUB_backup_ServiceReverse_IncrementalRestoreOnBundleFinished_0100
1316  * @tc.desc: 测试 IncrementalRestoreOnBundleFinished 接口
1317  * @tc.size: MEDIUM
1318  * @tc.type: FUNC
1319  * @tc.level Level 1
1320  * @tc.require: I9116W
1321  */
1322 HWTEST_F(ServiceReverseTest,
1323          SUB_backup_ServiceReverse_IncrementalRestoreOnBundleFinished_0100,
1324          testing::ext::TestSize.Level1)
1325 {
1326     GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalRestoreOnBundleFinished_0100";
1327     try {
1328         IncrementalInit(IServiceReverse::Scenario::RESTORE);
1329         if (service_ == nullptr) {
1330             GTEST_LOG_(INFO) <<
1331                 "SUB_backup_ServiceReverse_IncrementalRestoreOnBundleFinished_0100 service_ == nullptr";
1332             return;
1333         }
1334         service_->IncrementalRestoreOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME);
1335         service_->IncrementalBackupOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME);
1336     } catch (...) {
1337         EXPECT_TRUE(false);
1338         GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by IncrementalRestoreOnBundleFinished.";
1339     }
1340     GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_IncrementalRestoreOnBundleFinished_0100";
1341 }
1342 
1343 /**
1344  * @tc.number: SUB_backup_ServiceReverse_IncrementalRestoreOnBundleFinished_0101
1345  * @tc.name: SUB_backup_ServiceReverse_IncrementalRestoreOnBundleFinished_0101
1346  * @tc.desc: 测试 IncrementalRestoreOnBundleFinished 接口
1347  * @tc.size: MEDIUM
1348  * @tc.type: FUNC
1349  * @tc.level Level 1
1350  * @tc.require: I9116W
1351  */
1352 HWTEST_F(ServiceReverseTest,
1353          SUB_backup_ServiceReverse_IncrementalRestoreOnBundleFinished_0101,
1354          testing::ext::TestSize.Level1)
1355 {
1356     GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalRestoreOnBundleFinished_0101";
1357     try {
1358         IncrementalInit(IServiceReverse::Scenario::BACKUP);
1359         if (service_ == nullptr) {
1360             GTEST_LOG_(INFO) <<
1361                 "SUB_backup_ServiceReverse_IncrementalRestoreOnBundleFinished_0101 service_ == nullptr";
1362             return;
1363         }
1364         service_->IncrementalRestoreOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME);
1365 
1366         IncrementalInit(IServiceReverse::Scenario::RESTORE, 1);
1367         service_->IncrementalRestoreOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME);
1368     } catch (...) {
1369         EXPECT_TRUE(false);
1370         GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by IncrementalRestoreOnBundleFinished.";
1371     }
1372     GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_IncrementalRestoreOnBundleFinished_0101";
1373 }
1374 
1375 /**
1376  * @tc.number: SUB_backup_ServiceReverse_IncrementalRestoreOnAllBundlesFinished_0100
1377  * @tc.name: SUB_backup_ServiceReverse_IncrementalRestoreOnAllBundlesFinished_0100
1378  * @tc.desc: 测试 IncrementalRestoreOnAllBundlesFinished 接口
1379  * @tc.size: MEDIUM
1380  * @tc.type: FUNC
1381  * @tc.level Level 1
1382  * @tc.require: I9116W
1383  */
1384 HWTEST_F(ServiceReverseTest,
1385          SUB_backup_ServiceReverse_IncrementalRestoreOnAllBundlesFinished_0100,
1386          testing::ext::TestSize.Level1)
1387 {
1388     GTEST_LOG_(INFO)
1389         << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalRestoreOnAllBundlesFinished_0100";
1390     try {
1391         IncrementalInit(IServiceReverse::Scenario::RESTORE);
1392         if (service_ == nullptr) {
1393             GTEST_LOG_(INFO) <<
1394                 "SUB_backup_ServiceReverse_IncrementalRestoreOnAllBundlesFinished_0100 service_ == nullptr";
1395             return;
1396         }
1397         service_->IncrementalRestoreOnAllBundlesFinished(BError(BError::Codes::OK));
1398         service_->IncrementalBackupOnAllBundlesFinished(BError(BError::Codes::OK));
1399     } catch (...) {
1400         EXPECT_TRUE(false);
1401         GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by IncrementalRestoreOnAllBundlesFinished.";
1402     }
1403     GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_IncrementalRestoreOnAllBundlesFinished_0100";
1404 }
1405 
1406 /**
1407  * @tc.number: SUB_backup_ServiceReverse_IncrementalRestoreOnAllBundlesFinished_0101
1408  * @tc.name: SUB_backup_ServiceReverse_IncrementalRestoreOnAllBundlesFinished_0101
1409  * @tc.desc: 测试 IncrementalRestoreOnAllBundlesFinished 接口
1410  * @tc.size: MEDIUM
1411  * @tc.type: FUNC
1412  * @tc.level Level 1
1413  * @tc.require: I9116W
1414  */
1415 HWTEST_F(ServiceReverseTest,
1416          SUB_backup_ServiceReverse_IncrementalRestoreOnAllBundlesFinished_0101,
1417          testing::ext::TestSize.Level1)
1418 {
1419     GTEST_LOG_(INFO)
1420         << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalRestoreOnAllBundlesFinished_0101";
1421     try {
1422         IncrementalInit(IServiceReverse::Scenario::BACKUP);
1423         if (service_ == nullptr) {
1424             GTEST_LOG_(INFO) <<
1425                 "SUB_backup_ServiceReverse_IncrementalRestoreOnAllBundlesFinished_0101 service_ == nullptr";
1426             return;
1427         }
1428         service_->IncrementalRestoreOnAllBundlesFinished(BError(BError::Codes::OK));
1429 
1430         IncrementalInit(IServiceReverse::Scenario::RESTORE, 1);
1431         service_->IncrementalRestoreOnAllBundlesFinished(BError(BError::Codes::OK));
1432     } catch (...) {
1433         EXPECT_TRUE(false);
1434         GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by IncrementalRestoreOnAllBundlesFinished.";
1435     }
1436     GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_IncrementalRestoreOnAllBundlesFinished_0101";
1437 }
1438 
1439 /**
1440  * @tc.number: SUB_backup_ServiceReverse_RestoreOnResultReport_0100
1441  * @tc.name: SUB_backup_ServiceReverse_RestoreOnResultReport_0100
1442  * @tc.desc: 测试 RestoreOnResultReport 接口
1443  * @tc.size: MEDIUM
1444  * @tc.type: FUNC
1445  * @tc.level Level 1
1446  * @tc.require: I6F3GV
1447  */
1448 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_RestoreOnResultReport_0100, testing::ext::TestSize.Level1)
1449 {
1450     GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_RestoreOnResultReport_0100";
1451     try {
1452         Init(IServiceReverse::Scenario::RESTORE);
1453         if (service_ == nullptr) {
1454             GTEST_LOG_(INFO) << "SUB_backup_ServiceReverse_RestoreOnResultReport_0100 service_ == nullptr";
1455             return;
1456         }
1457         std::string resultReport = "result_report";
1458         std::string bundleName = BUNDLE_NAME;
1459         service_->RestoreOnResultReport(resultReport, bundleName);
1460     } catch (...) {
1461         EXPECT_TRUE(false);
1462         GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by RestoreOnResultReport.";
1463     }
1464     GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_RestoreOnResultReport_0100";
1465 }
1466 
1467 /**
1468  * @tc.number: SUB_backup_ServiceReverse_RestoreOnResultReport_0101
1469  * @tc.name: SUB_backup_ServiceReverse_RestoreOnResultReport_0101
1470  * @tc.desc: 测试 RestoreOnResultReport 接口
1471  * @tc.size: MEDIUM
1472  * @tc.type: FUNC
1473  * @tc.level Level 1
1474  * @tc.require: I6F3GV
1475  */
1476 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_RestoreOnResultReport_0101, testing::ext::TestSize.Level1)
1477 {
1478     GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_RestoreOnResultReport_0101";
1479     try {
1480         Init(IServiceReverse::Scenario::RESTORE, 1);
1481         if (service_ == nullptr) {
1482             GTEST_LOG_(INFO) << "SUB_backup_ServiceReverse_RestoreOnResultReport_0101 service_ == nullptr";
1483             return;
1484         }
1485         std::string resultReport = "result_report";
1486         std::string bundleName = BUNDLE_NAME;
1487         service_->RestoreOnResultReport(resultReport, bundleName);
1488     } catch (...) {
1489         EXPECT_TRUE(false);
1490         GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by RestoreOnResultReport.";
1491     }
1492     GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_RestoreOnResultReport_0101";
1493 }
1494 
1495 /**
1496  * @tc.number: SUB_backup_ServiceReverse_IncrementalRestoreOnResultReport_0100
1497  * @tc.name: SUB_backup_ServiceReverse_IncrementalRestoreOnResultReport_0100
1498  * @tc.desc: 测试 IncrementalRestoreOnResultReport 接口
1499  * @tc.size: MEDIUM
1500  * @tc.type: FUNC
1501  * @tc.level Level 1
1502  * @tc.require: I6F3GV
1503  */
1504 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_IncrementalRestoreOnResultReport_0100,
1505     testing::ext::TestSize.Level1)
1506 {
1507     GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalRestoreOnResultReport_0100";
1508     try {
1509         IncrementalInit(IServiceReverse::Scenario::RESTORE);
1510         if (service_ == nullptr) {
1511             GTEST_LOG_(INFO) << "SUB_backup_ServiceReverse_IncrementalRestoreOnResultReport_0100 service_ == nullptr";
1512             return;
1513         }
1514         std::string resultReport = "result_report";
1515         std::string bundleName = BUNDLE_NAME;
1516         service_->IncrementalRestoreOnResultReport(resultReport, bundleName);
1517     } catch (...) {
1518         EXPECT_TRUE(false);
1519         GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by IncrementalRestoreOnResultReport.";
1520     }
1521     GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_IncrementalRestoreOnResultReport_0100";
1522 }
1523 
1524 /**
1525  * @tc.number: SUB_backup_ServiceReverse_IncrementalRestoreOnResultReport_0101
1526  * @tc.name: SUB_backup_ServiceReverse_IncrementalRestoreOnResultReport_0101
1527  * @tc.desc: 测试 IncrementalRestoreOnResultReport 接口
1528  * @tc.size: MEDIUM
1529  * @tc.type: FUNC
1530  * @tc.level Level 1
1531  * @tc.require: I6F3GV
1532  */
1533 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_IncrementalRestoreOnResultReport_0101,
1534     testing::ext::TestSize.Level1)
1535 {
1536     GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalRestoreOnResultReport_0101";
1537     try {
1538         IncrementalInit(IServiceReverse::Scenario::RESTORE, 1);
1539         if (service_ == nullptr) {
1540             GTEST_LOG_(INFO) << "SUB_backup_ServiceReverse_IncrementalRestoreOnResultReport_0101 service_ == nullptr";
1541             return;
1542         }
1543         std::string resultReport = "result_report";
1544         std::string bundleName = BUNDLE_NAME;
1545         service_->IncrementalRestoreOnResultReport(resultReport, bundleName);
1546     } catch (...) {
1547         EXPECT_TRUE(false);
1548         GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by IncrementalRestoreOnResultReport.";
1549     }
1550     GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_IncrementalRestoreOnResultReport_0101";
1551 }
1552 
1553 /**
1554  * @tc.number: SUB_backup_ServiceReverse_BackupOnResultReport_0100
1555  * @tc.name: SUB_backup_ServiceReverse_BackupOnResultReport_0100
1556  * @tc.desc: 测试 BackupOnResultReport 接口
1557  * @tc.size: MEDIUM
1558  * @tc.type: FUNC
1559  * @tc.level Level 1
1560  * @tc.require: I6F3GV
1561  */
1562 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_BackupOnResultReport_0100, testing::ext::TestSize.Level1)
1563 {
1564     GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_BackupOnResultReport_0100";
1565     try {
1566         Init(IServiceReverse::Scenario::BACKUP);
1567         std::string resultReport = "result_report";
1568         std::string bundleName = BUNDLE_NAME;
1569         if (service_ == nullptr) {
1570             GTEST_LOG_(INFO) << "SUB_backup_ServiceReverse_BackupOnResultReport_0100 service_ == nullptr";
1571             return;
1572         }
1573         service_->BackupOnResultReport(resultReport, bundleName);
1574     } catch (...) {
1575         EXPECT_TRUE(false);
1576         GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by BackupOnResultReport.";
1577     }
1578     GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_BackupOnResultReport_0100";
1579 }
1580 
1581 /**
1582  * @tc.number: SUB_backup_ServiceReverse_BackupOnResultReport_0101
1583  * @tc.name: SUB_backup_ServiceReverse_BackupOnResultReport_0101
1584  * @tc.desc: 测试 BackupOnResultReport 接口
1585  * @tc.size: MEDIUM
1586  * @tc.type: FUNC
1587  * @tc.level Level 1
1588  * @tc.require: I6F3GV
1589  */
1590 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_BackupOnResultReport_0101, testing::ext::TestSize.Level1)
1591 {
1592     GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_BackupOnResultReport_0101";
1593     try {
1594         Init(IServiceReverse::Scenario::BACKUP, 1);
1595         std::string resultReport = "result_report";
1596         std::string bundleName = BUNDLE_NAME;
1597         if (service_ == nullptr) {
1598             GTEST_LOG_(INFO) << "SUB_backup_ServiceReverse_BackupOnResultReport_0101 service_ == nullptr";
1599             return;
1600         }
1601         service_->BackupOnResultReport(resultReport, bundleName);
1602     } catch (...) {
1603         EXPECT_TRUE(false);
1604         GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by BackupOnResultReport.";
1605     }
1606     GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_BackupOnResultReport_0101";
1607 }
1608 
1609 /**
1610  * @tc.number: SUB_backup_ServiceReverse_IncrementalBackupOnResultReport_0100
1611  * @tc.name: SUB_backup_ServiceReverse_IncrementalBackupOnResultReport_0100
1612  * @tc.desc: 测试 IncrementalBackupOnResultReport 接口
1613  * @tc.size: MEDIUM
1614  * @tc.type: FUNC
1615  * @tc.level Level 1
1616  * @tc.require: I6F3GV
1617  */
1618 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_IncrementalBackupOnResultReport_0100,
1619     testing::ext::TestSize.Level1)
1620 {
1621     GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalBackupOnResultReport_0100";
1622     try {
1623         IncrementalInit(IServiceReverse::Scenario::BACKUP);
1624         std::string resultReport = "result_report";
1625         std::string bundleName = BUNDLE_NAME;
1626         if (service_ == nullptr) {
1627             GTEST_LOG_(INFO) << "SUB_backup_ServiceReverse_IncrementalBackupOnResultReport_0100 service_ == nullptr";
1628             return;
1629         }
1630         service_->IncrementalBackupOnResultReport(resultReport, bundleName);
1631     } catch (...) {
1632         EXPECT_TRUE(false);
1633         GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by IncrementalBackupOnResultReport.";
1634     }
1635     GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_IncrementalBackupOnResultReport_0100";
1636 }
1637 
1638 /**
1639  * @tc.number: SUB_backup_ServiceReverse_IncrementalBackupOnResultReport_0101
1640  * @tc.name: SUB_backup_ServiceReverse_IncrementalBackupOnResultReport_0101
1641  * @tc.desc: 测试 IncrementalBackupOnResultReport 接口
1642  * @tc.size: MEDIUM
1643  * @tc.type: FUNC
1644  * @tc.level Level 1
1645  * @tc.require: I6F3GV
1646  */
1647 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_IncrementalBackupOnResultReport_0101,
1648     testing::ext::TestSize.Level1)
1649 {
1650     GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalBackupOnResultReport_0101";
1651     try {
1652         IncrementalInit(IServiceReverse::Scenario::BACKUP, 1);
1653         std::string resultReport = "result_report";
1654         std::string bundleName = BUNDLE_NAME;
1655         if (service_ == nullptr) {
1656             GTEST_LOG_(INFO) << "SUB_backup_ServiceReverse_IncrementalBackupOnResultReport_0101 service_ == nullptr";
1657             return;
1658         }
1659         service_->IncrementalBackupOnResultReport(resultReport, bundleName);
1660     } catch (...) {
1661         EXPECT_TRUE(false);
1662         GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by IncrementalBackupOnResultReport.";
1663     }
1664     GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_IncrementalBackupOnResultReport_0101";
1665 }
1666 } // namespace OHOS::FileManagement::Backup