• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2022-2025 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 <fstream>
17 #include <iostream>
18 #include <map>
19 #include <sstream>
20 #include <string>
21 #include <sys/stat.h>
22 #include <unistd.h>
23 #include <vector>
24 
25 #include <gtest/gtest.h>
26 
27 #include "b_error/b_error.h"
28 #include "b_error/b_excep_utils.h"
29 #include "ext_backup_mock.h"
30 #include "ext_extension_mock.h"
31 #include "tar_file.h"
32 #include "untar_file.h"
33 
34 #include "sub_ext_extension.cpp"
35 
36 namespace OHOS::FileManagement::Backup {
37 using namespace std;
38 using namespace testing;
39 
40 namespace {
41 const string FILE_NAME = "1.txt";
42 const string BUNDLE_NAME = "com.example.app2backup/";
43 const string MANAGE_JSON = "manage.json";
44 const string PATH = "/data/storage/el2/backup/test/";
45 const string TAR_FILE = "1.tar";
46 const string BUNDLE_BASE_DIR = "/data/storage/el2/base/";
47 const string PATH_BUNDLE_BACKUP_HOME_EL1 = "/data/storage/el1/base/.backup";
48 const string PATH_BUNDLE_BACKUP_HOME = "/data/storage/el2/base/.backup";
49 } // namespace
50 
51 class ExtExtensionSubTest : public testing::Test {
52 public:
53     //所有测试用例执行之前执行
54     static void SetUpTestCase(void);
55     //所有测试用例执行之后执行
56     static void TearDownTestCase(void);
57     //每次测试用例执行之前执行
SetUp()58     void SetUp() {};
59     //每次测试用例执行之后执行
TearDown()60     void TearDown() {};
61 
62     static inline sptr<BackupExtExtension> extExtension = nullptr;
63     static inline shared_ptr<ExtBackup> extension = nullptr;
64     static inline shared_ptr<ExtBackupMock> extBackupMock = nullptr;
65     static inline shared_ptr<ExtExtensionMock> extExtensionMock = nullptr;
66 };
67 
SetUpTestCase(void)68 void ExtExtensionSubTest::SetUpTestCase(void)
69 {
70     //创建测试路径
71     string cmdMkdir = string("mkdir -p ") + PATH + BUNDLE_NAME;
72     system(cmdMkdir.c_str());
73 
74     string cmdMkdir1 = string("mkdir -p ") + BUNDLE_BASE_DIR;
75     system(cmdMkdir1.c_str());
76 
77     string cmdMkdir2 = string("mkdir -p ") + PATH_BUNDLE_BACKUP_HOME_EL1;
78     system(cmdMkdir2.c_str());
79 
80     string cmdMkdir3 = string("mkdir -p ") + PATH_BUNDLE_BACKUP_HOME;
81     system(cmdMkdir3.c_str());
82     //创建测试文件
83     string touchFile = string("touch ") + PATH + BUNDLE_NAME + FILE_NAME;
84     system(touchFile.c_str());
85     string touchFile2 = string("touch ") + PATH + BUNDLE_NAME + "2.txt";
86     system(touchFile2.c_str());
87     string touchFile3 = string("touch ") + PATH + BUNDLE_NAME + TAR_FILE;
88     system(touchFile3.c_str());
89 
90     extBackupMock = make_shared<ExtBackupMock>();
91     ExtBackupMock::extBackup = extBackupMock;
92 
93     extExtensionMock = make_shared<ExtExtensionMock>();
94     ExtExtensionMock::extExtension = extExtensionMock;
95 
96     extExtension = sptr<BackupExtExtension>(new BackupExtExtension(
97         nullptr, BUNDLE_NAME));
98     extension = make_shared<ExtBackup>();
99     extExtension->extension_ = extension;
100 };
101 
TearDownTestCase(void)102 void ExtExtensionSubTest::TearDownTestCase(void)
103 {
104     //删除测试文件夹和文件
105     string rmDir = string("rm -r ") + PATH + BUNDLE_NAME;
106     system(rmDir.c_str());
107 
108     rmDir = string("rm -r ") + "/data/storage/el2/";
109     system(rmDir.c_str());
110 
111     rmDir = string("rm -r ") + "/data/storage/el1/";
112     system(rmDir.c_str());
113 
114     extension = nullptr;
115     extExtension = nullptr;
116     ExtBackupMock::extBackup = nullptr;
117     extBackupMock = nullptr;
118     ExtExtensionMock::extExtension = nullptr;
119     extExtensionMock = nullptr;
120 };
121 
122 /**
123  * @tc.number: Ext_Extension_Sub_SetClearDataFlag_Test_0100
124  * @tc.name: Ext_Extension_Sub_SetClearDataFlag_Test_0100
125  * @tc.desc: 测试SetClearDataFlag
126  * @tc.size: MEDIUM
127  * @tc.type: FUNC
128  * @tc.level Level 1
129  * @tc.require: I9P3Y3
130  */
131 HWTEST_F(ExtExtensionSubTest, Ext_Extension_Sub_SetClearDataFlag_Test_0100, testing::ext::TestSize.Level1)
132 {
133     GTEST_LOG_(INFO) << "ExtExtensionSubTest-begin Ext_Extension_Sub_SetClearDataFlag_Test_0100";
134     try {
135         ASSERT_TRUE(extExtension != nullptr);
136         extExtension->SetClearDataFlag(true);
137         EXPECT_TRUE(extExtension->isClearData_ == true);
138 
139         extExtension->extension_ = nullptr;
140         extExtension->SetClearDataFlag(false);
141         EXPECT_TRUE(extExtension->isClearData_ == false);
142 
143         extExtension->extension_ = extension;
144     } catch (...) {
145         EXPECT_TRUE(false);
146         GTEST_LOG_(INFO) << "ExtExtensionSubTest-an exception occurred by construction.";
147     }
148     GTEST_LOG_(INFO) << "ExtExtensionSubTest-end Ext_Extension_Sub_SetClearDataFlag_Test_0100";
149 }
150 
151 /**
152  * @tc.number: Ext_Extension_Sub_HandleIncrementalBackup_Test_0100
153  * @tc.name: Ext_Extension_Sub_HandleIncrementalBackup_Test_0100
154  * @tc.desc: 测试HandleIncrementalBackup
155  * @tc.size: MEDIUM
156  * @tc.type: FUNC
157  * @tc.level Level 1
158  * @tc.require: I9P3Y3
159  */
160 HWTEST_F(ExtExtensionSubTest, Ext_Extension_Sub_HandleIncrementalBackup_Test_0100, testing::ext::TestSize.Level1)
161 {
162     GTEST_LOG_(INFO) << "ExtExtensionSubTest-begin Ext_Extension_Sub_HandleIncrementalBackup_Test_0100";
163     try {
164         ASSERT_TRUE(extExtension != nullptr);
165         string incrementalFile = PATH + BUNDLE_NAME + "2.txt";
166         int incrementalFd = open(incrementalFile.data(), O_RDWR | O_TRUNC, S_IRWXU);
167         EXPECT_GT(incrementalFd, 0);
168         string manifestFile = PATH + BUNDLE_NAME + FILE_NAME;
169         int manifestFd = open(manifestFile.data(), O_RDWR | O_TRUNC, S_IRWXU);
170         EXPECT_GT(manifestFd, 0);
171 
172         EXPECT_EQ(extExtension->HandleIncrementalBackup(incrementalFd, manifestFd), BError::E_FORBID);
173         close(incrementalFd);
174         close(manifestFd);
175     } catch (...) {
176         EXPECT_TRUE(false);
177         GTEST_LOG_(INFO) << "ExtExtensionSubTest-an exception occurred by construction.";
178     }
179     GTEST_LOG_(INFO) << "ExtExtensionSubTest-end Ext_Extension_Sub_HandleIncrementalBackup_Test_0100";
180 }
181 
182 /**
183  * @tc.number: Ext_Extension_Sub_IncrementalOnBackup_Test_0100
184  * @tc.name: Ext_Extension_Sub_IncrementalOnBackup_Test_0100
185  * @tc.desc: 测试IncrementalOnBackup
186  * @tc.size: MEDIUM
187  * @tc.type: FUNC
188  * @tc.level Level 1
189  * @tc.require: I9P3Y3
190  */
191 HWTEST_F(ExtExtensionSubTest, Ext_Extension_Sub_IncrementalOnBackup_Test_0100, testing::ext::TestSize.Level1)
192 {
193     GTEST_LOG_(INFO) << "ExtExtensionSubTest-begin Ext_Extension_Sub_IncrementalOnBackup_Test_0100";
194     try {
195         ASSERT_TRUE(extExtension != nullptr);
196         EXPECT_EQ(extExtension->IncrementalOnBackup(false), BError::E_FORBID);
197     } catch (...) {
198         EXPECT_TRUE(false);
199         GTEST_LOG_(INFO) << "ExtExtensionSubTest-an exception occurred by construction.";
200     }
201     GTEST_LOG_(INFO) << "ExtExtensionSubTest-end Ext_Extension_Sub_IncrementalOnBackup_Test_0100";
202 }
203 
204 /**
205  * @tc.number: Ext_Extension_Sub_WaitToSendFd_Test_0100
206  * @tc.name: Ext_Extension_Sub_WaitToSendFd_Test_0100
207  * @tc.desc: 测试WaitToSendFd
208  * @tc.size: MEDIUM
209  * @tc.type: FUNC
210  * @tc.level Level 1
211  * @tc.require: I9P3Y3
212  */
213 HWTEST_F(ExtExtensionSubTest, Ext_Extension_Sub_WaitToSendFd_Test_0100, testing::ext::TestSize.Level1)
214 {
215     GTEST_LOG_(INFO) << "ExtExtensionSubTest-begin Ext_Extension_Sub_WaitToSendFd_Test_0100";
216     try {
217         ASSERT_TRUE(extExtension != nullptr);
218         auto startTime = std::chrono::system_clock::now();
219         int fdSendNum = 61;
220         extExtension->WaitToSendFd(startTime, fdSendNum);
221         EXPECT_EQ(fdSendNum, 0);
222         fdSendNum = 1;
223         extExtension->WaitToSendFd(startTime, fdSendNum);
224         EXPECT_EQ(fdSendNum, 1);
225     } catch (...) {
226         EXPECT_TRUE(false);
227         GTEST_LOG_(INFO) << "ExtExtensionSubTest-an exception occurred by construction.";
228     }
229     GTEST_LOG_(INFO) << "ExtExtensionSubTest-end Ext_Extension_Sub_WaitToSendFd_Test_0100";
230 }
231 
232 /**
233  * @tc.number: Ext_Extension_Sub_RefreshTimeInfo_Test_0100
234  * @tc.name: Ext_Extension_Sub_RefreshTimeInfo_Test_0100
235  * @tc.desc: 测试RefreshTimeInfo
236  * @tc.size: MEDIUM
237  * @tc.type: FUNC
238  * @tc.level Level 1
239  * @tc.require: I9P3Y3
240  */
241 HWTEST_F(ExtExtensionSubTest, Ext_Extension_Sub_RefreshTimeInfo_Test_0100, testing::ext::TestSize.Level1)
242 {
243     GTEST_LOG_(INFO) << "ExtExtensionSubTest-begin Ext_Extension_Sub_RefreshTimeInfo_Test_0100";
244     try {
245         ASSERT_TRUE(extExtension != nullptr);
246         auto startTime = std::chrono::system_clock::now();
247         int fdSendNum = 1;
248         extExtension->RefreshTimeInfo(startTime, fdSendNum);
249         EXPECT_EQ(fdSendNum, 1);
250     } catch (...) {
251         EXPECT_TRUE(false);
252         GTEST_LOG_(INFO) << "ExtExtensionSubTest-an exception occurred by construction.";
253     }
254     GTEST_LOG_(INFO) << "ExtExtensionSubTest-end Ext_Extension_Sub_RefreshTimeInfo_Test_0100";
255 }
256 
257 /**
258  * @tc.number: Ext_Extension_Sub_GetBundlePath_Test_0100
259  * @tc.name: Ext_Extension_Sub_GetBundlePath_Test_0100
260  * @tc.desc: 测试GetBundlePath
261  * @tc.size: MEDIUM
262  * @tc.type: FUNC
263  * @tc.level Level 1
264  * @tc.require: I9P3Y3
265  */
266 HWTEST_F(ExtExtensionSubTest, Ext_Extension_Sub_GetBundlePath_Test_0100, testing::ext::TestSize.Level1)
267 {
268     GTEST_LOG_(INFO) << "ExtExtensionSubTest-begin Ext_Extension_Sub_GetBundlePath_Test_0100";
269     try {
270         ASSERT_TRUE(extExtension != nullptr);
271         auto path = string(BConstants::PATH_BUNDLE_BACKUP_HOME).append(BConstants::SA_BUNDLE_BACKUP_RESTORE);
272         auto ret = extExtension->GetBundlePath();
273         EXPECT_EQ(ret, path);
274 
275         extExtension->bundleName_ = BConstants::BUNDLE_FILE_MANAGER;
276         path = string(BConstants::PATH_FILEMANAGE_BACKUP_HOME).append(BConstants::SA_BUNDLE_BACKUP_RESTORE);
277         ret = extExtension->GetBundlePath();
278         EXPECT_EQ(ret, path);
279 
280         extExtension->bundleName_ = BConstants::BUNDLE_MEDIAL_DATA;
281         path = string(BConstants::PATH_MEDIALDATA_BACKUP_HOME).append(BConstants::SA_BUNDLE_BACKUP_RESTORE);
282         ret = extExtension->GetBundlePath();
283         EXPECT_EQ(ret, path);
284         extExtension->bundleName_ = BUNDLE_NAME;
285     } catch (...) {
286         EXPECT_TRUE(false);
287         GTEST_LOG_(INFO) << "ExtExtensionSubTest-an exception occurred by construction.";
288     }
289     GTEST_LOG_(INFO) << "ExtExtensionSubTest-end Ext_Extension_Sub_GetBundlePath_Test_0100";
290 }
291 
292 /**
293  * @tc.number: Ext_Extension_Sub_CheckRstoreFileInfos_Test_0100
294  * @tc.name: Ext_Extension_Sub_CheckRstoreFileInfos_Test_0100
295  * @tc.desc: 测试CheckRstoreFileInfos
296  * @tc.size: MEDIUM
297  * @tc.type: FUNC
298  * @tc.level Level 1
299  * @tc.require: I9P3Y3
300  */
301 HWTEST_F(ExtExtensionSubTest, Ext_Extension_Sub_CheckRstoreFileInfos_Test_0100, testing::ext::TestSize.Level1)
302 {
303     GTEST_LOG_(INFO) << "ExtExtensionSubTest-begin Ext_Extension_Sub_CheckRstoreFileInfos_Test_0100";
304     try {
305         ASSERT_TRUE(extExtension != nullptr);
306         tuple<bool, vector<string>> result;
307         string tarName = PATH_BUNDLE_BACKUP_HOME + "/part0.tar";
308         string untarPath = PATH_BUNDLE_BACKUP_HOME;
309 
310         result = extExtension->CheckRestoreFileInfos();
311         EXPECT_EQ(std::get<0>(result), true);
312 
313         auto [err, fileInfos, errInfos] = UntarFile::GetInstance().UnPacket(tarName, untarPath);
314         extExtension->endFileInfos_[tarName] = 1;
315         extExtension->endFileInfos_.merge(fileInfos);
316 
317         result = extExtension->CheckRestoreFileInfos();
318         EXPECT_EQ(std::get<0>(result), false);
319     } catch (...) {
320         EXPECT_TRUE(false);
321         GTEST_LOG_(INFO) << "ExtExtensionSubTest-an exception occurred by construction.";
322     }
323     GTEST_LOG_(INFO) << "ExtExtensionSubTest-end Ext_Extension_Sub_CheckRstoreFileInfos_Test_0100";
324 }
325 
326 /**
327  * @tc.number: Ext_Extension_Sub_OnRestoreCallback_Test_0100
328  * @tc.name: Ext_Extension_Sub_OnRestoreCallback_Test_0100
329  * @tc.desc: 测试OnRestoreCallback
330  * @tc.size: MEDIUM
331  * @tc.type: FUNC
332  * @tc.level Level 1
333  * @tc.require: I9P3Y3
334  */
335 HWTEST_F(ExtExtensionSubTest, Ext_Extension_Sub_OnRestoreCallback_Test_0100, testing::ext::TestSize.Level1)
336 {
337     GTEST_LOG_(INFO) << "ExtExtensionSubTest-begin Ext_Extension_Sub_OnRestoreCallback_Test_0100";
338     try {
339         ErrCode errCode = 0;
340         string errMsg = "";
341 
342         ASSERT_TRUE(extExtension != nullptr);
343         extExtension->SetClearDataFlag(false);
344         std::function<void(ErrCode, string)> restoreCallBack = extExtension->OnRestoreCallback(nullptr);
345         restoreCallBack(errCode, errMsg);
346         EXPECT_EQ(errMsg, "");
347 
348         errMsg = "err";
349         extExtension->isExecAppDone_.store(true);
350         restoreCallBack = extExtension->OnRestoreCallback(extExtension);
351         restoreCallBack(errCode, errMsg);
352         extExtension->isExecAppDone_.store(false);
353         EXPECT_EQ(errMsg, "err");
354 
355     } catch (...) {
356         EXPECT_TRUE(false);
357         GTEST_LOG_(INFO) << "ExtExtensionSubTest-an exception occurred by construction.";
358     }
359     GTEST_LOG_(INFO) << "ExtExtensionSubTest-end Ext_Extension_Sub_OnRestoreCallback_Test_0100";
360 }
361 
362 /**
363  * @tc.number: Ext_Extension_Sub_OnRestoreExCallback_Test_0100
364  * @tc.name: Ext_Extension_Sub_OnRestoreExCallback_Test_0100
365  * @tc.desc: 测试OnRestoreExCallback
366  * @tc.size: MEDIUM
367  * @tc.type: FUNC
368  * @tc.level Level 1
369  * @tc.require: I9P3Y3
370  */
371 HWTEST_F(ExtExtensionSubTest, Ext_Extension_Sub_OnRestoreExCallback_Test_0100, testing::ext::TestSize.Level1)
372 {
373     GTEST_LOG_(INFO) << "ExtExtensionSubTest-begin Ext_Extension_Sub_OnRestoreExCallback_Test_0100";
374     try {
375         ErrCode errCode = 0;
376         string restoreRetInfo = "";
377 
378         ASSERT_TRUE(extExtension != nullptr);
379         extExtension->SetClearDataFlag(false);
380         std::function<void(ErrCode, string)> restoreCallBack = extExtension->OnRestoreExCallback(nullptr);
381         restoreCallBack(errCode, restoreRetInfo);
382         EXPECT_EQ(restoreRetInfo, "");
383 
384         restoreRetInfo = "";
385         restoreCallBack = extExtension->OnRestoreExCallback(extExtension);
386         extExtension->extension_ = nullptr;
387         restoreCallBack(errCode, restoreRetInfo);
388         extExtension->extension_ = extension;
389         EXPECT_EQ(restoreRetInfo, "");
390 
391         restoreRetInfo = "err";
392         extExtension->isExecAppDone_.store(true);
393         restoreCallBack = extExtension->OnRestoreExCallback(extExtension);
394         restoreCallBack(errCode, restoreRetInfo);
395         extExtension->isExecAppDone_.store(false);
396         EXPECT_EQ(restoreRetInfo, "err");
397 
398     } catch (...) {
399         EXPECT_TRUE(false);
400         GTEST_LOG_(INFO) << "ExtExtensionSubTest-an exception occurred by construction.";
401     }
402     GTEST_LOG_(INFO) << "ExtExtensionSubTest-end Ext_Extension_Sub_OnRestoreExCallback_Test_0100";
403 }
404 
405 /**
406  * @tc.number: Ext_Extension_Sub_AppDoneCallbackEx_Test_0100
407  * @tc.name: Ext_Extension_Sub_AppDoneCallbackEx_Test_0100
408  * @tc.desc: 测试AppDoneCallbackEx
409  * @tc.size: MEDIUM
410  * @tc.type: FUNC
411  * @tc.level Level 1
412  * @tc.require: I9P3Y3
413  */
414 HWTEST_F(ExtExtensionSubTest, Ext_Extension_Sub_AppDoneCallbackEx_Test_0100, testing::ext::TestSize.Level1)
415 {
416     GTEST_LOG_(INFO) << "ExtExtensionSubTest-begin Ext_Extension_Sub_AppDoneCallbackEx_Test_0100";
417     try {
418         ErrCode errCode = 0;
419         string errMessage = "";
420 
421         ASSERT_TRUE(extExtension != nullptr);
422         extExtension->SetClearDataFlag(false);
423         std::function<void(ErrCode, string)> restoreCallBack = extExtension->AppDoneCallbackEx(nullptr);
424         restoreCallBack(errCode, errMessage);
425         EXPECT_EQ(errMessage, "");
426 
427         restoreCallBack = extExtension->AppDoneCallbackEx(extExtension);
428         restoreCallBack(errCode, errMessage);
429         extExtension->extension_ = extension;
430         EXPECT_EQ(errMessage, "");
431 
432     } catch (...) {
433         EXPECT_TRUE(false);
434         GTEST_LOG_(INFO) << "ExtExtensionSubTest-an exception occurred by construction.";
435     }
436     GTEST_LOG_(INFO) << "ExtExtensionSubTest-end Ext_Extension_Sub_AppDoneCallbackEx_Test_0100";
437 }
438 
439 /**
440  * @tc.number: Ext_Extension_Sub_GetComInfoCallback_Test_0100
441  * @tc.name: Ext_Extension_Sub_GetComInfoCallback_Test_0100
442  * @tc.desc: 测试GetComInfoCallback
443  * @tc.size: MEDIUM
444  * @tc.type: FUNC
445  * @tc.level Level 1
446  * @tc.require: I9P3Y3
447  */
448 HWTEST_F(ExtExtensionSubTest, Ext_Extension_Sub_GetComInfoCallback_Test_0100, testing::ext::TestSize.Level1)
449 {
450     GTEST_LOG_(INFO) << "ExtExtensionSubTest-begin Ext_Extension_Sub_GetComInfoCallback_Test_0100";
451     try {
452         ASSERT_TRUE(extExtension != nullptr);
453         std::string compatibilityInfo = "test";
454         extExtension->GetComInfoCallback(nullptr)(BError(BError::Codes::OK).GetCode(), compatibilityInfo);
455         EXPECT_NE(extExtension->compatibilityInfo_, compatibilityInfo);
456 
457         auto extensionTmp = extExtension->extension_;
458         extExtension->extension_ = nullptr;
459         auto ptr = wptr<BackupExtExtension>(extExtension);
460         extExtension->GetComInfoCallback(ptr)(BError(BError::Codes::OK).GetCode(), compatibilityInfo);
461         extExtension->extension_ = extensionTmp;
462         EXPECT_NE(extExtension->compatibilityInfo_, compatibilityInfo);
463 
464         bool stopGetComInfo = extExtension->stopGetComInfo_.load();
465         extExtension->stopGetComInfo_.store(true);
466         extExtension->GetComInfoCallback(ptr)(BError(BError::Codes::OK).GetCode(), compatibilityInfo);
467         extExtension->stopGetComInfo_.store(stopGetComInfo);
468         EXPECT_NE(extExtension->compatibilityInfo_, compatibilityInfo);
469 
470         extExtension->stopGetComInfo_.store(false);
471         extExtension->GetComInfoCallback(ptr)(BError(BError::Codes::OK).GetCode(), compatibilityInfo);
472         extExtension->stopGetComInfo_.store(stopGetComInfo);
473         EXPECT_EQ(extExtension->compatibilityInfo_, compatibilityInfo);
474     } catch (...) {
475         EXPECT_TRUE(false);
476         GTEST_LOG_(INFO) << "ExtExtensionSubTest-an exception occurred by construction.";
477     }
478     GTEST_LOG_(INFO) << "ExtExtensionSubTest-end Ext_Extension_Sub_GetComInfoCallback_Test_0100";
479 }
480 
481 /**
482  * @tc.number: Ext_Extension_Sub_HandleGetCompatibilityInfo_Test_0100
483  * @tc.name: Ext_Extension_Sub_HandleGetCompatibilityInfo_Test_0100
484  * @tc.desc: 测试HandleGetCompatibilityInfo
485  * @tc.size: MEDIUM
486  * @tc.type: FUNC
487  * @tc.level Level 1
488  * @tc.require: I9P3Y3
489  */
490 HWTEST_F(ExtExtensionSubTest, Ext_Extension_Sub_HandleGetCompatibilityInfo_Test_0100, testing::ext::TestSize.Level1)
491 {
492     GTEST_LOG_(INFO) << "ExtExtensionSubTest-begin Ext_Extension_Sub_HandleGetCompatibilityInfo_Test_0100";
493     try {
494         ASSERT_TRUE(extExtension != nullptr);
495         std::string extInfo = "test";
496         std::string compatibilityInfo = "";
497         int32_t scenario = BConstants::ExtensionScenario::BACKUP;
498         auto ret = extExtension->HandleGetCompatibilityInfo(extInfo, scenario, compatibilityInfo);
499         EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode());
500 
501         scenario = BConstants::ExtensionScenario::RESTORE;
502         ret = extExtension->HandleGetCompatibilityInfo(extInfo, scenario, compatibilityInfo);
503         EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode());
504 
505         scenario = BConstants::ExtensionScenario::INVALID;
506         ret = extExtension->HandleGetCompatibilityInfo(extInfo, scenario, compatibilityInfo);
507         EXPECT_EQ(ret, BError(BError::Codes::EXT_INVAL_ARG).GetCode());
508 
509         scenario = BConstants::ExtensionScenario::BACKUP;
510         EXPECT_CALL(*extBackupMock, GetBackupCompatibilityInfo(_, _))
511             .WillOnce(Return(BError(BError::Codes::EXT_INVAL_ARG).GetCode()));
512         ret = extExtension->HandleGetCompatibilityInfo(extInfo, scenario, compatibilityInfo);
513         EXPECT_EQ(ret, BError(BError::Codes::EXT_INVAL_ARG).GetCode());
514     } catch (...) {
515         EXPECT_TRUE(false);
516         GTEST_LOG_(INFO) << "ExtExtensionSubTest-an exception occurred by construction.";
517     }
518     GTEST_LOG_(INFO) << "ExtExtensionSubTest-end Ext_Extension_Sub_HandleGetCompatibilityInfo_Test_0100";
519 }
520 
521 /**
522  * @tc.number: Ext_Extension_Sub_HandleOnRelease_Test_0100
523  * @tc.name: Ext_Extension_Sub_HandleOnRelease_Test_0100
524  * @tc.desc: 测试HandleOnRelease
525  * @tc.size: MEDIUM
526  * @tc.type: FUNC
527  * @tc.level Level 1
528  * @tc.require: I9P3Y3
529  */
530 HWTEST_F(ExtExtensionSubTest, Ext_Extension_Sub_HandleOnRelease_Test_0100, testing::ext::TestSize.Level1)
531 {
532     GTEST_LOG_(INFO) << "ExtExtensionSubTest-begin Ext_Extension_Sub_HandleOnRelease_Test_0100";
533     try {
534         ASSERT_TRUE(extExtension != nullptr);
535         int32_t scenario = 1;
536         bool isOnReleased = extExtension->isOnReleased_.load();
537         extExtension->isOnReleased_.store(true);
538         auto ret = extExtension->HandleOnRelease(scenario);
539         EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode());
540 
541         extExtension->isOnReleased_.store(false);
542         auto ext = extExtension->extension_;
543         extExtension->extension_ = nullptr;
544         ret = extExtension->HandleOnRelease(scenario);
545         extExtension->extension_ = ext;
546         EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode());
547 
548         ret = extExtension->HandleOnRelease(scenario);
549         extExtension->isOnReleased_.store(isOnReleased);
550         EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode());
551     } catch (...) {
552         EXPECT_TRUE(false);
553         GTEST_LOG_(INFO) << "ExtExtensionSubTest-an exception occurred by construction.";
554     }
555     GTEST_LOG_(INFO) << "ExtExtensionSubTest-end Ext_Extension_Sub_HandleOnRelease_Test_0100";
556 }
557 
558 /**
559  * @tc.number: Ext_Extension_Sub_HandleExtOnRelease_Test_0100
560  * @tc.name: Ext_Extension_Sub_HandleExtOnRelease_Test_0100
561  * @tc.desc: 测试HandleExtOnRelease
562  * @tc.size: MEDIUM
563  * @tc.type: FUNC
564  * @tc.level Level 1
565  * @tc.require: I9P3Y3
566  */
567 HWTEST_F(ExtExtensionSubTest, Ext_Extension_Sub_HandleExtOnRelease_Test_0100, testing::ext::TestSize.Level1)
568 {
569     GTEST_LOG_(INFO) << "ExtExtensionSubTest-begin Ext_Extension_Sub_HandleExtOnRelease_Test_0100";
570     try {
571         ASSERT_TRUE(extExtension != nullptr);
572         auto curScenario = extExtension->curScenario_;
573         extExtension->curScenario_ = BackupRestoreScenario::FULL_BACKUP;
574         auto ext = extExtension->extension_;
575         extExtension->extension_ = nullptr;
576         extExtension->HandleExtOnRelease(false, BError(BError::Codes::OK).GetCode());
577         EXPECT_TRUE(true);
578 
579         extExtension->curScenario_ = BackupRestoreScenario::FULL_RESTORE;
580         extExtension->HandleExtOnRelease(false, BError(BError::Codes::OK).GetCode());
581         EXPECT_TRUE(true);
582 
583         extExtension->extension_ = ext;
584         EXPECT_NE(extExtension->extension_, nullptr);
585         bool isOnReleased = extExtension->isOnReleased_.load();
586         extExtension->isOnReleased_.store(true);
587         extExtension->HandleExtOnRelease(false, BError(BError::Codes::OK).GetCode());
588         EXPECT_TRUE(true);
589 
590         extExtension->isOnReleased_.store(false);
591         EXPECT_CALL(*extBackupMock, OnRelease(_, _)).WillOnce(Return(BError(BError::Codes::EXT_INVAL_ARG).GetCode()));
592         extExtension->HandleExtOnRelease(false, BError(BError::Codes::OK).GetCode());
593         EXPECT_TRUE(true);
594 
595         EXPECT_CALL(*extBackupMock, OnRelease(_, _)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
596         extExtension->needAppResultReport_.store(false);
597         extExtension->HandleExtOnRelease(false, BError(BError::Codes::OK).GetCode());
598         EXPECT_TRUE(true);
599 
600         extExtension->isOnReleased_.store(isOnReleased);
601         extExtension->curScenario_ = curScenario;
602     } catch (...) {
603         EXPECT_TRUE(false);
604         GTEST_LOG_(INFO) << "ExtExtensionSubTest-an exception occurred by construction.";
605     }
606     GTEST_LOG_(INFO) << "ExtExtensionSubTest-end Ext_Extension_Sub_HandleExtOnRelease_Test_0100";
607 }
608 
609 /**
610  * @tc.number: Ext_Extension_Sub_PreDealExcludes_Test_0100
611  * @tc.name: Ext_Extension_Sub_PreDealExcludes_Test_0100
612  * @tc.desc: 测试PreDealExcludes
613  * @tc.size: MEDIUM
614  * @tc.type: FUNC
615  * @tc.level Level 1
616  * @tc.require: I9P3Y3
617  */
618 HWTEST_F(ExtExtensionSubTest, Ext_Extension_Sub_PreDealExcludes_Test_0100, testing::ext::TestSize.Level1)
619 {
620     GTEST_LOG_(INFO) << "ExtExtensionSubTest-begin Ext_Extension_Sub_PreDealExcludes_Test_0100";
621     try {
622         ASSERT_TRUE(extExtension != nullptr);
623         std::vector<std::string> excludes {"test1", "test2/", ""};
624         extExtension->PreDealExcludes(excludes);
625         EXPECT_EQ(excludes.size(), 2);
626         EXPECT_EQ(excludes[0], "test1");
627         EXPECT_EQ(excludes[1], "/test2/*");
628     } catch (...) {
629         EXPECT_TRUE(false);
630         GTEST_LOG_(INFO) << "ExtExtensionSubTest-an exception occurred by construction.";
631     }
632     GTEST_LOG_(INFO) << "ExtExtensionSubTest-end Ext_Extension_Sub_PreDealExcludes_Test_0100";
633 }
634 
635 /**
636  * @tc.number: Ext_Extension_Sub_DoBackupBigFiles_Test_0100
637  * @tc.name: Ext_Extension_Sub_DoBackupBigFiles_Test_0100
638  * @tc.desc: 测试DoBackupBigFiles
639  * @tc.size: MEDIUM
640  * @tc.type: FUNC
641  * @tc.level Level 1
642  * @tc.require: I9P3Y3
643  */
644 HWTEST_F(ExtExtensionSubTest, Ext_Extension_Sub_DoBackupBigFiles_Test_0100, testing::ext::TestSize.Level1)
645 {
646     GTEST_LOG_(INFO) << "ExtExtensionSubTest-begin Ext_Extension_Sub_DoBackupBigFiles_Test_0100";
647     try {
648         ASSERT_TRUE(extExtension != nullptr);
649         TarMap tarMap {};
650         uint32_t backupedFileSize = 0;
651         auto ext = extExtension->extension_;
652         extExtension->extension_ = nullptr;
653         auto ret = extExtension->DoBackupBigFiles(tarMap, backupedFileSize);
654         extExtension->extension_ = ext;
655         EXPECT_EQ(ret, EPERM);
656 
657         EXPECT_CALL(*extBackupMock, GetExtensionAction()).WillOnce(Return(BConstants::ExtensionAction::INVALID));
658         ret = extExtension->DoBackupBigFiles(tarMap, backupedFileSize);
659         EXPECT_EQ(ret, EPERM);
660 
661         EXPECT_CALL(*extBackupMock, GetExtensionAction()).WillOnce(Return(BConstants::ExtensionAction::BACKUP));
662         EXPECT_CALL(*extExtensionMock, BigFileReady(_, _, _)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
663         ret = extExtension->DoBackupBigFiles(tarMap, backupedFileSize);
664         EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode());
665     } catch (...) {
666         EXPECT_TRUE(false);
667         GTEST_LOG_(INFO) << "ExtExtensionSubTest-an exception occurred by construction.";
668     }
669     GTEST_LOG_(INFO) << "ExtExtensionSubTest-end Ext_Extension_Sub_DoBackupBigFiles_Test_0100";
670 }
671 
672 /**
673  * @tc.number: Ext_Extension_Sub_MatchFiles_Test_0100
674  * @tc.name: Ext_Extension_Sub_MatchFiles_Test_0100
675  * @tc.desc: 测试MatchFiles
676  * @tc.size: MEDIUM
677  * @tc.type: FUNC
678  * @tc.level Level 1
679  * @tc.require: I9P3Y3
680  */
681 HWTEST_F(ExtExtensionSubTest, Ext_Extension_Sub_MatchFiles_Test_0100, testing::ext::TestSize.Level1)
682 {
683     GTEST_LOG_(INFO) << "ExtExtensionSubTest-begin Ext_Extension_Sub_MatchFiles_Test_0100";
684     try {
685         ASSERT_TRUE(extExtension != nullptr);
686         std::map<std::string, int> files = {{"", 1}, {"test2.log", 2}, {"test3.txt", 3}, {"test4", 4}};
687         std::vector<std::string> endExcludes {};
688         std::map<std::string, int> ret = extExtension->MatchFiles(files, endExcludes);
689         EXPECT_EQ(ret.size(), 4);
690 
691         endExcludes = {"*.txt"};
692         ret = extExtension->MatchFiles(files, endExcludes);
693         EXPECT_EQ(ret.size(), 3);
694     } catch (...) {
695         EXPECT_TRUE(false);
696         GTEST_LOG_(INFO) << "ExtExtensionSubTest-an exception occurred by construction.";
697     }
698     GTEST_LOG_(INFO) << "ExtExtensionSubTest-end Ext_Extension_Sub_MatchFiles_Test_0100";
699 }
700 
701 /**
702  * @tc.number: Ext_Extension_Sub_IfCloudSpecialRestore_Test_0100
703  * @tc.name: Ext_Extension_Sub_IfCloudSpecialRestore_Test_0100
704  * @tc.desc: 测试IfCloudSpecialRestore
705  * @tc.size: MEDIUM
706  * @tc.type: FUNC
707  * @tc.level Level 1
708  * @tc.require: I9P3Y3
709  */
710 HWTEST_F(ExtExtensionSubTest, Ext_Extension_Sub_IfCloudSpecialRestore_Test_0100, testing::ext::TestSize.Level1)
711 {
712     GTEST_LOG_(INFO) << "ExtExtensionSubTest-begin Ext_Extension_Sub_IfCloudSpecialRestore_Test_0100";
713     try {
714         ASSERT_TRUE(extExtension != nullptr);
715         std::string tarName = "test";
716         auto ret = extExtension->IfCloudSpecialRestore(tarName);
717         EXPECT_FALSE(ret);
718     } catch (...) {
719         EXPECT_TRUE(false);
720         GTEST_LOG_(INFO) << "ExtExtensionSubTest-an exception occurred by construction.";
721     }
722     GTEST_LOG_(INFO) << "ExtExtensionSubTest-end Ext_Extension_Sub_IfCloudSpecialRestore_Test_0100";
723 }
724 
725 /**
726  * @tc.number: Ext_Extension_Sub_CompareFiles_Test_0100
727  * @tc.name: Ext_Extension_Sub_CompareFiles_Test_0100
728  * @tc.desc: 测试CompareFiles
729  * @tc.size: MEDIUM
730  * @tc.type: FUNC
731  * @tc.level Level 1
732  * @tc.require: I9P3Y3
733  */
734 HWTEST_F(ExtExtensionSubTest, Ext_Extension_Sub_CompareFiles_Test_0100, testing::ext::TestSize.Level1)
735 {
736     GTEST_LOG_(INFO) << "ExtExtensionSubTest-begin Ext_Extension_Sub_CompareFiles_Test_0100";
737     try {
738         ASSERT_TRUE(extExtension != nullptr);
739         string actualPath1 = PATH + BUNDLE_NAME + FILE_NAME;
740         string actualPath2 = PATH + BUNDLE_NAME + "2.txt";
741         ReportFileInfo fileInfo1, fileInfo2, fileInfo3, fileInfo4, fileInfo5;
742         fileInfo1.filePath = "";
743         fileInfo2.filePath = "test2";
744         fileInfo2.isIncremental = true;
745         fileInfo2.isDir = true;
746         fileInfo3.filePath = actualPath1;
747         fileInfo3.isIncremental = true;
748         fileInfo4.filePath = actualPath2;
749         fileInfo4.isIncremental = true;
750         fileInfo4.size = BConstants::BIG_FILE_BOUNDARY + 1;
751         fileInfo5.filePath = "test5";
752         fileInfo5.isIncremental = true;
753         unordered_map<string, struct ReportFileInfo> localFilesInfo {{"test1", fileInfo1}, {"test2", fileInfo2},
754             {actualPath1, fileInfo3}, {actualPath2, fileInfo4}, {"test5", fileInfo5}};
755         unordered_map<string, struct ReportFileInfo> cloudFiles {{"test5", fileInfo5}};
756         vector<struct ReportFileInfo> allFiles, smallFiles, bigFiles;
757         extExtension->CompareFiles(allFiles, smallFiles, bigFiles, cloudFiles, localFilesInfo);
758         EXPECT_EQ(allFiles.size(), 4);
759         EXPECT_EQ(smallFiles.size(), 2);
760         EXPECT_EQ(bigFiles.size(), 1);
761     } catch (...) {
762         EXPECT_TRUE(false);
763         GTEST_LOG_(INFO) << "ExtExtensionSubTest-an exception occurred by construction.";
764     }
765     GTEST_LOG_(INFO) << "ExtExtensionSubTest-end Ext_Extension_Sub_CompareFiles_Test_0100";
766 }
767 
768 /**
769  * @tc.number: Ext_Extension_Sub_ReportOnProcessResultCallback_Test_0100
770  * @tc.name: Ext_Extension_Sub_ReportOnProcessResultCallback_Test_0100
771  * @tc.desc: 测试ReportOnProcessResultCallback
772  * @tc.size: MEDIUM
773  * @tc.type: FUNC
774  * @tc.level Level 1
775  * @tc.require: I9P3Y3
776  */
777 HWTEST_F(ExtExtensionSubTest, Ext_Extension_Sub_ReportOnProcessResultCallback_Test_0100, testing::ext::TestSize.Level1)
778 {
779     GTEST_LOG_(INFO) << "ExtExtensionSubTest-begin Ext_Extension_Sub_ReportOnProcessResultCallback_Test_0100";
780     try {
781         ASSERT_TRUE(extExtension != nullptr);
782         BackupRestoreScenario scenario = BackupRestoreScenario::FULL_BACKUP;
783         ErrCode errCode = BError(BError::Codes::OK).GetCode();
784         string processInfo = "";
785         extExtension->ReportOnProcessResultCallback(nullptr, scenario)(errCode, processInfo);
786 
787         auto ptr = wptr<BackupExtExtension>(extExtension);
788         extExtension->onProcessTimeout_.store(true);
789         extExtension->ReportOnProcessResultCallback(ptr, scenario)(errCode, processInfo);
790         EXPECT_FALSE(extExtension->onProcessTimeout_.load());
791 
792         extExtension->onProcessTimeoutCnt_.store(1);
793         extExtension->ReportOnProcessResultCallback(ptr, scenario)(errCode, processInfo);
794         EXPECT_EQ(extExtension->onProcessTimeoutCnt_.load(), 0);
795 
796         extExtension->onProcessTimeoutCnt_.store(0);
797         processInfo = "test";
798         extExtension->ReportOnProcessResultCallback(ptr, scenario)(errCode, processInfo);
799         EXPECT_EQ(extExtension->onProcessTimeoutCnt_.load(), 0);
800     } catch (...) {
801         EXPECT_TRUE(false);
802         GTEST_LOG_(INFO) << "ExtExtensionSubTest-an exception occurred by construction.";
803     }
804     GTEST_LOG_(INFO) << "ExtExtensionSubTest-end Ext_Extension_Sub_ReportOnProcessResultCallback_Test_0100";
805 }
806 
807 /**
808  * @tc.number: Ext_Extension_Sub_UpdateFileStat_Test_0100
809  * @tc.name: Ext_Extension_Sub_UpdateFileStat_Test_0100
810  * @tc.desc: 测试UpdateFileStat
811  * @tc.size: MEDIUM
812  * @tc.type: FUNC
813  * @tc.level Level 1
814  * @tc.require: I9P3Y3
815  */
816 HWTEST_F(ExtExtensionSubTest, Ext_Extension_Sub_UpdateFileStat_Test_0100, testing::ext::TestSize.Level1)
817 {
818     GTEST_LOG_(INFO) << "ExtExtensionSubTest-begin Ext_Extension_Sub_UpdateFileStat_Test_0100";
819     try {
820         ASSERT_TRUE(extExtension != nullptr);
821         string actualPath = PATH + BUNDLE_NAME + FILE_NAME;
822         extExtension->UpdateFileStat(actualPath, 0);
823     } catch (...) {
824         EXPECT_TRUE(false);
825         GTEST_LOG_(INFO) << "ExtExtensionSubTest-an exception occurred by construction.";
826     }
827     GTEST_LOG_(INFO) << "ExtExtensionSubTest-end Ext_Extension_Sub_UpdateFileStat_Test_0100";
828 }
829 
830 /**
831  * @tc.number: Ext_Extension_Sub_IfAllowToBackupRestore_Test_0100
832  * @tc.name: Ext_Extension_Sub_IfAllowToBackupRestore_Test_0100
833  * @tc.desc: 测试IfAllowToBackupRestore
834  * @tc.size: MEDIUM
835  * @tc.type: FUNC
836  * @tc.level Level 1
837  * @tc.require: I9P3Y3
838  */
839 HWTEST_F(ExtExtensionSubTest, Ext_Extension_Sub_IfAllowToBackupRestore_Test_0100, testing::ext::TestSize.Level1)
840 {
841     GTEST_LOG_(INFO) << "ExtExtensionSubTest-begin Ext_Extension_Sub_IfAllowToBackupRestore_Test_0100";
842     try {
843         ASSERT_TRUE(extExtension != nullptr);
844         auto extension = extExtension->extension_;
845         extExtension->extension_ = nullptr;
846         auto ret = extExtension->IfAllowToBackupRestore();
847         EXPECT_FALSE(ret);
848 
849         extExtension->extension_ = extension;
850         string usrConfig = "{\"allowToBackupRestore\":false}";
851         EXPECT_CALL(*extBackupMock, GetUsrConfig()).WillOnce(Return(usrConfig));
852         ret = extExtension->IfAllowToBackupRestore();
853         EXPECT_FALSE(ret);
854 
855         usrConfig = "{\"allowToBackupRestore\":true}";
856         EXPECT_CALL(*extBackupMock, GetUsrConfig()).WillOnce(Return(usrConfig));
857         ret = extExtension->IfAllowToBackupRestore();
858         EXPECT_TRUE(ret);
859     } catch (...) {
860         EXPECT_TRUE(false);
861         GTEST_LOG_(INFO) << "ExtExtensionSubTest-an exception occurred by construction.";
862     }
863     GTEST_LOG_(INFO) << "ExtExtensionSubTest-end Ext_Extension_Sub_IfAllowToBackupRestore_Test_0100";
864 }
865 
866 /**
867  * @tc.number: Ext_Extension_Sub_SetStagingPathProperties_Test_0100
868  * @tc.name: Ext_Extension_Sub_SetStagingPathProperties_Test_0100
869  * @tc.desc: 测试SetStagingPathProperties
870  * @tc.size: MEDIUM
871  * @tc.type: FUNC
872  * @tc.level Level 1
873  * @tc.require: I9P3Y3
874  */
875 HWTEST_F(ExtExtensionSubTest, Ext_Extension_Sub_SetStagingPathProperties_Test_0100, testing::ext::TestSize.Level1)
876 {
877     GTEST_LOG_(INFO) << "ExtExtensionSubTest-begin Ext_Extension_Sub_SetStagingPathProperties_Test_0100";
878     try {
879         ASSERT_TRUE(extExtension != nullptr);
880         auto ret = extExtension->SetStagingPathProperties();
881         EXPECT_TRUE(ret);
882 
883         string dirAct = string("rm -r ") + BUNDLE_BASE_DIR;
884         system(dirAct.c_str());
885         ret = extExtension->SetStagingPathProperties();
886         dirAct = string("mkdir -p ") + BUNDLE_BASE_DIR;
887         system(dirAct.c_str());
888         EXPECT_FALSE(ret);
889 
890         dirAct = string("rm -r ") + PATH_BUNDLE_BACKUP_HOME;
891         system(dirAct.c_str());
892         ret = extExtension->SetStagingPathProperties();
893         dirAct = string("mkdir -p ") + PATH_BUNDLE_BACKUP_HOME;
894         system(dirAct.c_str());
895         EXPECT_FALSE(ret);
896 
897         dirAct = string("rm -r ") + PATH_BUNDLE_BACKUP_HOME_EL1;
898         system(dirAct.c_str());
899         ret = extExtension->SetStagingPathProperties();
900         dirAct = string("mkdir -p ") + PATH_BUNDLE_BACKUP_HOME_EL1;
901         system(dirAct.c_str());
902         EXPECT_FALSE(ret);
903     } catch (...) {
904         EXPECT_TRUE(false);
905         GTEST_LOG_(INFO) << "ExtExtensionSubTest-an exception occurred by construction.";
906     }
907     GTEST_LOG_(INFO) << "ExtExtensionSubTest-end Ext_Extension_Sub_SetStagingPathProperties_Test_0100";
908 }
909 
910 /**
911  * @tc.number: Ext_Extension_Sub_UpdateFdSendRate_Test_0100
912  * @tc.name: Ext_Extension_Sub_UpdateFdSendRate_Test_0100
913  * @tc.desc: 测试UpdateFdSendRate
914  * @tc.size: MEDIUM
915  * @tc.type: FUNC
916  * @tc.level Level 1
917  * @tc.require: I9P3Y3
918  */
919 HWTEST_F(ExtExtensionSubTest, Ext_Extension_Sub_UpdateFdSendRate_Test_0100, testing::ext::TestSize.Level1)
920 {
921     GTEST_LOG_(INFO) << "ExtExtensionSubTest-begin Ext_Extension_Sub_UpdateFdSendRate_Test_0100";
922     try {
923         ASSERT_TRUE(extExtension != nullptr);
924         auto ret = extExtension->UpdateFdSendRate(BUNDLE_NAME, 0);
925         EXPECT_EQ(extExtension->sendRate_, 0);
926         EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode());
927 
928         ret = extExtension->UpdateFdSendRate(BUNDLE_NAME, 10);
929         EXPECT_EQ(extExtension->sendRate_, 10);
930         EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode());
931     } catch (...) {
932         EXPECT_TRUE(false);
933         GTEST_LOG_(INFO) << "ExtExtensionSubTest-an exception occurred by construction.";
934     }
935     GTEST_LOG_(INFO) << "ExtExtensionSubTest-end Ext_Extension_Sub_UpdateFdSendRate_Test_0100";
936 }
937 
938 /**
939  * @tc.number: Ext_Extension_Sub_GetBackupInfo_Test_0100
940  * @tc.name: Ext_Extension_Sub_GetBackupInfo_Test_0100
941  * @tc.desc: 测试GetBackupInfo
942  * @tc.size: MEDIUM
943  * @tc.type: FUNC
944  * @tc.level Level 1
945  * @tc.require: I9P3Y3
946  */
947 HWTEST_F(ExtExtensionSubTest, Ext_Extension_Sub_GetBackupInfo_Test_0100, testing::ext::TestSize.Level1)
948 {
949     GTEST_LOG_(INFO) << "ExtExtensionSubTest-begin Ext_Extension_Sub_GetBackupInfo_Test_0100";
950     try {
951         ASSERT_TRUE(extExtension != nullptr);
952         string result = "";
953         auto ext = extExtension->extension_;
954         extExtension->extension_ = nullptr;
955         auto ret = extExtension->GetBackupInfo(result);
956         EXPECT_EQ(ret, BError(BError::Codes::EXT_INVAL_ARG).GetCode());
957 
958         extExtension->extension_ = ext;
959         EXPECT_CALL(*extBackupMock, GetBackupInfo(_)).WillOnce(Return(BError(BError::Codes::EXT_INVAL_ARG).GetCode()));
960         ret = extExtension->GetBackupInfo(result);
961         EXPECT_EQ(ret, BError(BError::Codes::EXT_INVAL_ARG).GetCode());
962 
963         EXPECT_CALL(*extBackupMock, GetBackupInfo(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
964         ret = extExtension->GetBackupInfo(result);
965         EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode());
966     } catch (...) {
967         EXPECT_TRUE(false);
968         GTEST_LOG_(INFO) << "ExtExtensionSubTest-an exception occurred by construction.";
969     }
970     GTEST_LOG_(INFO) << "ExtExtensionSubTest-end Ext_Extension_Sub_GetBackupInfo_Test_0100";
971 }
972 
973 /**
974  * @tc.number: Ext_Extension_Sub_SyncCallJsOnProcessTask_Test_0100
975  * @tc.name: Ext_Extension_Sub_SyncCallJsOnProcessTask_Test_0100
976  * @tc.desc: 测试SyncCallJsOnProcessTask
977  * @tc.size: MEDIUM
978  * @tc.type: FUNC
979  * @tc.level Level 1
980  * @tc.require: I9P3Y3
981  */
982 HWTEST_F(ExtExtensionSubTest, Ext_Extension_Sub_SyncCallJsOnProcessTask_Test_0100, testing::ext::TestSize.Level1)
983 {
984     GTEST_LOG_(INFO) << "ExtExtensionSubTest-begin Ext_Extension_Sub_SyncCallJsOnProcessTask_Test_0100";
985     try {
986         ASSERT_TRUE(extExtension != nullptr);
987         auto obj = wptr<BackupExtExtension>(extExtension);
988         BackupRestoreScenario scenario = BackupRestoreScenario::FULL_BACKUP;
989         extExtension->stopCallJsOnProcess_.store(true);
990         extExtension->SyncCallJsOnProcessTask(obj, scenario);
991         EXPECT_TRUE(extExtension->stopCallJsOnProcess_.load());
992 
993         extExtension->stopCallJsOnProcess_.store(false);
994         extExtension->SyncCallJsOnProcessTask(nullptr, scenario);
995         EXPECT_FALSE(extExtension->stopCallJsOnProcess_.load());
996 
997         auto ext = extExtension->extension_;
998         extExtension->extension_ = nullptr;
999         extExtension->SyncCallJsOnProcessTask(obj, scenario);
1000         EXPECT_FALSE(extExtension->stopCallJsOnProcess_.load());
1001 
1002         extExtension->extension_ = ext;
1003         EXPECT_CALL(*extBackupMock, OnProcess(_)).WillOnce(Return(BError(BError::Codes::EXT_INVAL_ARG).GetCode()));
1004         extExtension->SyncCallJsOnProcessTask(obj, scenario);
1005         EXPECT_FALSE(extExtension->stopCallJsOnProcess_.load());
1006 
1007         EXPECT_CALL(*extBackupMock, OnProcess(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode()));
1008         extExtension->SyncCallJsOnProcessTask(obj, scenario);
1009         EXPECT_FALSE(extExtension->stopCallJsOnProcess_.load());
1010     } catch (...) {
1011         EXPECT_TRUE(false);
1012         GTEST_LOG_(INFO) << "ExtExtensionSubTest-an exception occurred by construction.";
1013     }
1014     GTEST_LOG_(INFO) << "ExtExtensionSubTest-end Ext_Extension_Sub_SyncCallJsOnProcessTask_Test_0100";
1015 }
1016 
1017 /**
1018  * @tc.number: Ext_Extension_Sub_IncreOnRestoreExCallback_Test_0100
1019  * @tc.name: Ext_Extension_Sub_IncreOnRestoreExCallback_Test_0100
1020  * @tc.desc: 测试IncreOnRestoreExCallback
1021  * @tc.size: MEDIUM
1022  * @tc.type: FUNC
1023  * @tc.level Level 1
1024  * @tc.require: I9P3Y3
1025  */
1026 HWTEST_F(ExtExtensionSubTest, Ext_Extension_Sub_IncreOnRestoreExCallback_Test_0100, testing::ext::TestSize.Level1)
1027 {
1028     GTEST_LOG_(INFO) << "ExtExtensionSubTest-begin Ext_Extension_Sub_IncreOnRestoreExCallback_Test_0100";
1029     try {
1030         ASSERT_TRUE(extExtension != nullptr);
1031         auto obj = wptr<BackupExtExtension>(extExtension);
1032         ErrCode errCode = BError(BError::Codes::OK).GetCode();
1033         string restoreRetInfo = "";
1034         extExtension->IncreOnRestoreExCallback(nullptr)(errCode, restoreRetInfo);
1035         EXPECT_EQ(restoreRetInfo, "");
1036 
1037         auto ext = extExtension->extension_;
1038         extExtension->extension_ = nullptr;
1039         extExtension->IncreOnRestoreExCallback(obj)(errCode, restoreRetInfo);
1040         EXPECT_EQ(restoreRetInfo, "");
1041 
1042         extExtension->extension_ = ext;
1043         extExtension->isExecAppDone_.store(true);
1044         extExtension->IncreOnRestoreExCallback(obj)(errCode, restoreRetInfo);
1045         EXPECT_TRUE(extExtension->isExecAppDone_.load());
1046 
1047         extExtension->isExecAppDone_.store(false);
1048         restoreRetInfo = "test";
1049         extExtension->IncreOnRestoreExCallback(obj)(errCode, restoreRetInfo);
1050         EXPECT_EQ(restoreRetInfo, "test");
1051 
1052         restoreRetInfo = "";
1053         extExtension->IncreOnRestoreExCallback(obj)(errCode, restoreRetInfo);
1054         EXPECT_EQ(restoreRetInfo, "");
1055 
1056         errCode = BError(BError::Codes::EXT_INVAL_ARG).GetCode();
1057         extExtension->IncreOnRestoreExCallback(obj)(errCode, restoreRetInfo);
1058         EXPECT_EQ(restoreRetInfo, "");
1059 
1060         restoreRetInfo = "test";
1061         extExtension->IncreOnRestoreExCallback(obj)(errCode, restoreRetInfo);
1062         EXPECT_EQ(restoreRetInfo, "test");
1063     } catch (...) {
1064         EXPECT_TRUE(false);
1065         GTEST_LOG_(INFO) << "ExtExtensionSubTest-an exception occurred by construction.";
1066     }
1067     GTEST_LOG_(INFO) << "ExtExtensionSubTest-end Ext_Extension_Sub_IncreOnRestoreExCallback_Test_0100";
1068 }
1069 
1070 /**
1071  * @tc.number: Ext_Extension_Sub_IncreOnRestoreCallback_Test_0100
1072  * @tc.name: Ext_Extension_Sub_IncreOnRestoreCallback_Test_0100
1073  * @tc.desc: 测试IncreOnRestoreCallback
1074  * @tc.size: MEDIUM
1075  * @tc.type: FUNC
1076  * @tc.level Level 1
1077  * @tc.require: I9P3Y3
1078  */
1079 HWTEST_F(ExtExtensionSubTest, Ext_Extension_Sub_IncreOnRestoreCallback_Test_0100, testing::ext::TestSize.Level1)
1080 {
1081     GTEST_LOG_(INFO) << "ExtExtensionSubTest-begin Ext_Extension_Sub_IncreOnRestoreCallback_Test_0100";
1082     try {
1083         ASSERT_TRUE(extExtension != nullptr);
1084         auto obj = wptr<BackupExtExtension>(extExtension);
1085         ErrCode errCode = BError(BError::Codes::OK).GetCode();
1086         string errMsg = "";
1087         extExtension->IncreOnRestoreCallback(nullptr)(errCode, errMsg);
1088         EXPECT_EQ(errMsg, "");
1089 
1090         extExtension->isExecAppDone_.store(true);
1091         extExtension->IncreOnRestoreCallback(obj)(errCode, errMsg);
1092         EXPECT_TRUE(extExtension->isExecAppDone_.load());
1093 
1094         extExtension->isExecAppDone_.store(false);
1095         errMsg = "test";
1096         extExtension->IncreOnRestoreCallback(obj)(errCode, errMsg);
1097         EXPECT_EQ(errMsg, "test");
1098 
1099         errMsg = "";
1100         extExtension->IncreOnRestoreCallback(obj)(errCode, errMsg);
1101         EXPECT_EQ(errMsg, "");
1102 
1103         errCode = BError(BError::Codes::EXT_INVAL_ARG).GetCode();
1104         extExtension->IncreOnRestoreCallback(obj)(errCode, errMsg);
1105         EXPECT_EQ(errMsg, "");
1106     } catch (...) {
1107         EXPECT_TRUE(false);
1108         GTEST_LOG_(INFO) << "ExtExtensionSubTest-an exception occurred by construction.";
1109     }
1110     GTEST_LOG_(INFO) << "ExtExtensionSubTest-end Ext_Extension_Sub_IncreOnRestoreCallback_Test_0100";
1111 }
1112 
1113 /**
1114  * @tc.number: Ext_Extension_Sub_OnBackupCallback_Test_0100
1115  * @tc.name: Ext_Extension_Sub_OnBackupCallback_Test_0100
1116  * @tc.desc: 测试OnBackupCallback
1117  * @tc.size: MEDIUM
1118  * @tc.type: FUNC
1119  * @tc.level Level 1
1120  * @tc.require: I9P3Y3
1121  */
1122 HWTEST_F(ExtExtensionSubTest, Ext_Extension_Sub_OnBackupCallback_Test_0100, testing::ext::TestSize.Level1)
1123 {
1124     GTEST_LOG_(INFO) << "ExtExtensionSubTest-begin Ext_Extension_Sub_OnBackupCallback_Test_0100";
1125     try {
1126         ASSERT_TRUE(extExtension != nullptr);
1127         auto obj = wptr<BackupExtExtension>(extExtension);
1128         ErrCode errCode = BError(BError::Codes::OK).GetCode();
1129         string errMsg = "";
1130         extExtension->OnBackupCallback(nullptr)(errCode, errMsg);
1131         EXPECT_EQ(errMsg, "");
1132 
1133         auto ext = extExtension->extension_;
1134         extExtension->extension_ = nullptr;
1135         extExtension->OnBackupCallback(obj)(errCode, errMsg);
1136         EXPECT_EQ(errMsg, "");
1137 
1138         extExtension->extension_ = ext;
1139         extExtension->isExecAppDone_.store(true);
1140         extExtension->OnBackupCallback(obj)(errCode, errMsg);
1141         EXPECT_TRUE(extExtension->isExecAppDone_.load());
1142 
1143         extExtension->isExecAppDone_.store(false);
1144         errMsg = "test";
1145         string usrConfig = "{\"allowToBackupRestore\":true}";
1146         EXPECT_CALL(*extBackupMock, GetUsrConfig()).WillOnce(Return(usrConfig));
1147         extExtension->OnBackupCallback(obj)(errCode, errMsg);
1148         EXPECT_EQ(errMsg, "test");
1149 
1150         errCode = BError(BError::Codes::EXT_INVAL_ARG).GetCode();
1151         extExtension->OnBackupCallback(obj)(errCode, errMsg);
1152         EXPECT_EQ(errMsg, "test");
1153 
1154         errMsg = "";
1155         extExtension->OnBackupCallback(obj)(errCode, errMsg);
1156         EXPECT_EQ(errMsg, "");
1157     } catch (...) {
1158         EXPECT_TRUE(false);
1159         GTEST_LOG_(INFO) << "ExtExtensionSubTest-an exception occurred by construction.";
1160     }
1161     GTEST_LOG_(INFO) << "ExtExtensionSubTest-end Ext_Extension_Sub_OnBackupCallback_Test_0100";
1162 }
1163 
1164 /**
1165  * @tc.number: Ext_Extension_Sub_OnBackupExCallback_Test_0100
1166  * @tc.name: Ext_Extension_Sub_OnBackupExCallback_Test_0100
1167  * @tc.desc: 测试OnBackupExCallback
1168  * @tc.size: MEDIUM
1169  * @tc.type: FUNC
1170  * @tc.level Level 1
1171  * @tc.require: I9P3Y3
1172  */
1173 HWTEST_F(ExtExtensionSubTest, Ext_Extension_Sub_OnBackupExCallback_Test_0100, testing::ext::TestSize.Level1)
1174 {
1175     GTEST_LOG_(INFO) << "ExtExtensionSubTest-begin Ext_Extension_Sub_OnBackupExCallback_Test_0100";
1176     try {
1177         ASSERT_TRUE(extExtension != nullptr);
1178         auto obj = wptr<BackupExtExtension>(extExtension);
1179         ErrCode errCode = BError(BError::Codes::OK).GetCode();
1180         string errMsg = "";
1181         extExtension->OnBackupExCallback(nullptr)(errCode, errMsg);
1182         EXPECT_EQ(errMsg, "");
1183 
1184         auto ext = extExtension->extension_;
1185         extExtension->extension_ = nullptr;
1186         extExtension->OnBackupExCallback(obj)(errCode, errMsg);
1187         EXPECT_EQ(errMsg, "");
1188 
1189         extExtension->extension_ = ext;
1190         extExtension->isExecAppDone_.store(true);
1191         extExtension->OnBackupExCallback(obj)(errCode, errMsg);
1192         EXPECT_TRUE(extExtension->isExecAppDone_.load());
1193 
1194         extExtension->isExecAppDone_.store(false);
1195         errMsg = "test";
1196         string usrConfig = "{\"allowToBackupRestore\":true}";
1197         EXPECT_CALL(*extBackupMock, GetUsrConfig()).WillOnce(Return(usrConfig));
1198         extExtension->OnBackupExCallback(obj)(errCode, errMsg);
1199         EXPECT_EQ(errMsg, "test");
1200 
1201         errMsg = "";
1202         extExtension->OnBackupExCallback(obj)(errCode, errMsg);
1203         EXPECT_EQ(errMsg, "");
1204 
1205         errCode = BError(BError::Codes::EXT_INVAL_ARG).GetCode();
1206         extExtension->OnBackupExCallback(obj)(errCode, errMsg);
1207         EXPECT_EQ(errMsg, "");
1208 
1209         errMsg = "test";
1210         extExtension->OnBackupExCallback(obj)(errCode, errMsg);
1211         EXPECT_EQ(errMsg, "test");
1212     } catch (...) {
1213         EXPECT_TRUE(false);
1214         GTEST_LOG_(INFO) << "ExtExtensionSubTest-an exception occurred by construction.";
1215     }
1216     GTEST_LOG_(INFO) << "ExtExtensionSubTest-end Ext_Extension_Sub_OnBackupExCallback_Test_0100";
1217 }
1218 
1219 /**
1220  * @tc.number: Ext_Extension_Sub_IncOnBackupCallback_Test_0100
1221  * @tc.name: Ext_Extension_Sub_IncOnBackupCallback_Test_0100
1222  * @tc.desc: 测试IncOnBackupCallback
1223  * @tc.size: MEDIUM
1224  * @tc.type: FUNC
1225  * @tc.level Level 1
1226  * @tc.require: I9P3Y3
1227  */
1228 HWTEST_F(ExtExtensionSubTest, Ext_Extension_Sub_IncOnBackupCallback_Test_0100, testing::ext::TestSize.Level1)
1229 {
1230     GTEST_LOG_(INFO) << "ExtExtensionSubTest-begin Ext_Extension_Sub_IncOnBackupCallback_Test_0100";
1231     try {
1232         ASSERT_TRUE(extExtension != nullptr);
1233         auto obj = wptr<BackupExtExtension>(extExtension);
1234         ErrCode errCode = BError(BError::Codes::OK).GetCode();
1235         string errMsg = "";
1236         extExtension->IncOnBackupCallback(nullptr)(errCode, errMsg);
1237         EXPECT_EQ(errMsg, "");
1238 
1239         extExtension->isExecAppDone_.store(true);
1240         extExtension->IncOnBackupCallback(obj)(errCode, errMsg);
1241         EXPECT_TRUE(extExtension->isExecAppDone_.load());
1242 
1243         extExtension->isExecAppDone_.store(false);
1244         errMsg = "test";
1245         extExtension->IncOnBackupCallback(obj)(errCode, errMsg);
1246         EXPECT_EQ(errMsg, "test");
1247 
1248         errCode = BError(BError::Codes::EXT_INVAL_ARG).GetCode();
1249         extExtension->IncOnBackupCallback(obj)(errCode, errMsg);
1250         EXPECT_EQ(errMsg, "test");
1251 
1252         errMsg = "";
1253         extExtension->IncOnBackupCallback(obj)(errCode, errMsg);
1254         EXPECT_EQ(errMsg, "");
1255     } catch (...) {
1256         EXPECT_TRUE(false);
1257         GTEST_LOG_(INFO) << "ExtExtensionSubTest-an exception occurred by construction.";
1258     }
1259     GTEST_LOG_(INFO) << "ExtExtensionSubTest-end Ext_Extension_Sub_IncOnBackupCallback_Test_0100";
1260 }
1261 
1262 /**
1263  * @tc.number: Ext_Extension_Sub_IncOnBackupExCallback_Test_0100
1264  * @tc.name: Ext_Extension_Sub_IncOnBackupExCallback_Test_0100
1265  * @tc.desc: 测试IncOnBackupExCallback
1266  * @tc.size: MEDIUM
1267  * @tc.type: FUNC
1268  * @tc.level Level 1
1269  * @tc.require: I9P3Y3
1270  */
1271 HWTEST_F(ExtExtensionSubTest, Ext_Extension_Sub_IncOnBackupExCallback_Test_0100, testing::ext::TestSize.Level1)
1272 {
1273     GTEST_LOG_(INFO) << "ExtExtensionSubTest-begin Ext_Extension_Sub_IncOnBackupExCallback_Test_0100";
1274     try {
1275         ASSERT_TRUE(extExtension != nullptr);
1276         auto obj = wptr<BackupExtExtension>(extExtension);
1277         ErrCode errCode = BError(BError::Codes::OK).GetCode();
1278         string errMsg = "";
1279         extExtension->IncOnBackupExCallback(nullptr)(errCode, errMsg);
1280         EXPECT_EQ(errMsg, "");
1281 
1282         auto ext = extExtension->extension_;
1283         extExtension->extension_ = nullptr;
1284         extExtension->IncOnBackupExCallback(obj)(errCode, errMsg);
1285         EXPECT_EQ(errMsg, "");
1286 
1287         extExtension->extension_ = ext;
1288         extExtension->isExecAppDone_.store(true);
1289         extExtension->IncOnBackupExCallback(obj)(errCode, errMsg);
1290         EXPECT_TRUE(extExtension->isExecAppDone_.load());
1291 
1292         extExtension->isExecAppDone_.store(false);
1293         errMsg = "test";
1294         extExtension->IncOnBackupExCallback(obj)(errCode, errMsg);
1295         EXPECT_EQ(errMsg, "test");
1296 
1297         errMsg = "";
1298         extExtension->IncOnBackupExCallback(obj)(errCode, errMsg);
1299         EXPECT_EQ(errMsg, "");
1300 
1301         errCode = BError(BError::Codes::EXT_INVAL_ARG).GetCode();
1302         extExtension->IncOnBackupExCallback(obj)(errCode, errMsg);
1303         EXPECT_EQ(errMsg, "");
1304 
1305         errMsg = "test";
1306         extExtension->IncOnBackupExCallback(obj)(errCode, errMsg);
1307         EXPECT_EQ(errMsg, "test");
1308     } catch (...) {
1309         EXPECT_TRUE(false);
1310         GTEST_LOG_(INFO) << "ExtExtensionSubTest-an exception occurred by construction.";
1311     }
1312     GTEST_LOG_(INFO) << "ExtExtensionSubTest-end Ext_Extension_Sub_IncOnBackupExCallback_Test_0100";
1313 }
1314 }