From 8dd03d07f9e2f5d73180c36d968076575d5326a9 Mon Sep 17 00:00:00 2001 From: lizhengxing Date: Fri, 11 Jul 2025 18:53:56 +0800 Subject: [PATCH] add ut sub extension2 Signed-off-by: lizhengxing --- .../backup_ext/include/ext_extension_mock.h | 16 + .../backup_ext/src/ext_extension_mock.cpp | 16 + tests/unittests/backup_ext/BUILD.gn | 2 + .../backup_ext/ext_extension_sub_test.cpp | 324 +++++++++++++++++- 4 files changed, 345 insertions(+), 13 deletions(-) diff --git a/tests/mock/backup_ext/include/ext_extension_mock.h b/tests/mock/backup_ext/include/ext_extension_mock.h index bff5767cd..6f2058470 100644 --- a/tests/mock/backup_ext/include/ext_extension_mock.h +++ b/tests/mock/backup_ext/include/ext_extension_mock.h @@ -63,6 +63,7 @@ public: virtual void DoClearInner() = 0; virtual void StartFwkTimer(bool &isFwkStart) = 0; virtual ErrCode CleanBundleTempDir() = 0; + virtual void AsyncTaskIncreRestoreSpecialVersion() = 0; public: BExtExtension() = default; virtual ~BExtExtension() = default; @@ -103,6 +104,21 @@ public: MOCK_METHOD(ErrCode, IncrementalBigFileReady, (TarMap&, const std::vector&, sptr)); MOCK_METHOD(ErrCode, CleanBundleTempDir, ()); + MOCK_METHOD((std::tuple), GetIncrementalFileHandle, + (const string &)); + MOCK_METHOD(ErrCode, GetFileHandleWithUniqueFd, (const std::string &, int32_t &, int&)); + MOCK_METHOD(std::string, GetBackupInfo, ()); + MOCK_METHOD(void, UpdateOnStartTime, ()); + MOCK_METHOD(ErrCode, IncrementalTarFileReady, (const TarMap &, const vector &, + sptr)); + MOCK_METHOD(void, ReportAppStatistic, (const std::string &, ErrCode)); + MOCK_METHOD(ErrCode, IncrementalAllFileReady, (const TarMap &, const vector &, + sptr)); + MOCK_METHOD(void, VerifyCaller, ()); + MOCK_METHOD((std::function), ReportErrFileByProc, (wptr, + BackupRestoreScenario)); + MOCK_METHOD(void, DoClearInner, ()); + MOCK_METHOD(void, StartFwkTimer, (bool &)); }; } // namespace OHOS::FileManagement::Backup #endif // OHOS_FILEMGMT_BACKUP_EXT_EXTENSION_MOCK_H \ No newline at end of file diff --git a/tests/mock/backup_ext/src/ext_extension_mock.cpp b/tests/mock/backup_ext/src/ext_extension_mock.cpp index 16b750556..d409d47a4 100644 --- a/tests/mock/backup_ext/src/ext_extension_mock.cpp +++ b/tests/mock/backup_ext/src/ext_extension_mock.cpp @@ -20,6 +20,7 @@ namespace OHOS::FileManagement::Backup { using namespace std; void BackupExtExtension::VerifyCaller() { + BExtExtension::extExtension->VerifyCaller(); } UniqueFd BackupExtExtension::GetFileHandle(const string &fileName, int32_t &errCode) @@ -77,40 +78,49 @@ int BackupExtExtension::DoIncrementalRestore() void BackupExtExtension::AsyncTaskBackup(const string config) { + BExtExtension::extExtension->AsyncTaskBackup(config); } void BackupExtExtension::AsyncTaskRestore(std::set fileSet, const std::vector extManageInfo) { + BExtExtension::extExtension->AsyncTaskRestore(fileSet, extManageInfo); } void BackupExtExtension::AsyncTaskIncrementalRestore() { + BExtExtension::extExtension->AsyncTaskIncrementalRestore(); } void BackupExtExtension::AsyncTaskIncreRestoreSpecialVersion() { + BExtExtension::extExtension->AsyncTaskIncreRestoreSpecialVersion(); } void BackupExtExtension::AsyncTaskIncrementalRestoreForUpgrade() { + BExtExtension::extExtension->AsyncTaskIncrementalRestoreForUpgrade(); } void BackupExtExtension::DoClear() { + BExtExtension::extExtension->DoClear(); } void BackupExtExtension::AppDone(ErrCode errCode) { + BExtExtension::extExtension->AppDone(errCode); } void BackupExtExtension::AppResultReport(const std::string restoreRetInfo, BackupRestoreScenario scenario, ErrCode errCode) { + BExtExtension::extExtension->AppResultReport(restoreRetInfo, scenario, errCode); } void BackupExtExtension::AsyncTaskOnBackup() { + BExtExtension::extExtension->AsyncTaskOnBackup(); } ErrCode BackupExtExtension::HandleRestore(bool isClearData) @@ -126,6 +136,7 @@ ErrCode BackupExtExtension::IncrementalBigFileReady(TarMap &pkgInfo, void BackupExtExtension::StartFwkTimer(bool &isFwkStart) { + BExtExtension::extExtension->StartFwkTimer(isFwkStart); } ErrCode BackupExtExtension::GetFileHandleWithUniqueFd(const std::string &fileName, int32_t &errCode, int& fd) @@ -139,14 +150,18 @@ void BackupExtExtension::FillFileInfos(UniqueFd incrementalFd, vector &smallFiles, vector &bigFiles) { + BExtExtension::extExtension->FillFileInfos(move(incrementalFd), move(manifestFd), allFiles, + smallFiles, bigFiles); } void BackupExtExtension::ReportAppStatistic(const std::string &func, ErrCode errCode) { + BExtExtension::extExtension->ReportAppStatistic(func, errCode); } void BackupExtExtension::UpdateOnStartTime() { + BExtExtension::extExtension->UpdateOnStartTime(); } ErrCode BackupExtExtension::IncrementalTarFileReady(const TarMap &bigFileInfo, @@ -169,6 +184,7 @@ std::function BackupExtExtension::ReportErrFileByProc(wp void BackupExtExtension::DoClearInner() { + BExtExtension::extExtension->DoClearInner(); } ErrCode BackupExtExtension::CleanBundleTempDir() diff --git a/tests/unittests/backup_ext/BUILD.gn b/tests/unittests/backup_ext/BUILD.gn index 0e44de2a6..ed59b5e9a 100644 --- a/tests/unittests/backup_ext/BUILD.gn +++ b/tests/unittests/backup_ext/BUILD.gn @@ -509,6 +509,8 @@ ohos_unittest("ext_extension_sub_test") { "${path_backup}/tests/mock/backup_kit_inner/service_proxy_mock.cpp", "${path_backup}/tests/mock/utils_mock/src/utils_mock_global_variable.cpp", "${path_backup}/tests/utils/src/test_manager.cpp", + "${path_backup}/frameworks/native/backup_ext/src/tar_file.cpp", + "${path_backup}/frameworks/native/backup_ext/src/untar_file.cpp", "ext_extension_sub_test.cpp", ] diff --git a/tests/unittests/backup_ext/ext_extension_sub_test.cpp b/tests/unittests/backup_ext/ext_extension_sub_test.cpp index 2cc8137db..9a3c76695 100644 --- a/tests/unittests/backup_ext/ext_extension_sub_test.cpp +++ b/tests/unittests/backup_ext/ext_extension_sub_test.cpp @@ -13,6 +13,7 @@ * limitations under the License. */ +#include #include #include #include @@ -20,7 +21,6 @@ #include #include #include -#include #include @@ -28,8 +28,9 @@ #include "b_error/b_excep_utils.h" #include "ext_backup_mock.h" #include "ext_extension_mock.h" +#include "tar_file.h" +#include "untar_file.h" -#include "tar_file.cpp" #include "sub_ext_extension.cpp" namespace OHOS::FileManagement::Backup { @@ -61,6 +62,7 @@ public: static inline sptr extExtension = nullptr; static inline shared_ptr extension = nullptr; static inline shared_ptr extBackupMock = nullptr; + static inline shared_ptr extExtensionMock = nullptr; }; void ExtExtensionSubTest::SetUpTestCase(void) @@ -82,10 +84,15 @@ void ExtExtensionSubTest::SetUpTestCase(void) system(touchFile.c_str()); string touchFile2 = string("touch ") + PATH + BUNDLE_NAME + "2.txt"; system(touchFile2.c_str()); + string touchFile3 = string("touch ") + PATH + BUNDLE_NAME + TAR_FILE; + system(touchFile3.c_str()); extBackupMock = make_shared(); ExtBackupMock::extBackup = extBackupMock; + extExtensionMock = make_shared(); + ExtExtensionMock::extExtension = extExtensionMock; + extExtension = sptr(new BackupExtExtension( nullptr, BUNDLE_NAME)); extension = make_shared(); @@ -98,35 +105,34 @@ void ExtExtensionSubTest::TearDownTestCase(void) string rmDir = string("rm -r ") + PATH + BUNDLE_NAME; system(rmDir.c_str()); - rmDir = string("rm -r ") + BUNDLE_BASE_DIR; - system(rmDir.c_str()); - - rmDir = string("rm -r ") + PATH_BUNDLE_BACKUP_HOME_EL1; + rmDir = string("rm -r ") + "/data/storage/el2/"; system(rmDir.c_str()); - rmDir = string("rm -r ") + PATH_BUNDLE_BACKUP_HOME; + rmDir = string("rm -r ") + "/data/storage/el1/"; system(rmDir.c_str()); extension = nullptr; extExtension = nullptr; ExtBackupMock::extBackup = nullptr; extBackupMock = nullptr; + ExtExtensionMock::extExtension = nullptr; + extExtensionMock = nullptr; }; /** - * @tc.number: Ext_Extension_Sub_Test_0001 - * @tc.name: Ext_Extension_Sub_Test_0001 + * @tc.number: Ext_Extension_Sub_SetClearDataFlag_Test_0100 + * @tc.name: Ext_Extension_Sub_SetClearDataFlag_Test_0100 * @tc.desc: 测试SetClearDataFlag * @tc.size: MEDIUM * @tc.type: FUNC * @tc.level Level 1 * @tc.require: I9P3Y3 */ -HWTEST_F(ExtExtensionSubTest, Ext_Extension_Sub_Test_0001, testing::ext::TestSize.Level1) +HWTEST_F(ExtExtensionSubTest, Ext_Extension_Sub_SetClearDataFlag_Test_0100, testing::ext::TestSize.Level1) { - GTEST_LOG_(INFO) << "ExtExtensionSubTest-begin Ext_Extension_Sub_Test_0001"; + GTEST_LOG_(INFO) << "ExtExtensionSubTest-begin Ext_Extension_Sub_SetClearDataFlag_Test_0100"; try { - EXPECT_TRUE(extExtension != nullptr); + ASSERT_TRUE(extExtension != nullptr); extExtension->SetClearDataFlag(true); EXPECT_TRUE(extExtension->isClearData_ == true); @@ -139,7 +145,295 @@ HWTEST_F(ExtExtensionSubTest, Ext_Extension_Sub_Test_0001, testing::ext::TestSiz EXPECT_TRUE(false); GTEST_LOG_(INFO) << "ExtExtensionSubTest-an exception occurred by construction."; } - GTEST_LOG_(INFO) << "ExtExtensionSubTest-end Ext_Extension_Sub_Test_0001"; + GTEST_LOG_(INFO) << "ExtExtensionSubTest-end Ext_Extension_Sub_SetClearDataFlag_Test_0100"; +} + +/** + * @tc.number: Ext_Extension_Sub_HandleIncrementalBackup_Test_0100 + * @tc.name: Ext_Extension_Sub_HandleIncrementalBackup_Test_0100 + * @tc.desc: 测试HandleIncrementalBackup + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: I9P3Y3 + */ +HWTEST_F(ExtExtensionSubTest, Ext_Extension_Sub_HandleIncrementalBackup_Test_0100, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "ExtExtensionSubTest-begin Ext_Extension_Sub_HandleIncrementalBackup_Test_0100"; + try { + ASSERT_TRUE(extExtension != nullptr); + string incrementalFile = PATH + BUNDLE_NAME + "2.txt"; + int incrementalFd = open(incrementalFile.data(), O_RDWR | O_TRUNC, S_IRWXU); + EXPECT_GT(incrementalFd, 0); + string manifestFile = PATH + BUNDLE_NAME + FILE_NAME; + int manifestFd = open(manifestFile.data(), O_RDWR | O_TRUNC, S_IRWXU); + EXPECT_GT(manifestFd, 0); + + EXPECT_EQ(extExtension->HandleIncrementalBackup(incrementalFd, manifestFd), BError::E_FORBID); + close(incrementalFd); + close(manifestFd); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "ExtExtensionSubTest-an exception occurred by construction."; + } + GTEST_LOG_(INFO) << "ExtExtensionSubTest-end Ext_Extension_Sub_HandleIncrementalBackup_Test_0100"; +} + +/** + * @tc.number: Ext_Extension_Sub_IncrementalOnBackup_Test_0100 + * @tc.name: Ext_Extension_Sub_IncrementalOnBackup_Test_0100 + * @tc.desc: 测试IncrementalOnBackup + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: I9P3Y3 + */ +HWTEST_F(ExtExtensionSubTest, Ext_Extension_Sub_IncrementalOnBackup_Test_0100, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "ExtExtensionSubTest-begin Ext_Extension_Sub_IncrementalOnBackup_Test_0100"; + try { + ASSERT_TRUE(extExtension != nullptr); + EXPECT_EQ(extExtension->IncrementalOnBackup(false), BError::E_FORBID); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "ExtExtensionSubTest-an exception occurred by construction."; + } + GTEST_LOG_(INFO) << "ExtExtensionSubTest-end Ext_Extension_Sub_IncrementalOnBackup_Test_0100"; +} + +/** + * @tc.number: Ext_Extension_Sub_WaitToSendFd_Test_0100 + * @tc.name: Ext_Extension_Sub_WaitToSendFd_Test_0100 + * @tc.desc: 测试WaitToSendFd + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: I9P3Y3 + */ +HWTEST_F(ExtExtensionSubTest, Ext_Extension_Sub_WaitToSendFd_Test_0100, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "ExtExtensionSubTest-begin Ext_Extension_Sub_WaitToSendFd_Test_0100"; + try { + ASSERT_TRUE(extExtension != nullptr); + auto startTime = std::chrono::system_clock::now(); + int fdSendNum = 61; + extExtension->WaitToSendFd(startTime, fdSendNum); + EXPECT_EQ(fdSendNum, 0); + fdSendNum = 1; + extExtension->WaitToSendFd(startTime, fdSendNum); + EXPECT_EQ(fdSendNum, 1); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "ExtExtensionSubTest-an exception occurred by construction."; + } + GTEST_LOG_(INFO) << "ExtExtensionSubTest-end Ext_Extension_Sub_WaitToSendFd_Test_0100"; +} + +/** + * @tc.number: Ext_Extension_Sub_RefreshTimeInfo_Test_0100 + * @tc.name: Ext_Extension_Sub_RefreshTimeInfo_Test_0100 + * @tc.desc: 测试RefreshTimeInfo + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: I9P3Y3 + */ +HWTEST_F(ExtExtensionSubTest, Ext_Extension_Sub_RefreshTimeInfo_Test_0100, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "ExtExtensionSubTest-begin Ext_Extension_Sub_RefreshTimeInfo_Test_0100"; + try { + ASSERT_TRUE(extExtension != nullptr); + auto startTime = std::chrono::system_clock::now(); + int fdSendNum = 1; + extExtension->RefreshTimeInfo(startTime, fdSendNum); + EXPECT_EQ(fdSendNum, 1); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "ExtExtensionSubTest-an exception occurred by construction."; + } + GTEST_LOG_(INFO) << "ExtExtensionSubTest-end Ext_Extension_Sub_RefreshTimeInfo_Test_0100"; +} + +/** + * @tc.number: Ext_Extension_Sub_GetBundlePath_Test_0100 + * @tc.name: Ext_Extension_Sub_GetBundlePath_Test_0100 + * @tc.desc: 测试GetBundlePath + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: I9P3Y3 + */ +HWTEST_F(ExtExtensionSubTest, Ext_Extension_Sub_GetBundlePath_Test_0100, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "ExtExtensionSubTest-begin Ext_Extension_Sub_GetBundlePath_Test_0100"; + try { + ASSERT_TRUE(extExtension != nullptr); + auto path = string(BConstants::PATH_BUNDLE_BACKUP_HOME).append(BConstants::SA_BUNDLE_BACKUP_RESTORE); + auto ret = extExtension->GetBundlePath(); + EXPECT_EQ(ret, path); + + extExtension->bundleName_ = BConstants::BUNDLE_FILE_MANAGER; + path = string(BConstants::PATH_FILEMANAGE_BACKUP_HOME).append(BConstants::SA_BUNDLE_BACKUP_RESTORE); + ret = extExtension->GetBundlePath(); + EXPECT_EQ(ret, path); + + extExtension->bundleName_ = BConstants::BUNDLE_MEDIAL_DATA; + path = string(BConstants::PATH_MEDIALDATA_BACKUP_HOME).append(BConstants::SA_BUNDLE_BACKUP_RESTORE); + ret = extExtension->GetBundlePath(); + EXPECT_EQ(ret, path); + extExtension->bundleName_ = BUNDLE_NAME; + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "ExtExtensionSubTest-an exception occurred by construction."; + } + GTEST_LOG_(INFO) << "ExtExtensionSubTest-end Ext_Extension_Sub_GetBundlePath_Test_0100"; +} + +/** + * @tc.number: Ext_Extension_Sub_CheckRstoreFileInfos_Test_0100 + * @tc.name: Ext_Extension_Sub_CheckRstoreFileInfos_Test_0100 + * @tc.desc: 测试CheckRstoreFileInfos + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: I9P3Y3 + */ +HWTEST_F(ExtExtensionSubTest, Ext_Extension_Sub_CheckRstoreFileInfos_Test_0100, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "ExtExtensionSubTest-begin Ext_Extension_Sub_CheckRstoreFileInfos_Test_0100"; + try { + ASSERT_TRUE(extExtension != nullptr); + tuple> result; + string tarName = PATH_BUNDLE_BACKUP_HOME + "/part0.tar"; + string untarPath = PATH_BUNDLE_BACKUP_HOME; + + result = extExtension->CheckRestoreFileInfos(); + EXPECT_EQ(std::get<0>(result), true); + + auto [err, fileInfos, errInfos] = UntarFile::GetInstance().UnPacket(tarName, untarPath); + extExtension->endFileInfos_[tarName] = 1; + extExtension->endFileInfos_.merge(fileInfos); + + result = extExtension->CheckRestoreFileInfos(); + EXPECT_EQ(std::get<0>(result), false); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "ExtExtensionSubTest-an exception occurred by construction."; + } + GTEST_LOG_(INFO) << "ExtExtensionSubTest-end Ext_Extension_Sub_CheckRstoreFileInfos_Test_0100"; +} + +/** + * @tc.number: Ext_Extension_Sub_OnRestoreCallback_Test_0100 + * @tc.name: Ext_Extension_Sub_OnRestoreCallback_Test_0100 + * @tc.desc: 测试OnRestoreCallback + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: I9P3Y3 + */ +HWTEST_F(ExtExtensionSubTest, Ext_Extension_Sub_OnRestoreCallback_Test_0100, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "ExtExtensionSubTest-begin Ext_Extension_Sub_OnRestoreCallback_Test_0100"; + try { + ErrCode errCode = 0; + string errMsg = ""; + + ASSERT_TRUE(extExtension != nullptr); + extExtension->SetClearDataFlag(false); + std::function restoreCallBack = extExtension->OnRestoreCallback(nullptr); + restoreCallBack(errCode, errMsg); + EXPECT_EQ(errMsg, ""); + + errMsg = "err"; + extExtension->isExecAppDone_.store(true); + restoreCallBack = extExtension->OnRestoreCallback(extExtension); + restoreCallBack(errCode, errMsg); + extExtension->isExecAppDone_.store(false); + EXPECT_EQ(errMsg, "err"); + + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "ExtExtensionSubTest-an exception occurred by construction."; + } + GTEST_LOG_(INFO) << "ExtExtensionSubTest-end Ext_Extension_Sub_OnRestoreCallback_Test_0100"; +} + +/** + * @tc.number: Ext_Extension_Sub_OnRestoreExCallback_Test_0100 + * @tc.name: Ext_Extension_Sub_OnRestoreExCallback_Test_0100 + * @tc.desc: 测试OnRestoreExCallback + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: I9P3Y3 + */ +HWTEST_F(ExtExtensionSubTest, Ext_Extension_Sub_OnRestoreExCallback_Test_0100, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "ExtExtensionSubTest-begin Ext_Extension_Sub_OnRestoreExCallback_Test_0100"; + try { + ErrCode errCode = 0; + string restoreRetInfo = ""; + + ASSERT_TRUE(extExtension != nullptr); + extExtension->SetClearDataFlag(false); + std::function restoreCallBack = extExtension->OnRestoreExCallback(nullptr); + restoreCallBack(errCode, restoreRetInfo); + EXPECT_EQ(restoreRetInfo, ""); + + restoreRetInfo = ""; + restoreCallBack = extExtension->OnRestoreExCallback(extExtension); + extExtension->extension_ = nullptr; + restoreCallBack(errCode, restoreRetInfo); + extExtension->extension_ = extension; + EXPECT_EQ(restoreRetInfo, ""); + + restoreRetInfo = "err"; + extExtension->isExecAppDone_.store(true); + restoreCallBack = extExtension->OnRestoreExCallback(extExtension); + restoreCallBack(errCode, restoreRetInfo); + extExtension->isExecAppDone_.store(false); + EXPECT_EQ(restoreRetInfo, "err"); + + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "ExtExtensionSubTest-an exception occurred by construction."; + } + GTEST_LOG_(INFO) << "ExtExtensionSubTest-end Ext_Extension_Sub_OnRestoreExCallback_Test_0100"; +} + +/** + * @tc.number: Ext_Extension_Sub_AppDoneCallbackEx_Test_0100 + * @tc.name: Ext_Extension_Sub_AppDoneCallbackEx_Test_0100 + * @tc.desc: 测试AppDoneCallbackEx + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: I9P3Y3 + */ +HWTEST_F(ExtExtensionSubTest, Ext_Extension_Sub_AppDoneCallbackEx_Test_0100, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "ExtExtensionSubTest-begin Ext_Extension_Sub_AppDoneCallbackEx_Test_0100"; + try { + ErrCode errCode = 0; + string errMessage = ""; + + ASSERT_TRUE(extExtension != nullptr); + extExtension->SetClearDataFlag(false); + std::function restoreCallBack = extExtension->AppDoneCallbackEx(nullptr); + restoreCallBack(errCode, errMessage); + EXPECT_EQ(errMessage, ""); + + restoreCallBack = extExtension->AppDoneCallbackEx(extExtension); + restoreCallBack(errCode, errMessage); + extExtension->extension_ = extension; + EXPECT_EQ(errMessage, ""); + + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "ExtExtensionSubTest-an exception occurred by construction."; + } + GTEST_LOG_(INFO) << "ExtExtensionSubTest-end Ext_Extension_Sub_AppDoneCallbackEx_Test_0100"; } /** @@ -155,6 +449,7 @@ HWTEST_F(ExtExtensionSubTest, Ext_Extension_Sub_GetComInfoCallback_Test_0100, te { GTEST_LOG_(INFO) << "ExtExtensionSubTest-begin Ext_Extension_Sub_GetComInfoCallback_Test_0100"; try { + ASSERT_TRUE(extExtension != nullptr); std::string compatibilityInfo = "test"; extExtension->GetComInfoCallback(nullptr)(BError(BError::Codes::OK).GetCode(), compatibilityInfo); EXPECT_NE(extExtension->compatibilityInfo_, compatibilityInfo); @@ -196,6 +491,7 @@ HWTEST_F(ExtExtensionSubTest, Ext_Extension_Sub_HandleGetCompatibilityInfo_Test_ { GTEST_LOG_(INFO) << "ExtExtensionSubTest-begin Ext_Extension_Sub_HandleGetCompatibilityInfo_Test_0100"; try { + ASSERT_TRUE(extExtension != nullptr); std::string extInfo = "test"; std::string compatibilityInfo = ""; int32_t scenario = BConstants::ExtensionScenario::BACKUP; @@ -234,6 +530,7 @@ HWTEST_F(ExtExtensionSubTest, Ext_Extension_Sub_HandleOnRelease_Test_0100, testi { GTEST_LOG_(INFO) << "ExtExtensionSubTest-begin Ext_Extension_Sub_HandleOnRelease_Test_0100"; try { + ASSERT_TRUE(extExtension != nullptr); int32_t scenario = 1; bool isOnReleased = extExtension->isOnReleased_.load(); extExtension->isOnReleased_.store(true); @@ -270,6 +567,7 @@ HWTEST_F(ExtExtensionSubTest, Ext_Extension_Sub_HandleExtOnRelease_Test_0100, te { GTEST_LOG_(INFO) << "ExtExtensionSubTest-begin Ext_Extension_Sub_HandleExtOnRelease_Test_0100"; try { + ASSERT_TRUE(extExtension != nullptr); auto curScenario = extExtension->curScenario_; extExtension->curScenario_ = BackupRestoreScenario::FULL_BACKUP; auto ext = extExtension->extension_; -- Gitee