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_backup.cpp"
25 #include "utils_mock_global_variable.h"
26 
27 namespace OHOS::FileManagement::Backup {
28 using namespace std;
29 class ToolsOpIncrementalBackupTest : public testing::Test {
30 public:
SetUpTestCase(void)31     static void SetUpTestCase(void) {};
TearDownTestCase()32     static void TearDownTestCase() {};
SetUp()33     void SetUp() {};
TearDown()34     void TearDown() {};
35 };
36 
37 /**
38  * @tc.number: SUB_backup_tools_op_backup_0100
39  * @tc.name: SUB_backup_tools_op_backup_0100
40  * @tc.desc: 测试backup流程
41  * @tc.size: MEDIUM
42  * @tc.type: FUNC
43  * @tc.level Level 1
44  * @tc.require: I6F3GV
45  */
46 HWTEST_F(ToolsOpIncrementalBackupTest, SUB_backup_tools_op_incremental_backup_0100, testing::ext::TestSize.Level1)
47 {
48     GTEST_LOG_(INFO) << "ToolsOpIncrementalBackupTest-begin SUB_backup_tools_op_backup_0100";
49     try {
50         SetMockGetInstance(true);
51         GTEST_LOG_(INFO) << "ToolsOpIncrementalBackupTest-info";
52         map<string, vector<string>> mapArgToVal;
53         string localCap = string(BConstants::GetSaBundleBackupToolDir(BConstants::DEFAULT_USER_ID).data()) + "/tmp";
54         vector<string> path = { localCap.data() };
55         mapArgToVal.insert(make_pair("pathCapFile", path));
56         vector<string> bundles = { "com.example.app2backup" };
57         mapArgToVal.insert(make_pair("bundles", bundles));
58         vector<string> incrementalTime = { "0" };
59         mapArgToVal.insert(make_pair("incrementalTime", incrementalTime));
60 
61         // 尝试匹配当前命令，成功后执行
62         GTEST_LOG_(INFO) << "ToolsOpIncrementalBackupTest-backup";
63         vector<string_view> curOp;
64         curOp.emplace_back("incrementalbackup");
__anon702a50b20102(const ToolsOp &op) 65         auto tryOpSucceed = [&curOp](const ToolsOp &op) { return op.TryMatch(curOp); };
66         auto &&opeartions = ToolsOp::GetAllOperations();
67         auto matchedOp = find_if(opeartions.begin(), opeartions.end(), tryOpSucceed);
68         if (matchedOp != opeartions.end()) {
69             auto ret = matchedOp->Execute(mapArgToVal);
70             EXPECT_EQ(ret, 0);
71         }
72     } catch (...) {
73         EXPECT_TRUE(false);
74         GTEST_LOG_(INFO) << "ToolsOpIncrementalBackupTest-an exception occurred by construction.";
75     }
76     GTEST_LOG_(INFO) << "ToolsOpIncrementalBackupTest-end SUB_backup_tools_op_backup_0100";
77 }
78 
79 /**
80  * @tc.number: SUB_backup_tools_op_backup_0200
81  * @tc.name: SUB_backup_tools_op_backup_0200
82  * @tc.desc: 测试Exec分支
83  * @tc.size: MEDIUM
84  * @tc.type: FUNC
85  * @tc.level Level 1
86  * @tc.require: I6F3GV
87  */
88 HWTEST_F(ToolsOpIncrementalBackupTest, SUB_backup_tools_op_incremental_backup_0200, testing::ext::TestSize.Level1)
89 {
90     GTEST_LOG_(INFO) << "ToolsOpIncrementalBackupTest-begin SUB_backup_tools_op_backup_0200";
91     try {
92         GTEST_LOG_(INFO) << "ToolsOpIncrementalBackupTest-The pathCapFile field is not contained.";
93         map<string, vector<string>> mapArgToVal;
94         vector<string> bundles = {"com.example.app2backup"};
95         vector<string> path = {"/data/backup/tmp"};
96         vector<string> incrementalTime = {"0"};
97         mapArgToVal.insert(make_pair("bundles", bundles));
98         mapArgToVal.insert(make_pair("incrementalTime", incrementalTime));
99 
100         vector<string_view> curOp;
101         curOp.emplace_back("incrementalbackup");
__anon702a50b20202(const ToolsOp &op) 102         auto tryOpSucceed = [&curOp](const ToolsOp &op) { return op.TryMatch(curOp); };
103         auto &&opeartions = ToolsOp::GetAllOperations();
104         auto matchedOp = find_if(opeartions.begin(), opeartions.end(), tryOpSucceed);
105         int ret = 0;
106         if (matchedOp != opeartions.end()) {
107             ret = matchedOp->Execute(mapArgToVal);
108             EXPECT_NE(ret, 0);
109         }
110 
111         GTEST_LOG_(INFO) << "ToolsOpIncrementalBackupTest-The bundles field is noGt contained.";
112         mapArgToVal.clear();
113         mapArgToVal.insert(make_pair("pathCapFile", path));
114         mapArgToVal.insert(make_pair("incrementalTime", incrementalTime));
115         if (matchedOp != opeartions.end()) {
116             ret = matchedOp->Execute(mapArgToVal);
117             EXPECT_NE(ret, 0);
118         }
119 
120         GTEST_LOG_(INFO) << "ToolsOpIncrementalBackupTest-The incrementalTime field is noGt contained.";
121         mapArgToVal.clear();
122         mapArgToVal.insert(make_pair("pathCapFile", path));
123         mapArgToVal.insert(make_pair("bundles", bundles));
124         if (matchedOp != opeartions.end()) {
125             ret = matchedOp->Execute(mapArgToVal);
126             EXPECT_NE(ret, 0);
127         }
128 
129         GTEST_LOG_(INFO) << "ToolsOpIncrementalRestoreTest-The all fields are not contained.";
130         mapArgToVal.clear();
131         if (matchedOp != opeartions.end()) {
132             ret = matchedOp->Execute(mapArgToVal);
133             EXPECT_NE(ret, 0);
134         }
135     } catch (...) {
136         EXPECT_TRUE(false);
137         GTEST_LOG_(INFO) << "ToolsOpIncrementalBackupTest-an exception occurred by construction.";
138     }
139     GTEST_LOG_(INFO) << "ToolsOpIncrementalBackupTest-end SUB_backup_tools_op_backup_0200";
140 }
141 
142 /**
143  * @tc.number: SUB_backup_tools_op_backup_0300
144  * @tc.name: SUB_backup_tools_op_backup_0300
145  * @tc.desc: 测试Exec分支
146  * @tc.size: MEDIUM
147  * @tc.type: FUNC
148  * @tc.level Level 1
149  * @tc.require: I6F3GV
150  */
151 HWTEST_F(ToolsOpIncrementalBackupTest, SUB_backup_tools_op_incremental_backup_0300, testing::ext::TestSize.Level1)
152 {
153     GTEST_LOG_(INFO) << "ToolsOpIncrementalBackupTest-begin SUB_backup_tools_op_backup_0300";
154     try {
155         GTEST_LOG_(INFO) << "ToolsOpIncrementalBackupTest-info";
156         map<string, vector<string>> mapArgToVal;
157         vector<string> path = {"/data/backup/tmp"};
158         mapArgToVal.insert(make_pair("pathCapFile", path));
159         vector<string> bundles = {"com.example.app2backup"};
160         mapArgToVal.insert(make_pair("bundles", bundles));
161         vector<string> incrementalTime = {"0"};
162         mapArgToVal.insert(make_pair("incrementalTime", incrementalTime));
163 
164         // 尝试匹配当前命令，成功后执行
165         GTEST_LOG_(INFO) << "ToolsOpIncrementalBackupTest-backup";
166         vector<string_view> curOp;
167         curOp.emplace_back("incrementalbackup");
__anon702a50b20302(const ToolsOp &op) 168         auto tryOpSucceed = [&curOp](const ToolsOp &op) { return op.TryMatch(curOp); };
169         auto &&opeartions = ToolsOp::GetAllOperations();
170         auto matchedOp = find_if(opeartions.begin(), opeartions.end(), tryOpSucceed);
171         if (matchedOp != opeartions.end()) {
172             auto ret = matchedOp->Execute(mapArgToVal);
173             EXPECT_EQ(ret, 0);
174         }
175     } catch (...) {
176         EXPECT_TRUE(false);
177         GTEST_LOG_(INFO) << "ToolsOpIncrementalBackupTest-an exception occurred by construction.";
178     }
179     GTEST_LOG_(INFO) << "ToolsOpIncrementalBackupTest-end SUB_backup_tools_op_backup_0300";
180 }
181 
182 /**
183  * @tc.number: SUB_backup_tools_op_incremental_backup_0400
184  * @tc.name: SUB_backup_tools_op_incremental_backup_0400
185  * @tc.desc: 测试OnFileReady分支
186  * @tc.size: MEDIUM
187  * @tc.type: FUNC
188  * @tc.level Level 1
189  * @tc.require: I6F3GV
190  */
191 HWTEST_F(ToolsOpIncrementalBackupTest, SUB_backup_tools_op_incremental_restore_0400, testing::ext::TestSize.Level1)
192 {
193     GTEST_LOG_(INFO) << "ToolsOpIncrementalBackupTest-begin SUB_backup_tools_op_incremental_restore_0400";
194     try {
195         auto ctx = make_shared<SessionBckup>();
196         BFileInfo fileInfo;
197         fileInfo.owner = "test";
198         fileInfo.fileName = "/manage.json";
199         fileInfo.sn = 1;
200         UniqueFd fd(open("textFile", O_RDONLY));
201         UniqueFd manifestFd(open("textManifest", O_RDONLY));
202         OnFileReady(ctx, fileInfo, move(fd), move(manifestFd));
203     } catch (BError &e) {
204         EXPECT_EQ(e.GetCode(), BError(BError::Codes::TOOL_INVAL_ARG).GetCode());
205         EXPECT_TRUE(true);
206     } catch (...) {
207         EXPECT_TRUE(false);
208         GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-an exception occurred by construction.";
209     }
210     GTEST_LOG_(INFO) << "ToolsOpIncrementalBackupTest-end SUB_backup_tools_op_incremental_restore_0400";
211 }
212 
213 /**
214  * @tc.number: SUB_backup_tools_op_incremental_backup_0500
215  * @tc.name: SUB_backup_tools_op_incremental_backup_0500
216  * @tc.desc: 测试OnBundleStarted分支
217  * @tc.size: MEDIUM
218  * @tc.type: FUNC
219  * @tc.level Level 1
220  * @tc.require: I6F3GV
221  */
222 HWTEST_F(ToolsOpIncrementalBackupTest, SUB_backup_tools_op_incremental_backup_0500, testing::ext::TestSize.Level1)
223 {
224     GTEST_LOG_(INFO) << "ToolsOpIncrementalBackupTest-begin SUB_backup_tools_op_incremental_backup_0500";
225     try {
226         auto ctx = make_shared<SessionBckup>();
227         ErrCode err = 0;
228         BundleName name = "bundle";
229         OnBundleStarted(ctx, err, name);
230         EXPECT_TRUE(true);
231     } catch (...) {
232         EXPECT_TRUE(false);
233         GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-an exception occurred by construction.";
234     }
235     GTEST_LOG_(INFO) << "ToolsOpIncrementalBackupTest-end SUB_backup_tools_op_incremental_backup_0500";
236 }
237 
238 /**
239  * @tc.number: SUB_backup_tools_op_incremental_backup_0501
240  * @tc.name: SUB_backup_tools_op_incremental_backup_0501
241  * @tc.desc: 测试OnBundleStarted分支
242  * @tc.size: MEDIUM
243  * @tc.type: FUNC
244  * @tc.level Level 1
245  * @tc.require: I6F3GV
246  */
247 HWTEST_F(ToolsOpIncrementalBackupTest, SUB_backup_tools_op_incremental_backup_0501, testing::ext::TestSize.Level1)
248 {
249     GTEST_LOG_(INFO) << "ToolsOpIncrementalBackupTest-begin SUB_backup_tools_op_incremental_backup_0501";
250     try {
251         auto ctx = make_shared<SessionBckup>();
252         ctx->SetBundleFinishedCount(1);
253         ErrCode err = -1;
254         BundleName name = "bundle";
255         OnBundleStarted(ctx, err, name);
256         EXPECT_TRUE(true);
257     } catch (...) {
258         EXPECT_TRUE(false);
259         GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-an exception occurred by construction.";
260     }
261     GTEST_LOG_(INFO) << "ToolsOpIncrementalBackupTest-end SUB_backup_tools_op_incremental_backup_0501";
262 }
263 
264 /**
265  * @tc.number: SUB_backup_tools_op_incremental_backup_0600
266  * @tc.name: SUB_backup_tools_op_incremental_backup_0600
267  * @tc.desc: 测试OnBundleFinished分支
268  * @tc.size: MEDIUM
269  * @tc.type: FUNC
270  * @tc.level Level 1
271  * @tc.require: I6F3GV
272  */
273 HWTEST_F(ToolsOpIncrementalBackupTest, SUB_backup_tools_op_incremental_backup_0600, testing::ext::TestSize.Level1)
274 {
275     GTEST_LOG_(INFO) << "ToolsOpIncrementalBackupTest-begin SUB_backup_tools_op_incremental_backup_0600";
276     try {
277         auto ctx = make_shared<SessionBckup>();
278         ctx->SetBundleFinishedCount(1);
279         ErrCode err = 0;
280         BundleName name = "bundle";
281         OnBundleFinished(ctx, err, name);
282         EXPECT_TRUE(true);
283     } catch (...) {
284         EXPECT_TRUE(false);
285         GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-an exception occurred by construction.";
286     }
287     GTEST_LOG_(INFO) << "ToolsOpIncrementalBackupTest-end SUB_backup_tools_op_incremental_backup_0600";
288 }
289 
290 /**
291  * @tc.number: SUB_backup_tools_op_incremental_backup_0700
292  * @tc.name: SUB_backup_tools_op_incremental_backup_0700
293  * @tc.desc: 测试OnAllBundlesFinished分支
294  * @tc.size: MEDIUM
295  * @tc.type: FUNC
296  * @tc.level Level 1
297  * @tc.require: I6F3GV
298  */
299 HWTEST_F(ToolsOpIncrementalBackupTest, SUB_backup_tools_op_incremental_backup_0700, testing::ext::TestSize.Level1)
300 {
301     GTEST_LOG_(INFO) << "ToolsOpIncrementalBackupTest-begin SUB_backup_tools_op_incremental_backup_0700";
302     try {
303         auto ctx = make_shared<SessionBckup>();
304         ErrCode err = 0;
305         OnAllBundlesFinished(ctx, err);
306         EXPECT_TRUE(true);
307     } catch (...) {
308         EXPECT_TRUE(false);
309         GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-an exception occurred by construction.";
310     }
311     GTEST_LOG_(INFO) << "ToolsOpIncrementalBackupTest-end SUB_backup_tools_op_incremental_backup_0700";
312 }
313 
314 /**
315  * @tc.number: SUB_backup_tools_op_incremental_backup_0701
316  * @tc.name: SUB_backup_tools_op_incremental_backup_0701
317  * @tc.desc: 测试OnAllBundlesFinished分支
318  * @tc.size: MEDIUM
319  * @tc.type: FUNC
320  * @tc.level Level 1
321  * @tc.require: I6F3GV
322  */
323 HWTEST_F(ToolsOpIncrementalBackupTest, SUB_backup_tools_op_incremental_backup_0701, testing::ext::TestSize.Level1)
324 {
325     GTEST_LOG_(INFO) << "ToolsOpIncrementalBackupTest-begin SUB_backup_tools_op_incremental_backup_0701";
326     try {
327         auto ctx = make_shared<SessionBckup>();
328         ErrCode err = -1;
329         OnAllBundlesFinished(ctx, err);
330         EXPECT_TRUE(true);
331     } catch (...) {
332         EXPECT_TRUE(false);
333         GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-an exception occurred by construction.";
334     }
335     GTEST_LOG_(INFO) << "ToolsOpIncrementalBackupTest-end SUB_backup_tools_op_incremental_backup_0701";
336 }
337 
338 /**
339  * @tc.number: SUB_backup_tools_op_incremental_backup_0800
340  * @tc.name: SUB_backup_tools_op_incremental_backup_0800
341  * @tc.desc: 测试OnBackupServiceDied分支
342  * @tc.size: MEDIUM
343  * @tc.type: FUNC
344  * @tc.level Level 1
345  * @tc.require: I6F3GV
346  */
347 HWTEST_F(ToolsOpIncrementalBackupTest, SUB_backup_tools_op_incremental_backup_0800, testing::ext::TestSize.Level1)
348 {
349     GTEST_LOG_(INFO) << "ToolsOpIncrementalBackupTest-begin SUB_backup_tools_op_incremental_backup_0800";
350     try {
351         auto ctx = make_shared<SessionBckup>();
352         OnBackupServiceDied(ctx);
353         EXPECT_TRUE(true);
354     } catch (...) {
355         EXPECT_TRUE(false);
356         GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-an exception occurred by construction.";
357     }
358     GTEST_LOG_(INFO) << "ToolsOpIncrementalBackupTest-end SUB_backup_tools_op_incremental_backup_0800";
359 }
360 
361 /**
362  * @tc.number: SUB_backup_tools_op_incremental_backup_0900
363  * @tc.name: SUB_backup_tools_op_incremental_backup_0900
364  * @tc.desc: 测试BackupToolDirSoftlinkToBackupDir分支
365  * @tc.size: MEDIUM
366  * @tc.type: FUNC
367  * @tc.level Level 1
368  * @tc.require: I6F3GV
369  */
370 HWTEST_F(ToolsOpIncrementalBackupTest, SUB_backup_tools_op_incremental_backup_0900, testing::ext::TestSize.Level1)
371 {
372     GTEST_LOG_(INFO) << "ToolsOpIncrementalBackupTest-begin SUB_backup_tools_op_incremental_backup_0900";
373     try {
374         BackupToolDirSoftlinkToBackupDir();
375         EXPECT_TRUE(true);
376     } catch (...) {
377         EXPECT_TRUE(false);
378         GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-an exception occurred by construction.";
379     }
380     GTEST_LOG_(INFO) << "ToolsOpIncrementalBackupTest-end SUB_backup_tools_op_incremental_backup_0900";
381 }
382 
383 /**
384  * @tc.number: SUB_backup_tools_op_incremental_backup_1000
385  * @tc.name: SUB_backup_tools_op_incremental_backup_1000
386  * @tc.desc: 测试GetLocalCapabilitiesIncremental分支
387  * @tc.size: MEDIUM
388  * @tc.type: FUNC
389  * @tc.level Level 1
390  * @tc.require: I6F3GV
391  */
392 HWTEST_F(ToolsOpIncrementalBackupTest, SUB_backup_tools_op_incremental_backup_1000, testing::ext::TestSize.Level1)
393 {
394     GTEST_LOG_(INFO) << "ToolsOpIncrementalBackupTest-begin SUB_backup_tools_op_incremental_backup_1000";
395     try {
396         auto ctx = make_shared<SessionBckup>();
397         string pathCapFile = "";
398         vector<string> bundleNames;
399         bundleNames.push_back("bundle1");
400         bundleNames.push_back("bundle2");
401         vector<string> times = {"100"};
402         int32_t ret = GetLocalCapabilitiesIncremental(ctx, pathCapFile, bundleNames, times);
403         EXPECT_EQ(-EPERM, ret);
404     } catch (...) {
405         EXPECT_TRUE(false);
406         GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-an exception occurred by construction.";
407     }
408     GTEST_LOG_(INFO) << "ToolsOpIncrementalBackupTest-end SUB_backup_tools_op_incremental_backup_1000";
409 }
410 
411 /**
412  * @tc.number: SUB_backup_tools_op_incremental_backup_1001
413  * @tc.name: SUB_backup_tools_op_incremental_backup_1001
414  * @tc.desc: 测试GetLocalCapabilitiesIncremental分支
415  * @tc.size: MEDIUM
416  * @tc.type: FUNC
417  * @tc.level Level 1
418  * @tc.require: I6F3GV
419  */
420 HWTEST_F(ToolsOpIncrementalBackupTest, SUB_backup_tools_op_incremental_backup_1001, testing::ext::TestSize.Level1)
421 {
422     GTEST_LOG_(INFO) << "ToolsOpIncrementalBackupTest-begin SUB_backup_tools_op_incremental_backup_1001";
423     try {
424         auto ctx = make_shared<SessionBckup>();
425         string pathCapFile = "/data/backup";
426         vector<string> bundleNames;
427         bundleNames.push_back("bundle1");
428         bundleNames.push_back("bundle2");
429         vector<string> times;
430         times.push_back("100");
431         times.push_back("200");
432         int32_t ret = GetLocalCapabilitiesIncremental(ctx, pathCapFile, bundleNames, times);
433         EXPECT_EQ(-EPERM, ret);
434     } catch (...) {
435         EXPECT_TRUE(false);
436         GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-an exception occurred by construction.";
437     }
438     GTEST_LOG_(INFO) << "ToolsOpIncrementalBackupTest-end SUB_backup_tools_op_incremental_backup_1001";
439 }
440 
441 /**
442  * @tc.number: SUB_backup_tools_op_incremental_backup_1100
443  * @tc.name: SUB_backup_tools_op_incremental_backup_1100
444  * @tc.desc: 测试Init分支
445  * @tc.size: MEDIUM
446  * @tc.type: FUNC
447  * @tc.level Level 1
448  * @tc.require: I6F3GV
449  */
450 HWTEST_F(ToolsOpIncrementalBackupTest, SUB_backup_tools_op_incremental_backup_1100, testing::ext::TestSize.Level1)
451 {
452     GTEST_LOG_(INFO) << "ToolsOpIncrementalBackupTest-begin SUB_backup_tools_op_incremental_backup_1100";
453     try {
454         string pathCapFile = "/data/backup";
455         vector<string> bundleNames;
456         bundleNames.push_back("bundle1");
457         bundleNames.push_back("bundle2");
458         vector<string> times;
459         times.push_back("100");
460         times.push_back("200");
461         int32_t ret = Init(pathCapFile, bundleNames, times);
462         EXPECT_EQ(-EPERM, ret);
463     } catch (...) {
464         EXPECT_TRUE(false);
465         GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-an exception occurred by construction.";
466     }
467     GTEST_LOG_(INFO) << "ToolsOpIncrementalBackupTest-end SUB_backup_tools_op_incremental_backup_1100";
468 }
469 
470 /**
471  * @tc.number: SUB_backup_tools_op_incremental_backup_1200
472  * @tc.name: SUB_backup_tools_op_incremental_backup_1200
473  * @tc.desc: 测试Exec分支
474  * @tc.size: MEDIUM
475  * @tc.type: FUNC
476  * @tc.level Level 1
477  * @tc.require: I6F3GV
478  */
479 HWTEST_F(ToolsOpIncrementalBackupTest, SUB_backup_tools_op_incremental_backup_1200, testing::ext::TestSize.Level1)
480 {
481     GTEST_LOG_(INFO) << "ToolsOpIncrementalBackupTest-begin SUB_backup_tools_op_incremental_backup_1200";
482     try {
483         map<string, vector<string>> mapArgToVal = {
484             {"pathCapFile", {"path"}},
485             {"bundles", {"bundle1", "bundle2"}},
486             {"incrementalTime", {"time"}}
487         };
488         int ret = g_exec(mapArgToVal);
489         EXPECT_LT(ret, 0);
490     } catch (...) {
491         EXPECT_TRUE(false);
492         GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-an exception occurred by construction.";
493     }
494     GTEST_LOG_(INFO) << "ToolsOpIncrementalBackupTest-end SUB_backup_tools_op_incremental_backup_1200";
495 }
496 
497 /**
498  * @tc.number: SUB_backup_tools_op_incremental_backup_1201
499  * @tc.name: SUB_backup_tools_op_incremental_backup_1201
500  * @tc.desc: 测试Exec分支
501  * @tc.size: MEDIUM
502  * @tc.type: FUNC
503  * @tc.level Level 1
504  * @tc.require: I6F3GV
505  */
506 HWTEST_F(ToolsOpIncrementalBackupTest, SUB_backup_tools_op_incremental_backup_1201, testing::ext::TestSize.Level1)
507 {
508     GTEST_LOG_(INFO) << "ToolsOpIncrementalBackupTest-begin SUB_backup_tools_op_incremental_backup_1201";
509     try {
510         map<string, vector<string>> mapArgToVal = {
511             {"bundles", {"bundle1"}},
512             {"incrementalTime", {"time"}}
513         };
514         int ret = g_exec(mapArgToVal);
515         EXPECT_LT(ret, 0);
516     } catch (...) {
517         EXPECT_TRUE(false);
518         GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-an exception occurred by construction.";
519     }
520     GTEST_LOG_(INFO) << "ToolsOpIncrementalBackupTest-end SUB_backup_tools_op_incremental_backup_1201";
521 }
522 
523 /**
524  * @tc.number: SUB_backup_tools_op_incremental_backup_1202
525  * @tc.name: SUB_backup_tools_op_incremental_backup_1202
526  * @tc.desc: 测试Exec分支
527  * @tc.size: MEDIUM
528  * @tc.type: FUNC
529  * @tc.level Level 1
530  * @tc.require: I6F3GV
531  */
532 HWTEST_F(ToolsOpIncrementalBackupTest, SUB_backup_tools_op_incremental_backup_1202, testing::ext::TestSize.Level1)
533 {
534     GTEST_LOG_(INFO) << "ToolsOpIncrementalBackupTest-begin SUB_backup_tools_op_incremental_backup_1202";
535     try {
536         map<string, vector<string>> mapArgToVal = {
537             {"pathCapFile", {"path"}},
538             {"incrementalTime", {"time"}}
539         };
540         int ret = g_exec(mapArgToVal);
541         EXPECT_LT(ret, 0);
542     } catch (...) {
543         EXPECT_TRUE(false);
544         GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-an exception occurred by construction.";
545     }
546     GTEST_LOG_(INFO) << "ToolsOpIncrementalBackupTest-end SUB_backup_tools_op_incremental_backup_1202";
547 }
548 
549 /**
550  * @tc.number: SUB_backup_tools_op_incremental_backup_1203
551  * @tc.name: SUB_backup_tools_op_incremental_backup_1203
552  * @tc.desc: 测试Exec分支
553  * @tc.size: MEDIUM
554  * @tc.type: FUNC
555  * @tc.level Level 1
556  * @tc.require: I6F3GV
557  */
558 HWTEST_F(ToolsOpIncrementalBackupTest, SUB_backup_tools_op_incremental_backup_1203, testing::ext::TestSize.Level1)
559 {
560     GTEST_LOG_(INFO) << "ToolsOpIncrementalBackupTest-begin SUB_backup_tools_op_incremental_backup_1203";
561     try {
562         map<string, vector<string>> mapArgToVal = {
563             {"pathCapFile", {"path"}},
564             {"bundles", {"bundle1"}}
565         };
566         int ret = g_exec(mapArgToVal);
567         EXPECT_LT(ret, 0);
568     } catch (...) {
569         EXPECT_TRUE(false);
570         GTEST_LOG_(INFO) << "ToolsOpRestoreAsyncTest-an exception occurred by construction.";
571     }
572     GTEST_LOG_(INFO) << "ToolsOpIncrementalBackupTest-end SUB_backup_tools_op_incremental_backup_1203";
573 }
574 } // namespace OHOS::FileManagement::Backup