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 <iostream>
17 #include <map>
18 #include <sstream>
19 
20 #include <gtest/gtest.h>
21 
22 #include "b_resources/b_constants.h"
23 #include "tools_op.h"
24 #include "tools_op_incremental_restore.cpp"
25 
26 namespace OHOS::FileManagement::Backup {
27 using namespace std;
28 
29 namespace {
30 const string BUNDLE_NAME = "com.example.app2backup/";
31 const string MANAGE_JSON = "manage.json";
32 const string FILE_NAME = "1.tar";
33 } // namespace
34 
35 class ToolsOpIncrementalRestoreTest : public testing::Test {
36 public:
SetUpTestCase(void)37     static void SetUpTestCase(void) {};
TearDownTestCase()38     static void TearDownTestCase() {};
SetUp()39     void SetUp() {};
TearDown()40     void TearDown() {};
41 };
42 
43 /**
44  * @tc.number: SUB_backup_tools_op_restore_0100
45  * @tc.name: SUB_backup_tools_op_restore_0100
46  * @tc.desc: 测试
47  * @tc.size: MEDIUM
48  * @tc.type: FUNC
49  * @tc.level Level 1
50  * @tc.require: I6F3GV
51  */
52 HWTEST_F(ToolsOpIncrementalRestoreTest, SUB_backup_tools_op_incremental_restore_0100, testing::ext::TestSize.Level1)
53 {
54     GTEST_LOG_(INFO) << "ToolsOpIncrementalRestoreTest-begin SUB_backup_tools_op_restore_0100";
55     try {
56         GTEST_LOG_(INFO) << "ToolsOpIncrementalRestoreTest-info";
57         map<string, vector<string>> mapArgToVal;
58         string localCap = string(BConstants::GetSaBundleBackupToolDir(BConstants::DEFAULT_USER_ID).data()) + "/tmp";
59         vector<string> path = { localCap.data() };
60         mapArgToVal.insert(make_pair("pathCapFile", path));
61         vector<string> bundles = { "com.example.app2backup" };
62         mapArgToVal.insert(make_pair("bundles", bundles));
63         vector<string> incrementalTime = { "0" };
64         mapArgToVal.insert(make_pair("incrementalTime", incrementalTime));
65 
66         // 创建测试路径以及测试环境
67         string cmdMkdir = string("mkdir -p ") + BConstants::BACKUP_TOOL_RECEIVE_DIR.data() + BUNDLE_NAME;
68         system(cmdMkdir.c_str());
69         string cmdTool = string("mkdir -p ") + BConstants::GetSaBundleBackupToolDir(BConstants::DEFAULT_USER_ID).data();
70         system(cmdTool.c_str());
71         string touchTar = string("touch ") + BConstants::BACKUP_TOOL_RECEIVE_DIR.data() + BUNDLE_NAME + FILE_NAME;
72         system(touchTar.c_str());
73         string touchManage = string("touch ") + BConstants::BACKUP_TOOL_RECEIVE_DIR.data() + BUNDLE_NAME + MANAGE_JSON;
74         system(touchManage.c_str());
75         string touchTmp = string("touch ") + localCap;
76         system(touchTmp.c_str());
77 
78         // 尝试匹配当前命令，成功后执行
79         GTEST_LOG_(INFO) << "ToolsOpIncrementalRestoreTest-restore";
80         vector<string_view> curOp;
81         curOp.emplace_back("incrementalrestore");
__anon57fb31e00202(const ToolsOp &op) 82         auto tryOpSucceed = [&curOp](const ToolsOp &op) { return op.TryMatch(curOp); };
83         auto &&opeartions = ToolsOp::GetAllOperations();
84         auto matchedOp = find_if(opeartions.begin(), opeartions.end(), tryOpSucceed);
85         if (matchedOp != opeartions.end()) {
86             auto ret = matchedOp->Execute(mapArgToVal);
87             EXPECT_EQ(ret, 0);
88         }
89     } catch (...) {
90         EXPECT_TRUE(false);
91         GTEST_LOG_(INFO) << "ToolsOpIncrementalRestoreTest-an exception occurred by construction.";
92     }
93     GTEST_LOG_(INFO) << "ToolsOpIncrementalRestoreTest-end SUB_backup_tools_op_restore_0100";
94 }
95 
96 /**
97  * @tc.number: SUB_backup_tools_op_restore_0200
98  * @tc.name: SUB_backup_tools_op_restore_0200
99  * @tc.desc: 测试
100  * @tc.size: MEDIUM
101  * @tc.type: FUNC
102  * @tc.level Level 1
103  * @tc.require: I6F3GV
104  */
105 HWTEST_F(ToolsOpIncrementalRestoreTest, SUB_backup_tools_op_incremental_restore_0200, testing::ext::TestSize.Level1)
106 {
107     GTEST_LOG_(INFO) << "ToolsOpIncrementalRestoreTest-begin SUB_backup_tools_op_restore_0200";
108     try {
109         GTEST_LOG_(INFO) << "ToolsOpIncrementalRestoreTest-The pathCapFile field is not contained.";
110         map<string, vector<string>> mapArgToVal;
111         vector<string> bundles = {"com.example.app2backup"};
112         vector<string> path = {"/data/backup/tmp"};
113         vector<string> incrementalTime = {"0"};
114         mapArgToVal.insert(make_pair("bundles", bundles));
115         mapArgToVal.insert(make_pair("incrementalTime", incrementalTime));
116 
117         vector<string_view> curOp;
118         curOp.emplace_back("incrementalrestore");
__anon57fb31e00302(const ToolsOp &op) 119         auto tryOpSucceed = [&curOp](const ToolsOp &op) { return op.TryMatch(curOp); };
120         auto &&opeartions = ToolsOp::GetAllOperations();
121         auto matchedOp = find_if(opeartions.begin(), opeartions.end(), tryOpSucceed);
122         int ret = 0;
123         if (matchedOp != opeartions.end()) {
124             ret = matchedOp->Execute(mapArgToVal);
125             EXPECT_NE(ret, 0);
126         }
127 
128         GTEST_LOG_(INFO) << "ToolsOpIncrementalRestoreTest-The bundles field is not contained.";
129         mapArgToVal.clear();
130         mapArgToVal.insert(make_pair("pathCapFile", path));
131         mapArgToVal.insert(make_pair("incrementalTime", incrementalTime));
132         if (matchedOp != opeartions.end()) {
133             ret = matchedOp->Execute(mapArgToVal);
134             EXPECT_NE(ret, 0);
135         }
136 
137         GTEST_LOG_(INFO) << "ToolsOpIncrementalRestoreTest-The incrementalTime field is not contained.";
138         mapArgToVal.clear();
139         mapArgToVal.insert(make_pair("pathCapFile", path));
140         mapArgToVal.insert(make_pair("bundles", bundles));
141         if (matchedOp != opeartions.end()) {
142             ret = matchedOp->Execute(mapArgToVal);
143             EXPECT_NE(ret, 0);
144         }
145 
146         GTEST_LOG_(INFO) << "ToolsOpIncrementalRestoreTest-The all fields are not contained.";
147         mapArgToVal.clear();
148         if (matchedOp != opeartions.end()) {
149             ret = matchedOp->Execute(mapArgToVal);
150             EXPECT_NE(ret, 0);
151         }
152     } catch (...) {
153         EXPECT_TRUE(false);
154         GTEST_LOG_(INFO) << "ToolsOpIncrementalRestoreTest-an exception occurred by construction.";
155     }
156     GTEST_LOG_(INFO) << "ToolsOpIncrementalRestoreTest-end SUB_backup_tools_op_restore_0200";
157 }
158 
159 /**
160  * @tc.number: SUB_backup_tools_op_restore_0300
161  * @tc.name: SUB_backup_tools_op_restore_0300
162  * @tc.desc: 测试
163  * @tc.size: MEDIUM
164  * @tc.type: FUNC
165  * @tc.level Level 1
166  * @tc.require: I6F3GV
167  */
168 HWTEST_F(ToolsOpIncrementalRestoreTest, SUB_backup_tools_op_incremental_restore_0300, testing::ext::TestSize.Level1)
169 {
170     GTEST_LOG_(INFO) << "ToolsOpIncrementalRestoreTest-begin SUB_backup_tools_op_restore_0300";
171     try {
172         GTEST_LOG_(INFO) << "ToolsOpIncrementalRestoreTest-The all required fields are contained.";
173         map<string, vector<string>> mapArgToVal;
174 
175         vector<string> bundles = {"com.example.app2backup"};
176         vector<string> path = {"/data/backup/tmp"};
177         vector<string> incrementalTime = {"0"};
178         mapArgToVal.insert(make_pair("pathCapFile", path));
179         mapArgToVal.insert(make_pair("bundles", bundles));
180         mapArgToVal.insert(make_pair("incrementalTime", incrementalTime));
181 
182         vector<string_view> curOp;
183         curOp.emplace_back("incrementalrestore");
__anon57fb31e00402(const ToolsOp &op) 184         auto tryOpSucceed = [&curOp](const ToolsOp &op) { return op.TryMatch(curOp); };
185         auto &&opeartions = ToolsOp::GetAllOperations();
186         auto matchedOp = find_if(opeartions.begin(), opeartions.end(), tryOpSucceed);
187         int ret = 0;
188         if (matchedOp != opeartions.end()) {
189             ret = matchedOp->Execute(mapArgToVal);
190             EXPECT_EQ(ret, 0);
191         }
192     } catch (...) {
193         EXPECT_TRUE(false);
194         GTEST_LOG_(INFO) << "ToolsOpIncrementalRestoreTest-an exception occurred by construction.";
195     }
196     GTEST_LOG_(INFO) << "ToolsOpIncrementalRestoreTest-end SUB_backup_tools_op_restore_0300";
197 }
198 
199 /**
200  * @tc.number: SUB_backup_tools_op_incremental_restore_0400
201  * @tc.name: SUB_backup_tools_op_incremental_restore_0400
202  * @tc.desc: 测试
203  * @tc.size: MEDIUM
204  * @tc.type: FUNC
205  * @tc.level Level 1
206  * @tc.require: I6F3GV
207  */
208 HWTEST_F(ToolsOpIncrementalRestoreTest, SUB_backup_tools_op_incremental_restore_0400, testing::ext::TestSize.Level1)
209 {
210     GTEST_LOG_(INFO) << "ToolsOpIncrementalRestoreTest-begin SUB_backup_tools_op_incremental_restore_0400";
211     try {
212         auto ctx = make_shared<SessionRestore>();
213         BFileInfo fileInfo;
214         fileInfo.owner = "test";
215         fileInfo.fileName = "/manage.json";
216         fileInfo.sn = 1;
217         UniqueFd fd(open("textFile", O_RDONLY));
218         UniqueFd manifestFd(open("textManifest", O_RDONLY));
219         OnFileReady(ctx, fileInfo, move(fd), move(manifestFd), 0);
220     } catch (BError &e) {
221         EXPECT_EQ(e.GetCode(), BError(BError::Codes::TOOL_INVAL_ARG).GetCode());
222         EXPECT_TRUE(true);
223     } catch (...) {
224         EXPECT_TRUE(false);
225         GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-an exception occurred by construction.";
226     }
227     GTEST_LOG_(INFO) << "ToolsOpIncrementalRestoreTest-end SUB_backup_tools_op_incremental_restore_0400";
228 }
229 
230 /**
231  * @tc.number: SUB_backup_tools_op_incremental_restore_0500
232  * @tc.name: SUB_backup_tools_op_incremental_restore_0500
233  * @tc.desc: 测试
234  * @tc.size: MEDIUM
235  * @tc.type: FUNC
236  * @tc.level Level 1
237  * @tc.require: I6F3GV
238  */
239 HWTEST_F(ToolsOpIncrementalRestoreTest, SUB_backup_tools_op_incremental_restore_0500, testing::ext::TestSize.Level1)
240 {
241     GTEST_LOG_(INFO) << "ToolsOpIncrementalRestoreTest-begin SUB_backup_tools_op_incremental_restore_0500";
242     try {
243         auto ctx = make_shared<SessionRestore>();
244         vector<BundleName> bundleNames;
245         bundleNames.push_back("bundle1");
246         bundleNames.push_back("bundle2");
247         vector<string> times = {"100"};
248         int32_t ret = InitRestoreSession(ctx, bundleNames, times);
249         EXPECT_EQ(-EPERM, ret);
250     } catch (...) {
251         EXPECT_TRUE(false);
252         GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-an exception occurred by construction.";
253     }
254     GTEST_LOG_(INFO) << "ToolsOpIncrementalRestoreTest-end SUB_backup_tools_op_incremental_restore_0500";
255 }
256 
257 /**
258  * @tc.number: SUB_backup_tools_op_incremental_restore_0501
259  * @tc.name: SUB_backup_tools_op_incremental_restore_0501
260  * @tc.desc: 测试
261  * @tc.size: MEDIUM
262  * @tc.type: FUNC
263  * @tc.level Level 1
264  * @tc.require: I6F3GV
265  */
266 HWTEST_F(ToolsOpIncrementalRestoreTest, SUB_backup_tools_op_incremental_restore_0501, testing::ext::TestSize.Level1)
267 {
268     GTEST_LOG_(INFO) << "ToolsOpIncrementalRestoreTest-begin SUB_backup_tools_op_incremental_restore_0501";
269     try {
270         auto ctx = make_shared<SessionRestore>();
271         vector<BundleName> bundleNames;
272         bundleNames.push_back("bundle1");
273         bundleNames.push_back("bundle2");
274         vector<string> times;
275         times.push_back("100");
276         times.push_back("200");
277         int32_t ret = InitRestoreSession(nullptr, bundleNames, times);
278         EXPECT_EQ(-EPERM, ret);
279     } catch (...) {
280         EXPECT_TRUE(false);
281         GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-an exception occurred by construction.";
282     }
283     GTEST_LOG_(INFO) << "ToolsOpIncrementalRestoreTest-end SUB_backup_tools_op_incremental_restore_0501";
284 }
285 
286 /**
287  * @tc.number: SUB_backup_tools_op_incremental_restore_0502
288  * @tc.name: SUB_backup_tools_op_incremental_restore_0502
289  * @tc.desc: 测试
290  * @tc.size: MEDIUM
291  * @tc.type: FUNC
292  * @tc.level Level 1
293  * @tc.require: I6F3GV
294  */
295 HWTEST_F(ToolsOpIncrementalRestoreTest, SUB_backup_tools_op_incremental_restore_0502, testing::ext::TestSize.Level1)
296 {
297     GTEST_LOG_(INFO) << "ToolsOpIncrementalRestoreTest-begin SUB_backup_tools_op_incremental_restore_0502";
298     try {
299         auto ctx = make_shared<SessionRestore>();
300         vector<BundleName> bundleNames;
301         bundleNames.push_back("bundle1");
302         bundleNames.push_back("bundle2");
303         vector<string> times;
304         times.push_back("10");
305         times.push_back("20");
306         int32_t ret = InitRestoreSession(ctx, bundleNames, times);
307         EXPECT_EQ(0, ret);
308 
309         BFileInfo fileInfo;
310         fileInfo.owner = "test";
311         fileInfo.fileName = "manage.json";
312         fileInfo.sn = 1;
313         UniqueFd fd(open("textFile", O_RDONLY));
314         UniqueFd manifestFd(open("textManifest", O_RDONLY));
315         OnFileReady(ctx, fileInfo, move(fd), move(manifestFd), 0);
316     } catch (BError &e) {
317         EXPECT_EQ(e.GetCode(), BError(BError::Codes::TOOL_INVAL_ARG).GetCode());
318         EXPECT_TRUE(true);
319     } catch (...) {
320         EXPECT_TRUE(false);
321         GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-an exception occurred by construction.";
322     }
323     GTEST_LOG_(INFO) << "ToolsOpIncrementalRestoreTest-end SUB_backup_tools_op_incremental_restore_0502";
324 }
325 
326 /**
327  * @tc.number: SUB_backup_tools_op_incremental_restore_0600
328  * @tc.name: SUB_backup_tools_op_incremental_restore_0600
329  * @tc.desc: 测试
330  * @tc.size: MEDIUM
331  * @tc.type: FUNC
332  * @tc.level Level 1
333  * @tc.require: I6F3GV
334  */
335 HWTEST_F(ToolsOpIncrementalRestoreTest, SUB_backup_tools_op_incremental_restore_0600, testing::ext::TestSize.Level1)
336 {
337     GTEST_LOG_(INFO) << "ToolsOpIncrementalRestoreTest-begin SUB_backup_tools_op_incremental_restore_0600";
338     try {
339         auto ctx = make_shared<SessionRestore>();
340         ErrCode err = 0;
341         BundleName name = "bundle";
342         OnBundleStarted(ctx, err, name);
343         EXPECT_TRUE(true);
344     } catch (...) {
345         EXPECT_TRUE(false);
346         GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-an exception occurred by construction.";
347     }
348     GTEST_LOG_(INFO) << "ToolsOpIncrementalRestoreTest-end SUB_backup_tools_op_incremental_restore_0600";
349 }
350 
351 /**
352  * @tc.number: SUB_backup_tools_op_incremental_restore_0601
353  * @tc.name: SUB_backup_tools_op_incremental_restore_0601
354  * @tc.desc: 测试
355  * @tc.size: MEDIUM
356  * @tc.type: FUNC
357  * @tc.level Level 1
358  * @tc.require: I6F3GV
359  */
360 HWTEST_F(ToolsOpIncrementalRestoreTest, SUB_backup_tools_op_incremental_restore_0601, testing::ext::TestSize.Level1)
361 {
362     GTEST_LOG_(INFO) << "ToolsOpIncrementalRestoreTest-begin SUB_backup_tools_op_incremental_restore_0601";
363     try {
364         auto ctx = make_shared<SessionRestore>();
365         ctx->cnt_ = 1;
366         ErrCode err = -1;
367         BundleName name = "bundle";
368         OnBundleStarted(ctx, err, name);
369         EXPECT_TRUE(true);
370     } catch (...) {
371         EXPECT_TRUE(false);
372         GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-an exception occurred by construction.";
373     }
374     GTEST_LOG_(INFO) << "ToolsOpIncrementalRestoreTest-end SUB_backup_tools_op_incremental_restore_0601";
375 }
376 
377 /**
378  * @tc.number: SUB_backup_tools_op_incremental_restore_0700
379  * @tc.name: SUB_backup_tools_op_incremental_restore_0700
380  * @tc.desc: 测试
381  * @tc.size: MEDIUM
382  * @tc.type: FUNC
383  * @tc.level Level 1
384  * @tc.require: I6F3GV
385  */
386 HWTEST_F(ToolsOpIncrementalRestoreTest, SUB_backup_tools_op_incremental_restore_0700, testing::ext::TestSize.Level1)
387 {
388     GTEST_LOG_(INFO) << "ToolsOpIncrementalRestoreTest-begin SUB_backup_tools_op_incremental_restore_0700";
389     try {
390         auto ctx = make_shared<SessionRestore>();
391         ctx->cnt_ = 1;
392         ErrCode err = 0;
393         BundleName name = "bundle";
394         OnBundleFinished(ctx, err, name);
395         EXPECT_TRUE(true);
396     } catch (...) {
397         EXPECT_TRUE(false);
398         GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-an exception occurred by construction.";
399     }
400     GTEST_LOG_(INFO) << "ToolsOpIncrementalRestoreTest-end SUB_backup_tools_op_incremental_restore_0700";
401 }
402 
403 /**
404  * @tc.number: SUB_backup_tools_op_incremental_restore_0701
405  * @tc.name: SUB_backup_tools_op_incremental_restore_0701
406  * @tc.desc: 测试
407  * @tc.size: MEDIUM
408  * @tc.type: FUNC
409  * @tc.level Level 1
410  * @tc.require: I6F3GV
411  */
412 HWTEST_F(ToolsOpIncrementalRestoreTest, SUB_backup_tools_op_incremental_restore_0701, testing::ext::TestSize.Level1)
413 {
414     GTEST_LOG_(INFO) << "ToolsOpIncrementalRestoreTest-begin SUB_backup_tools_op_incremental_restore_0701";
415     try {
416         auto ctx = make_shared<SessionRestore>();
417         ctx->cnt_ = 1;
418         ErrCode err = -1;
419         BundleName name = "bundle";
420         OnBundleFinished(ctx, err, name);
421         EXPECT_TRUE(true);
422     } catch (...) {
423         EXPECT_TRUE(false);
424         GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-an exception occurred by construction.";
425     }
426     GTEST_LOG_(INFO) << "ToolsOpIncrementalRestoreTest-end SUB_backup_tools_op_incremental_restore_0701";
427 }
428 
429 /**
430  * @tc.number: SUB_backup_tools_op_incremental_restore_0800
431  * @tc.name: SUB_backup_tools_op_incremental_restore_0800
432  * @tc.desc: 测试
433  * @tc.size: MEDIUM
434  * @tc.type: FUNC
435  * @tc.level Level 1
436  * @tc.require: I6F3GV
437  */
438 HWTEST_F(ToolsOpIncrementalRestoreTest, SUB_backup_tools_op_incremental_restore_0800, testing::ext::TestSize.Level1)
439 {
440     GTEST_LOG_(INFO) << "ToolsOpIncrementalRestoreTest-begin SUB_backup_tools_op_incremental_restore_0800";
441     try {
442         auto ctx = make_shared<SessionRestore>();
443         ErrCode err = 0;
444         OnAllBundlesFinished(ctx, err);
445         EXPECT_TRUE(true);
446     } catch (...) {
447         EXPECT_TRUE(false);
448         GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-an exception occurred by construction.";
449     }
450     GTEST_LOG_(INFO) << "ToolsOpIncrementalRestoreTest-end SUB_backup_tools_op_incremental_restore_0800";
451 }
452 
453 /**
454  * @tc.number: SUB_backup_tools_op_incremental_restore_0801
455  * @tc.name: SUB_backup_tools_op_incremental_restore_0801
456  * @tc.desc: 测试
457  * @tc.size: MEDIUM
458  * @tc.type: FUNC
459  * @tc.level Level 1
460  * @tc.require: I6F3GV
461  */
462 HWTEST_F(ToolsOpIncrementalRestoreTest, SUB_backup_tools_op_incremental_restore_0801, testing::ext::TestSize.Level1)
463 {
464     GTEST_LOG_(INFO) << "ToolsOpIncrementalRestoreTest-begin SUB_backup_tools_op_incremental_restore_0801";
465     try {
466         auto ctx = make_shared<SessionRestore>();
467         ErrCode err = -1;
468         OnAllBundlesFinished(ctx, err);
469         EXPECT_TRUE(true);
470     } catch (...) {
471         EXPECT_TRUE(false);
472         GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-an exception occurred by construction.";
473     }
474     GTEST_LOG_(INFO) << "ToolsOpIncrementalRestoreTest-end SUB_backup_tools_op_incremental_restore_0801";
475 }
476 
477 /**
478  * @tc.number: SUB_backup_tools_op_incremental_restore_0900
479  * @tc.name: SUB_backup_tools_op_incremental_restore_0900
480  * @tc.desc: 测试
481  * @tc.size: MEDIUM
482  * @tc.type: FUNC
483  * @tc.level Level 1
484  * @tc.require: I6F3GV
485  */
486 HWTEST_F(ToolsOpIncrementalRestoreTest, SUB_backup_tools_op_incremental_restore_0900, testing::ext::TestSize.Level1)
487 {
488     GTEST_LOG_(INFO) << "ToolsOpIncrementalRestoreTest-begin SUB_backup_tools_op_incremental_restore_0900";
489     try {
490         auto ctx = make_shared<SessionRestore>();
491         OnBackupServiceDied(ctx);
492         EXPECT_TRUE(true);
493     } catch (...) {
494         EXPECT_TRUE(false);
495         GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-an exception occurred by construction.";
496     }
497     GTEST_LOG_(INFO) << "ToolsOpIncrementalRestoreTest-end SUB_backup_tools_op_incremental_restore_0900";
498 }
499 
500 /**
501  * @tc.number: SUB_backup_tools_op_incremental_restore_1000
502  * @tc.name: SUB_backup_tools_op_incremental_restore_1000
503  * @tc.desc: 测试
504  * @tc.size: MEDIUM
505  * @tc.type: FUNC
506  * @tc.level Level 1
507  * @tc.require: I6F3GV
508  */
509 HWTEST_F(ToolsOpIncrementalRestoreTest, SUB_backup_tools_op_incremental_restore_1000, testing::ext::TestSize.Level1)
510 {
511     GTEST_LOG_(INFO) << "ToolsOpIncrementalRestoreTest-begin SUB_backup_tools_op_incremental_restore_1000";
512     try {
513         shared_ptr<SessionRestore> restore = nullptr;
514         RestoreApp(restore);
515     } catch (BError &e) {
516         EXPECT_EQ(e.GetCode(), BError(BError::Codes::TOOL_INVAL_ARG).GetCode());
517         EXPECT_TRUE(true);
518     } catch (...) {
519         EXPECT_TRUE(false);
520         GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-an exception occurred by construction.";
521     }
522     GTEST_LOG_(INFO) << "ToolsOpIncrementalRestoreTest-end SUB_backup_tools_op_incremental_restore_1000";
523 }
524 
525 /**
526  * @tc.number: SUB_backup_tools_op_incremental_restore_1001
527  * @tc.name: SUB_backup_tools_op_incremental_restore_1001
528  * @tc.desc: 测试
529  * @tc.size: MEDIUM
530  * @tc.type: FUNC
531  * @tc.level Level 1
532  * @tc.require: I6F3GV
533  */
534 HWTEST_F(ToolsOpIncrementalRestoreTest, SUB_backup_tools_op_incremental_restore_1001, testing::ext::TestSize.Level1)
535 {
536     GTEST_LOG_(INFO) << "ToolsOpIncrementalRestoreTest-begin SUB_backup_tools_op_incremental_restore_1001";
537     try {
538         shared_ptr<SessionRestore> restore = make_shared<SessionRestore>();
539         restore->session_ = nullptr;
540         RestoreApp(restore);
541     } catch (BError &e) {
542         EXPECT_EQ(e.GetCode(), BError(BError::Codes::TOOL_INVAL_ARG).GetCode());
543         EXPECT_TRUE(true);
544     } catch (...) {
545         EXPECT_TRUE(false);
546         GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-an exception occurred by construction.";
547     }
548     GTEST_LOG_(INFO) << "ToolsOpIncrementalRestoreTest-end SUB_backup_tools_op_incremental_restore_1001";
549 }
550 
551 /**
552  * @tc.number: SUB_backup_tools_op_incremental_restore_1002
553  * @tc.name: SUB_backup_tools_op_incremental_restore_1002
554  * @tc.desc: 测试
555  * @tc.size: MEDIUM
556  * @tc.type: FUNC
557  * @tc.level Level 1
558  * @tc.require: I6F3GV
559  */
560 HWTEST_F(ToolsOpIncrementalRestoreTest, SUB_backup_tools_op_incremental_restore_1002, testing::ext::TestSize.Level1)
561 {
562     GTEST_LOG_(INFO) << "ToolsOpIncrementalRestoreTest-begin SUB_backup_tools_op_incremental_restore_1002";
563     try {
564         shared_ptr<SessionRestore> restore = make_shared<SessionRestore>();
565         restore->session_ = {};
566         BIncrementalData data("text", 1);
567         restore->lastIncrementalData = {data};
568         RestoreApp(restore);
569         EXPECT_TRUE(true);
570     } catch (BError &e) {
571         EXPECT_EQ(e.GetCode(), BError(BError::Codes::TOOL_INVAL_ARG).GetCode());
572         EXPECT_TRUE(true);
573     } catch (...) {
574         EXPECT_TRUE(false);
575         GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-an exception occurred by construction.";
576     }
577     GTEST_LOG_(INFO) << "ToolsOpIncrementalRestoreTest-end SUB_backup_tools_op_incremental_restore_1002";
578 }
579 
580 /**
581  * @tc.number: SUB_backup_tools_op_incremental_restore_1003
582  * @tc.name: SUB_backup_tools_op_incremental_restore_1003
583  * @tc.desc: 测试
584  * @tc.size: MEDIUM
585  * @tc.type: FUNC
586  * @tc.level Level 1
587  * @tc.require: I6F3GV
588  */
589 HWTEST_F(ToolsOpIncrementalRestoreTest, SUB_backup_tools_op_incremental_restore_1003, testing::ext::TestSize.Level1)
590 {
591     GTEST_LOG_(INFO) << "ToolsOpIncrementalRestoreTest-begin SUB_backup_tools_op_incremental_restore_1003";
592     try {
593         auto ctx = make_shared<SessionRestore>();
594         vector<BundleName> bundleNames;
595         bundleNames.push_back("bundle1");
596         bundleNames.push_back("bundle2");
597         vector<string> times;
598         times.push_back("10");
599         times.push_back("20");
600         int32_t ret = InitRestoreSession(ctx, bundleNames, times);
601         EXPECT_EQ(0, ret);
602 
603         RestoreApp(ctx);
604         EXPECT_TRUE(ctx);
605     } catch (BError &e) {
606         EXPECT_EQ(e.GetCode(), BError(BError::Codes::TOOL_INVAL_ARG).GetCode());
607         EXPECT_TRUE(true);
608     } catch (...) {
609         EXPECT_TRUE(false);
610         GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-an exception occurred by construction.";
611     }
612     GTEST_LOG_(INFO) << "ToolsOpIncrementalRestoreTest-end SUB_backup_tools_op_incremental_restore_1003";
613 }
614 
615 /**
616  * @tc.number: SUB_backup_tools_op_incremental_restore_1100
617  * @tc.name: SUB_backup_tools_op_incremental_restore_1100
618  * @tc.desc: 测试
619  * @tc.size: MEDIUM
620  * @tc.type: FUNC
621  * @tc.level Level 1
622  * @tc.require: I6F3GV
623  */
624 HWTEST_F(ToolsOpIncrementalRestoreTest, SUB_backup_tools_op_incremental_restore_1100, testing::ext::TestSize.Level1)
625 {
626     GTEST_LOG_(INFO) << "ToolsOpIncrementalRestoreTest-begin SUB_backup_tools_op_incremental_restore_1100";
627     try {
628         string pathCapFile = "";
629         vector<string> bundleNames = {"com.example.app2backup/"};
630         bool depMode = true;
631         vector<string> times = {"10"};
632         int32_t ret = Init(pathCapFile, bundleNames, depMode, times);
633         EXPECT_LT(ret, 0);
634     } catch (...) {
635         EXPECT_TRUE(false);
636         GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-an exception occurred by construction.";
637     }
638     GTEST_LOG_(INFO) << "ToolsOpIncrementalRestoreTest-end SUB_backup_tools_op_incremental_restore_1100";
639 }
640 
641 /**
642  * @tc.number: SUB_backup_tools_op_incremental_restore_1101
643  * @tc.name: SUB_backup_tools_op_incremental_restore_1101
644  * @tc.desc: 测试
645  * @tc.size: MEDIUM
646  * @tc.type: FUNC
647  * @tc.level Level 1
648  * @tc.require: I6F3GV
649  */
650 HWTEST_F(ToolsOpIncrementalRestoreTest, SUB_backup_tools_op_incremental_restore_1101, testing::ext::TestSize.Level1)
651 {
652     GTEST_LOG_(INFO) << "ToolsOpIncrementalRestoreTest-begin SUB_backup_tools_op_incremental_restore_1101";
653     try {
654         string pathCapFile = "/data/backup";
655         vector<string> bundleNames = {"com.example.app2backup/"};
656         bool depMode = true;
657         vector<string> times = {"1"};
658         int32_t ret = Init(pathCapFile, bundleNames, depMode, times);
659         EXPECT_LT(ret, 0);
660     } catch (...) {
661         EXPECT_TRUE(false);
662         GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-an exception occurred by construction.";
663     }
664     GTEST_LOG_(INFO) << "ToolsOpIncrementalRestoreTest-end SUB_backup_tools_op_incremental_restore_1101";
665 }
666 
667 /**
668  * @tc.number: SUB_backup_tools_op_incremental_restore_1102
669  * @tc.name: SUB_backup_tools_op_incremental_restore_1102
670  * @tc.desc: 测试
671  * @tc.size: MEDIUM
672  * @tc.type: FUNC
673  * @tc.level Level 1
674  * @tc.require: I6F3GV
675  */
676 HWTEST_F(ToolsOpIncrementalRestoreTest, SUB_backup_tools_op_incremental_restore_1102, testing::ext::TestSize.Level1)
677 {
678     GTEST_LOG_(INFO) << "ToolsOpIncrementalRestoreTest-begin SUB_backup_tools_op_incremental_restore_1102";
679     try {
680         string pathCapFile = "";
681         vector<string> bundleNames = {"com.example.app2backup/"};
682         bool depMode = false;
683         vector<string> times = {"10"};
684         int32_t ret = Init(pathCapFile, bundleNames, depMode, times);
685         EXPECT_LT(ret, 0);
686     } catch (...) {
687         EXPECT_TRUE(false);
688         GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-an exception occurred by construction.";
689     }
690     GTEST_LOG_(INFO) << "ToolsOpIncrementalRestoreTest-end SUB_backup_tools_op_incremental_restore_1102";
691 }
692 
693 /**
694  * @tc.number: SUB_backup_tools_op_incremental_restore_1200
695  * @tc.name: SUB_backup_tools_op_incremental_restore_1200
696  * @tc.desc: 测试
697  * @tc.size: MEDIUM
698  * @tc.type: FUNC
699  * @tc.level Level 1
700  * @tc.require: I6F3GV
701  */
702 HWTEST_F(ToolsOpIncrementalRestoreTest, SUB_backup_tools_op_incremental_restore_1200, testing::ext::TestSize.Level1)
703 {
704     GTEST_LOG_(INFO) << "ToolsOpIncrementalRestoreTest-begin SUB_backup_tools_op_incremental_restore_1200";
705     try {
706         map<string, vector<string>> mapArgToVal;
707         mapArgToVal["depMode"] = {"false"};
708         g_exec(mapArgToVal);
709         EXPECT_EQ(mapArgToVal["depMode"][0], "false");
710     } catch (...) {
711         EXPECT_TRUE(false);
712         GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-an exception occurred by construction.";
713     }
714     GTEST_LOG_(INFO) << "ToolsOpIncrementalRestoreTest-end SUB_backup_tools_op_incremental_restore_1200";
715 }
716 
717 /**
718  * @tc.number: SUB_backup_tools_op_incremental_restore_1201
719  * @tc.name: SUB_backup_tools_op_incremental_restore_1201
720  * @tc.desc: 测试
721  * @tc.size: MEDIUM
722  * @tc.type: FUNC
723  * @tc.level Level 1
724  * @tc.require: I6F3GV
725  */
726 HWTEST_F(ToolsOpIncrementalRestoreTest, SUB_backup_tools_op_incremental_restore_1201, testing::ext::TestSize.Level1)
727 {
728     GTEST_LOG_(INFO) << "ToolsOpIncrementalRestoreTest-begin SUB_backup_tools_op_incremental_restore_1201";
729     try {
730         map<string, vector<string>> mapArgToVal = {
731             {"pathCapFile", {"path"}},
732             {"bundles", {"bundle1"}},
733             {"incrementalTime", {"time"}}
734         };
735         int ret = g_exec(mapArgToVal);
736         EXPECT_LT(ret, 0);
737     } catch (...) {
738         EXPECT_TRUE(false);
739         GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-an exception occurred by construction.";
740     }
741     GTEST_LOG_(INFO) << "ToolsOpIncrementalRestoreTest-end SUB_backup_tools_op_incremental_restore_1201";
742 }
743 
744 /**
745  * @tc.number: SUB_backup_tools_op_incremental_restore_1202
746  * @tc.name: SUB_backup_tools_op_incremental_restore_1202
747  * @tc.desc: 测试
748  * @tc.size: MEDIUM
749  * @tc.type: FUNC
750  * @tc.level Level 1
751  * @tc.require: I6F3GV
752  */
753 HWTEST_F(ToolsOpIncrementalRestoreTest, SUB_backup_tools_op_incremental_restore_1202, testing::ext::TestSize.Level1)
754 {
755     GTEST_LOG_(INFO) << "ToolsOpIncrementalRestoreTest-begin SUB_backup_tools_op_incremental_restore_1202";
756     try {
757         map<string, vector<string>> mapArgToVal = {
758             {"bundles", {"bundle1"}},
759             {"incrementalTime", {"time"}}
760         };
761         int ret = g_exec(mapArgToVal);
762         EXPECT_LT(ret, 0);
763     } catch (...) {
764         EXPECT_TRUE(false);
765         GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-an exception occurred by construction.";
766     }
767     GTEST_LOG_(INFO) << "ToolsOpIncrementalRestoreTest-end SUB_backup_tools_op_incremental_restore_1202";
768 }
769 
770 /**
771  * @tc.number: SUB_backup_tools_op_incremental_restore_1203
772  * @tc.name: SUB_backup_tools_op_incremental_restore_1203
773  * @tc.desc: 测试
774  * @tc.size: MEDIUM
775  * @tc.type: FUNC
776  * @tc.level Level 1
777  * @tc.require: I6F3GV
778  */
779 HWTEST_F(ToolsOpIncrementalRestoreTest, SUB_backup_tools_op_incremental_restore_1203, testing::ext::TestSize.Level1)
780 {
781     GTEST_LOG_(INFO) << "ToolsOpIncrementalRestoreTest-begin SUB_backup_tools_op_incremental_restore_1203";
782     try {
783         map<string, vector<string>> mapArgToVal = {
784             {"pathCapFile", {"path"}},
785             {"bundles", {"bundle1"}},
786             {"incrementalTime", {"time"}},
787             {"depMode", {"true"}}
788         };
789         int ret = g_exec(mapArgToVal);
790         EXPECT_LT(ret, 0);
791     } catch (...) {
792         EXPECT_TRUE(false);
793         GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-an exception occurred by construction.";
794     }
795     GTEST_LOG_(INFO) << "ToolsOpIncrementalRestoreTest-end SUB_backup_tools_op_incremental_restore_1203";
796 }
797 
798 /**
799  * @tc.number: SUB_backup_tools_op_incremental_restore_1204
800  * @tc.name: SUB_backup_tools_op_incremental_restore_1204
801  * @tc.desc: 测试
802  * @tc.size: MEDIUM
803  * @tc.type: FUNC
804  * @tc.level Level 1
805  * @tc.require: I6F3GV
806  */
807 HWTEST_F(ToolsOpIncrementalRestoreTest, SUB_backup_tools_op_incremental_restore_1204, testing::ext::TestSize.Level1)
808 {
809     GTEST_LOG_(INFO) << "ToolsOpIncrementalRestoreTest-begin SUB_backup_tools_op_incremental_restore_1204";
810     try {
811         map<string, vector<string>> mapArgToVal = {
812             {"pathCapFile", {"path"}},
813             {"incrementalTime", {"time"}}
814         };
815         int ret = g_exec(mapArgToVal);
816         EXPECT_LT(ret, 0);
817     } catch (...) {
818         EXPECT_TRUE(false);
819         GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-an exception occurred by construction.";
820     }
821     GTEST_LOG_(INFO) << "ToolsOpIncrementalRestoreTest-end SUB_backup_tools_op_incremental_restore_1204";
822 }
823 
824 /**
825  * @tc.number: SUB_backup_tools_op_incremental_restore_1205
826  * @tc.name: SUB_backup_tools_op_incremental_restore_1205
827  * @tc.desc: 测试
828  * @tc.size: MEDIUM
829  * @tc.type: FUNC
830  * @tc.level Level 1
831  * @tc.require: I6F3GV
832  */
833 HWTEST_F(ToolsOpIncrementalRestoreTest, SUB_backup_tools_op_incremental_restore_1205, testing::ext::TestSize.Level1)
834 {
835     GTEST_LOG_(INFO) << "ToolsOpIncrementalRestoreTest-begin SUB_backup_tools_op_incremental_restore_1205";
836     try {
837         map<string, vector<string>> mapArgToVal = {
838             {"pathCapFile", {"path"}},
839             {"bundles", {"bundle1"}}
840         };
841         int ret = g_exec(mapArgToVal);
842         EXPECT_LT(ret, 0);
843     } catch (...) {
844         EXPECT_TRUE(false);
845         GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-an exception occurred by construction.";
846     }
847     GTEST_LOG_(INFO) << "ToolsOpIncrementalRestoreTest-end SUB_backup_tools_op_incremental_restore_1205";
848 }
849 } // namespace OHOS::FileManagement::Backup