From 74b1006f280140ff59956c5b359c01513f388cae Mon Sep 17 00:00:00 2001 From: lizhengxing Date: Fri, 4 Jul 2025 10:00:23 +0800 Subject: [PATCH] add ut subextension Signed-off-by: lizhengxing --- .../mock/backup_ext/include/ext_backup_mock.h | 2 + .../backup_ext/include/ext_extension_mock.h | 86 ++++------- tests/mock/backup_ext/src/ext_backup_mock.cpp | 5 + .../backup_ext/src/ext_extension_mock.cpp | 124 +++++---------- tests/unittests/backup_ext/BUILD.gn | 81 ++++++++++ .../backup_ext/ext_extension_sub_test.cpp | 144 ++++++++++++++++++ 6 files changed, 301 insertions(+), 141 deletions(-) create mode 100644 tests/unittests/backup_ext/ext_extension_sub_test.cpp diff --git a/tests/mock/backup_ext/include/ext_backup_mock.h b/tests/mock/backup_ext/include/ext_backup_mock.h index bee304753..6e966d6e5 100644 --- a/tests/mock/backup_ext/include/ext_backup_mock.h +++ b/tests/mock/backup_ext/include/ext_backup_mock.h @@ -53,6 +53,7 @@ public: virtual ErrCode GetParament(const AAFwk::Want &) = 0; virtual ErrCode OnProcess(std::function callback) = 0; virtual ErrCode OnRelease(std::function callback, int32_t scenario) = 0; + virtual void SetBackupExtExtension(const wptr &) = 0; public: virtual std::unique_ptr LoadSystemModuleByEngine(napi_env, const std::string&, const napi_value*, size_t) = 0; @@ -99,6 +100,7 @@ public: MOCK_METHOD(ErrCode, GetParament, (const AAFwk::Want &)); MOCK_METHOD(napi_value, CreateExtBackupJsContext, (napi_env, std::shared_ptr)); MOCK_METHOD(ErrCode, OnRelease, (std::function, int32_t)); + MOCK_METHOD(void, SetBackupExtExtension, (const wptr &)); public: MOCK_METHOD((std::unique_ptr), LoadSystemModuleByEngine, (napi_env, const std::string&, const napi_value*, size_t)); diff --git a/tests/mock/backup_ext/include/ext_extension_mock.h b/tests/mock/backup_ext/include/ext_extension_mock.h index a92a98bb1..bff5767cd 100644 --- a/tests/mock/backup_ext/include/ext_extension_mock.h +++ b/tests/mock/backup_ext/include/ext_extension_mock.h @@ -23,51 +23,46 @@ namespace OHOS::FileManagement::Backup { class BExtExtension { public: - virtual ErrCode GetIncrementalFileHandle(const string &) = 0; + virtual std::tuple GetIncrementalFileHandle(const string &) = 0; + virtual ErrCode GetIncrementalFileHandle(const string &fileName, int &fd, + int &reportFd, int32_t &fdErrCode) = 0; virtual UniqueFd GetFileHandle(const string &, int32_t &) = 0; virtual ErrCode HandleClear() = 0; - virtual ErrCode BigFileReady(sptr) = 0; + virtual ErrCode BigFileReady(TarMap &, sptr, int) = 0; virtual ErrCode PublishFile(const std::string &) = 0; virtual ErrCode PublishIncrementalFile(const string &) = 0; - virtual ErrCode HandleBackup() = 0; - virtual int DoBackup(const BJsonEntityExtensionConfig &) = 0; - virtual int DoRestore(const string &) = 0; + virtual ErrCode HandleBackup(bool) = 0; + virtual int DoBackup(TarMap &, TarMap &, map &, uint32_t, uint32_t) = 0; + virtual int DoRestore(const string &, const off_t) = 0; virtual int DoIncrementalRestore() = 0; virtual void AsyncTaskBackup(const string) = 0; virtual void AsyncTaskRestore(std::set, const std::vector) = 0; virtual void AsyncTaskIncrementalRestore() = 0; - virtual void AsyncTaskIncreRestoreSpecialVersion() = 0; - virtual void AsyncTaskRestoreForUpgrade() = 0; virtual void ExtClear() = 0; virtual void AsyncTaskIncrementalRestoreForUpgrade() = 0; virtual void DoClear() = 0; virtual void AppDone(ErrCode) = 0; virtual void AppResultReport(const std::string, BackupRestoreScenario, ErrCode) = 0; virtual void AsyncTaskOnBackup() = 0; - virtual ErrCode HandleRestore() = 0; - virtual void PreparaBackupFiles(UniqueFd, UniqueFd, std::vector&, - std::vector&, std::vector&) = 0; - virtual ErrCode HandleIncrementalBackup(UniqueFd, UniqueFd) = 0; - virtual ErrCode IncrementalOnBackup() = 0; - virtual tuple GetIncrementalBackupFileHandle() = 0; - virtual ErrCode IncrementalBigFileReady(const TarMap&, const std::vector&, + virtual ErrCode HandleRestore(bool) = 0; + virtual ErrCode IncrementalBigFileReady(TarMap&, const std::vector&, sptr) = 0; - virtual void AsyncTaskDoIncrementalBackup(UniqueFd, UniqueFd) = 0; - virtual void AsyncTaskOnIncrementalBackup() = 0; - virtual void IncrementalPacket(const std::vector&, TarMap&, sptr) = 0; - virtual int DoIncrementalBackup(const std::vector&, - const std::vector&, const std::vector&) = 0; - virtual void AppIncrementalDone(ErrCode) = 0; - virtual ErrCode GetBackupInfo(std::string&) = 0; - virtual ErrCode UpdateFdSendRate(std::string&, int32_t) = 0; - virtual std::function RestoreResultCallbackEx(wptr) = 0; - virtual std::function AppDoneCallbackEx(wptr) = 0; - virtual std::function IncRestoreResultCallbackEx(wptr) = 0; - virtual std::function HandleBackupEx(wptr) = 0; - virtual std::function HandleTaskBackupEx(wptr) = 0; - virtual void WaitToSendFd(std::chrono::system_clock::time_point&, int&) = 0; - virtual void RefreshTimeInfo(std::chrono::system_clock::time_point&, int&) = 0; - virtual ErrCode HandleOnRelease(int32_t) = 0; + virtual ErrCode GetFileHandleWithUniqueFd(const std::string &fileName, int32_t &errCode, int& fd) = 0; + virtual std::string GetBackupInfo() = 0; + virtual void UpdateOnStartTime() = 0; + virtual ErrCode IncrementalTarFileReady(const TarMap &bigFileInfo, const vector &srcFiles, + sptr proxy) = 0; + virtual void FillFileInfos(UniqueFd incrementalFd, UniqueFd manifestFd, vector &allFiles, + vector &smallFiles, vector &bigFiles) = 0; + virtual void ReportAppStatistic(const std::string &func, ErrCode errCode) = 0; + virtual ErrCode IncrementalAllFileReady(const TarMap &pkgInfo, const vector &srcFiles, + sptr proxy) = 0; + virtual void VerifyCaller() = 0; + virtual std::function ReportErrFileByProc(wptr obj, + BackupRestoreScenario scenario) = 0; + virtual void DoClearInner() = 0; + virtual void StartFwkTimer(bool &isFwkStart) = 0; + virtual ErrCode CleanBundleTempDir() = 0; public: BExtExtension() = default; virtual ~BExtExtension() = default; @@ -78,14 +73,15 @@ public: class ExtExtensionMock : public BExtExtension { public: MOCK_METHOD(UniqueFd, GetFileHandle, (const string &, int32_t &)); - MOCK_METHOD(std::tuple, GetIncrementalFileHandle, (const string &)); + MOCK_METHOD(ErrCode, GetIncrementalFileHandle, (const string &fileName, int &fd, + int &reportFd, int32_t &fdErrCode)); MOCK_METHOD(ErrCode, HandleClear, ()); - MOCK_METHOD(ErrCode, BigFileReady, (sptr)); + MOCK_METHOD(ErrCode, BigFileReady, (TarMap &, sptr, int)); MOCK_METHOD(ErrCode, PublishFile, (const std::string &)); MOCK_METHOD(ErrCode, PublishIncrementalFile, (const string &)); - MOCK_METHOD(ErrCode, HandleBackup, ()); - MOCK_METHOD(int, DoBackup, (const BJsonEntityExtensionConfig &)); - MOCK_METHOD(int, DoRestore, (const string &)); + MOCK_METHOD(ErrCode, HandleBackup, (bool)); + MOCK_METHOD(int, DoBackup, (TarMap &, TarMap &, (map &), uint32_t, uint32_t)); + MOCK_METHOD(int, DoRestore, (const string &, const off_t)); MOCK_METHOD(int, DoIncrementalRestore, ()); MOCK_METHOD(void, AsyncTaskBackup, (const string)); MOCK_METHOD(void, AsyncTaskRestore, (std::set, const std::vector)); @@ -98,31 +94,15 @@ public: MOCK_METHOD(void, AppDone, (ErrCode)); MOCK_METHOD(void, AppResultReport, (const std::string, BackupRestoreScenario, ErrCode)); MOCK_METHOD(void, AsyncTaskOnBackup, ()); - MOCK_METHOD(ErrCode, HandleRestore, ()); + MOCK_METHOD(ErrCode, HandleRestore, (bool)); MOCK_METHOD(void, FillFileInfos, (UniqueFd, UniqueFd, (std::vector&), (std::vector&), (std::vector&))); MOCK_METHOD(ErrCode, HandleIncrementalBackup, (UniqueFd, UniqueFd)); MOCK_METHOD(ErrCode, IncrementalOnBackup, ()); MOCK_METHOD((std::tuple), GetIncrementalBackupFileHandle, ()); - MOCK_METHOD(ErrCode, IncrementalBigFileReady, (const TarMap&, (const std::vector&), + MOCK_METHOD(ErrCode, IncrementalBigFileReady, (TarMap&, const std::vector&, sptr)); - MOCK_METHOD(void, AsyncTaskDoIncrementalBackup, (UniqueFd, UniqueFd)); - MOCK_METHOD(void, AsyncTaskOnIncrementalBackup, ()); - MOCK_METHOD(void, IncrementalPacket, ((const std::vector&), TarMap&, sptr)); - MOCK_METHOD(int, DoIncrementalBackup, ((const std::vector&), - (const std::vector&), (const std::vector&))); - MOCK_METHOD(void, AppIncrementalDone, (ErrCode)); - MOCK_METHOD(ErrCode, GetBackupInfo, (std::string&)); - MOCK_METHOD(ErrCode, UpdateFdSendRate, (std::string&, int32_t)); - MOCK_METHOD((std::function), RestoreResultCallbackEx, (wptr)); - MOCK_METHOD((std::function), AppDoneCallbackEx, (wptr)); - MOCK_METHOD((std::function), IncRestoreResultCallbackEx, (wptr)); - MOCK_METHOD((std::function), HandleBackupEx, (wptr)); - MOCK_METHOD((std::function), HandleTaskBackupEx, (wptr)); - MOCK_METHOD(void, WaitToSendFd, ((std::chrono::system_clock::time_point&), int&)); - MOCK_METHOD(void, RefreshTimeInfo, ((std::chrono::system_clock::time_point&), int&)); MOCK_METHOD(ErrCode, CleanBundleTempDir, ()); - MOCK_METHOD(ErrCode, HandleOnRelease, (int32_t)); }; } // 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_backup_mock.cpp b/tests/mock/backup_ext/src/ext_backup_mock.cpp index 43f091594..9e76eb794 100644 --- a/tests/mock/backup_ext/src/ext_backup_mock.cpp +++ b/tests/mock/backup_ext/src/ext_backup_mock.cpp @@ -143,4 +143,9 @@ ErrCode ExtBackup::OnRelease(function callback, int3 { return BExtBackup::extBackup->OnRelease(callback, scenario); } + +void ExtBackup::SetBackupExtExtension(const wptr &extExtension) +{ + BExtBackup::extBackup->SetBackupExtExtension(extExtension); +} } // namespace OHOS::FileManagement::Backup diff --git a/tests/mock/backup_ext/src/ext_extension_mock.cpp b/tests/mock/backup_ext/src/ext_extension_mock.cpp index b38cd0573..16b750556 100644 --- a/tests/mock/backup_ext/src/ext_extension_mock.cpp +++ b/tests/mock/backup_ext/src/ext_extension_mock.cpp @@ -27,9 +27,10 @@ UniqueFd BackupExtExtension::GetFileHandle(const string &fileName, int32_t &errC return BExtExtension::extExtension->GetFileHandle(fileName, errCode); } -ErrCode BackupExtExtension::GetIncrementalFileHandle(const string &fileName) +ErrCode BackupExtExtension::GetIncrementalFileHandle(const string &fileName, + int &fd, int &reportFd, int32_t &fdErrCode) { - return BExtExtension::extExtension->GetIncrementalFileHandle(fileName); + return BExtExtension::extExtension->GetIncrementalFileHandle(fileName, fd, reportFd, fdErrCode); } ErrCode BackupExtExtension::HandleClear() @@ -37,9 +38,9 @@ ErrCode BackupExtExtension::HandleClear() return BExtExtension::extExtension->HandleClear(); } -ErrCode BackupExtExtension::BigFileReady(sptr proxy) +ErrCode BackupExtExtension::BigFileReady(TarMap &bigFileInfo, sptr proxy, int backupedFileSize) { - return BExtExtension::extExtension->BigFileReady(proxy); + return BExtExtension::extExtension->BigFileReady(bigFileInfo, proxy, backupedFileSize); } ErrCode BackupExtExtension::PublishFile(const std::string &fileName) @@ -52,19 +53,21 @@ ErrCode BackupExtExtension::PublishIncrementalFile(const string &fileName) return BExtExtension::extExtension->PublishIncrementalFile(fileName); } -ErrCode BackupExtExtension::HandleBackup() +ErrCode BackupExtExtension::HandleBackup(bool isClearData) { - return BExtExtension::extExtension->HandleBackup(); + return BExtExtension::extExtension->HandleBackup(isClearData); } -int BackupExtExtension::DoBackup(const BJsonEntityExtensionConfig &usrConfig) +int BackupExtExtension::DoBackup(TarMap &bigFileInfo, TarMap &bigFileInfoBackuped, + map &smallFiles, uint32_t includesNum, uint32_t excludesNum) { - return BExtExtension::extExtension->DoBackup(usrConfig); + return BExtExtension::extExtension->DoBackup(bigFileInfo, bigFileInfoBackuped, smallFiles, + includesNum, excludesNum); } -int BackupExtExtension::DoRestore(const string &fileName) +int BackupExtExtension::DoRestore(const string &fileName, const off_t fileSize) { - return BExtExtension::extExtension->DoRestore(fileName); + return BExtExtension::extExtension->DoRestore(fileName, fileSize); } int BackupExtExtension::DoIncrementalRestore() @@ -89,14 +92,6 @@ void BackupExtExtension::AsyncTaskIncreRestoreSpecialVersion() { } -void BackupExtExtension::AsyncTaskRestoreForUpgrade() -{ -} - -void BackupExtExtension::ExtClear() -{ -} - void BackupExtExtension::AsyncTaskIncrementalRestoreForUpgrade() { } @@ -118,103 +113,61 @@ void BackupExtExtension::AsyncTaskOnBackup() { } -ErrCode BackupExtExtension::HandleRestore() -{ - return BExtExtension::extExtension->HandleRestore(); -} - -void BackupExtExtension::PreparaBackupFiles(UniqueFd incrementalFd, - UniqueFd manifestFd, - vector &allFiles, - vector &smallFiles, - vector &bigFiles) -{ -} - -ErrCode BackupExtExtension::HandleIncrementalBackup(UniqueFd incrementalFd, UniqueFd manifestFd) -{ - return BExtExtension::extExtension->HandleIncrementalBackup(std::move(incrementalFd), std::move(manifestFd)); -} - -ErrCode BackupExtExtension::IncrementalOnBackup() -{ - return BExtExtension::extExtension->IncrementalOnBackup(); -} - -tuple BackupExtExtension::GetIncrementalBackupFileHandle() +ErrCode BackupExtExtension::HandleRestore(bool isClearData) { - return BExtExtension::extExtension->GetIncrementalBackupFileHandle(); + return BExtExtension::extExtension->HandleRestore(isClearData); } -ErrCode BackupExtExtension::IncrementalBigFileReady(const TarMap &pkgInfo, +ErrCode BackupExtExtension::IncrementalBigFileReady(TarMap &pkgInfo, const vector &bigInfos, sptr proxy) { return BExtExtension::extExtension->IncrementalBigFileReady(pkgInfo, bigInfos, proxy); } -void BackupExtExtension::AsyncTaskDoIncrementalBackup(UniqueFd incrementalFd, UniqueFd manifestFd) +void BackupExtExtension::StartFwkTimer(bool &isFwkStart) { } -void BackupExtExtension::AsyncTaskOnIncrementalBackup() +ErrCode BackupExtExtension::GetFileHandleWithUniqueFd(const std::string &fileName, int32_t &errCode, int& fd) { + return BExtExtension::extExtension->GetFileHandleWithUniqueFd(fileName, errCode, fd); } -void BackupExtExtension::IncrementalPacket(const vector &, TarMap &, sptr) +void BackupExtExtension::FillFileInfos(UniqueFd incrementalFd, + UniqueFd manifestFd, + vector &allFiles, + vector &smallFiles, + vector &bigFiles) { } -int BackupExtExtension::DoIncrementalBackup(const vector &allFiles, - const vector &smallFiles, - const vector &bigFiles) +void BackupExtExtension::ReportAppStatistic(const std::string &func, ErrCode errCode) { - return BExtExtension::extExtension->DoIncrementalBackup(allFiles, smallFiles, bigFiles); } -void BackupExtExtension::AppIncrementalDone(ErrCode errCode) +void BackupExtExtension::UpdateOnStartTime() { } -ErrCode BackupExtExtension::GetBackupInfo(std::string &result) +ErrCode BackupExtExtension::IncrementalTarFileReady(const TarMap &bigFileInfo, + const vector &srcFiles, sptr proxy) { - return BExtExtension::extExtension->GetBackupInfo(result); + return BExtExtension::extExtension->IncrementalTarFileReady(bigFileInfo, srcFiles, proxy); } -ErrCode BackupExtExtension::UpdateFdSendRate(std::string &bundleName, int32_t sendRate) +ErrCode BackupExtExtension::IncrementalAllFileReady(const TarMap &pkgInfo, + const vector &srcFiles, sptr proxy) { - return BExtExtension::extExtension->UpdateFdSendRate(bundleName, sendRate); + return BExtExtension::extExtension->IncrementalAllFileReady(pkgInfo, srcFiles, proxy); } -std::function BackupExtExtension::RestoreResultCallbackEx(wptr obj) +std::function BackupExtExtension::ReportErrFileByProc(wptr obj, + BackupRestoreScenario scenario) { - return BExtExtension::extExtension->RestoreResultCallbackEx(obj); + return BExtExtension::extExtension->ReportErrFileByProc(obj, scenario); } -std::function BackupExtExtension::AppDoneCallbackEx(wptr obj) -{ - return BExtExtension::extExtension->AppDoneCallbackEx(obj); -} - -std::function BackupExtExtension::IncRestoreResultCallbackEx(wptr obj) -{ - return BExtExtension::extExtension->IncRestoreResultCallbackEx(obj); -} - -std::function BackupExtExtension::HandleBackupEx(wptr obj) -{ - return BExtExtension::extExtension->HandleBackupEx(obj); -} - -std::function BackupExtExtension::HandleTaskBackupEx(wptr obj) -{ - return BExtExtension::extExtension->HandleTaskBackupEx(obj); -} - -void BackupExtExtension::WaitToSendFd(std::chrono::system_clock::time_point &startTime, int &fdSendNum) -{ -} - -void BackupExtExtension::RefreshTimeInfo(std::chrono::system_clock::time_point &startTime, int &fdSendNum) +void BackupExtExtension::DoClearInner() { } @@ -222,9 +175,4 @@ ErrCode BackupExtExtension::CleanBundleTempDir() { return BExtExtension::extExtension->CleanBundleTempDir(); } - -ErrCode BackupExtExtension::HandleOnRelease(int32_t scenario) -{ - return BExtExtension::extExtension->HandleOnRelease(scenario); -} } // namespace OHOS::FileManagement::Backup diff --git a/tests/unittests/backup_ext/BUILD.gn b/tests/unittests/backup_ext/BUILD.gn index 1f2fccc23..6cdcee1cb 100644 --- a/tests/unittests/backup_ext/BUILD.gn +++ b/tests/unittests/backup_ext/BUILD.gn @@ -489,12 +489,93 @@ ohos_unittest("installd_un_tar_file_test") { use_exceptions = true } +ohos_unittest("ext_extension_sub_test") { + branch_protector_ret = "pac_ret" + sanitize = { + integer_overflow = true + cfi = true + cfi_cross_dso = true + cfi_vcall_icall_only = true + debug = false + blocklist = "${path_backup}/cfi_blocklist.txt" + } + + module_out_path = path_module_out_tests + + sources = [ + "${path_backup}/tests/mock/backup_ext/src/ext_backup_mock.cpp", + "${path_backup}/tests/mock/backup_ext/src/ext_extension_mock.cpp", + "${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", + "ext_extension_sub_test.cpp", + ] + + public_configs = [ "${path_backup}/services/backup_sa:public_idl_config" ] + + include_dirs = [ + "${path_backup}/frameworks/native/backup_ext/include", + "${path_backup}/frameworks/native/backup_ext/src", + "${path_backup}/frameworks/native/backup_kit_inner/src", + "${path_backup}/interfaces/inner_api/native/backup_kit_inner/impl", + "${path_backup}/interfaces/common/include", + "${path_backup}/tests/mock/backup_ext/src", + "${path_backup}/tests/mock/backup_ext/include", + "${path_backup}/tests/mock/utils_mock/include", + "${path_backup}/tests/mock/backup_kit_inner", + "${path_backup}/tests/utils/include", + "${path_backup}/tests/utils_mock/include", + "${path_backup}/utils/include", + ] + + deps = [ + "${path_backup}/interfaces/inner_api/native/backup_kit_inner:backup_kit_inner", + "${path_backup}/services/backup_sa:backup_sa_ipc_stub", + "${path_backup}/utils:backup_utils", + ] + + cflags = [ "--coverage" ] + ldflags = [ "--coverage" ] + cflags_cc = [ "--coverage" ] + + external_deps = [ + "ability_base:want", + "ability_runtime:ability_context_native", + "ability_runtime:abilitykit_native", + "ability_runtime:app_context", + "ability_runtime:appkit_native", + "ability_runtime:runtime", + "access_token:libaccesstoken_sdk", + "bundle_framework:appexecfwk_core", + "c_utils:utils", + "googletest:gmock_main", + "googletest:gtest_main", + "hilog:libhilog", + "hitrace:hitrace_meter", + "ipc:ipc_core", + "ipc:ipc_napi", + "jsoncpp:jsoncpp", + "napi:ace_napi", + "safwk:system_ability_fwk", + "samgr:samgr_proxy", + ] + + defines = [ + "LOG_TAG=\"app_file_service\"", + "LOG_DOMAIN=0xD004303", + "private=public", + ] + + use_exceptions = true +} + group("backup_ext_test") { testonly = true if (!use_libfuzzer) { deps = [ ":ext_backup_js_test", ":ext_extension_test", + ":ext_extension_sub_test", ":installd_un_tar_file_test", ":tar_file_sub_test", ":tar_file_test", diff --git a/tests/unittests/backup_ext/ext_extension_sub_test.cpp b/tests/unittests/backup_ext/ext_extension_sub_test.cpp new file mode 100644 index 000000000..106e8e2e3 --- /dev/null +++ b/tests/unittests/backup_ext/ext_extension_sub_test.cpp @@ -0,0 +1,144 @@ +/* + * Copyright (c) 2022-2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#include "b_error/b_error.h" +#include "b_error/b_excep_utils.h" +#include "ext_backup_mock.h" +#include "ext_extension_mock.h" + +#include "tar_file.cpp" +#include "sub_ext_extension.cpp" + +namespace OHOS::FileManagement::Backup { +using namespace std; +using namespace testing; + +namespace { +const string FILE_NAME = "1.txt"; +const string BUNDLE_NAME = "com.example.app2backup/"; +const string MANAGE_JSON = "manage.json"; +const string PATH = "/data/storage/el2/backup/test/"; +const string TAR_FILE = "1.tar"; +const string BUNDLE_BASE_DIR = "/data/storage/el2/base/"; +const string PATH_BUNDLE_BACKUP_HOME_EL1 = "/data/storage/el1/base/.backup"; +const string PATH_BUNDLE_BACKUP_HOME = "/data/storage/el2/base/.backup"; +} // namespace + +class ExtExtensionSubTest : public testing::Test { +public: + //所有测试用例执行之前执行 + static void SetUpTestCase(void); + //所有测试用例执行之后执行 + static void TearDownTestCase(void); + //每次测试用例执行之前执行 + void SetUp() {}; + //每次测试用例执行之后执行 + void TearDown() {}; + + static inline sptr extExtension = nullptr; + static inline shared_ptr extension = nullptr; + static inline shared_ptr extBackupMock = nullptr; +}; + +void ExtExtensionSubTest::SetUpTestCase(void) +{ + //创建测试路径 + string cmdMkdir = string("mkdir -p ") + PATH + BUNDLE_NAME; + system(cmdMkdir.c_str()); + + string cmdMkdir1 = string("mkdir -p ") + BUNDLE_BASE_DIR; + system(cmdMkdir1.c_str()); + + string cmdMkdir2 = string("mkdir -p ") + PATH_BUNDLE_BACKUP_HOME_EL1; + system(cmdMkdir2.c_str()); + + string cmdMkdir3 = string("mkdir -p ") + PATH_BUNDLE_BACKUP_HOME; + system(cmdMkdir3.c_str()); + //创建测试文件 + string touchFile = string("touch ") + PATH + BUNDLE_NAME + FILE_NAME; + system(touchFile.c_str()); + string touchFile2 = string("touch ") + PATH + BUNDLE_NAME + "2.txt"; + system(touchFile2.c_str()); + + extBackupMock = make_shared(); + ExtBackupMock::extBackup = extBackupMock; + + extExtension = sptr(new BackupExtExtension( + nullptr, BUNDLE_NAME)); + extension = make_shared(); + extExtension->extension_ = extension; +}; + +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; + system(rmDir.c_str()); + + rmDir = string("rm -r ") + PATH_BUNDLE_BACKUP_HOME; + system(rmDir.c_str()); + + extension = nullptr; + extExtension = nullptr; + ExtBackupMock::extBackup = nullptr; + extBackupMock = nullptr; +}; + +/** + * @tc.number: Ext_Extension_Sub_Test_0001 + * @tc.name: Ext_Extension_Sub_Test_0001 + * @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) +{ + GTEST_LOG_(INFO) << "ExtExtensionSubTest-begin Ext_Extension_Sub_Test_0001"; + try { + EXPECT_TRUE(extExtension != nullptr); + extExtension->SetClearDataFlag(true); + EXPECT_TRUE(extExtension->isClearData_ == true); + + extExtension->extension_ = nullptr; + extExtension->SetClearDataFlag(false); + EXPECT_TRUE(extExtension->isClearData_ == false); + + extExtension->extension_ = extension; + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "ExtExtensionSubTest-an exception occurred by construction."; + } + GTEST_LOG_(INFO) << "ExtExtensionSubTest-end Ext_Extension_Sub_Test_0001"; +} +} \ No newline at end of file -- Gitee