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(IServiceReverseType::Scenario scenario, int nType = 0);
49 void IncrementalInit(IServiceReverseType::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(IServiceReverseType::Scenario scenario,int nType)92 void ServiceReverseTest::Init(IServiceReverseType::Scenario scenario, int nType)
93 {
94 if (scenario == IServiceReverseType::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(IServiceReverseType::Scenario scenario,int nType)131 void ServiceReverseTest::IncrementalInit(IServiceReverseType::Scenario scenario, int nType)
132 {
133 if (scenario == IServiceReverseType::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(IServiceReverseType::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(IServiceReverseType::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(IServiceReverseType::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_BackupOnFileReadyWithoutFd_0100
253 * @tc.name: SUB_backup_ServiceReverse_BackupOnFileReadyWithoutFd_0100
254 * @tc.desc: 测试 BackupOnFileReadyWithoutFd 正常分支（回调非空且场景为BACKUP）
255 * @tc.size: MEDIUM
256 * @tc.type: FUNC
257 * @tc.level Level 1
258 */
259 HWTEST_F(ServiceReverseTest,
260 SUB_backup_ServiceReverse_BackupOnFileReadyWithoutFd_0100,
261 testing::ext::TestSize.Level1)
262 {
263 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_BackupOnFileReadyWithoutFd_0100";
264 Init(IServiceReverseType::Scenario::BACKUP, 0);
265 ASSERT_NE(service_, nullptr);
266 bool called = false;
__anon7403e2900202(const BFileInfo&, UniqueFd, int32_t) 267 service_->callbacksBackup_.onFileReady = [&](const BFileInfo&, UniqueFd, int32_t) {
268 called = true;
269 };
270 auto ret = service_->BackupOnFileReadyWithoutFd("bundle", "file", 123);
271 EXPECT_EQ(ret, 0);
272 EXPECT_TRUE(called);
273 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_BackupOnFileReadyWithoutFd_0100";
274 }
275
276 /**
277 * @tc.number: SUB_backup_ServiceReverse_BackupOnFileReadyWithoutFd_0101
278 * @tc.name: SUB_backup_ServiceReverse_BackupOnFileReadyWithoutFd_0101
279 * @tc.desc: 测试 BackupOnFileReadyWithoutFd 回调为nullptr分支
280 * @tc.size: MEDIUM
281 * @tc.type: FUNC
282 * @tc.level Level 1
283 */
284 HWTEST_F(ServiceReverseTest,
285 SUB_backup_ServiceReverse_BackupOnFileReadyWithoutFd_0101,
286 testing::ext::TestSize.Level1)
287 {
288 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_BackupOnFileReadyWithoutFd_0101";
289 Init(IServiceReverseType::Scenario::BACKUP, 0);
290 ASSERT_NE(service_, nullptr);
291 service_->callbacksBackup_.onFileReady = nullptr;
292 auto ret = service_->BackupOnFileReadyWithoutFd("bundle", "file", 123);
293 EXPECT_EQ(ret, 0);
294 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_BackupOnFileReadyWithoutFd_0101";
295 }
296
297 /**
298 * @tc.number: SUB_backup_ServiceReverse_BackupOnFileReadyWithoutFd_0102
299 * @tc.name: SUB_backup_ServiceReverse_BackupOnFileReadyWithoutFd_0102
300 * @tc.desc: 测试 BackupOnFileReadyWithoutFd 场景非BACKUP分支
301 * @tc.size: MEDIUM
302 * @tc.type: FUNC
303 * @tc.level Level 1
304 */
305 HWTEST_F(ServiceReverseTest,
306 SUB_backup_ServiceReverse_BackupOnFileReadyWithoutFd_0102,
307 testing::ext::TestSize.Level1)
308 {
309 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_BackupOnFileReadyWithoutFd_0102";
310 Init(IServiceReverseType::Scenario::RESTORE, 0); // 场景非BACKUP
311 ASSERT_NE(service_, nullptr);
312 bool called = false;
__anon7403e2900302(const BFileInfo&, UniqueFd, int32_t) 313 service_->callbacksBackup_.onFileReady = [&](const BFileInfo&, UniqueFd, int32_t) {
314 called = true;
315 };
316 auto ret = service_->BackupOnFileReadyWithoutFd("bundle", "file", 123);
317 EXPECT_EQ(ret, 0);
318 EXPECT_FALSE(called);
319 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_BackupOnFileReadyWithoutFd_0102";
320 }
321
322 /**
323 * @tc.number: SUB_backup_ServiceReverse_BackupOnBundleStarted_0100
324 * @tc.name: SUB_backup_ServiceReverse_BackupOnBundleStarted_0100
325 * @tc.desc: 测试 BackupOnBundleStarted 接口
326 * @tc.size: MEDIUM
327 * @tc.type: FUNC
328 * @tc.level Level 1
329 * @tc.require: I6F3GV
330 */
331 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_BackupOnBundleStarted_0100, testing::ext::TestSize.Level1)
332 {
333 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_BackupOnBundleStarted_0100";
334 try {
335 Init(IServiceReverseType::Scenario::BACKUP);
336 if (service_ == nullptr) {
337 GTEST_LOG_(INFO) <<
338 "SUB_backup_ServiceReverse_BackupOnBundleStarted_0100 service_ == nullptr";
339 return;
340 }
341 service_->BackupOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME);
342 service_->RestoreOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME);
343 } catch (...) {
344 EXPECT_TRUE(false);
345 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by BackupOnBundleStarted.";
346 }
347 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_BackupOnBundleStarted_0100";
348 }
349
350 /**
351 * @tc.number: SUB_backup_ServiceReverse_BackupOnBundleStarted_0101
352 * @tc.name: SUB_backup_ServiceReverse_BackupOnBundleStarted_0101
353 * @tc.desc: 测试 BackupOnBundleStarted 接口
354 * @tc.size: MEDIUM
355 * @tc.type: FUNC
356 * @tc.level Level 1
357 * @tc.require: I6F3GV
358 */
359 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_BackupOnBundleStarted_0101, testing::ext::TestSize.Level1)
360 {
361 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_BackupOnBundleStarted_0101";
362 try {
363 Init(IServiceReverseType::Scenario::RESTORE);
364 if (service_ == nullptr) {
365 GTEST_LOG_(INFO) <<
366 "SUB_backup_ServiceReverse_BackupOnBundleStarted_0101 service_ == nullptr";
367 return;
368 }
369 service_->BackupOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME);
370 } catch (...) {
371 EXPECT_TRUE(false);
372 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by BackupOnBundleStarted.";
373 }
374 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_BackupOnBundleStarted_0101";
375 }
376
377 /**
378 * @tc.number: SUB_backup_ServiceReverse_BackupOnBundleStarted_0102
379 * @tc.name: SUB_backup_ServiceReverse_BackupOnBundleStarted_0102
380 * @tc.desc: 测试 BackupOnBundleStarted 接口
381 * @tc.size: MEDIUM
382 * @tc.type: FUNC
383 * @tc.level Level 1
384 * @tc.require: I6F3GV
385 */
386 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_BackupOnBundleStarted_0102, testing::ext::TestSize.Level1)
387 {
388 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_BackupOnBundleStarted_0102";
389 try {
390 Init(IServiceReverseType::Scenario::BACKUP, 1);
391 if (service_ == nullptr) {
392 GTEST_LOG_(INFO) <<
393 "SUB_backup_ServiceReverse_BackupOnBundleStarted_0102 service_ == nullptr";
394 return;
395 }
396 service_->BackupOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME);
397 } catch (...) {
398 EXPECT_TRUE(false);
399 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by BackupOnBundleStarted.";
400 }
401 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_BackupOnBundleStarted_0102";
402 }
403
404 /**
405 * @tc.number: SUB_backup_ServiceReverse_BackupOnBundleFinished_0100
406 * @tc.name: SUB_backup_ServiceReverse_BackupOnBundleFinished_0100
407 * @tc.desc: 测试 BackupOnBundleFinished 接口
408 * @tc.size: MEDIUM
409 * @tc.type: FUNC
410 * @tc.level Level 1
411 * @tc.require: I6F3GV
412 */
413 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_BackupOnBundleFinished_0100, testing::ext::TestSize.Level1)
414 {
415 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_BackupOnBundleFinished_0100";
416 try {
417 Init(IServiceReverseType::Scenario::BACKUP);
418 if (service_ == nullptr) {
419 GTEST_LOG_(INFO) <<
420 "SUB_backup_ServiceReverse_BackupOnBundleFinished_0100 service_ == nullptr";
421 return;
422 }
423 service_->BackupOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME);
424 service_->RestoreOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME);
425 } catch (...) {
426 EXPECT_TRUE(false);
427 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by BackupOnBundleFinished.";
428 }
429 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_BackupOnBundleFinished_0100";
430 }
431
432 /**
433 * @tc.number: SUB_backup_ServiceReverse_BackupOnBundleFinished_0101
434 * @tc.name: SUB_backup_ServiceReverse_BackupOnBundleFinished_0101
435 * @tc.desc: 测试 BackupOnBundleFinished 接口
436 * @tc.size: MEDIUM
437 * @tc.type: FUNC
438 * @tc.level Level 1
439 * @tc.require: I6F3GV
440 */
441 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_BackupOnBundleFinished_0101, testing::ext::TestSize.Level1)
442 {
443 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_BackupOnBundleFinished_0101";
444 try {
445 Init(IServiceReverseType::Scenario::RESTORE);
446 if (service_ == nullptr) {
447 GTEST_LOG_(INFO) <<
448 "SUB_backup_ServiceReverse_BackupOnBundleFinished_0101 service_ == nullptr";
449 return;
450 }
451 service_->BackupOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME);
452 } catch (...) {
453 EXPECT_TRUE(false);
454 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by BackupOnBundleFinished.";
455 }
456 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_BackupOnBundleFinished_0101";
457 }
458
459 /**
460 * @tc.number: SUB_backup_ServiceReverse_BackupOnBundleFinished_0102
461 * @tc.name: SUB_backup_ServiceReverse_BackupOnBundleFinished_0102
462 * @tc.desc: 测试 BackupOnBundleFinished 接口
463 * @tc.size: MEDIUM
464 * @tc.type: FUNC
465 * @tc.level Level 1
466 * @tc.require: I6F3GV
467 */
468 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_BackupOnBundleFinished_0102, testing::ext::TestSize.Level1)
469 {
470 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_BackupOnBundleFinished_0102";
471 try {
472 Init(IServiceReverseType::Scenario::BACKUP, 1);
473 if (service_ == nullptr) {
474 GTEST_LOG_(INFO) <<
475 "SUB_backup_ServiceReverse_BackupOnBundleFinished_0102 service_ == nullptr";
476 return;
477 }
478 service_->BackupOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME);
479 } catch (...) {
480 EXPECT_TRUE(false);
481 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by BackupOnBundleFinished.";
482 }
483 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_BackupOnBundleFinished_0102";
484 }
485
486 /**
487 * @tc.number: SUB_backup_ServiceReverse_BackupOnAllBundlesFinished_0100
488 * @tc.name: SUB_backup_ServiceReverse_BackupOnAllBundlesFinished_0100
489 * @tc.desc: 测试 BackupOnAllBundlesFinished 接口
490 * @tc.size: MEDIUM
491 * @tc.type: FUNC
492 * @tc.level Level 1
493 * @tc.require: I6F3GV
494 */
495 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_BackupOnAllBundlesFinished_0100, testing::ext::TestSize.Level1)
496 {
497 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_BackupOnAllBundlesFinished_0100";
498 try {
499 Init(IServiceReverseType::Scenario::BACKUP);
500 if (service_ == nullptr) {
501 GTEST_LOG_(INFO) <<
502 "SUB_backup_ServiceReverse_BackupOnAllBundlesFinished_0100 service_ == nullptr";
503 return;
504 }
505 service_->BackupOnAllBundlesFinished(BError(BError::Codes::OK));
506 service_->RestoreOnAllBundlesFinished(BError(BError::Codes::OK));
507 } catch (...) {
508 EXPECT_TRUE(false);
509 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by BackupOnAllBundlesFinished.";
510 }
511 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_BackupOnAllBundlesFinished_0100";
512 }
513
514 /**
515 * @tc.number: SUB_backup_ServiceReverse_BackupOnAllBundlesFinished_0101
516 * @tc.name: SUB_backup_ServiceReverse_BackupOnAllBundlesFinished_0101
517 * @tc.desc: 测试 BackupOnAllBundlesFinished 接口
518 * @tc.size: MEDIUM
519 * @tc.type: FUNC
520 * @tc.level Level 1
521 * @tc.require: I6F3GV
522 */
523 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_BackupOnAllBundlesFinished_0101, testing::ext::TestSize.Level1)
524 {
525 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_BackupOnAllBundlesFinished_0101";
526 try {
527 Init(IServiceReverseType::Scenario::RESTORE);
528 if (service_ == nullptr) {
529 GTEST_LOG_(INFO) <<
530 "SUB_backup_ServiceReverse_BackupOnAllBundlesFinished_0101 service_ == nullptr";
531 return;
532 }
533 service_->BackupOnAllBundlesFinished(BError(BError::Codes::OK));
534 } catch (...) {
535 EXPECT_TRUE(false);
536 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by BackupOnAllBundlesFinished.";
537 }
538 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_BackupOnAllBundlesFinished_0101";
539 }
540
541 /**
542 * @tc.number: SUB_backup_ServiceReverse_BackupOnAllBundlesFinished_0102
543 * @tc.name: SUB_backup_ServiceReverse_BackupOnAllBundlesFinished_0102
544 * @tc.desc: 测试 BackupOnAllBundlesFinished 接口
545 * @tc.size: MEDIUM
546 * @tc.type: FUNC
547 * @tc.level Level 1
548 * @tc.require: I6F3GV
549 */
550 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_BackupOnAllBundlesFinished_0102, testing::ext::TestSize.Level1)
551 {
552 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_BackupOnAllBundlesFinished_0102";
553 try {
554 Init(IServiceReverseType::Scenario::BACKUP, 1);
555 if (service_ == nullptr) {
556 GTEST_LOG_(INFO) <<
557 "SUB_backup_ServiceReverse_BackupOnAllBundlesFinished_0102 service_ == nullptr";
558 return;
559 }
560 service_->BackupOnAllBundlesFinished(BError(BError::Codes::OK));
561 } catch (...) {
562 EXPECT_TRUE(false);
563 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by BackupOnAllBundlesFinished.";
564 }
565 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_BackupOnAllBundlesFinished_0102";
566 }
567
568 /**
569 * @tc.number: SUB_backup_ServiceReverse_RestoreOnFileReady_0100
570 * @tc.name: SUB_backup_ServiceReverse_RestoreOnFileReady_0100
571 * @tc.desc: 测试 RestoreOnFileReady 接口
572 * @tc.size: MEDIUM
573 * @tc.type: FUNC
574 * @tc.level Level 1
575 * @tc.require: I6F3GV
576 */
577 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_RestoreOnFileReady_0100, testing::ext::TestSize.Level1)
578 {
579 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_RestoreOnFileReady_0100";
580 try {
581 Init(IServiceReverseType::Scenario::RESTORE);
582 if (service_ == nullptr) {
583 GTEST_LOG_(INFO) <<
584 "SUB_backup_ServiceReverse_RestoreOnFileReady_0100 service_ == nullptr";
585 return;
586 }
587 service_->RestoreOnFileReady(BUNDLE_NAME, FILE_NAME, -1, 0);
588 service_->BackupOnFileReady(BUNDLE_NAME, FILE_NAME, -1, 0);
589 } catch (...) {
590 EXPECT_TRUE(false);
591 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by RestoreOnFileReady.";
592 }
593 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_RestoreOnFileReady_0100";
594 }
595
596 /**
597 * @tc.number: SUB_backup_ServiceReverse_RestoreOnFileReady_0101
598 * @tc.name: SUB_backup_ServiceReverse_RestoreOnFileReady_0101
599 * @tc.desc: 测试 RestoreOnFileReady 接口
600 * @tc.size: MEDIUM
601 * @tc.type: FUNC
602 * @tc.level Level 1
603 * @tc.require: I6F3GV
604 */
605 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_RestoreOnFileReady_0101, testing::ext::TestSize.Level1)
606 {
607 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_RestoreOnFileReady_0101";
608 try {
609 Init(IServiceReverseType::Scenario::BACKUP);
610 if (service_ == nullptr) {
611 GTEST_LOG_(INFO) <<
612 "SUB_backup_ServiceReverse_RestoreOnFileReady_0101 service_ == nullptr";
613 return;
614 }
615 service_->RestoreOnFileReady(BUNDLE_NAME, FILE_NAME, -1, 0);
616 } catch (...) {
617 EXPECT_TRUE(false);
618 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by RestoreOnFileReady.";
619 }
620 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_RestoreOnFileReady_0101";
621 }
622
623 /**
624 * @tc.number: SUB_backup_ServiceReverse_RestoreOnFileReady_0102
625 * @tc.name: SUB_backup_ServiceReverse_RestoreOnFileReady_0102
626 * @tc.desc: 测试 RestoreOnFileReady 接口
627 * @tc.size: MEDIUM
628 * @tc.type: FUNC
629 * @tc.level Level 1
630 * @tc.require: I6F3GV
631 */
632 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_RestoreOnFileReady_0102, testing::ext::TestSize.Level1)
633 {
634 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_RestoreOnFileReady_0102";
635 try {
636 Init(IServiceReverseType::Scenario::RESTORE, 1);
637 if (service_ == nullptr) {
638 GTEST_LOG_(INFO) <<
639 "SUB_backup_ServiceReverse_RestoreOnFileReady_0102 service_ == nullptr";
640 return;
641 }
642 service_->RestoreOnFileReady(BUNDLE_NAME, FILE_NAME, -1, 0);
643 } catch (...) {
644 EXPECT_TRUE(false);
645 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by RestoreOnFileReady.";
646 }
647 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_RestoreOnFileReady_0102";
648 }
649
650
651 /**
652 * @tc.number: SUB_backup_ServiceReverse_RestoreOnFileReadyWithoutFd_0100
653 * @tc.name: SUB_backup_ServiceReverse_RestoreOnFileReadyWithoutFd_0100
654 * @tc.desc: 测试 RestoreOnFileReadyWithoutFd 正常分支（回调非空且场景为RESTORE）
655 * @tc.size: MEDIUM
656 * @tc.type: FUNC
657 * @tc.level Level 1
658 */
659 HWTEST_F(ServiceReverseTest,
660 SUB_backup_ServiceReverse_RestoreOnFileReadyWithoutFd_0100,
661 testing::ext::TestSize.Level1)
662 {
663 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_RestoreOnFileReadyWithoutFd_0100";
664 Init(IServiceReverseType::Scenario::RESTORE, 0);
665 ASSERT_NE(service_, nullptr);
666 bool called = false;
__anon7403e2900402(const BFileInfo&, UniqueFd, int32_t) 667 service_->callbacksRestore_.onFileReady = [&](const BFileInfo&, UniqueFd, int32_t) {
668 called = true;
669 };
670 auto ret = service_->RestoreOnFileReadyWithoutFd("bundle", "file", 123);
671 EXPECT_EQ(ret, 0);
672 EXPECT_TRUE(called);
673 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_RestoreOnFileReadyWithoutFd_0100";
674 }
675
676 /**
677 * @tc.number: SUB_backup_ServiceReverse_RestoreOnFileReadyWithoutFd_0101
678 * @tc.name: SUB_backup_ServiceReverse_RestoreOnFileReadyWithoutFd_0101
679 * @tc.desc: 测试 RestoreOnFileReadyWithoutFd 回调为nullptr分支
680 * @tc.size: MEDIUM
681 * @tc.type: FUNC
682 * @tc.level Level 1
683 */
684 HWTEST_F(ServiceReverseTest,
685 SUB_backup_ServiceReverse_RestoreOnFileReadyWithoutFd_0101,
686 testing::ext::TestSize.Level1)
687 {
688 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_RestoreOnFileReadyWithoutFd_0101";
689 Init(IServiceReverseType::Scenario::RESTORE, 0);
690 ASSERT_NE(service_, nullptr);
691 service_->callbacksRestore_.onFileReady = nullptr;
692 auto ret = service_->RestoreOnFileReadyWithoutFd("bundle", "file", 123);
693 EXPECT_EQ(ret, 0);
694 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_RestoreOnFileReadyWithoutFd_0101";
695 }
696
697 /**
698 * @tc.number: SUB_backup_ServiceReverse_RestoreOnFileReadyWithoutFd_0102
699 * @tc.name: SUB_backup_ServiceReverse_RestoreOnFileReadyWithoutFd_0102
700 * @tc.desc: 测试 RestoreOnFileReadyWithoutFd 场景非RESTORE分支
701 * @tc.size: MEDIUM
702 * @tc.type: FUNC
703 * @tc.level Level 1
704 */
705 HWTEST_F(ServiceReverseTest,
706 SUB_backup_ServiceReverse_RestoreOnFileReadyWithoutFd_0102,
707 testing::ext::TestSize.Level1)
708 {
709 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_RestoreOnFileReadyWithoutFd_0102";
710 Init(IServiceReverseType::Scenario::BACKUP, 0); // 场景非RESTORE
711 ASSERT_NE(service_, nullptr);
712 bool called = false;
__anon7403e2900502(const BFileInfo&, UniqueFd, int32_t) 713 service_->callbacksRestore_.onFileReady = [&](const BFileInfo&, UniqueFd, int32_t) {
714 called = true;
715 };
716 auto ret = service_->RestoreOnFileReadyWithoutFd("bundle", "file", 123);
717 EXPECT_EQ(ret, 0);
718 EXPECT_FALSE(called);
719 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_RestoreOnFileReadyWithoutFd_0102";
720 }
721
722 /**
723 * @tc.number: SUB_backup_ServiceReverse_RestoreOnBundleStarted_0100
724 * @tc.name: SUB_backup_ServiceReverse_RestoreOnBundleStarted_0100
725 * @tc.desc: 测试 RestoreOnBundleStarted 接口
726 * @tc.size: MEDIUM
727 * @tc.type: FUNC
728 * @tc.level Level 1
729 * @tc.require: I6F3GV
730 */
731 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_RestoreOnBundleStarted_0100, testing::ext::TestSize.Level1)
732 {
733 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_RestoreOnBundleStarted_0100";
734 try {
735 Init(IServiceReverseType::Scenario::RESTORE);
736 if (service_ == nullptr) {
737 GTEST_LOG_(INFO) <<
738 "SUB_backup_ServiceReverse_RestoreOnBundleStarted_0100 service_ == nullptr";
739 return;
740 }
741 service_->RestoreOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME);
742 service_->BackupOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME);
743 } catch (...) {
744 EXPECT_TRUE(false);
745 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by RestoreOnBundleStarted.";
746 }
747 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_RestoreOnBundleStarted_0100";
748 }
749
750 /**
751 * @tc.number: SUB_backup_ServiceReverse_RestoreOnBundleStarted_0101
752 * @tc.name: SUB_backup_ServiceReverse_RestoreOnBundleStarted_0101
753 * @tc.desc: 测试 RestoreOnBundleStarted 接口
754 * @tc.size: MEDIUM
755 * @tc.type: FUNC
756 * @tc.level Level 1
757 * @tc.require: I6F3GV
758 */
759 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_RestoreOnBundleStarted_0101, testing::ext::TestSize.Level1)
760 {
761 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_RestoreOnBundleStarted_0101";
762 try {
763 Init(IServiceReverseType::Scenario::BACKUP);
764 if (service_ == nullptr) {
765 GTEST_LOG_(INFO) <<
766 "SUB_backup_ServiceReverse_RestoreOnBundleStarted_0101 service_ == nullptr";
767 return;
768 }
769 service_->RestoreOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME);
770 } catch (...) {
771 EXPECT_TRUE(false);
772 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by RestoreOnBundleStarted.";
773 }
774 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_RestoreOnBundleStarted_0101";
775 }
776
777 /**
778 * @tc.number: SUB_backup_ServiceReverse_RestoreOnBundleStarted_0102
779 * @tc.name: SUB_backup_ServiceReverse_RestoreOnBundleStarted_0102
780 * @tc.desc: 测试 RestoreOnBundleStarted 接口
781 * @tc.size: MEDIUM
782 * @tc.type: FUNC
783 * @tc.level Level 1
784 * @tc.require: I6F3GV
785 */
786 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_RestoreOnBundleStarted_0102, testing::ext::TestSize.Level1)
787 {
788 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_RestoreOnBundleStarted_0102";
789 try {
790 Init(IServiceReverseType::Scenario::RESTORE, 1);
791 if (service_ == nullptr) {
792 GTEST_LOG_(INFO) <<
793 "SUB_backup_ServiceReverse_RestoreOnBundleStarted_0102 service_ == nullptr";
794 return;
795 }
796 service_->RestoreOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME);
797 } catch (...) {
798 EXPECT_TRUE(false);
799 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by RestoreOnBundleStarted.";
800 }
801 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_RestoreOnBundleStarted_0102";
802 }
803
804 /**
805 * @tc.number: SUB_backup_ServiceReverse_RestoreOnBundleFinished_0100
806 * @tc.name: SUB_backup_ServiceReverse_RestoreOnBundleFinished_0100
807 * @tc.desc: 测试 RestoreOnBundleFinished 接口
808 * @tc.size: MEDIUM
809 * @tc.type: FUNC
810 * @tc.level Level 1
811 * @tc.require: I6F3GV
812 */
813 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_RestoreOnBundleFinished_0100, testing::ext::TestSize.Level1)
814 {
815 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_RestoreOnBundleFinished_0100";
816 try {
817 Init(IServiceReverseType::Scenario::RESTORE);
818 if (service_ == nullptr) {
819 GTEST_LOG_(INFO) <<
820 "SUB_backup_ServiceReverse_RestoreOnBundleFinished_0100 service_ == nullptr";
821 return;
822 }
823 service_->RestoreOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME);
824 service_->BackupOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME);
825 } catch (...) {
826 EXPECT_TRUE(false);
827 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by RestoreOnBundleFinished.";
828 }
829 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_RestoreOnBundleFinished_0100";
830 }
831
832 /**
833 * @tc.number: SUB_backup_ServiceReverse_RestoreOnBundleFinished_0101
834 * @tc.name: SUB_backup_ServiceReverse_RestoreOnBundleFinished_0101
835 * @tc.desc: 测试 RestoreOnBundleFinished 接口
836 * @tc.size: MEDIUM
837 * @tc.type: FUNC
838 * @tc.level Level 1
839 * @tc.require: I6F3GV
840 */
841 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_RestoreOnBundleFinished_0101, testing::ext::TestSize.Level1)
842 {
843 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_RestoreOnBundleFinished_0101";
844 try {
845 Init(IServiceReverseType::Scenario::BACKUP);
846 if (service_ == nullptr) {
847 GTEST_LOG_(INFO) <<
848 "SUB_backup_ServiceReverse_RestoreOnBundleFinished_0101 service_ == nullptr";
849 return;
850 }
851 service_->RestoreOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME);
852 } catch (...) {
853 EXPECT_TRUE(false);
854 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by RestoreOnBundleFinished.";
855 }
856 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_RestoreOnBundleFinished_0101";
857 }
858
859 /**
860 * @tc.number: SUB_backup_ServiceReverse_RestoreOnBundleFinished_0102
861 * @tc.name: SUB_backup_ServiceReverse_RestoreOnBundleFinished_0102
862 * @tc.desc: 测试 RestoreOnBundleFinished 接口
863 * @tc.size: MEDIUM
864 * @tc.type: FUNC
865 * @tc.level Level 1
866 * @tc.require: I6F3GV
867 */
868 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_RestoreOnBundleFinished_0102, testing::ext::TestSize.Level1)
869 {
870 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_RestoreOnBundleFinished_0102";
871 try {
872 Init(IServiceReverseType::Scenario::RESTORE, 1);
873 if (service_ == nullptr) {
874 GTEST_LOG_(INFO) <<
875 "SUB_backup_ServiceReverse_RestoreOnBundleFinished_0102 service_ == nullptr";
876 return;
877 }
878 service_->RestoreOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME);
879 } catch (...) {
880 EXPECT_TRUE(false);
881 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by RestoreOnBundleFinished.";
882 }
883 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_RestoreOnBundleFinished_0102";
884 }
885
886 /**
887 * @tc.number: SUB_backup_ServiceReverse_RestoreOnAllBundlesFinished_0100
888 * @tc.name: SUB_backup_ServiceReverse_RestoreOnAllBundlesFinished_0100
889 * @tc.desc: 测试 RestoreOnAllBundlesFinished 接口
890 * @tc.size: MEDIUM
891 * @tc.type: FUNC
892 * @tc.level Level 1
893 * @tc.require: I6F3GV
894 */
895 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_RestoreOnAllBundlesFinished_0100, testing::ext::TestSize.Level1)
896 {
897 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_RestoreOnAllBundlesFinished_0100";
898 try {
899 Init(IServiceReverseType::Scenario::RESTORE);
900 if (service_ == nullptr) {
901 GTEST_LOG_(INFO) <<
902 "SUB_backup_ServiceReverse_RestoreOnAllBundlesFinished_0100 service_ == nullptr";
903 return;
904 }
905 service_->RestoreOnAllBundlesFinished(BError(BError::Codes::OK));
906 service_->BackupOnAllBundlesFinished(BError(BError::Codes::OK));
907 } catch (...) {
908 EXPECT_TRUE(false);
909 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by RestoreOnAllBundlesFinished.";
910 }
911 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_RestoreOnAllBundlesFinished_0100";
912 }
913
914 /**
915 * @tc.number: SUB_backup_ServiceReverse_RestoreOnAllBundlesFinished_0101
916 * @tc.name: SUB_backup_ServiceReverse_RestoreOnAllBundlesFinished_0101
917 * @tc.desc: 测试 RestoreOnAllBundlesFinished 接口
918 * @tc.size: MEDIUM
919 * @tc.type: FUNC
920 * @tc.level Level 1
921 * @tc.require: I6F3GV
922 */
923 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_RestoreOnAllBundlesFinished_0101, testing::ext::TestSize.Level1)
924 {
925 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_RestoreOnAllBundlesFinished_0101";
926 try {
927 Init(IServiceReverseType::Scenario::BACKUP);
928 if (service_ == nullptr) {
929 GTEST_LOG_(INFO) <<
930 "SUB_backup_ServiceReverse_RestoreOnAllBundlesFinished_0101 service_ == nullptr";
931 return;
932 }
933 service_->RestoreOnAllBundlesFinished(BError(BError::Codes::OK));
934 } catch (...) {
935 EXPECT_TRUE(false);
936 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by RestoreOnAllBundlesFinished.";
937 }
938 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_RestoreOnAllBundlesFinished_0101";
939 }
940
941 /**
942 * @tc.number: SUB_backup_ServiceReverse_RestoreOnAllBundlesFinished_0102
943 * @tc.name: SUB_backup_ServiceReverse_RestoreOnAllBundlesFinished_0102
944 * @tc.desc: 测试 RestoreOnAllBundlesFinished 接口
945 * @tc.size: MEDIUM
946 * @tc.type: FUNC
947 * @tc.level Level 1
948 * @tc.require: I6F3GV
949 */
950 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_RestoreOnAllBundlesFinished_0102, testing::ext::TestSize.Level1)
951 {
952 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_RestoreOnAllBundlesFinished_0102";
953 try {
954 Init(IServiceReverseType::Scenario::RESTORE, 1);
955 if (service_ == nullptr) {
956 GTEST_LOG_(INFO) <<
957 "SUB_backup_ServiceReverse_RestoreOnAllBundlesFinished_0102 service_ == nullptr";
958 return;
959 }
960 service_->RestoreOnAllBundlesFinished(BError(BError::Codes::OK));
961 } catch (...) {
962 EXPECT_TRUE(false);
963 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by RestoreOnAllBundlesFinished.";
964 }
965 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_RestoreOnAllBundlesFinished_0102";
966 }
967
968 /**
969 * @tc.number: SUB_backup_ServiceReverse_BackupOnProcessInfo_0100
970 * @tc.name: SUB_backup_ServiceReverse_BackupOnProcessInfo_0100
971 * @tc.desc: 测试 BackupOnProcessInfo 接口
972 * @tc.size: MEDIUM
973 * @tc.type: FUNC
974 * @tc.level Level 1
975 * @tc.require: I6F3GV
976 */
977 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_BackupOnProcessInfo_0100, testing::ext::TestSize.Level1)
978 {
979 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_BackupOnProcessInfo_0100";
980 try {
981 Init(IServiceReverseType::Scenario::BACKUP);
982 if (service_ == nullptr) {
983 GTEST_LOG_(INFO) <<
984 "SUB_backup_ServiceReverse_BackupOnProcessInfo_0100 service_ == nullptr";
985 return;
986 }
987 std::string bundleName = BUNDLE_NAME;
988 std::string processInfo = "{\"timeInfo\": \"\", \"resultInfo\": \"\"}";
989 service_->BackupOnProcessInfo(bundleName, processInfo);
990 service_->RestoreOnProcessInfo(bundleName, processInfo);
991 } catch (...) {
992 EXPECT_TRUE(false);
993 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by BackupOnProcessInfo.";
994 }
995 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_BackupOnProcessInfo_0100";
996 }
997
998 /**
999 * @tc.number: SUB_backup_ServiceReverse_BackupOnProcessInfo_0101
1000 * @tc.name: SUB_backup_ServiceReverse_BackupOnProcessInfo_0101
1001 * @tc.desc: 测试 BackupOnProcessInfo 接口
1002 * @tc.size: MEDIUM
1003 * @tc.type: FUNC
1004 * @tc.level Level 1
1005 * @tc.require: I6F3GV
1006 */
1007 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_BackupOnProcessInfo_0101, testing::ext::TestSize.Level1)
1008 {
1009 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_BackupOnProcessInfo_0101";
1010 try {
1011 Init(IServiceReverseType::Scenario::RESTORE);
1012 if (service_ == nullptr) {
1013 GTEST_LOG_(INFO) <<
1014 "SUB_backup_ServiceReverse_BackupOnProcessInfo_0101 service_ == nullptr";
1015 return;
1016 }
1017 std::string bundleName = BUNDLE_NAME;
1018 std::string processInfo = "{\"timeInfo\": \"\", \"resultInfo\": \"\"}";
1019 service_->BackupOnProcessInfo(bundleName, processInfo);
1020 } catch (...) {
1021 EXPECT_TRUE(false);
1022 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by BackupOnProcessInfo.";
1023 }
1024 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_BackupOnProcessInfo_0101";
1025 }
1026
1027 /**
1028 * @tc.number: SUB_backup_ServiceReverse_BackupOnProcessInfo_0102
1029 * @tc.name: SUB_backup_ServiceReverse_BackupOnProcessInfo_0102
1030 * @tc.desc: 测试 BackupOnProcessInfo 接口
1031 * @tc.size: MEDIUM
1032 * @tc.type: FUNC
1033 * @tc.level Level 1
1034 * @tc.require: I6F3GV
1035 */
1036 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_BackupOnProcessInfo_0102, testing::ext::TestSize.Level1)
1037 {
1038 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_BackupOnProcessInfo_0102";
1039 try {
1040 Init(IServiceReverseType::Scenario::BACKUP, 1);
1041 if (service_ == nullptr) {
1042 GTEST_LOG_(INFO) <<
1043 "SUB_backup_ServiceReverse_BackupOnProcessInfo_0102 service_ == nullptr";
1044 return;
1045 }
1046 std::string bundleName = BUNDLE_NAME;
1047 std::string processInfo = "{\"timeInfo\": \"\", \"resultInfo\": \"\"}";
1048 service_->BackupOnProcessInfo(bundleName, processInfo);
1049 } catch (...) {
1050 EXPECT_TRUE(false);
1051 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by BackupOnProcessInfo.";
1052 }
1053 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_BackupOnProcessInfo_0102";
1054 }
1055
1056 /**
1057 * @tc.number: SUB_backup_ServiceReverse_0200
1058 * @tc.name: SUB_backup_ServiceReverse_0200
1059 * @tc.desc: 测试分支
1060 * @tc.size: MEDIUM
1061 * @tc.type: FUNC
1062 * @tc.level Level 1
1063 * @tc.require: I6F3GV
1064 */
1065 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_0200, testing::ext::TestSize.Level1)
1066 {
1067 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_0200";
1068 try {
1069 Init(IServiceReverseType::Scenario::RESTORE, 1);
1070 if (service_ == nullptr) {
1071 GTEST_LOG_(INFO) <<
1072 "SUB_backup_ServiceReverse_0200 service_ == nullptr";
1073 return;
1074 }
1075 service_->RestoreOnFileReady(BUNDLE_NAME, FILE_NAME, -1, 0);
1076 service_->RestoreOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME);
1077 service_->RestoreOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME);
1078 service_->RestoreOnAllBundlesFinished(BError(BError::Codes::OK));
1079 } catch (...) {
1080 EXPECT_TRUE(false);
1081 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred.";
1082 }
1083 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_0200";
1084 }
1085
1086 /**
1087 * @tc.number: SUB_backup_ServiceReverse_0201
1088 * @tc.name: SUB_backup_ServiceReverse_0201
1089 * @tc.desc: 测试分支
1090 * @tc.size: MEDIUM
1091 * @tc.type: FUNC
1092 * @tc.level Level 1
1093 * @tc.require: I6F3GV
1094 */
1095 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_0201, testing::ext::TestSize.Level1)
1096 {
1097 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_0201";
1098 try {
1099 Init(IServiceReverseType::Scenario::RESTORE, 0);
1100 if (service_ == nullptr) {
1101 GTEST_LOG_(INFO) <<
1102 "SUB_backup_ServiceReverse_0201 service_ == nullptr";
1103 return;
1104 }
1105 service_->RestoreOnFileReady(BUNDLE_NAME, FILE_NAME, -1, 0);
1106 service_->RestoreOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME);
1107 service_->RestoreOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME);
1108 service_->RestoreOnAllBundlesFinished(BError(BError::Codes::OK));
1109 } catch (...) {
1110 EXPECT_TRUE(false);
1111 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred.";
1112 }
1113 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_0201";
1114 }
1115
1116 /**
1117 * @tc.number: SUB_backup_ServiceReverse_0300
1118 * @tc.name: SUB_backup_ServiceReverse_0300
1119 * @tc.desc: 测试分支
1120 * @tc.size: MEDIUM
1121 * @tc.type: FUNC
1122 * @tc.level Level 1
1123 * @tc.require: I6F3GV
1124 */
1125 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_0300, testing::ext::TestSize.Level1)
1126 {
1127 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_0300";
1128 try {
1129 Init(IServiceReverseType::Scenario::BACKUP, 1);
1130 if (service_ == nullptr) {
1131 GTEST_LOG_(INFO) <<
1132 "SUB_backup_ServiceReverse_0300 service_ == nullptr";
1133 return;
1134 }
1135 service_->BackupOnFileReady(BUNDLE_NAME, FILE_NAME, -1, 0);
1136 service_->BackupOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME);
1137 service_->BackupOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME);
1138 service_->BackupOnAllBundlesFinished(BError(BError::Codes::OK));
1139 } catch (...) {
1140 EXPECT_TRUE(false);
1141 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred.";
1142 }
1143 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_0300";
1144 }
1145
1146 /**
1147 * @tc.number: SUB_backup_ServiceReverse_0301
1148 * @tc.name: SUB_backup_ServiceReverse_0301
1149 * @tc.desc: 测试分支
1150 * @tc.size: MEDIUM
1151 * @tc.type: FUNC
1152 * @tc.level Level 1
1153 * @tc.require: I6F3GV
1154 */
1155 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_0301, testing::ext::TestSize.Level1)
1156 {
1157 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_0301";
1158 try {
1159 Init(IServiceReverseType::Scenario::BACKUP, 0);
1160 if (service_ == nullptr) {
1161 GTEST_LOG_(INFO) <<
1162 "SUB_backup_ServiceReverse_0301 service_ == nullptr";
1163 return;
1164 }
1165 service_->BackupOnFileReady(BUNDLE_NAME, FILE_NAME, -1, 0);
1166 service_->BackupOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME);
1167 service_->BackupOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME);
1168 service_->BackupOnAllBundlesFinished(BError(BError::Codes::OK));
1169 } catch (...) {
1170 EXPECT_TRUE(false);
1171 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred.";
1172 }
1173 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_0301";
1174 }
1175
1176 /**
1177 * @tc.number: SUB_backup_ServiceReverse_IncrementalBackupOnFileReady_0100
1178 * @tc.name: SUB_backup_ServiceReverse_IncrementalBackupOnFileReady_0100
1179 * @tc.desc: 测试 IncrementalBackupOnFileReady 接口
1180 * @tc.size: MEDIUM
1181 * @tc.type: FUNC
1182 * @tc.level Level 1
1183 * @tc.require: I9116W
1184 */
1185 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_IncrementalBackupOnFileReady_0100,
1186 testing::ext::TestSize.Level1)
1187 {
1188 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalBackupOnFileReady_0100";
1189 try {
1190 IncrementalInit(IServiceReverseType::Scenario::BACKUP);
1191 if (service_ == nullptr) {
1192 GTEST_LOG_(INFO) <<
1193 "SUB_backup_ServiceReverse_IncrementalBackupOnFileReady_0100 service_ == nullptr";
1194 return;
1195 }
1196 service_->IncrementalBackupOnFileReady(BUNDLE_NAME, FILE_NAME, -1, -1, 0);
1197 service_->IncrementalRestoreOnFileReady(BUNDLE_NAME, FILE_NAME, -1, -1, 0);
1198 } catch (...) {
1199 EXPECT_TRUE(false);
1200 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by RestoreOnAllBundlesFinished.";
1201 }
1202 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_IncrementalBackupOnFileReady_0100";
1203 }
1204
1205 /**
1206 * @tc.number: SUB_backup_ServiceReverse_IncrementalBackupOnFileReady_0101
1207 * @tc.name: SUB_backup_ServiceReverse_IncrementalBackupOnFileReady_0101
1208 * @tc.desc: 测试 IncrementalBackupOnFileReady 接口
1209 * @tc.size: MEDIUM
1210 * @tc.type: FUNC
1211 * @tc.level Level 1
1212 * @tc.require: I9116W
1213 */
1214 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_IncrementalBackupOnFileReady_0101,
1215 testing::ext::TestSize.Level1)
1216 {
1217 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalBackupOnFileReady_0101";
1218 try {
1219 IncrementalInit(IServiceReverseType::Scenario::RESTORE);
1220 if (service_ == nullptr) {
1221 GTEST_LOG_(INFO) <<
1222 "SUB_backup_ServiceReverse_IncrementalBackupOnFileReady_0101 service_ == nullptr";
1223 return;
1224 }
1225 service_->IncrementalBackupOnFileReady(BUNDLE_NAME, FILE_NAME, -1, -1, 0);
1226
1227 IncrementalInit(IServiceReverseType::Scenario::BACKUP, 1);
1228 service_->IncrementalBackupOnFileReady(BUNDLE_NAME, FILE_NAME, -1, -1, 0);
1229 } catch (...) {
1230 EXPECT_TRUE(false);
1231 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by IncrementalBackupOnFileReady.";
1232 }
1233 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_IncrementalBackupOnFileReady_0101";
1234 }
1235
1236 /**
1237 * @tc.number: SUB_backup_ServiceReverse_IncrementalBackupOnFileReadyWithoutFd_0100
1238 * @tc.name: SUB_backup_ServiceReverse_IncrementalBackupOnFileReadyWithoutFd_0100
1239 * @tc.desc: 测试 IncrementalBackupOnFileReadyWithoutFd 正常分支（回调非空且场景为BACKUP）
1240 * @tc.size: MEDIUM
1241 * @tc.type: FUNC
1242 * @tc.level Level 1
1243 */
1244 HWTEST_F(ServiceReverseTest,
1245 SUB_backup_ServiceReverse_IncrementalBackupOnFileReadyWithoutFd_0100,
1246 testing::ext::TestSize.Level1)
1247 {
1248 GTEST_LOG_(INFO) <<
1249 "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalBackupOnFileReadyWithoutFd_0100";
1250 bool called = false;
1251 IncrementalInit(IServiceReverseType::Scenario::BACKUP, 0);
1252 if (service_ == nullptr) {
1253 GTEST_LOG_(INFO) << "service_ == nullptr";
1254 return;
1255 }
1256 // 设置回调
__anon7403e2900602(const BFileInfo&, UniqueFd, UniqueFd, int32_t) 1257 service_->callbacksIncrementalBackup_.onFileReady = [&](const BFileInfo&, UniqueFd, UniqueFd, int32_t) {
1258 called = true;
1259 };
1260 auto ret = service_->IncrementalBackupOnFileReadyWithoutFd("bundle", "file", 123);
1261 EXPECT_EQ(ret, 0);
1262 EXPECT_TRUE(called);
1263 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_IncrementalBackupOnFileReadyWithoutFd_0100";
1264 }
1265
1266 /**
1267 * @tc.number: SUB_backup_ServiceReverse_IncrementalBackupOnFileReadyWithoutFd_0101
1268 * @tc.name: SUB_backup_ServiceReverse_IncrementalBackupOnFileReadyWithoutFd_0101
1269 * @tc.desc: 测试 IncrementalBackupOnFileReadyWithoutFd 回调为nullptr分支
1270 * @tc.size: MEDIUM
1271 * @tc.type: FUNC
1272 * @tc.level Level 1
1273 */
1274 HWTEST_F(ServiceReverseTest,
1275 SUB_backup_ServiceReverse_IncrementalBackupOnFileReadyWithoutFd_0101,
1276 testing::ext::TestSize.Level1)
1277 {
1278 GTEST_LOG_(INFO) <<
1279 "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalBackupOnFileReadyWithoutFd_0101";
1280 IncrementalInit(IServiceReverseType::Scenario::BACKUP, 0);
1281 if (service_ == nullptr) {
1282 GTEST_LOG_(INFO) << "service_ == nullptr";
1283 return;
1284 }
1285 service_->callbacksIncrementalBackup_.onFileReady = nullptr;
1286 auto ret = service_->IncrementalBackupOnFileReadyWithoutFd("bundle", "file", 123);
1287 EXPECT_EQ(ret, 0);
1288 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_IncrementalBackupOnFileReadyWithoutFd_0101";
1289 }
1290
1291 /**
1292 * @tc.number: SUB_backup_ServiceReverse_IncrementalBackupOnFileReadyWithoutFd_0102
1293 * @tc.name: SUB_backup_ServiceReverse_IncrementalBackupOnFileReadyWithoutFd_0102
1294 * @tc.desc: 测试 IncrementalBackupOnFileReadyWithoutFd 场景非BACKUP分支
1295 * @tc.size: MEDIUM
1296 * @tc.type: FUNC
1297 * @tc.level Level 1
1298 */
1299 HWTEST_F(ServiceReverseTest,
1300 SUB_backup_ServiceReverse_IncrementalBackupOnFileReadyWithoutFd_0102,
1301 testing::ext::TestSize.Level1)
1302 {
1303 GTEST_LOG_(INFO) <<
1304 "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalBackupOnFileReadyWithoutFd_0102";
1305 IncrementalInit(IServiceReverseType::Scenario::RESTORE, 0); // 场景非BACKUP
1306 if (service_ == nullptr) {
1307 GTEST_LOG_(INFO) << "service_ == nullptr";
1308 return;
1309 }
1310 bool called = false;
__anon7403e2900702(const BFileInfo&, UniqueFd, UniqueFd, int32_t) 1311 service_->callbacksIncrementalBackup_.onFileReady = [&](const BFileInfo&, UniqueFd, UniqueFd, int32_t) {
1312 called = true;
1313 };
1314 auto ret = service_->IncrementalBackupOnFileReadyWithoutFd("bundle", "file", 123);
1315 EXPECT_EQ(ret, 0);
1316 EXPECT_FALSE(called);
1317 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_IncrementalBackupOnFileReadyWithoutFd_0102";
1318 }
1319
1320 /**
1321 * @tc.number: SUB_backup_ServiceReverse_IncrementalBackupOnBundleStarted_0100
1322 * @tc.name: SUB_backup_ServiceReverse_IncrementalBackupOnBundleStarted_0100
1323 * @tc.desc: 测试 IncrementalBackupOnBundleStarted 接口
1324 * @tc.size: MEDIUM
1325 * @tc.type: FUNC
1326 * @tc.level Level 1
1327 * @tc.require: I9116W
1328 */
1329 HWTEST_F(ServiceReverseTest,
1330 SUB_backup_ServiceReverse_IncrementalBackupOnBundleStarted_0100,
1331 testing::ext::TestSize.Level1)
1332 {
1333 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalBackupOnBundleStarted_0100";
1334 try {
1335 IncrementalInit(IServiceReverseType::Scenario::BACKUP);
1336 if (service_ == nullptr) {
1337 GTEST_LOG_(INFO) <<
1338 "SUB_backup_ServiceReverse_IncrementalBackupOnBundleStarted_0100 service_ == nullptr";
1339 return;
1340 }
1341 service_->IncrementalBackupOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME);
1342 service_->IncrementalRestoreOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME);
1343 } catch (...) {
1344 EXPECT_TRUE(false);
1345 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by IncrementalBackupOnBundleStarted.";
1346 }
1347 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_IncrementalBackupOnBundleStarted_0100";
1348 }
1349
1350 /**
1351 * @tc.number: SUB_backup_ServiceReverse_IncrementalBackupOnBundleStarted_0101
1352 * @tc.name: SUB_backup_ServiceReverse_IncrementalBackupOnBundleStarted_0101
1353 * @tc.desc: 测试 IncrementalBackupOnBundleStarted 接口
1354 * @tc.size: MEDIUM
1355 * @tc.type: FUNC
1356 * @tc.level Level 1
1357 * @tc.require: I9116W
1358 */
1359 HWTEST_F(ServiceReverseTest,
1360 SUB_backup_ServiceReverse_IncrementalBackupOnBundleStarted_0101,
1361 testing::ext::TestSize.Level1)
1362 {
1363 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalBackupOnBundleStarted_0101";
1364 try {
1365 IncrementalInit(IServiceReverseType::Scenario::RESTORE);
1366 if (service_ == nullptr) {
1367 GTEST_LOG_(INFO) <<
1368 "SUB_backup_ServiceReverse_IncrementalBackupOnBundleStarted_0101 service_ == nullptr";
1369 return;
1370 }
1371 service_->IncrementalBackupOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME);
1372
1373 IncrementalInit(IServiceReverseType::Scenario::BACKUP, 1);
1374 service_->IncrementalBackupOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME);
1375 } catch (...) {
1376 EXPECT_TRUE(false);
1377 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by IncrementalBackupOnBundleStarted.";
1378 }
1379 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_IncrementalBackupOnBundleStarted_0101";
1380 }
1381
1382 /**
1383 * @tc.number: SUB_backup_ServiceReverse_IncrementalBackupOnBundleFinished_0100
1384 * @tc.name: SUB_backup_ServiceReverse_IncrementalBackupOnBundleFinished_0100
1385 * @tc.desc: 测试 IncrementalBackupOnBundleFinished 接口
1386 * @tc.size: MEDIUM
1387 * @tc.type: FUNC
1388 * @tc.level Level 1
1389 * @tc.require: I9116W
1390 */
1391 HWTEST_F(ServiceReverseTest,
1392 SUB_backup_ServiceReverse_IncrementalBackupOnBundleFinished_0100,
1393 testing::ext::TestSize.Level1)
1394 {
1395 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalBackupOnBundleFinished_0100";
1396 try {
1397 IncrementalInit(IServiceReverseType::Scenario::BACKUP);
1398 if (service_ == nullptr) {
1399 GTEST_LOG_(INFO) <<
1400 "SUB_backup_ServiceReverse_IncrementalBackupOnBundleFinished_0100 service_ == nullptr";
1401 return;
1402 }
1403 service_->IncrementalBackupOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME);
1404 service_->IncrementalRestoreOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME);
1405 } catch (...) {
1406 EXPECT_TRUE(false);
1407 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by IncrementalBackupOnBundleFinished.";
1408 }
1409 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_IncrementalBackupOnBundleFinished_0100";
1410 }
1411
1412 /**
1413 * @tc.number: SUB_backup_ServiceReverse_IncrementalBackupOnBundleFinished_0101
1414 * @tc.name: SUB_backup_ServiceReverse_IncrementalBackupOnBundleFinished_0101
1415 * @tc.desc: 测试 IncrementalBackupOnBundleFinished 接口
1416 * @tc.size: MEDIUM
1417 * @tc.type: FUNC
1418 * @tc.level Level 1
1419 * @tc.require: I9116W
1420 */
1421 HWTEST_F(ServiceReverseTest,
1422 SUB_backup_ServiceReverse_IncrementalBackupOnBundleFinished_0101,
1423 testing::ext::TestSize.Level1)
1424 {
1425 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalBackupOnBundleFinished_0101";
1426 try {
1427 IncrementalInit(IServiceReverseType::Scenario::RESTORE);
1428 if (service_ == nullptr) {
1429 GTEST_LOG_(INFO) <<
1430 "SUB_backup_ServiceReverse_IncrementalBackupOnBundleFinished_0101 service_ == nullptr";
1431 return;
1432 }
1433 service_->IncrementalBackupOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME);
1434
1435 IncrementalInit(IServiceReverseType::Scenario::BACKUP, 1);
1436 service_->IncrementalBackupOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME);
1437 } catch (...) {
1438 EXPECT_TRUE(false);
1439 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by IncrementalBackupOnBundleFinished.";
1440 }
1441 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_IncrementalBackupOnBundleFinished_0101";
1442 }
1443
1444 /**
1445 * @tc.number: SUB_backup_ServiceReverse_IncrementalBackupOnAllBundlesFinished_0100
1446 * @tc.name: SUB_backup_ServiceReverse_IncrementalBackupOnAllBundlesFinished_0100
1447 * @tc.desc: 测试 IncrementalBackupOnAllBundlesFinished 接口
1448 * @tc.size: MEDIUM
1449 * @tc.type: FUNC
1450 * @tc.level Level 1
1451 * @tc.require: I9116W
1452 */
1453 HWTEST_F(ServiceReverseTest,
1454 SUB_backup_ServiceReverse_IncrementalBackupOnAllBundlesFinished_0100,
1455 testing::ext::TestSize.Level1)
1456 {
1457 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalBackupOnAllBundlesFinished_0100";
1458 try {
1459 IncrementalInit(IServiceReverseType::Scenario::BACKUP);
1460 if (service_ == nullptr) {
1461 GTEST_LOG_(INFO) <<
1462 "SUB_backup_ServiceReverse_IncrementalBackupOnAllBundlesFinished_0100 service_ == nullptr";
1463 return;
1464 }
1465 service_->IncrementalBackupOnAllBundlesFinished(BError(BError::Codes::OK));
1466 service_->IncrementalRestoreOnAllBundlesFinished(BError(BError::Codes::OK));
1467 } catch (...) {
1468 EXPECT_TRUE(false);
1469 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by IncrementalBackupOnAllBundlesFinished.";
1470 }
1471 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_IncrementalBackupOnAllBundlesFinished_0100";
1472 }
1473
1474 /**
1475 * @tc.number: SUB_backup_ServiceReverse_IncrementalBackupOnAllBundlesFinished_0101
1476 * @tc.name: SUB_backup_ServiceReverse_IncrementalBackupOnAllBundlesFinished_0101
1477 * @tc.desc: 测试 IncrementalBackupOnAllBundlesFinished 接口
1478 * @tc.size: MEDIUM
1479 * @tc.type: FUNC
1480 * @tc.level Level 1
1481 * @tc.require: I9116W
1482 */
1483 HWTEST_F(ServiceReverseTest,
1484 SUB_backup_ServiceReverse_IncrementalBackupOnAllBundlesFinished_0101,
1485 testing::ext::TestSize.Level1)
1486 {
1487 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalBackupOnAllBundlesFinished_0101";
1488 try {
1489 IncrementalInit(IServiceReverseType::Scenario::RESTORE);
1490 if (service_ == nullptr) {
1491 GTEST_LOG_(INFO) <<
1492 "SUB_backup_ServiceReverse_IncrementalBackupOnAllBundlesFinished_0101 service_ == nullptr";
1493 return;
1494 }
1495 service_->IncrementalBackupOnAllBundlesFinished(BError(BError::Codes::OK));
1496
1497 IncrementalInit(IServiceReverseType::Scenario::BACKUP, 1);
1498 service_->IncrementalBackupOnAllBundlesFinished(BError(BError::Codes::OK));
1499 } catch (...) {
1500 EXPECT_TRUE(false);
1501 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by IncrementalBackupOnAllBundlesFinished.";
1502 }
1503 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_IncrementalBackupOnAllBundlesFinished_0101";
1504 }
1505
1506 /**
1507 * @tc.number: SUB_backup_ServiceReverse_IncrementalRestoreOnFileReady_0100
1508 * @tc.name: SUB_backup_ServiceReverse_IncrementalRestoreOnFileReady_0100
1509 * @tc.desc: 测试 IncrementalRestoreOnFileReady 接口
1510 * @tc.size: MEDIUM
1511 * @tc.type: FUNC
1512 * @tc.level Level 1
1513 * @tc.require: I9116W
1514 */
1515 HWTEST_F(ServiceReverseTest,
1516 SUB_backup_ServiceReverse_IncrementalRestoreOnFileReady_0100,
1517 testing::ext::TestSize.Level1)
1518 {
1519 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalRestoreOnFileReady_0100";
1520 try {
1521 IncrementalInit(IServiceReverseType::Scenario::RESTORE);
1522 if (service_ == nullptr) {
1523 GTEST_LOG_(INFO) <<
1524 "SUB_backup_ServiceReverse_IncrementalRestoreOnFileReady_0100 service_ == nullptr";
1525 return;
1526 }
1527 service_->IncrementalRestoreOnFileReady(BUNDLE_NAME, FILE_NAME, -1, -1, 0);
1528 service_->IncrementalBackupOnFileReady(BUNDLE_NAME, FILE_NAME, -1, -1, 0);
1529 } catch (...) {
1530 EXPECT_TRUE(false);
1531 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by IncrementalRestoreOnFileReady.";
1532 }
1533 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_IncrementalRestoreOnFileReady_0100";
1534 }
1535
1536 /**
1537 * @tc.number: SUB_backup_ServiceReverse_IncrementalRestoreOnFileReady_0101
1538 * @tc.name: SUB_backup_ServiceReverse_IncrementalRestoreOnFileReady_0101
1539 * @tc.desc: 测试 IncrementalRestoreOnFileReady 接口
1540 * @tc.size: MEDIUM
1541 * @tc.type: FUNC
1542 * @tc.level Level 1
1543 * @tc.require: I9116W
1544 */
1545 HWTEST_F(ServiceReverseTest,
1546 SUB_backup_ServiceReverse_IncrementalRestoreOnFileReady_0101,
1547 testing::ext::TestSize.Level1)
1548 {
1549 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalRestoreOnFileReady_0101";
1550 try {
1551 IncrementalInit(IServiceReverseType::Scenario::BACKUP);
1552 if (service_ == nullptr) {
1553 GTEST_LOG_(INFO) <<
1554 "SUB_backup_ServiceReverse_IncrementalRestoreOnFileReady_0101 service_ == nullptr";
1555 return;
1556 }
1557 service_->IncrementalRestoreOnFileReady(BUNDLE_NAME, FILE_NAME, -1, -1, 0);
1558
1559 IncrementalInit(IServiceReverseType::Scenario::RESTORE, 1);
1560 service_->IncrementalRestoreOnFileReady(BUNDLE_NAME, FILE_NAME, -1, -1, 0);
1561 } catch (...) {
1562 EXPECT_TRUE(false);
1563 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by IncrementalRestoreOnFileReady.";
1564 }
1565 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_IncrementalRestoreOnFileReady_0101";
1566 }
1567
1568 /**
1569 * @tc.number: SUB_backup_ServiceReverse_IncrementalRestoreOnFileReadyWithoutFd_0100
1570 * @tc.name: SUB_backup_ServiceReverse_IncrementalRestoreOnFileReadyWithoutFd_0100
1571 * @tc.desc: 测试 IncrementalRestoreOnFileReadyWithoutFd 正常分支（回调非空且场景为RESTORE）
1572 * @tc.size: MEDIUM
1573 * @tc.type: FUNC
1574 * @tc.level Level 1
1575 */
1576 HWTEST_F(ServiceReverseTest,
1577 SUB_backup_ServiceReverse_IncrementalRestoreOnFileReadyWithoutFd_0100,
1578 testing::ext::TestSize.Level1)
1579 {
1580 GTEST_LOG_(INFO) <<
1581 "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalRestoreOnFileReadyWithoutFd_0100";
1582 bool called = false;
1583 IncrementalInit(IServiceReverseType::Scenario::RESTORE, 0);
1584 if (service_ == nullptr) {
1585 GTEST_LOG_(INFO) << "service_ == nullptr";
1586 return;
1587 }
__anon7403e2900802(const BFileInfo&, UniqueFd, UniqueFd, int32_t) 1588 service_->callbacksIncrementalRestore_.onFileReady = [&](const BFileInfo&, UniqueFd, UniqueFd, int32_t) {
1589 called = true;
1590 };
1591 auto ret = service_->IncrementalRestoreOnFileReadyWithoutFd("bundle", "file", 123);
1592 EXPECT_EQ(ret, 0);
1593 EXPECT_TRUE(called);
1594 GTEST_LOG_(INFO) <<
1595 "ServiceReverseTest-end SUB_backup_ServiceReverse_IncrementalRestoreOnFileReadyWithoutFd_0100";
1596 }
1597
1598 /**
1599 * @tc.number: SUB_backup_ServiceReverse_IncrementalRestoreOnFileReadyWithoutFd_0101
1600 * @tc.name: SUB_backup_ServiceReverse_IncrementalRestoreOnFileReadyWithoutFd_0101
1601 * @tc.desc: 测试 IncrementalRestoreOnFileReadyWithoutFd 回调为nullptr分支
1602 * @tc.size: MEDIUM
1603 * @tc.type: FUNC
1604 * @tc.level Level 1
1605 */
1606 HWTEST_F(ServiceReverseTest,
1607 SUB_backup_ServiceReverse_IncrementalRestoreOnFileReadyWithoutFd_0101,
1608 testing::ext::TestSize.Level1)
1609 {
1610 GTEST_LOG_(INFO) <<
1611 "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalRestoreOnFileReadyWithoutFd_0101";
1612 IncrementalInit(IServiceReverseType::Scenario::RESTORE, 0);
1613 if (service_ == nullptr) {
1614 GTEST_LOG_(INFO) << "service_ == nullptr";
1615 return;
1616 }
1617 service_->callbacksIncrementalRestore_.onFileReady = nullptr;
1618 auto ret = service_->IncrementalRestoreOnFileReadyWithoutFd("bundle", "file", 123);
1619 EXPECT_EQ(ret, 0);
1620 GTEST_LOG_(INFO) <<
1621 "ServiceReverseTest-end SUB_backup_ServiceReverse_IncrementalRestoreOnFileReadyWithoutFd_0101";
1622 }
1623
1624 /**
1625 * @tc.number: SUB_backup_ServiceReverse_IncrementalRestoreOnFileReadyWithoutFd_0102
1626 * @tc.name: SUB_backup_ServiceReverse_IncrementalRestoreOnFileReadyWithoutFd_0102
1627 * @tc.desc: 测试 IncrementalRestoreOnFileReadyWithoutFd 场景非RESTORE分支
1628 * @tc.size: MEDIUM
1629 * @tc.type: FUNC
1630 * @tc.level Level 1
1631 */
1632 HWTEST_F(ServiceReverseTest,
1633 SUB_backup_ServiceReverse_IncrementalRestoreOnFileReadyWithoutFd_0102,
1634 testing::ext::TestSize.Level1)
1635 {
1636 GTEST_LOG_(INFO) <<
1637 "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalRestoreOnFileReadyWithoutFd_0102";
1638 IncrementalInit(IServiceReverseType::Scenario::BACKUP, 0); // 场景非RESTORE
1639 if (service_ == nullptr) {
1640 GTEST_LOG_(INFO) << "service_ == nullptr";
1641 return;
1642 }
1643 bool called = false;
__anon7403e2900902(const BFileInfo&, UniqueFd, UniqueFd, int32_t) 1644 service_->callbacksIncrementalRestore_.onFileReady = [&](const BFileInfo&, UniqueFd, UniqueFd, int32_t) {
1645 called = true;
1646 };
1647 auto ret = service_->IncrementalRestoreOnFileReadyWithoutFd("bundle", "file", 123);
1648 EXPECT_EQ(ret, 0);
1649 EXPECT_FALSE(called);
1650 GTEST_LOG_(INFO) <<
1651 "ServiceReverseTest-end SUB_backup_ServiceReverse_IncrementalRestoreOnFileReadyWithoutFd_0102";
1652 }
1653
1654 /**
1655 * @tc.number: SUB_backup_ServiceReverse_IncrementalRestoreOnBundleStarted_0100
1656 * @tc.name: SUB_backup_ServiceReverse_IncrementalRestoreOnBundleStarted_0100
1657 * @tc.desc: 测试 IncrementalRestoreOnBundleStarted 接口
1658 * @tc.size: MEDIUM
1659 * @tc.type: FUNC
1660 * @tc.level Level 1
1661 * @tc.require: I9116W
1662 */
1663 HWTEST_F(ServiceReverseTest,
1664 SUB_backup_ServiceReverse_IncrementalRestoreOnBundleStarted_0100,
1665 testing::ext::TestSize.Level1)
1666 {
1667 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalRestoreOnBundleStarted_0100";
1668 try {
1669 IncrementalInit(IServiceReverseType::Scenario::RESTORE);
1670 if (service_ == nullptr) {
1671 GTEST_LOG_(INFO) <<
1672 "SUB_backup_ServiceReverse_IncrementalRestoreOnBundleStarted_0100 service_ == nullptr";
1673 return;
1674 }
1675 service_->IncrementalRestoreOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME);
1676 service_->IncrementalBackupOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME);
1677 } catch (...) {
1678 EXPECT_TRUE(false);
1679 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by IncrementalRestoreOnBundleStarted.";
1680 }
1681 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_IncrementalRestoreOnBundleStarted_0100";
1682 }
1683
1684 /**
1685 * @tc.number: SUB_backup_ServiceReverse_IncrementalRestoreOnBundleStarted_0101
1686 * @tc.name: SUB_backup_ServiceReverse_IncrementalRestoreOnBundleStarted_0101
1687 * @tc.desc: 测试 IncrementalRestoreOnBundleStarted 接口
1688 * @tc.size: MEDIUM
1689 * @tc.type: FUNC
1690 * @tc.level Level 1
1691 * @tc.require: I9116W
1692 */
1693 HWTEST_F(ServiceReverseTest,
1694 SUB_backup_ServiceReverse_IncrementalRestoreOnBundleStarted_0101,
1695 testing::ext::TestSize.Level1)
1696 {
1697 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalRestoreOnBundleStarted_0101";
1698 try {
1699 IncrementalInit(IServiceReverseType::Scenario::BACKUP);
1700 if (service_ == nullptr) {
1701 GTEST_LOG_(INFO) <<
1702 "SUB_backup_ServiceReverse_IncrementalRestoreOnBundleStarted_0101 service_ == nullptr";
1703 return;
1704 }
1705 service_->IncrementalRestoreOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME);
1706
1707 IncrementalInit(IServiceReverseType::Scenario::RESTORE, 1);
1708 service_->IncrementalRestoreOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME);
1709 } catch (...) {
1710 EXPECT_TRUE(false);
1711 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by IncrementalRestoreOnBundleStarted.";
1712 }
1713 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_IncrementalRestoreOnBundleStarted_0101";
1714 }
1715
1716 /**
1717 * @tc.number: SUB_backup_ServiceReverse_IncrementalRestoreOnBundleFinished_0100
1718 * @tc.name: SUB_backup_ServiceReverse_IncrementalRestoreOnBundleFinished_0100
1719 * @tc.desc: 测试 IncrementalRestoreOnBundleFinished 接口
1720 * @tc.size: MEDIUM
1721 * @tc.type: FUNC
1722 * @tc.level Level 1
1723 * @tc.require: I9116W
1724 */
1725 HWTEST_F(ServiceReverseTest,
1726 SUB_backup_ServiceReverse_IncrementalRestoreOnBundleFinished_0100,
1727 testing::ext::TestSize.Level1)
1728 {
1729 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalRestoreOnBundleFinished_0100";
1730 try {
1731 IncrementalInit(IServiceReverseType::Scenario::RESTORE);
1732 if (service_ == nullptr) {
1733 GTEST_LOG_(INFO) <<
1734 "SUB_backup_ServiceReverse_IncrementalRestoreOnBundleFinished_0100 service_ == nullptr";
1735 return;
1736 }
1737 service_->IncrementalRestoreOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME);
1738 service_->IncrementalBackupOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME);
1739 } catch (...) {
1740 EXPECT_TRUE(false);
1741 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by IncrementalRestoreOnBundleFinished.";
1742 }
1743 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_IncrementalRestoreOnBundleFinished_0100";
1744 }
1745
1746 /**
1747 * @tc.number: SUB_backup_ServiceReverse_IncrementalRestoreOnBundleFinished_0101
1748 * @tc.name: SUB_backup_ServiceReverse_IncrementalRestoreOnBundleFinished_0101
1749 * @tc.desc: 测试 IncrementalRestoreOnBundleFinished 接口
1750 * @tc.size: MEDIUM
1751 * @tc.type: FUNC
1752 * @tc.level Level 1
1753 * @tc.require: I9116W
1754 */
1755 HWTEST_F(ServiceReverseTest,
1756 SUB_backup_ServiceReverse_IncrementalRestoreOnBundleFinished_0101,
1757 testing::ext::TestSize.Level1)
1758 {
1759 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalRestoreOnBundleFinished_0101";
1760 try {
1761 IncrementalInit(IServiceReverseType::Scenario::BACKUP);
1762 if (service_ == nullptr) {
1763 GTEST_LOG_(INFO) <<
1764 "SUB_backup_ServiceReverse_IncrementalRestoreOnBundleFinished_0101 service_ == nullptr";
1765 return;
1766 }
1767 service_->IncrementalRestoreOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME);
1768
1769 IncrementalInit(IServiceReverseType::Scenario::RESTORE, 1);
1770 service_->IncrementalRestoreOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME);
1771 } catch (...) {
1772 EXPECT_TRUE(false);
1773 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by IncrementalRestoreOnBundleFinished.";
1774 }
1775 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_IncrementalRestoreOnBundleFinished_0101";
1776 }
1777
1778 /**
1779 * @tc.number: SUB_backup_ServiceReverse_IncrementalRestoreOnAllBundlesFinished_0100
1780 * @tc.name: SUB_backup_ServiceReverse_IncrementalRestoreOnAllBundlesFinished_0100
1781 * @tc.desc: 测试 IncrementalRestoreOnAllBundlesFinished 接口
1782 * @tc.size: MEDIUM
1783 * @tc.type: FUNC
1784 * @tc.level Level 1
1785 * @tc.require: I9116W
1786 */
1787 HWTEST_F(ServiceReverseTest,
1788 SUB_backup_ServiceReverse_IncrementalRestoreOnAllBundlesFinished_0100,
1789 testing::ext::TestSize.Level1)
1790 {
1791 GTEST_LOG_(INFO)
1792 << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalRestoreOnAllBundlesFinished_0100";
1793 try {
1794 IncrementalInit(IServiceReverseType::Scenario::RESTORE);
1795 if (service_ == nullptr) {
1796 GTEST_LOG_(INFO) <<
1797 "SUB_backup_ServiceReverse_IncrementalRestoreOnAllBundlesFinished_0100 service_ == nullptr";
1798 return;
1799 }
1800 service_->IncrementalRestoreOnAllBundlesFinished(BError(BError::Codes::OK));
1801 service_->IncrementalBackupOnAllBundlesFinished(BError(BError::Codes::OK));
1802 } catch (...) {
1803 EXPECT_TRUE(false);
1804 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by IncrementalRestoreOnAllBundlesFinished.";
1805 }
1806 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_IncrementalRestoreOnAllBundlesFinished_0100";
1807 }
1808
1809 /**
1810 * @tc.number: SUB_backup_ServiceReverse_IncrementalRestoreOnAllBundlesFinished_0101
1811 * @tc.name: SUB_backup_ServiceReverse_IncrementalRestoreOnAllBundlesFinished_0101
1812 * @tc.desc: 测试 IncrementalRestoreOnAllBundlesFinished 接口
1813 * @tc.size: MEDIUM
1814 * @tc.type: FUNC
1815 * @tc.level Level 1
1816 * @tc.require: I9116W
1817 */
1818 HWTEST_F(ServiceReverseTest,
1819 SUB_backup_ServiceReverse_IncrementalRestoreOnAllBundlesFinished_0101,
1820 testing::ext::TestSize.Level1)
1821 {
1822 GTEST_LOG_(INFO)
1823 << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalRestoreOnAllBundlesFinished_0101";
1824 try {
1825 IncrementalInit(IServiceReverseType::Scenario::BACKUP);
1826 if (service_ == nullptr) {
1827 GTEST_LOG_(INFO) <<
1828 "SUB_backup_ServiceReverse_IncrementalRestoreOnAllBundlesFinished_0101 service_ == nullptr";
1829 return;
1830 }
1831 service_->IncrementalRestoreOnAllBundlesFinished(BError(BError::Codes::OK));
1832
1833 IncrementalInit(IServiceReverseType::Scenario::RESTORE, 1);
1834 service_->IncrementalRestoreOnAllBundlesFinished(BError(BError::Codes::OK));
1835 } catch (...) {
1836 EXPECT_TRUE(false);
1837 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by IncrementalRestoreOnAllBundlesFinished.";
1838 }
1839 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_IncrementalRestoreOnAllBundlesFinished_0101";
1840 }
1841
1842 /**
1843 * @tc.number: SUB_backup_ServiceReverse_RestoreOnResultReport_0100
1844 * @tc.name: SUB_backup_ServiceReverse_RestoreOnResultReport_0100
1845 * @tc.desc: 测试 RestoreOnResultReport 接口
1846 * @tc.size: MEDIUM
1847 * @tc.type: FUNC
1848 * @tc.level Level 1
1849 * @tc.require: I6F3GV
1850 */
1851 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_RestoreOnResultReport_0100, testing::ext::TestSize.Level1)
1852 {
1853 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_RestoreOnResultReport_0100";
1854 try {
1855 Init(IServiceReverseType::Scenario::RESTORE);
1856 if (service_ == nullptr) {
1857 GTEST_LOG_(INFO) << "SUB_backup_ServiceReverse_RestoreOnResultReport_0100 service_ == nullptr";
1858 return;
1859 }
1860 std::string resultReport = "result_report";
1861 std::string bundleName = BUNDLE_NAME;
1862 service_->RestoreOnResultReport(resultReport, bundleName);
1863 } catch (...) {
1864 EXPECT_TRUE(false);
1865 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by RestoreOnResultReport.";
1866 }
1867 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_RestoreOnResultReport_0100";
1868 }
1869
1870 /**
1871 * @tc.number: SUB_backup_ServiceReverse_RestoreOnResultReport_0101
1872 * @tc.name: SUB_backup_ServiceReverse_RestoreOnResultReport_0101
1873 * @tc.desc: 测试 RestoreOnResultReport 接口
1874 * @tc.size: MEDIUM
1875 * @tc.type: FUNC
1876 * @tc.level Level 1
1877 * @tc.require: I6F3GV
1878 */
1879 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_RestoreOnResultReport_0101, testing::ext::TestSize.Level1)
1880 {
1881 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_RestoreOnResultReport_0101";
1882 try {
1883 Init(IServiceReverseType::Scenario::RESTORE, 1);
1884 if (service_ == nullptr) {
1885 GTEST_LOG_(INFO) << "SUB_backup_ServiceReverse_RestoreOnResultReport_0101 service_ == nullptr";
1886 return;
1887 }
1888 std::string resultReport = "result_report";
1889 std::string bundleName = BUNDLE_NAME;
1890 service_->RestoreOnResultReport(resultReport, bundleName);
1891 } catch (...) {
1892 EXPECT_TRUE(false);
1893 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by RestoreOnResultReport.";
1894 }
1895 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_RestoreOnResultReport_0101";
1896 }
1897
1898 /**
1899 * @tc.number: SUB_backup_ServiceReverse_IncrementalRestoreOnResultReport_0100
1900 * @tc.name: SUB_backup_ServiceReverse_IncrementalRestoreOnResultReport_0100
1901 * @tc.desc: 测试 IncrementalRestoreOnResultReport 接口
1902 * @tc.size: MEDIUM
1903 * @tc.type: FUNC
1904 * @tc.level Level 1
1905 * @tc.require: I6F3GV
1906 */
1907 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_IncrementalRestoreOnResultReport_0100,
1908 testing::ext::TestSize.Level1)
1909 {
1910 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalRestoreOnResultReport_0100";
1911 try {
1912 IncrementalInit(IServiceReverseType::Scenario::RESTORE);
1913 if (service_ == nullptr) {
1914 GTEST_LOG_(INFO) << "SUB_backup_ServiceReverse_IncrementalRestoreOnResultReport_0100 service_ == nullptr";
1915 return;
1916 }
1917 std::string resultReport = "result_report";
1918 std::string bundleName = BUNDLE_NAME;
1919 service_->IncrementalRestoreOnResultReport(resultReport, bundleName, 0);
1920 } catch (...) {
1921 EXPECT_TRUE(false);
1922 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by IncrementalRestoreOnResultReport.";
1923 }
1924 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_IncrementalRestoreOnResultReport_0100";
1925 }
1926
1927 /**
1928 * @tc.number: SUB_backup_ServiceReverse_IncrementalRestoreOnResultReport_0101
1929 * @tc.name: SUB_backup_ServiceReverse_IncrementalRestoreOnResultReport_0101
1930 * @tc.desc: 测试 IncrementalRestoreOnResultReport 接口
1931 * @tc.size: MEDIUM
1932 * @tc.type: FUNC
1933 * @tc.level Level 1
1934 * @tc.require: I6F3GV
1935 */
1936 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_IncrementalRestoreOnResultReport_0101,
1937 testing::ext::TestSize.Level1)
1938 {
1939 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalRestoreOnResultReport_0101";
1940 try {
1941 IncrementalInit(IServiceReverseType::Scenario::RESTORE, 1);
1942 if (service_ == nullptr) {
1943 GTEST_LOG_(INFO) << "SUB_backup_ServiceReverse_IncrementalRestoreOnResultReport_0101 service_ == nullptr";
1944 return;
1945 }
1946 std::string resultReport = "result_report";
1947 std::string bundleName = BUNDLE_NAME;
1948 service_->IncrementalRestoreOnResultReport(resultReport, bundleName, 0);
1949 } catch (...) {
1950 EXPECT_TRUE(false);
1951 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by IncrementalRestoreOnResultReport.";
1952 }
1953 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_IncrementalRestoreOnResultReport_0101";
1954 }
1955
1956 /**
1957 * @tc.number: SUB_backup_ServiceReverse_BackupOnResultReport_0100
1958 * @tc.name: SUB_backup_ServiceReverse_BackupOnResultReport_0100
1959 * @tc.desc: 测试 BackupOnResultReport 接口
1960 * @tc.size: MEDIUM
1961 * @tc.type: FUNC
1962 * @tc.level Level 1
1963 * @tc.require: I6F3GV
1964 */
1965 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_BackupOnResultReport_0100, testing::ext::TestSize.Level1)
1966 {
1967 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_BackupOnResultReport_0100";
1968 try {
1969 Init(IServiceReverseType::Scenario::BACKUP);
1970 std::string resultReport = "result_report";
1971 std::string bundleName = BUNDLE_NAME;
1972 if (service_ == nullptr) {
1973 GTEST_LOG_(INFO) << "SUB_backup_ServiceReverse_BackupOnResultReport_0100 service_ == nullptr";
1974 return;
1975 }
1976 service_->BackupOnResultReport(resultReport, bundleName);
1977 } catch (...) {
1978 EXPECT_TRUE(false);
1979 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by BackupOnResultReport.";
1980 }
1981 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_BackupOnResultReport_0100";
1982 }
1983
1984 /**
1985 * @tc.number: SUB_backup_ServiceReverse_BackupOnResultReport_0101
1986 * @tc.name: SUB_backup_ServiceReverse_BackupOnResultReport_0101
1987 * @tc.desc: 测试 BackupOnResultReport 接口
1988 * @tc.size: MEDIUM
1989 * @tc.type: FUNC
1990 * @tc.level Level 1
1991 * @tc.require: I6F3GV
1992 */
1993 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_BackupOnResultReport_0101, testing::ext::TestSize.Level1)
1994 {
1995 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_BackupOnResultReport_0101";
1996 try {
1997 Init(IServiceReverseType::Scenario::BACKUP, 1);
1998 std::string resultReport = "result_report";
1999 std::string bundleName = BUNDLE_NAME;
2000 if (service_ == nullptr) {
2001 GTEST_LOG_(INFO) << "SUB_backup_ServiceReverse_BackupOnResultReport_0101 service_ == nullptr";
2002 return;
2003 }
2004 service_->BackupOnResultReport(resultReport, bundleName);
2005 } catch (...) {
2006 EXPECT_TRUE(false);
2007 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by BackupOnResultReport.";
2008 }
2009 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_BackupOnResultReport_0101";
2010 }
2011
2012 /**
2013 * @tc.number: SUB_backup_ServiceReverse_IncrementalBackupOnResultReport_0100
2014 * @tc.name: SUB_backup_ServiceReverse_IncrementalBackupOnResultReport_0100
2015 * @tc.desc: 测试 IncrementalBackupOnResultReport 接口
2016 * @tc.size: MEDIUM
2017 * @tc.type: FUNC
2018 * @tc.level Level 1
2019 * @tc.require: I6F3GV
2020 */
2021 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_IncrementalBackupOnResultReport_0100,
2022 testing::ext::TestSize.Level1)
2023 {
2024 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalBackupOnResultReport_0100";
2025 try {
2026 IncrementalInit(IServiceReverseType::Scenario::BACKUP);
2027 std::string resultReport = "result_report";
2028 std::string bundleName = BUNDLE_NAME;
2029 if (service_ == nullptr) {
2030 GTEST_LOG_(INFO) << "SUB_backup_ServiceReverse_IncrementalBackupOnResultReport_0100 service_ == nullptr";
2031 return;
2032 }
2033 service_->IncrementalBackupOnResultReport(resultReport, bundleName);
2034 } catch (...) {
2035 EXPECT_TRUE(false);
2036 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by IncrementalBackupOnResultReport.";
2037 }
2038 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_IncrementalBackupOnResultReport_0100";
2039 }
2040
2041 /**
2042 * @tc.number: SUB_backup_ServiceReverse_IncrementalBackupOnResultReport_0101
2043 * @tc.name: SUB_backup_ServiceReverse_IncrementalBackupOnResultReport_0101
2044 * @tc.desc: 测试 IncrementalBackupOnResultReport 接口
2045 * @tc.size: MEDIUM
2046 * @tc.type: FUNC
2047 * @tc.level Level 1
2048 * @tc.require: I6F3GV
2049 */
2050 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_IncrementalBackupOnResultReport_0101,
2051 testing::ext::TestSize.Level1)
2052 {
2053 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalBackupOnResultReport_0101";
2054 try {
2055 IncrementalInit(IServiceReverseType::Scenario::BACKUP, 1);
2056 std::string resultReport = "result_report";
2057 std::string bundleName = BUNDLE_NAME;
2058 if (service_ == nullptr) {
2059 GTEST_LOG_(INFO) << "SUB_backup_ServiceReverse_IncrementalBackupOnResultReport_0101 service_ == nullptr";
2060 return;
2061 }
2062 service_->IncrementalBackupOnResultReport(resultReport, bundleName);
2063 } catch (...) {
2064 EXPECT_TRUE(false);
2065 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by IncrementalBackupOnResultReport.";
2066 }
2067 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_IncrementalBackupOnResultReport_0101";
2068 }
2069
2070 /**
2071 * @tc.number: SUB_backup_ServiceReverse_BackupOnScanningInfo_0100
2072 * @tc.name: SUB_backup_ServiceReverse_BackupOnScanningInfo_0100
2073 * @tc.desc: 测试 BackupOnScanningInfo 接口
2074 * @tc.size: MEDIUM
2075 * @tc.type: FUNC
2076 * @tc.level Level 1
2077 * @tc.require: I6F3GV
2078 */
2079 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_BackupOnScanningInfo_0100, testing::ext::TestSize.Level1)
2080 {
2081 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_BackupOnScanningInfo_0100";
2082 try {
2083 Init(IServiceReverseType::Scenario::BACKUP);
2084 if (service_ == nullptr) {
2085 GTEST_LOG_(INFO) <<
2086 "SUB_backup_ServiceReverse_BackupOnScanningInfo_0100 service_ == nullptr";
2087 return;
2088 }
2089 std::string scannedInfo = "";
2090 service_->BackupOnScanningInfo(scannedInfo);
2091 } catch (...) {
2092 EXPECT_TRUE(false);
2093 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by BackupOnScanningInfo.";
2094 }
2095 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_BackupOnScanningInfo_0100";
2096 }
2097
2098 /**
2099 * @tc.number: SUB_backup_ServiceReverse_BackupOnScanningInfo_0101
2100 * @tc.name: SUB_backup_ServiceReverse_BackupOnScanningInfo_0101
2101 * @tc.desc: 测试 BackupOnScanningInfo 接口
2102 * @tc.size: MEDIUM
2103 * @tc.type: FUNC
2104 * @tc.level Level 1
2105 * @tc.require: I6F3GV
2106 */
2107 HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_BackupOnScanningInfo_0101, testing::ext::TestSize.Level1)
2108 {
2109 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_BackupOnScanningInfo_0101";
2110 try {
2111 Init(IServiceReverseType::Scenario::RESTORE);
2112 if (service_ == nullptr) {
2113 GTEST_LOG_(INFO) <<
2114 "SUB_backup_ServiceReverse_BackupOnScanningInfo_0101 service_ == nullptr";
2115 return;
2116 }
2117 std::string scannedInfo = "";
2118 service_->BackupOnScanningInfo(scannedInfo);
2119 } catch (...) {
2120 EXPECT_TRUE(false);
2121 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by BackupOnScanningInfo.";
2122 }
2123 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_BackupOnScanningInfo_0101";
2124 }
2125
2126 /**
2127 * @tc.number: SUB_backup_ServiceReverse_IncrementalBackupOnScanningInfo_0100
2128 * @tc.name: SUB_backup_ServiceReverse_IncrementalBackupOnScanningInfo_0100
2129 * @tc.desc: 测试 IncrementalBackupOnScanningInfo 接口
2130 * @tc.size: MEDIUM
2131 * @tc.type: FUNC
2132 * @tc.level Level 1
2133 * @tc.require: I6F3GV
2134 */
2135 HWTEST_F(ServiceReverseTest,
2136 SUB_backup_ServiceReverse_IncrementalBackupOnScanningInfo_0100, testing::ext::TestSize.Level1)
2137 {
2138 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalBackupOnScanningInfo_0100";
2139 try {
2140 Init(IServiceReverseType::Scenario::RESTORE);
2141 if (service_ == nullptr) {
2142 GTEST_LOG_(INFO) <<
2143 "SUB_backup_ServiceReverse_IncrementalBackupOnScanningInfo_0100 service_ == nullptr";
2144 return;
2145 }
2146 std::string scannedInfo = "";
2147 service_->BackupOnScanningInfo(scannedInfo);
2148 } catch (...) {
2149 EXPECT_TRUE(false);
2150 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by BackupOnScanningInfo.";
2151 }
2152 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_IncrementalBackupOnScanningInfo_0100";
2153 }
2154
2155 /**
2156 * @tc.number: SUB_backup_ServiceReverse_IncrementalBackupOnScanningInfo_0101
2157 * @tc.name: SUB_backup_ServiceReverse_IncrementalBackupOnScanningInfo_0101
2158 * @tc.desc: 测试 IncrementalBackupOnScanningInfo 接口
2159 * @tc.size: MEDIUM
2160 * @tc.type: FUNC
2161 * @tc.level Level 1
2162 * @tc.require: I6F3GV
2163 */
2164 HWTEST_F(ServiceReverseTest,
2165 SUB_backup_ServiceReverse_IncrementalBackupOnScanningInfo_0101, testing::ext::TestSize.Level1)
2166 {
2167 GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalBackupOnScanningInfo_0101";
2168 try {
2169 Init(IServiceReverseType::Scenario::BACKUP);
2170 if (service_ == nullptr) {
2171 GTEST_LOG_(INFO) <<
2172 "SUB_backup_ServiceReverse_IncrementalBackupOnScanningInfo_0101 service_ == nullptr";
2173 return;
2174 }
2175 std::string scannedInfo = "";
2176 service_->BackupOnScanningInfo(scannedInfo);
2177 } catch (...) {
2178 EXPECT_TRUE(false);
2179 GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by BackupOnScanningInfo.";
2180 }
2181 GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_IncrementalBackupOnScanningInfo_0101";
2182 }
2183 } // namespace OHOS::FileManagement::Backup