diff --git a/bundle.json b/bundle.json index d60092acc552d3a62bddafa0d0eaa7264c199622..22df2ad0637e0cd6e0c4099a1c638fef2a597f7b 100644 --- a/bundle.json +++ b/bundle.json @@ -146,9 +146,7 @@ "impl/b_session_restore_async.h", "impl/b_file_info.h", "impl/service_client.h", - "impl/b_session_backup.h", - "impl/i_service_reverse_ipc_interface_code.h", - "impl/iservice_reverse.h" + "impl/b_session_backup.h" ] } }, diff --git a/frameworks/native/backup_ext/BUILD.gn b/frameworks/native/backup_ext/BUILD.gn index 2fe333fc36bcdd6d2f2638151198837f1681dd86..6a0f591c68e9c870df4beccf6f218c1c7f79baa2 100644 --- a/frameworks/native/backup_ext/BUILD.gn +++ b/frameworks/native/backup_ext/BUILD.gn @@ -33,7 +33,6 @@ ohos_shared_library("backup_extension_ability_native") { "src/ext_backup_js.cpp", "src/ext_backup_loader.cpp", "src/ext_extension.cpp", - "src/ext_extension_stub.cpp", "src/sub_ext_extension.cpp", "src/tar_file.cpp", "src/untar_file.cpp", @@ -46,6 +45,8 @@ ohos_shared_library("backup_extension_ability_native") { include_dirs = [ "include" ] + public_configs = [ "${path_backup}/services/backup_sa:public_idl_config" ] + deps = [ "${path_backup}/interfaces/inner_api/native/backup_kit_inner:backup_kit_inner", "${path_backup}/interfaces/innerkits/native:sandbox_helper_native", diff --git a/frameworks/native/backup_ext/include/ext_extension.h b/frameworks/native/backup_ext/include/ext_extension.h index ca5611f4a20b19cb3a3aa0c3c532bce132a89c60..8b83b4a35dd4f5430ee30d3167d6dd98eff38c76 100644 --- a/frameworks/native/backup_ext/include/ext_extension.h +++ b/frameworks/native/backup_ext/include/ext_extension.h @@ -29,7 +29,7 @@ #include "b_json/b_report_entity.h" #include "b_radar/b_radar.h" #include "ext_backup_js.h" -#include "ext_extension_stub.h" +#include "extension_stub.h" #include "service_common.h" #include "iservice.h" #include "tar_file.h" @@ -42,20 +42,20 @@ namespace OHOS::FileManagement::Backup { using CompareFilesResult = tuple, map, map>; -class BackupExtExtension : public ExtExtensionStub { +class BackupExtExtension : public ExtensionStub { public: - UniqueFd GetFileHandle(const std::string &fileName, int32_t &errCode) override; + ErrCode GetFileHandleWithUniqueFd(const std::string &fileName, int32_t &errCode, int& fd) override; ErrCode HandleClear() override; ErrCode PublishFile(const std::string &fileName) override; ErrCode HandleBackup(bool isClearData) override; ErrCode HandleRestore(bool isClearData) override; - std::tuple GetIncrementalFileHandle(const std::string &fileName) override; + ErrCode GetIncrementalFileHandle(const std::string &fileName, UniqueFdGroup &fdGroup) override; ErrCode PublishIncrementalFile(const std::string &fileName) override; - ErrCode HandleIncrementalBackup(UniqueFd incrementalFd, UniqueFd manifestFd) override; + ErrCode HandleIncrementalBackup(int incrementalFd, int manifestFd) override; ErrCode IncrementalOnBackup(bool isClearData) override; - std::tuple GetIncrementalBackupFileHandle() override; + ErrCode GetIncrementalBackupFileHandle(UniqueFdGroup &fdGroup) override; ErrCode GetBackupInfo(std::string &result) override; - ErrCode UpdateFdSendRate(std::string &bundleName, int32_t sendRate) override; + ErrCode UpdateFdSendRate(const std::string &bundleName, int32_t sendRate) override; void AsyncTaskRestoreForUpgrade(void); void ExtClear(void); void AsyncTaskIncrementalRestoreForUpgrade(void); @@ -337,6 +337,10 @@ private: void ClearNoPermissionFiles(TarMap &pkgInfo, vector &noPermissionFiles); std::function ReportOnProcessResultCallback(wptr obj, BackupRestoreScenario scenario); + UniqueFd GetFileHandle(const std::string &fileName, int32_t &errCode); + std::tuple GetIncrementalFileHandle(const std::string &fileName); + ErrCode HandleIncrementalBackup(UniqueFd incrementalFd, UniqueFd manifestFd); + std::tuple GetIncrementalBackupFileHandle(); bool IfCloudSpecialRestore(std::string tarName); ErrCode CloudSpecialRestore(std::string tarName, std::string untarPath, off_t tarFileSize); void GetTarIncludes(const string &tarName, unordered_map &infos); diff --git a/frameworks/native/backup_ext/include/ext_extension_stub.h b/frameworks/native/backup_ext/include/ext_extension_stub.h deleted file mode 100644 index d969b3e9b80d5b8d491ced905c02ab2c7a6a9876..0000000000000000000000000000000000000000 --- a/frameworks/native/backup_ext/include/ext_extension_stub.h +++ /dev/null @@ -1,54 +0,0 @@ -/* - * Copyright (c) 2022-2024 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. - */ - -#ifndef OHOS_FILEMGMT_BACKUP_EXT_EXTENSION_STUB_H -#define OHOS_FILEMGMT_BACKUP_EXT_EXTENSION_STUB_H - -#include - -#include "i_extension.h" -#include "iremote_stub.h" - -namespace OHOS::FileManagement::Backup { -class ExtExtensionStub : public IRemoteStub { -public: - int OnRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) override; - -public: - ExtExtensionStub(); - ~ExtExtensionStub() = default; - -private: - ErrCode CmdGetFileHandle(MessageParcel &data, MessageParcel &reply); - ErrCode CmdHandleClear(MessageParcel &data, MessageParcel &reply); - ErrCode CmdHandleBackup(MessageParcel &data, MessageParcel &reply); - ErrCode CmdPublishFile(MessageParcel &data, MessageParcel &reply); - ErrCode CmdHandleRestore(MessageParcel &data, MessageParcel &reply); - ErrCode CmdGetIncrementalFileHandle(MessageParcel &data, MessageParcel &reply); - ErrCode CmdPublishIncrementalFile(MessageParcel &data, MessageParcel &reply); - ErrCode CmdHandleIncrementalBackup(MessageParcel &data, MessageParcel &reply); - ErrCode CmdIncrementalOnBackup(MessageParcel &data, MessageParcel &reply); - ErrCode CmdGetIncrementalBackupFileHandle(MessageParcel &data, MessageParcel &reply); - ErrCode CmdGetBackupInfo(MessageParcel &data, MessageParcel &reply); - ErrCode CmdUpdateFdSendRate(MessageParcel &data, MessageParcel &reply); - ErrCode CmdHandleUser0Backup(MessageParcel &data, MessageParcel &reply); - -private: - using ExtensionInterface = int32_t (ExtExtensionStub::*)(MessageParcel &data, MessageParcel &reply); - std::map opToInterfaceMap_; -}; -} // namespace OHOS::FileManagement::Backup - -#endif // OHOS_FILEMGMT_BACKUP_EXT_EXTENSION_STUB_H \ No newline at end of file diff --git a/frameworks/native/backup_ext/src/ext_extension.cpp b/frameworks/native/backup_ext/src/ext_extension.cpp index cead8c8870b3f577d93a201d38996a81212a09f2..43edecfa9d6960d7684bceff0495350e01111645 100644 --- a/frameworks/native/backup_ext/src/ext_extension.cpp +++ b/frameworks/native/backup_ext/src/ext_extension.cpp @@ -241,6 +241,15 @@ static UniqueFd GetFileHandleForSpecialCloneCloud(const string &fileName) return fd; } +ErrCode BackupExtExtension::GetFileHandleWithUniqueFd(const std::string &fileName, + int32_t &getFileHandleErrCode, + int &fd) +{ + UniqueFd fileHandleFd(GetFileHandle(fileName, getFileHandleErrCode)); + fd = fileHandleFd.Release(); + return ERR_OK; +} + UniqueFd BackupExtExtension::GetFileHandle(const string &fileName, int32_t &errCode) { HITRACE_METER_NAME(HITRACE_TAG_FILEMANAGEMENT, __PRETTY_FUNCTION__); @@ -386,6 +395,16 @@ tuple BackupExtExtension::GetIncreFileHandleForNorm return {errCode, move(fd), move(reportFd)}; } +ErrCode BackupExtExtension::GetIncrementalFileHandle(const std::string &fileName, UniqueFdGroup &fdGroup) +{ + HITRACE_METER_NAME(HITRACE_TAG_FILEMANAGEMENT, __PRETTY_FUNCTION__); + auto [errCode, fd, reportFd] = GetIncrementalFileHandle(fileName); + fdGroup.errCode = errCode; + fdGroup.fd = fd.Release(); + fdGroup.reportFd = reportFd.Release(); + return ERR_OK; +} + tuple BackupExtExtension::GetIncrementalFileHandle(const string &fileName) { HITRACE_METER_NAME(HITRACE_TAG_FILEMANAGEMENT, __PRETTY_FUNCTION__); @@ -1909,6 +1928,17 @@ void BackupExtExtension::FillFileInfos(UniqueFd incrementalFd, allFiles.size(), smallFiles.size(), bigFiles.size()); } +ErrCode BackupExtExtension::HandleIncrementalBackup(int incrementalFd, int manifestFd) +{ + HILOGI("Start HandleIncrementalBackup. incrementalFd:%{public}d, manifestFd:%{public}d", incrementalFd, manifestFd); + UniqueFd incrementalFdUnique(dup(incrementalFd)); + UniqueFd manifestFdUnique(dup(manifestFd)); + ErrCode ret = HandleIncrementalBackup(std::move(incrementalFdUnique), std::move(manifestFdUnique)); + close(incrementalFd); + close(manifestFd); + return ret; +} + ErrCode BackupExtExtension::HandleIncrementalBackup(UniqueFd incrementalFd, UniqueFd manifestFd) { HITRACE_METER_NAME(HITRACE_TAG_FILEMANAGEMENT, __PRETTY_FUNCTION__); @@ -1938,6 +1968,14 @@ ErrCode BackupExtExtension::IncrementalOnBackup(bool isClearData) return ERR_OK; } +ErrCode BackupExtExtension::GetIncrementalBackupFileHandle(UniqueFdGroup& fdGroup) +{ + auto [fd, reportFd] = GetIncrementalBackupFileHandle(); + fdGroup.fd = fd.Release(); + fdGroup.reportFd = reportFd.Release(); + return BError(BError::Codes::OK).GetCode(); +} + tuple BackupExtExtension::GetIncrementalBackupFileHandle() { HITRACE_METER_NAME(HITRACE_TAG_FILEMANAGEMENT, __PRETTY_FUNCTION__); diff --git a/frameworks/native/backup_ext/src/ext_extension_stub.cpp b/frameworks/native/backup_ext/src/ext_extension_stub.cpp deleted file mode 100644 index 38f4ce2f3ab78ed7ead69c0f9d03c0349387178a..0000000000000000000000000000000000000000 --- a/frameworks/native/backup_ext/src/ext_extension_stub.cpp +++ /dev/null @@ -1,266 +0,0 @@ -/* - * Copyright (c) 2022-2024 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 "ext_extension_stub.h" - -#include -#include - -#include "b_error/b_error.h" -#include "b_error/b_excep_utils.h" -#include "filemgmt_libhilog.h" - -namespace OHOS::FileManagement::Backup { -using namespace std; - -ExtExtensionStub::ExtExtensionStub() -{ - opToInterfaceMap_[static_cast(IExtensionInterfaceCode::CMD_GET_FILE_HANDLE)] = - &ExtExtensionStub::CmdGetFileHandle; - opToInterfaceMap_[static_cast(IExtensionInterfaceCode::CMD_HANDLE_CLAER)] = - &ExtExtensionStub::CmdHandleClear; - opToInterfaceMap_[static_cast(IExtensionInterfaceCode::CMD_HANDLE_BACKUP)] = - &ExtExtensionStub::CmdHandleBackup; - opToInterfaceMap_[static_cast(IExtensionInterfaceCode::CMD_PUBLISH_FILE)] = - &ExtExtensionStub::CmdPublishFile; - opToInterfaceMap_[static_cast(IExtensionInterfaceCode::CMD_HANDLE_RESTORE)] = - &ExtExtensionStub::CmdHandleRestore; - opToInterfaceMap_[static_cast(IExtensionInterfaceCode::CMD_GET_INCREMENTAL_FILE_HANDLE)] = - &ExtExtensionStub::CmdGetIncrementalFileHandle; - opToInterfaceMap_[static_cast(IExtensionInterfaceCode::CMD_PUBLISH_INCREMENTAL_FILE)] = - &ExtExtensionStub::CmdPublishIncrementalFile; - opToInterfaceMap_[static_cast(IExtensionInterfaceCode::CMD_HANDLE_INCREMENTAL_BACKUP)] = - &ExtExtensionStub::CmdHandleIncrementalBackup; - opToInterfaceMap_[static_cast(IExtensionInterfaceCode::CMD_GET_INCREMENTAL_BACKUP_FILE_HANDLE)] = - &ExtExtensionStub::CmdGetIncrementalBackupFileHandle; - opToInterfaceMap_[static_cast(IExtensionInterfaceCode::CMD_GET_BACKUP_INFO)] = - &ExtExtensionStub::CmdGetBackupInfo; - opToInterfaceMap_[static_cast(IExtensionInterfaceCode::CMD_INCREMENTAL_ON_BACKUP)] = - &ExtExtensionStub::CmdIncrementalOnBackup; - opToInterfaceMap_[static_cast(IExtensionInterfaceCode::CMD_UPDATE_FD_SENDRATE)] = - &ExtExtensionStub::CmdUpdateFdSendRate; - opToInterfaceMap_[static_cast(IExtensionInterfaceCode::CMD_HANDLE_USER_0_BACKUP)] = - &ExtExtensionStub::CmdHandleUser0Backup; -} - -int32_t ExtExtensionStub::OnRemoteRequest(uint32_t code, - MessageParcel &data, - MessageParcel &reply, - MessageOption &option) -{ - const std::u16string descriptor = ExtExtensionStub::GetDescriptor(); - const std::u16string remoteDescriptor = data.ReadInterfaceToken(); - if (descriptor != remoteDescriptor) { - return BError(BError::Codes::EXT_INVAL_ARG, "Invalid remote descriptor"); - } - - HILOGI("Begin to call procedure indexed %{public}u", code); - auto interfaceIndex = opToInterfaceMap_.find(code); - if (interfaceIndex == opToInterfaceMap_.end() || !interfaceIndex->second) { - HILOGE("Cannot response request %{public}d : unknown procedure", code); - return IPCObjectStub::OnRemoteRequest(code, data, reply, option); - } - - return BExcepUltils::ExceptionCatcherLocked( - [&]() { return ErrCode((this->*(interfaceIndex->second))(data, reply)); }); -} - -ErrCode ExtExtensionStub::CmdGetFileHandle(MessageParcel &data, MessageParcel &reply) -{ - string fileName; - if (!data.ReadString(fileName)) { - return BError(BError::Codes::EXT_INVAL_ARG, "Failed to receive fileName").GetCode(); - } - - int32_t errCode = ERR_OK; - UniqueFd fd = GetFileHandle(fileName, errCode); - bool fdFlag = fd < 0 ? false : true; - reply.WriteBool(fdFlag); - reply.WriteInt32(errCode); - if (fdFlag == true && !reply.WriteFileDescriptor(fd)) { - return BError(BError::Codes::EXT_BROKEN_IPC, "Failed to send out the file").GetCode(); - } - return BError(BError::Codes::OK); -} - -ErrCode ExtExtensionStub::CmdHandleClear(MessageParcel &data, MessageParcel &reply) -{ - ErrCode res = HandleClear(); - if (!reply.WriteInt32(res)) { - stringstream ss; - ss << "Failed to send the result " << res; - return BError(BError::Codes::EXT_BROKEN_IPC, ss.str()).GetCode(); - } - return BError(BError::Codes::OK); -} - -ErrCode ExtExtensionStub::CmdHandleBackup(MessageParcel &data, MessageParcel &reply) -{ - bool isClearData = true; - isClearData = data.ReadBool(); - ErrCode res = HandleBackup(isClearData); - if (!reply.WriteInt32(res)) { - stringstream ss; - ss << "Failed to send the result " << res; - return BError(BError::Codes::EXT_BROKEN_IPC, ss.str()).GetCode(); - } - return BError(BError::Codes::OK); -} - -ErrCode ExtExtensionStub::CmdPublishFile(MessageParcel &data, MessageParcel &reply) -{ - string fileName; - if (!data.ReadString(fileName)) { - return BError(BError::Codes::EXT_INVAL_ARG, "Failed to receive fileName"); - } - - ErrCode res = PublishFile(fileName); - if (!reply.WriteInt32(res)) { - stringstream ss; - ss << "Failed to send the result " << res; - return BError(BError::Codes::EXT_BROKEN_IPC, ss.str()).GetCode(); - } - return BError(BError::Codes::OK); -} - -ErrCode ExtExtensionStub::CmdHandleRestore(MessageParcel &data, MessageParcel &reply) -{ - bool isClearData = true; - isClearData = data.ReadBool(); - ErrCode res = HandleRestore(isClearData); - if (!reply.WriteInt32(res)) { - stringstream ss; - ss << "Failed to send the result " << res; - return BError(BError::Codes::EXT_BROKEN_IPC, ss.str()).GetCode(); - } - return BError(BError::Codes::OK); -} - -ErrCode ExtExtensionStub::CmdGetIncrementalFileHandle(MessageParcel &data, MessageParcel &reply) -{ - string fileName; - if (!data.ReadString(fileName)) { - return BError(BError::Codes::EXT_INVAL_ARG, "Failed to receive fileName").GetCode(); - } - - auto[errCode, fd, reportFd] = GetIncrementalFileHandle(fileName); - if (!reply.WriteInt32(errCode)) { - return BError(BError::Codes::EXT_BROKEN_IPC, "Failed to send out the file").GetCode(); - } - if (!reply.WriteFileDescriptor(fd)) { - return BError(BError::Codes::EXT_BROKEN_IPC, "Failed to send out the file").GetCode(); - } - if (!reply.WriteFileDescriptor(reportFd)) { - return BError(BError::Codes::EXT_BROKEN_IPC, "Failed to send out the file").GetCode(); - } - return BError(BError::Codes::OK); -} - -ErrCode ExtExtensionStub::CmdPublishIncrementalFile(MessageParcel &data, MessageParcel &reply) -{ - string fileName; - if (!data.ReadString(fileName)) { - return BError(BError::Codes::EXT_INVAL_ARG, "Failed to receive fileName"); - } - - ErrCode res = PublishIncrementalFile(fileName); - if (!reply.WriteInt32(res)) { - stringstream ss; - ss << "Failed to send the result " << res; - return BError(BError::Codes::EXT_BROKEN_IPC, ss.str()).GetCode(); - } - return BError(BError::Codes::OK); -} - -ErrCode ExtExtensionStub::CmdHandleIncrementalBackup(MessageParcel &data, MessageParcel &reply) -{ - UniqueFd incrementalFd(data.ReadFileDescriptor()); - UniqueFd manifestFd(data.ReadFileDescriptor()); - ErrCode res = HandleIncrementalBackup(move(incrementalFd), move(manifestFd)); - if (!reply.WriteInt32(res)) { - stringstream ss; - ss << "Failed to send the result " << res; - return BError(BError::Codes::EXT_BROKEN_IPC, ss.str()).GetCode(); - } - return BError(BError::Codes::OK); -} - -ErrCode ExtExtensionStub::CmdIncrementalOnBackup(MessageParcel &data, MessageParcel &reply) -{ - bool isClearData = true; - isClearData = data.ReadBool(); - ErrCode res = IncrementalOnBackup(isClearData); - if (!reply.WriteInt32(res)) { - stringstream ss; - ss << "Failed to send the result " << res; - return BError(BError::Codes::EXT_BROKEN_IPC, ss.str()).GetCode(); - } - return BError(BError::Codes::OK); -} - -ErrCode ExtExtensionStub::CmdGetIncrementalBackupFileHandle(MessageParcel &data, MessageParcel &reply) -{ - auto [incrementalFd, manifestFd] = GetIncrementalBackupFileHandle(); - if (!reply.WriteFileDescriptor(incrementalFd)) { - return BError(BError::Codes::EXT_BROKEN_IPC, "Failed to send out the file").GetCode(); - } - if (!reply.WriteFileDescriptor(manifestFd)) { - return BError(BError::Codes::EXT_BROKEN_IPC, "Failed to send out the file").GetCode(); - } - return BError(BError::Codes::OK); -} - -ErrCode ExtExtensionStub::CmdGetBackupInfo(MessageParcel &data, MessageParcel &reply) -{ - HILOGI("CmdGetBackupInfo Begin"); - std::string result; - int ret = GetBackupInfo(result); - if (!reply.WriteInt32(ret)) { - return BError(BError::Codes::EXT_BROKEN_IPC, "Failed to send out the ret").GetCode(); - } - if (!reply.WriteString(result)) { - return BError(BError::Codes::EXT_BROKEN_IPC, "Failed to send out the result").GetCode(); - } - return BError(BError::Codes::OK); -} - -ErrCode ExtExtensionStub::CmdUpdateFdSendRate(MessageParcel &data, MessageParcel &reply) -{ - HILOGD("CmdUpdateFdSendRate Begin"); - std::string bundleName; - if (!data.ReadString(bundleName)) { - return BError(BError::Codes::EXT_INVAL_ARG, "Failed to receive bundleName").GetCode(); - } - int32_t sendRate; - if (!data.ReadInt32(sendRate)) { - return BError(BError::Codes::EXT_INVAL_ARG, "Failed to receive sendRate").GetCode(); - } - int ret = UpdateFdSendRate(bundleName, sendRate); - if (!reply.WriteInt32(ret)) { - return BError(BError::Codes::EXT_BROKEN_IPC, "Failed to send out the ret").GetCode(); - } - return BError(BError::Codes::OK); -} - -ErrCode ExtExtensionStub::CmdHandleUser0Backup(MessageParcel &data, MessageParcel &reply) -{ - HILOGD("CmdHandleUser0Backup Begin"); - int ret = User0OnBackup(); - if (!reply.WriteInt32(ret)) { - return BError(BError::Codes::EXT_BROKEN_IPC, "Failed to send out the ret").GetCode(); - } - return BError(BError::Codes::OK); -} -} // namespace OHOS::FileManagement::Backup \ No newline at end of file diff --git a/frameworks/native/backup_ext/src/sub_ext_extension.cpp b/frameworks/native/backup_ext/src/sub_ext_extension.cpp index 5e126e256fef316d0156efe8cfa384b1939d9947..11ef67483ae8d9e5688e7a2d700aef9089f57083 100644 --- a/frameworks/native/backup_ext/src/sub_ext_extension.cpp +++ b/frameworks/native/backup_ext/src/sub_ext_extension.cpp @@ -785,7 +785,7 @@ ErrCode BackupExtExtension::GetBackupInfo(std::string &result) return ERR_OK; } -ErrCode BackupExtExtension::UpdateFdSendRate(std::string &bundleName, int32_t sendRate) +ErrCode BackupExtExtension::UpdateFdSendRate(const std::string &bundleName, int32_t sendRate) { try { std::lock_guard lock(updateSendRateLock_); diff --git a/frameworks/native/backup_kit_inner/include/service_reverse.h b/frameworks/native/backup_kit_inner/include/service_reverse.h index 83faba703ed6f79da88480fa5afbc326db5a4acf..90b51874e96a7cad33d6527e1d09c88b759230b2 100644 --- a/frameworks/native/backup_kit_inner/include/service_reverse.h +++ b/frameworks/native/backup_kit_inner/include/service_reverse.h @@ -28,39 +28,55 @@ const int DEFAULT_USER_ID = -1; class ServiceReverse final : public ServiceReverseStub { public: - void BackupOnFileReady(std::string bundleName, std::string fileName, int fd, int32_t errCode) override; - void BackupOnBundleStarted(int32_t errCode, std::string bundleName) override; - void BackupOnResultReport(std::string result, std::string bundleName) override; - void BackupOnBundleFinished(int32_t errCode, std::string bundleName) override; - void BackupOnAllBundlesFinished(int32_t errCode) override; - void BackupOnProcessInfo(std::string bundleName, std::string processInfo) override; - void BackupOnScanningInfo(std::string scannedInfo) override; + ErrCode BackupOnFileReady(const std::string &bundleName, + const std::string &fileName, + int fd, + int32_t errCode) override; + ErrCode BackupOnBundleStarted(int32_t errCode, const std::string &bundleName) override; + ErrCode BackupOnResultReport(const std::string &result, const std::string &bundleName) override; + ErrCode BackupOnBundleFinished(int32_t errCode, const std::string &bundleName) override; + ErrCode BackupOnAllBundlesFinished(int32_t errCode) override; + ErrCode BackupOnProcessInfo(const std::string &bundleName, const std::string &processInfo) override; + ErrCode BackupOnScanningInfo(const std::string &scannedInfo) override; - void RestoreOnBundleStarted(int32_t errCode, std::string bundleName) override; - void RestoreOnBundleFinished(int32_t errCode, std::string bundleName) override; - void RestoreOnAllBundlesFinished(int32_t errCode) override; - void RestoreOnFileReady(std::string bundleName, std::string fileName, int fd, int32_t errCode) override; - void RestoreOnResultReport(std::string result, std::string bundleName, - ErrCode errCode = 0) override; - void RestoreOnProcessInfo(std::string bundleName, std::string processInfo) override; + ErrCode RestoreOnBundleStarted(int32_t errCode, const std::string &bundleName) override; + ErrCode RestoreOnBundleFinished(int32_t errCode, const std::string &bundleName) override; + ErrCode RestoreOnAllBundlesFinished(int32_t errCode) override; + ErrCode RestoreOnFileReady(const std::string &bundleName, + const std::string &fileName, + int fd, + int32_t errCode) override; + ErrCode RestoreOnResultReport(const std::string &result, + const std::string &bundleName, + ErrCode errCode = 0) override; + ErrCode RestoreOnProcessInfo(const std::string &bundleName, const std::string &processInfo) override; - void IncrementalBackupOnFileReady(std::string bundleName, std::string fileName, int fd, int manifestFd, - int32_t errCode) override; - void IncrementalBackupOnBundleStarted(int32_t errCode, std::string bundleName) override; - void IncrementalBackupOnResultReport(std::string result, std::string bundleName) override; - void IncrementalBackupOnBundleFinished(int32_t errCode, std::string bundleName) override; - void IncrementalBackupOnAllBundlesFinished(int32_t errCode) override; - void IncrementalBackupOnProcessInfo(std::string bundleName, std::string processInfo) override; - void IncrementalBackupOnScanningInfo(std::string scannedInfo) override; + ErrCode IncrementalBackupOnFileReady(const std::string &bundleName, + const std::string &fileName, + int fd, + int manifestFd, + int32_t errCode) override; + ErrCode IncrementalSaBackupOnFileReady(const std::string &bundleName, const std::string &fileName, + int fd, int32_t errCode) override; + ErrCode IncrementalBackupOnBundleStarted(int32_t errCode, const std::string &bundleName) override; + ErrCode IncrementalBackupOnResultReport(const std::string &result, const std::string &bundleName) override; + ErrCode IncrementalBackupOnBundleFinished(int32_t errCode, const std::string &bundleName) override; + ErrCode IncrementalBackupOnAllBundlesFinished(int32_t errCode) override; + ErrCode IncrementalBackupOnProcessInfo(const std::string &bundleName, const std::string &processInfo) override; + ErrCode IncrementalBackupOnScanningInfo(const std::string &scannedInfo) override; - void IncrementalRestoreOnBundleStarted(int32_t errCode, std::string bundleName) override; - void IncrementalRestoreOnBundleFinished(int32_t errCode, std::string bundleName) override; - void IncrementalRestoreOnAllBundlesFinished(int32_t errCode) override; - void IncrementalRestoreOnFileReady(std::string bundleName, std::string fileName, int fd, int manifestFd, - int32_t errCode) override; - void IncrementalRestoreOnResultReport(std::string result, std::string bundleName, - ErrCode errCode = 0) override; - void IncrementalRestoreOnProcessInfo(std::string bundleName, std::string processInfo) override; + ErrCode IncrementalRestoreOnBundleStarted(int32_t errCode, const std::string &bundleName) override; + ErrCode IncrementalRestoreOnBundleFinished(int32_t errCode, const std::string &bundleName) override; + ErrCode IncrementalRestoreOnAllBundlesFinished(int32_t errCode) override; + ErrCode IncrementalRestoreOnFileReady(const std::string &bundleName, + const std::string &fileName, + int fd, + int manifestFd, + int32_t errCode) override; + ErrCode IncrementalRestoreOnResultReport(const std::string &result, + const std::string &bundleName, + ErrCode errCode) override; + ErrCode IncrementalRestoreOnProcessInfo(const std::string &bundleName, const std::string &processInfo) override; public: ServiceReverse() = delete; diff --git a/frameworks/native/backup_kit_inner/include/service_reverse_stub.h b/frameworks/native/backup_kit_inner/include/service_reverse_stub.h deleted file mode 100644 index c981c206f918579714f1436bf1167903e612aff6..0000000000000000000000000000000000000000 --- a/frameworks/native/backup_kit_inner/include/service_reverse_stub.h +++ /dev/null @@ -1,70 +0,0 @@ -/* - * 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. - */ - -#ifndef OHOS_FILEMGMT_BACKUP_SERVICE_REVERSE_STUB_H -#define OHOS_FILEMGMT_BACKUP_SERVICE_REVERSE_STUB_H - -#include - -#include "iservice_reverse.h" -#include "iremote_stub.h" - -namespace OHOS::FileManagement::Backup { -class ServiceReverseStub : public IRemoteStub { -public: - int32_t OnRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) override; - -public: - ServiceReverseStub(); - ~ServiceReverseStub() override = default; - -private: - using ServiceInterface = int32_t (ServiceReverseStub::*)(MessageParcel &data, MessageParcel &reply); - std::map opToInterfaceMap_; - - int32_t CmdBackupOnFileReady(MessageParcel &data, MessageParcel &reply); - int32_t CmdBackupOnBundleStarted(MessageParcel &data, MessageParcel &reply); - int32_t CmdBackupOnResultReport(MessageParcel &data, MessageParcel &reply); - int32_t CmdBackupOnBundleFinished(MessageParcel &data, MessageParcel &reply); - int32_t CmdBackupOnAllBundlesFinished(MessageParcel &data, MessageParcel &reply); - int32_t CmdBackupOnProcessInfo(MessageParcel &data, MessageParcel &reply); - int32_t CmdBackupOnScanningInfo(MessageParcel &data, MessageParcel &reply); - - int32_t CmdRestoreOnBundleStarted(MessageParcel &data, MessageParcel &reply); - int32_t CmdRestoreOnBundleFinished(MessageParcel &data, MessageParcel &reply); - int32_t CmdRestoreOnAllBundlesFinished(MessageParcel &data, MessageParcel &reply); - int32_t CmdRestoreOnFileReady(MessageParcel &data, MessageParcel &reply); - int32_t CmdRestoreOnResultReport(MessageParcel &data, MessageParcel &reply); - int32_t CmdRestoreOnProcessInfo(MessageParcel &data, MessageParcel &reply); - - int32_t CmdIncrementalBackupOnFileReady(MessageParcel &data, MessageParcel &reply); - int32_t CmdIncrementalBackupOnBundleStarted(MessageParcel &data, MessageParcel &reply); - int32_t CmdIncrementalBackupOnResultReport(MessageParcel &data, MessageParcel &reply); - int32_t CmdIncrementalBackupOnBundleFinished(MessageParcel &data, MessageParcel &reply); - int32_t CmdIncrementalBackupOnAllBundlesFinished(MessageParcel &data, MessageParcel &reply); - int32_t CmdIncrementalBackupOnProcessInfo(MessageParcel &data, MessageParcel &reply); - int32_t CmdIncrementalBackupOnScanningInfo(MessageParcel &data, MessageParcel &reply); - - int32_t CmdIncrementalRestoreOnBundleStarted(MessageParcel &data, MessageParcel &reply); - int32_t CmdIncrementalRestoreOnBundleFinished(MessageParcel &data, MessageParcel &reply); - int32_t CmdIncrementalRestoreOnAllBundlesFinished(MessageParcel &data, MessageParcel &reply); - int32_t CmdIncrementalRestoreOnFileReady(MessageParcel &data, MessageParcel &reply); - int32_t CmdIncrementalRestoreOnResultReport(MessageParcel &data, MessageParcel &reply); - int32_t CmdIncrementalRestoreOnProcessInfo(MessageParcel &data, MessageParcel &reply); - void ServiceReverseStubSupplement(); -}; -} // namespace OHOS::FileManagement::Backup - -#endif // OHOS_FILEMGMT_BACKUP_SERVICE_REVERSE_STUB_H diff --git a/frameworks/native/backup_kit_inner/src/service_incremental_reverse.cpp b/frameworks/native/backup_kit_inner/src/service_incremental_reverse.cpp index 81f6ed9e691f3bd1b1624906ed581abda4933550..7cc6458570aac10c339c4031051c59b07a4ce314 100644 --- a/frameworks/native/backup_kit_inner/src/service_incremental_reverse.cpp +++ b/frameworks/native/backup_kit_inner/src/service_incremental_reverse.cpp @@ -22,137 +22,174 @@ namespace OHOS::FileManagement::Backup { using namespace std; -void ServiceReverse::IncrementalBackupOnFileReady(string bundleName, string fileName, int fd, int manifestFd, - int32_t errCode) +ErrCode ServiceReverse::IncrementalBackupOnFileReady(const std::string &bundleName, + const std::string &fileName, + int fd, + int manifestFd, + int32_t errCode) { if (scenario_ != Scenario::BACKUP || !callbacksIncrementalBackup_.onFileReady) { HILOGE("Error scenario or callback is nullptr, scenario = %{public}d", scenario_); - return; + return BError(BError::Codes::OK); } BFileInfo bFileInfo(bundleName, fileName, 0); callbacksIncrementalBackup_.onFileReady(bFileInfo, UniqueFd(fd), UniqueFd(manifestFd), errCode); + return BError(BError::Codes::OK); } -void ServiceReverse::IncrementalBackupOnBundleStarted(int32_t errCode, string bundleName) +ErrCode ServiceReverse::IncrementalSaBackupOnFileReady(const std::string &bundleName, const std::string &fileName, + int fd, int32_t errCode) +{ + if (scenario_ != Scenario::BACKUP || !callbacksIncrementalBackup_.onFileReady) { + HILOGE("Error scenario or callback is nullptr, scenario = %{public}d", scenario_); + return BError(BError::Codes::OK); + } + BFileInfo bFileInfo(bundleName, fileName, 0); + callbacksIncrementalBackup_.onFileReady(bFileInfo, UniqueFd(fd), UniqueFd(INVALID_FD), errCode); + return BError(BError::Codes::OK); +} + +ErrCode ServiceReverse::IncrementalBackupOnBundleStarted(int32_t errCode, const std::string &bundleName) { if (scenario_ != Scenario::BACKUP || !callbacksIncrementalBackup_.onBundleStarted) { HILOGE("Error scenario or callback is nullptr, scenario = %{public}d", scenario_); - return; + return BError(BError::Codes::OK); } callbacksIncrementalBackup_.onBundleStarted(errCode, bundleName); + return BError(BError::Codes::OK); } -void ServiceReverse::IncrementalBackupOnResultReport(std::string result, std::string bundleName) +ErrCode ServiceReverse::IncrementalBackupOnResultReport(const std::string &result, const std::string &bundleName) { if (scenario_ != Scenario::BACKUP || !callbacksIncrementalBackup_.onResultReport) { HILOGE("Error scenario or callback is nullptr, scenario = %{public}d", scenario_); - return; + return BError(BError::Codes::OK); } callbacksIncrementalBackup_.onResultReport(bundleName, result); + return BError(BError::Codes::OK); } -void ServiceReverse::IncrementalBackupOnBundleFinished(int32_t errCode, string bundleName) +ErrCode ServiceReverse::IncrementalBackupOnBundleFinished(int32_t errCode, const std::string &bundleName) { if (scenario_ != Scenario::BACKUP || !callbacksIncrementalBackup_.onBundleFinished) { HILOGE("Error scenario or callback is nullptr, scenario = %{public}d", scenario_); - return; + return BError(BError::Codes::OK); } HILOGI("errCode = %{public}d, bundleName = %{public}s", errCode, bundleName.c_str()); callbacksIncrementalBackup_.onBundleFinished(errCode, bundleName); + return BError(BError::Codes::OK); } -void ServiceReverse::IncrementalBackupOnAllBundlesFinished(int32_t errCode) +ErrCode ServiceReverse::IncrementalBackupOnAllBundlesFinished(int32_t errCode) { HILOGI("errCode = %{public}d", errCode); if (scenario_ != Scenario::BACKUP || !callbacksIncrementalBackup_.onAllBundlesFinished) { HILOGE("Error scenario or callback is nullptr, scenario = %{public}d", scenario_); - return; + return BError(BError::Codes::OK); } callbacksIncrementalBackup_.onAllBundlesFinished(errCode); + return BError(BError::Codes::OK); } -void ServiceReverse::IncrementalBackupOnProcessInfo(std::string bundleName, std::string processInfo) +ErrCode ServiceReverse::IncrementalBackupOnProcessInfo(const std::string &bundleName, const std::string &processInfo) { HILOGI("bundleName = %{public}s", bundleName.c_str()); if (scenario_ != Scenario::BACKUP || !callbacksIncrementalBackup_.onProcess) { HILOGE("Error scenario or callback is nullptr, scenario = %{public}d", scenario_); - return; + return BError(BError::Codes::OK); } callbacksIncrementalBackup_.onProcess(bundleName, processInfo); + return BError(BError::Codes::OK); } -void ServiceReverse::IncrementalBackupOnScanningInfo(std::string scannedInfo) +ErrCode ServiceReverse::IncrementalBackupOnScanningInfo(const std::string &scannedInfo) { if (scenario_ != Scenario::BACKUP || !callbacksIncrementalBackup_.onBackupSizeReport) { HILOGE("Error scenario or callback is nullptr, scenario = %{public}d", scenario_); - return; + return BError(BError::Codes::OK); } callbacksIncrementalBackup_.onBackupSizeReport(scannedInfo); + return BError(BError::Codes::OK); } -void ServiceReverse::IncrementalRestoreOnBundleStarted(int32_t errCode, string bundleName) +ErrCode ServiceReverse::IncrementalRestoreOnBundleStarted(int32_t errCode, const std::string &bundleName) { if (scenario_ != Scenario::RESTORE || !callbacksIncrementalRestore_.onBundleStarted) { HILOGE("Error scenario or callback is nullptr, scenario = %{public}d", scenario_); - return; + return BError(BError::Codes::OK); } callbacksIncrementalRestore_.onBundleStarted(errCode, bundleName); + return BError(BError::Codes::OK); } -void ServiceReverse::IncrementalRestoreOnBundleFinished(int32_t errCode, string bundleName) +ErrCode ServiceReverse::IncrementalRestoreOnBundleFinished(int32_t errCode, const std::string &bundleName) { if (scenario_ != Scenario::RESTORE || !callbacksIncrementalRestore_.onBundleFinished) { HILOGE("Error scenario or callback is nullptr, scenario = %{public}d", scenario_); - return; + return BError(BError::Codes::OK); } HILOGI("errCode = %{public}d, bundleName = %{public}s", errCode, bundleName.c_str()); callbacksIncrementalRestore_.onBundleFinished(errCode, bundleName); + return BError(BError::Codes::OK); } -void ServiceReverse::IncrementalRestoreOnAllBundlesFinished(int32_t errCode) +ErrCode ServiceReverse::IncrementalRestoreOnAllBundlesFinished(int32_t errCode) { HILOGI("errCode = %{public}d", errCode); if (scenario_ != Scenario::RESTORE || !callbacksIncrementalRestore_.onAllBundlesFinished) { HILOGE("Error scenario or callback is nullptr, scenario = %{public}d", scenario_); - return; + return BError(BError::Codes::OK); } callbacksIncrementalRestore_.onAllBundlesFinished(errCode); + return BError(BError::Codes::OK); } -void ServiceReverse::IncrementalRestoreOnFileReady(string bundleName, string fileName, int fd, int manifestFd, - int32_t errCode) +ErrCode ServiceReverse::IncrementalRestoreOnFileReady(const std::string &bundleName, + const std::string &fileName, + int fd, + int manifestFd, + int32_t errCode) { + if (fd < 0 || manifestFd < 0) { + HILOGE("Error fd or manifestFd, fd = %{public}d, manifestFd = %{public}d", fd, manifestFd); + return BError(BError::Codes::SA_INVAL_ARG); + } if (scenario_ != Scenario::RESTORE || !callbacksIncrementalRestore_.onFileReady) { HILOGE("Error scenario or callback is nullptr, scenario = %{public}d", scenario_); - return; + return BError(BError::Codes::OK); } BFileInfo bFileInfo(bundleName, fileName, 0); callbacksIncrementalRestore_.onFileReady(bFileInfo, UniqueFd(fd), UniqueFd(manifestFd), errCode); + return BError(BError::Codes::OK); } -void ServiceReverse::IncrementalRestoreOnResultReport(std::string result, std::string bundleName, ErrCode errCode) +ErrCode ServiceReverse::IncrementalRestoreOnResultReport(const std::string &result, + const std::string &bundleName, + ErrCode errCode) { HILOGI("begin incremental restore on result report, bundleName:%{public}s", bundleName.c_str()); if (scenario_ != Scenario::RESTORE || !callbacksIncrementalRestore_.onResultReport) { HILOGE("Error scenario or callback is nullptr, scenario = %{public}d", scenario_); - return; + return BError(BError::Codes::OK); } callbacksIncrementalRestore_.onResultReport(bundleName, result); if (scenario_ != Scenario::RESTORE || !callbacksIncrementalRestore_.onBundleFinished) { HILOGE("Error scenario or callback is nullptr, scenario = %{public}d", scenario_); - return; + return BError(BError::Codes::OK); } callbacksIncrementalRestore_.onBundleFinished(errCode, bundleName); + return BError(BError::Codes::OK); } -void ServiceReverse::IncrementalRestoreOnProcessInfo(std::string bundleName, std::string processInfo) +ErrCode ServiceReverse::IncrementalRestoreOnProcessInfo(const std::string &bundleName, const std::string &processInfo) { HILOGI("begin incremental report processInfo, bundleName:%{public}s", bundleName.c_str()); if (scenario_ != Scenario::RESTORE || !callbacksIncrementalRestore_.onProcess) { HILOGE("Error scenario or callback is nullptr, scenario = %{public}d", scenario_); - return; + return BError(BError::Codes::OK); } callbacksIncrementalRestore_.onProcess(bundleName, processInfo); + return BError(BError::Codes::OK); } ServiceReverse::ServiceReverse(BIncrementalBackupSession::Callbacks callbacks) diff --git a/frameworks/native/backup_kit_inner/src/service_reverse.cpp b/frameworks/native/backup_kit_inner/src/service_reverse.cpp index 100a0dd09d4f7ef62b1b06b943ee4baa4b93fb83..0db73caec36d071d4a0b7954cfddbf1d1d0dfa0c 100644 --- a/frameworks/native/backup_kit_inner/src/service_reverse.cpp +++ b/frameworks/native/backup_kit_inner/src/service_reverse.cpp @@ -21,137 +21,156 @@ namespace OHOS::FileManagement::Backup { using namespace std; -void ServiceReverse::BackupOnFileReady(string bundleName, string fileName, int fd, int32_t errCode) +ErrCode ServiceReverse::BackupOnFileReady(const std::string &bundleName, + const std::string &fileName, + int fd, + int32_t errCode) { if (scenario_ != Scenario::BACKUP || !callbacksBackup_.onFileReady) { HILOGE("Error scenario or callback is nullptr, scenario = %{public}d", scenario_); - return; + return BError(BError::Codes::OK); } BFileInfo bFileInfo(bundleName, fileName, 0); callbacksBackup_.onFileReady(bFileInfo, UniqueFd(fd), errCode); + return BError(BError::Codes::OK); } -void ServiceReverse::BackupOnBundleStarted(int32_t errCode, string bundleName) +ErrCode ServiceReverse::BackupOnBundleStarted(int32_t errCode, const std::string &bundleName) { if (scenario_ != Scenario::BACKUP || !callbacksBackup_.onBundleStarted) { HILOGE("Error scenario or callback is nullptr, scenario = %{public}d", scenario_); - return; + return BError(BError::Codes::OK); } callbacksBackup_.onBundleStarted(errCode, bundleName); + return BError(BError::Codes::OK); } -void ServiceReverse::BackupOnResultReport(std::string result, std::string bundleName) +ErrCode ServiceReverse::BackupOnResultReport(const std::string &result, const std::string &bundleName) { if (scenario_ != Scenario::BACKUP || !callbacksBackup_.onResultReport) { HILOGE("Error scenario or callback is nullptr, scenario = %{public}d", scenario_); - return; + return BError(BError::Codes::OK); } callbacksBackup_.onResultReport(bundleName, result); + return BError(BError::Codes::OK); } -void ServiceReverse::BackupOnBundleFinished(int32_t errCode, string bundleName) +ErrCode ServiceReverse::BackupOnBundleFinished(int32_t errCode, const std::string &bundleName) { if (scenario_ != Scenario::BACKUP || !callbacksBackup_.onBundleFinished) { HILOGE("Error scenario or callback is nullptr, scenario = %{public}d", scenario_); - return; + return BError(BError::Codes::OK); } HILOGI("errCode = %{public}d, bundleName = %{public}s", errCode, bundleName.c_str()); callbacksBackup_.onBundleFinished(errCode, bundleName); + return BError(BError::Codes::OK); } -void ServiceReverse::BackupOnAllBundlesFinished(int32_t errCode) +ErrCode ServiceReverse::BackupOnAllBundlesFinished(int32_t errCode) { HILOGI("errCode = %{public}d", errCode); if (scenario_ != Scenario::BACKUP || !callbacksBackup_.onAllBundlesFinished) { HILOGE("Error scenario or callback is nullptr, scenario = %{public}d", scenario_); - return; + return BError(BError::Codes::OK); } callbacksBackup_.onAllBundlesFinished(errCode); + return BError(BError::Codes::OK); } -void ServiceReverse::BackupOnProcessInfo(std::string bundleName, std::string processInfo) +ErrCode ServiceReverse::BackupOnProcessInfo(const std::string &bundleName, const std::string &processInfo) { HILOGI("bundleName = %{public}s", bundleName.c_str()); if (scenario_ != Scenario::BACKUP || !callbacksBackup_.onProcess) { HILOGI("Error scenario or callback is nullptr"); - return; + return BError(BError::Codes::OK); } callbacksBackup_.onProcess(bundleName, processInfo); + return BError(BError::Codes::OK); } -void ServiceReverse::BackupOnScanningInfo(std::string scannedInfo) +ErrCode ServiceReverse::BackupOnScanningInfo(const std::string &scannedInfo) { if (scenario_ != Scenario::BACKUP || !callbacksBackup_.onBackupSizeReport) { HILOGE("Error scenario or callback is nullptr"); - return; + return BError(BError::Codes::OK); } callbacksBackup_.onBackupSizeReport(scannedInfo); + return BError(BError::Codes::OK); } -void ServiceReverse::RestoreOnBundleStarted(int32_t errCode, string bundleName) +ErrCode ServiceReverse::RestoreOnBundleStarted(int32_t errCode, const std::string &bundleName) { if (scenario_ != Scenario::RESTORE || !callbacksRestore_.onBundleStarted) { HILOGE("Error scenario or callback is nullptr, scenario = %{public}d", scenario_); - return; + return BError(BError::Codes::OK); } callbacksRestore_.onBundleStarted(errCode, bundleName); + return BError(BError::Codes::OK); } -void ServiceReverse::RestoreOnBundleFinished(int32_t errCode, string bundleName) +ErrCode ServiceReverse::RestoreOnBundleFinished(int32_t errCode, const std::string &bundleName) { if (scenario_ != Scenario::RESTORE || !callbacksRestore_.onBundleFinished) { HILOGE("Error scenario or callback is nullptr, scenario = %{public}d", scenario_); - return; + return BError(BError::Codes::OK); } HILOGI("errCode = %{public}d, bundleName = %{public}s", errCode, bundleName.c_str()); callbacksRestore_.onBundleFinished(errCode, bundleName); + return BError(BError::Codes::OK); } -void ServiceReverse::RestoreOnAllBundlesFinished(int32_t errCode) +ErrCode ServiceReverse::RestoreOnAllBundlesFinished(int32_t errCode) { HILOGI("errCode = %{public}d", errCode); if (scenario_ != Scenario::RESTORE || !callbacksRestore_.onAllBundlesFinished) { HILOGE("Error scenario or callback is nullptr, scenario = %{public}d", scenario_); - return; + return BError(BError::Codes::OK); } callbacksRestore_.onAllBundlesFinished(errCode); + return BError(BError::Codes::OK); } -void ServiceReverse::RestoreOnFileReady(string bundleName, string fileName, int fd, int32_t errCode) +ErrCode ServiceReverse::RestoreOnFileReady(const std::string &bundleName, + const std::string &fileName, + int fd, + int32_t errCode) { HILOGD("begin, bundleName is:%{public}s", bundleName.c_str()); if (scenario_ != Scenario::RESTORE || !callbacksRestore_.onFileReady) { HILOGE("Error scenario or callback is nullptr, scenario = %{public}d", scenario_); - return; + return BError(BError::Codes::OK); } BFileInfo bFileInfo(bundleName, fileName, 0); callbacksRestore_.onFileReady(bFileInfo, UniqueFd(fd), errCode); + return BError(BError::Codes::OK); } -void ServiceReverse::RestoreOnResultReport(string result, std::string bundleName, ErrCode errCode) +ErrCode ServiceReverse::RestoreOnResultReport(const std::string &result, const std::string &bundleName, ErrCode errCode) { HILOGI("ServiceReverse RestoreOnResultReport bundle %{public}s begin with result: %{public}s", bundleName.c_str(), - result.c_str()); + result.c_str()); if (scenario_ != Scenario::RESTORE || !callbacksRestore_.onResultReport) { HILOGE("Error scenario or callback is nullptr, scenario = %{public}d", scenario_); - return; + return BError(BError::Codes::OK); } callbacksRestore_.onResultReport(bundleName, result); if (scenario_ != Scenario::RESTORE || !callbacksRestore_.onBundleFinished) { HILOGE("Error scenario or callback is nullptr, scenario = %{public}d", scenario_); - return; + return BError(BError::Codes::OK); } callbacksRestore_.onBundleFinished(errCode, bundleName); + return BError(BError::Codes::OK); } -void ServiceReverse::RestoreOnProcessInfo(std::string bundleName, std::string processInfo) +ErrCode ServiceReverse::RestoreOnProcessInfo(const std::string &bundleName, const std::string &processInfo) { HILOGI("bundleName = %{public}s", bundleName.c_str()); if (scenario_ != Scenario::RESTORE || !callbacksRestore_.onProcess) { HILOGI("Error scenario or callback is nullptr"); - return; + return BError(BError::Codes::OK); } callbacksRestore_.onProcess(bundleName, processInfo); + return BError(BError::Codes::OK); } ServiceReverse::ServiceReverse(BSessionBackup::Callbacks callbacks) diff --git a/frameworks/native/backup_kit_inner/src/service_reverse_stub.cpp b/frameworks/native/backup_kit_inner/src/service_reverse_stub.cpp deleted file mode 100644 index 2fae0a24aa3980a95bbdb7700849d9f10f8720ee..0000000000000000000000000000000000000000 --- a/frameworks/native/backup_kit_inner/src/service_reverse_stub.cpp +++ /dev/null @@ -1,359 +0,0 @@ -/* - * Copyright (c) 2022-2024 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 "service_reverse_stub.h" - -#include -#include - -#include "b_error/b_error.h" -#include "filemgmt_libhilog.h" - -namespace OHOS::FileManagement::Backup { -using namespace std; -const int INVALID_FD = -1; -int32_t ServiceReverseStub::OnRemoteRequest(uint32_t code, - MessageParcel &data, - MessageParcel &reply, - MessageOption &option) -{ - const std::u16string descriptor = ServiceReverseStub::GetDescriptor(); - const std::u16string remoteDescriptor = data.ReadInterfaceToken(); - if (descriptor != remoteDescriptor) { - return BError(BError::Codes::SA_INVAL_ARG, "Invalid remote descriptor"); - } - - HILOGD("Begin to call procedure indexed %{public}u", code); - auto interfaceIndex = opToInterfaceMap_.find(code); - if (interfaceIndex == opToInterfaceMap_.end() || !interfaceIndex->second) { - HILOGE("Cannot response request %{public}d : unknown procedure", code); - return IPCObjectStub::OnRemoteRequest(code, data, reply, option); - } - return (this->*(interfaceIndex->second))(data, reply); -} -void ServiceReverseStub::ServiceReverseStubSupplement() -{ - opToInterfaceMap_[static_cast( - IServiceReverseInterfaceCode::SERVICER_INCREMENTAL_BACKUP_ON_SCANNED_INFO)] = - &ServiceReverseStub::CmdIncrementalBackupOnScanningInfo; - opToInterfaceMap_[static_cast(IServiceReverseInterfaceCode::SERVICER_INCREMENTAL_RESTORE_ON_FILE_READY)] = - &ServiceReverseStub::CmdIncrementalRestoreOnFileReady; - opToInterfaceMap_[static_cast( - IServiceReverseInterfaceCode::SERVICER_INCREMENTAL_RESTORE_ON_SUB_TASK_STARTED)] = - &ServiceReverseStub::CmdIncrementalRestoreOnBundleStarted; - opToInterfaceMap_[static_cast( - IServiceReverseInterfaceCode::SERVICER_INCREMENTAL_RESTORE_ON_RESULT_REPORT)] = - &ServiceReverseStub::CmdIncrementalRestoreOnResultReport; - opToInterfaceMap_[static_cast( - IServiceReverseInterfaceCode::SERVICER_INCREMENTAL_RESTORE_ON_SUB_TASK_FINISHED)] = - &ServiceReverseStub::CmdIncrementalRestoreOnBundleFinished; - opToInterfaceMap_[static_cast( - IServiceReverseInterfaceCode::SERVICER_INCREMENTAL_RESTORE_ON_TASK_FINISHED)] = - &ServiceReverseStub::CmdIncrementalRestoreOnAllBundlesFinished; - opToInterfaceMap_[static_cast( - IServiceReverseInterfaceCode::SERVICER_INCREMENTAL_RESTORE_ON_PROCESS_INFO)] = - &ServiceReverseStub::CmdIncrementalRestoreOnProcessInfo; -} - -ServiceReverseStub::ServiceReverseStub() -{ - opToInterfaceMap_[static_cast(IServiceReverseInterfaceCode::SERVICER_BACKUP_ON_FILE_READY)] = - &ServiceReverseStub::CmdBackupOnFileReady; - opToInterfaceMap_[static_cast(IServiceReverseInterfaceCode::SERVICER_BACKUP_ON_SUB_TASK_STARTED)] = - &ServiceReverseStub::CmdBackupOnBundleStarted; - opToInterfaceMap_[static_cast(IServiceReverseInterfaceCode::SERVICER_BACKUP_ON_RESULT_REPORT)] = - &ServiceReverseStub::CmdBackupOnResultReport; - opToInterfaceMap_[static_cast(IServiceReverseInterfaceCode::SERVICER_BACKUP_ON_SUB_TASK_FINISHED)] = - &ServiceReverseStub::CmdBackupOnBundleFinished; - opToInterfaceMap_[static_cast(IServiceReverseInterfaceCode::SERVICER_BACKUP_ON_TASK_FINISHED)] = - &ServiceReverseStub::CmdBackupOnAllBundlesFinished; - opToInterfaceMap_[static_cast(IServiceReverseInterfaceCode::SERVICER_BACKUP_ON_PROCESS_INFO)] = - &ServiceReverseStub::CmdBackupOnProcessInfo; - opToInterfaceMap_[static_cast(IServiceReverseInterfaceCode::SERVICER_BACKUP_ON_SCANNED_INFO)] = - &ServiceReverseStub::CmdBackupOnScanningInfo; - - opToInterfaceMap_[static_cast(IServiceReverseInterfaceCode::SERVICER_RESTORE_ON_FILE_READY)] = - &ServiceReverseStub::CmdRestoreOnFileReady; - opToInterfaceMap_[static_cast(IServiceReverseInterfaceCode::SERVICER_RESTORE_ON_SUB_TASK_STARTED)] = - &ServiceReverseStub::CmdRestoreOnBundleStarted; - opToInterfaceMap_[static_cast(IServiceReverseInterfaceCode::SERVICER_RESTORE_ON_RESULT_REPORT)] = - &ServiceReverseStub::CmdRestoreOnResultReport; - opToInterfaceMap_[static_cast(IServiceReverseInterfaceCode::SERVICER_RESTORE_ON_SUB_TASK_FINISHED)] = - &ServiceReverseStub::CmdRestoreOnBundleFinished; - opToInterfaceMap_[static_cast(IServiceReverseInterfaceCode::SERVICER_RESTORE_ON_TASK_FINISHED)] = - &ServiceReverseStub::CmdRestoreOnAllBundlesFinished; - opToInterfaceMap_[static_cast(IServiceReverseInterfaceCode::SERVICER_RESTORE_ON_PROCESS_INFO)] = - &ServiceReverseStub::CmdRestoreOnProcessInfo; - - opToInterfaceMap_[static_cast(IServiceReverseInterfaceCode::SERVICER_INCREMENTAL_BACKUP_ON_FILE_READY)] = - &ServiceReverseStub::CmdIncrementalBackupOnFileReady; - opToInterfaceMap_[static_cast( - IServiceReverseInterfaceCode::SERVICER_INCREMENTAL_BACKUP_ON_SUB_TASK_STARTED)] = - &ServiceReverseStub::CmdIncrementalBackupOnBundleStarted; - opToInterfaceMap_[static_cast(IServiceReverseInterfaceCode::SERVICER_INCREMENTAL_BACKUP_ON_RESULT_REPORT)] - = &ServiceReverseStub::CmdIncrementalBackupOnResultReport; - opToInterfaceMap_[static_cast( - IServiceReverseInterfaceCode::SERVICER_INCREMENTAL_BACKUP_ON_SUB_TASK_FINISHED)] = - &ServiceReverseStub::CmdIncrementalBackupOnBundleFinished; - opToInterfaceMap_[static_cast( - IServiceReverseInterfaceCode::SERVICER_INCREMENTAL_BACKUP_ON_TASK_FINISHED)] = - &ServiceReverseStub::CmdIncrementalBackupOnAllBundlesFinished; - opToInterfaceMap_[static_cast( - IServiceReverseInterfaceCode::SERVICER_INCREMENTAL_BACKUP_ON_PROCESS_INFO)] = - &ServiceReverseStub::CmdIncrementalBackupOnProcessInfo; - ServiceReverseStubSupplement(); -} - -int32_t ServiceReverseStub::CmdBackupOnFileReady(MessageParcel &data, MessageParcel &reply) -{ - auto bundleName = data.ReadString(); - auto fileName = data.ReadString(); - int fd = INVALID_FD; - bool fdFlag = data.ReadBool(); - if (fdFlag == true) { - fd = data.ReadFileDescriptor(); - } - int32_t errCode = data.ReadInt32(); - BackupOnFileReady(bundleName, fileName, fd, errCode); - return BError(BError::Codes::OK); -} - -int32_t ServiceReverseStub::CmdBackupOnResultReport(MessageParcel &data, MessageParcel &reply) -{ - std::string result = data.ReadString(); - std::string bundleName = data.ReadString(); - BackupOnResultReport(result, bundleName); - return BError(BError::Codes::OK); -} - -int32_t ServiceReverseStub::CmdBackupOnBundleStarted(MessageParcel &data, MessageParcel &reply) -{ - int32_t errCode = data.ReadInt32(); - auto bundleName = data.ReadString(); - BackupOnBundleStarted(errCode, bundleName); - return BError(BError::Codes::OK); -} - -int32_t ServiceReverseStub::CmdBackupOnBundleFinished(MessageParcel &data, MessageParcel &reply) -{ - int32_t errCode = data.ReadInt32(); - auto bundleName = data.ReadString(); - BackupOnBundleFinished(errCode, bundleName); - return BError(BError::Codes::OK); -} - -int32_t ServiceReverseStub::CmdBackupOnAllBundlesFinished(MessageParcel &data, MessageParcel &reply) -{ - int32_t errCode = data.ReadInt32(); - BackupOnAllBundlesFinished(errCode); - return BError(BError::Codes::OK); -} - -int32_t ServiceReverseStub::CmdBackupOnProcessInfo(MessageParcel &data, MessageParcel &reply) -{ - std::string bundleName = data.ReadString(); - std::string processInfo = data.ReadString(); - BackupOnProcessInfo(bundleName, processInfo); - return BError(BError::Codes::OK); -} - -int32_t ServiceReverseStub::CmdBackupOnScanningInfo(MessageParcel &data, MessageParcel &reply) -{ - std::string scannedInfo = data.ReadString(); - BackupOnScanningInfo(scannedInfo); - return BError(BError::Codes::OK); -} - -int32_t ServiceReverseStub::CmdRestoreOnBundleStarted(MessageParcel &data, MessageParcel &reply) -{ - int32_t errCode = data.ReadInt32(); - auto bundleName = data.ReadString(); - RestoreOnBundleStarted(errCode, bundleName); - return BError(BError::Codes::OK); -} - -int32_t ServiceReverseStub::CmdRestoreOnBundleFinished(MessageParcel &data, MessageParcel &reply) -{ - int32_t errCode = data.ReadInt32(); - auto bundleName = data.ReadString(); - RestoreOnBundleFinished(errCode, bundleName); - return BError(BError::Codes::OK); -} - -int32_t ServiceReverseStub::CmdRestoreOnAllBundlesFinished(MessageParcel &data, MessageParcel &reply) -{ - int32_t errCode = data.ReadInt32(); - RestoreOnAllBundlesFinished(errCode); - return BError(BError::Codes::OK); -} - -int32_t ServiceReverseStub::CmdRestoreOnFileReady(MessageParcel &data, MessageParcel &reply) -{ - auto bundleName = data.ReadString(); - auto fileName = data.ReadString(); - int fd = INVALID_FD; - bool fdFlag = data.ReadBool(); - if (fdFlag == true) { - fd = data.ReadFileDescriptor(); - } - int32_t errCode = data.ReadInt32(); - RestoreOnFileReady(bundleName, fileName, fd, errCode); - return BError(BError::Codes::OK); -} - -int32_t ServiceReverseStub::CmdRestoreOnResultReport(MessageParcel &data, MessageParcel &reply) -{ - std::string result; - if (!data.ReadString(result)) { - return BError(BError::Codes::EXT_INVAL_ARG, "Failed to read result").GetCode(); - } - std::string bundleName; - if (!data.ReadString(bundleName)) { - return BError(BError::Codes::EXT_INVAL_ARG, "Failed to read bundleName").GetCode(); - } - ErrCode errCode; - if (!data.ReadInt32(errCode)) { - return BError(BError::Codes::EXT_INVAL_ARG, "Failed to read errCode").GetCode(); - } - RestoreOnResultReport(result, bundleName, errCode); - return BError(BError::Codes::OK); -} - -int32_t ServiceReverseStub::CmdRestoreOnProcessInfo(MessageParcel &data, MessageParcel &reply) -{ - std::string bundleName = data.ReadString(); - std::string processInfo = data.ReadString(); - RestoreOnProcessInfo(bundleName, processInfo); - return BError(BError::Codes::OK); -} - -int32_t ServiceReverseStub::CmdIncrementalBackupOnFileReady(MessageParcel &data, MessageParcel &reply) -{ - auto bundleName = data.ReadString(); - auto fileName = data.ReadString(); - int fd = INVALID_FD; - int manifestFd = INVALID_FD; - bool fdFlag = data.ReadBool(); - if (fdFlag == true) { - fd = data.ReadFileDescriptor(); - manifestFd = data.ReadFileDescriptor(); - } - int32_t errCode = data.ReadInt32(); - IncrementalBackupOnFileReady(bundleName, fileName, fd, manifestFd, errCode); - return BError(BError::Codes::OK); -} - -int32_t ServiceReverseStub::CmdIncrementalBackupOnBundleStarted(MessageParcel &data, MessageParcel &reply) -{ - int32_t errCode = data.ReadInt32(); - auto bundleName = data.ReadString(); - IncrementalBackupOnBundleStarted(errCode, bundleName); - return BError(BError::Codes::OK); -} - -int32_t ServiceReverseStub::CmdIncrementalBackupOnResultReport(MessageParcel &data, MessageParcel &reply) -{ - std::string result = data.ReadString(); - std::string bundleName = data.ReadString(); - IncrementalBackupOnResultReport(result, bundleName); - return BError(BError::Codes::OK); -} - -int32_t ServiceReverseStub::CmdIncrementalBackupOnBundleFinished(MessageParcel &data, MessageParcel &reply) -{ - int32_t errCode = data.ReadInt32(); - auto bundleName = data.ReadString(); - IncrementalBackupOnBundleFinished(errCode, bundleName); - return BError(BError::Codes::OK); -} - -int32_t ServiceReverseStub::CmdIncrementalBackupOnAllBundlesFinished(MessageParcel &data, MessageParcel &reply) -{ - int32_t errCode = data.ReadInt32(); - IncrementalBackupOnAllBundlesFinished(errCode); - return BError(BError::Codes::OK); -} - -int32_t ServiceReverseStub::CmdIncrementalBackupOnProcessInfo(MessageParcel &data, MessageParcel &reply) -{ - std::string bundleName = data.ReadString(); - std::string processInfo = data.ReadString(); - IncrementalBackupOnProcessInfo(bundleName, processInfo); - return BError(BError::Codes::OK); -} - -int32_t ServiceReverseStub::CmdIncrementalBackupOnScanningInfo(MessageParcel &data, MessageParcel &reply) -{ - std::string scannedInfo = data.ReadString(); - IncrementalBackupOnScanningInfo(scannedInfo); - return BError(BError::Codes::OK); -} - -int32_t ServiceReverseStub::CmdIncrementalRestoreOnBundleStarted(MessageParcel &data, MessageParcel &reply) -{ - int32_t errCode = data.ReadInt32(); - auto bundleName = data.ReadString(); - IncrementalRestoreOnBundleStarted(errCode, bundleName); - return BError(BError::Codes::OK); -} - -int32_t ServiceReverseStub::CmdIncrementalRestoreOnBundleFinished(MessageParcel &data, MessageParcel &reply) -{ - int32_t errCode = data.ReadInt32(); - auto bundleName = data.ReadString(); - IncrementalRestoreOnBundleFinished(errCode, bundleName); - return BError(BError::Codes::OK); -} - -int32_t ServiceReverseStub::CmdIncrementalRestoreOnAllBundlesFinished(MessageParcel &data, MessageParcel &reply) -{ - int32_t errCode = data.ReadInt32(); - IncrementalRestoreOnAllBundlesFinished(errCode); - return BError(BError::Codes::OK); -} - -int32_t ServiceReverseStub::CmdIncrementalRestoreOnFileReady(MessageParcel &data, MessageParcel &reply) -{ - auto bundleName = data.ReadString(); - auto fileName = data.ReadString(); - int fd = INVALID_FD; - int manifestFd = INVALID_FD; - bool fdFlag = data.ReadBool(); - if (fdFlag == true) { - fd = data.ReadFileDescriptor(); - manifestFd = data.ReadFileDescriptor(); - } - int32_t errCode = data.ReadInt32(); - IncrementalRestoreOnFileReady(bundleName, fileName, fd, manifestFd, errCode); - return BError(BError::Codes::OK); -} - -int32_t ServiceReverseStub::CmdIncrementalRestoreOnResultReport(MessageParcel &data, MessageParcel &reply) -{ - auto result = data.ReadString(); - auto bundleName = data.ReadString(); - ErrCode errCode = data.ReadInt32(); - IncrementalRestoreOnResultReport(result, bundleName, errCode); - return BError(BError::Codes::OK); -} - -int32_t ServiceReverseStub::CmdIncrementalRestoreOnProcessInfo(MessageParcel &data, MessageParcel &reply) -{ - auto bundleName = data.ReadString(); - auto processInfo = data.ReadString(); - IncrementalRestoreOnProcessInfo(bundleName, processInfo); - return BError(BError::Codes::OK); -} -} // namespace OHOS::FileManagement::Backup \ No newline at end of file diff --git a/interfaces/inner_api/native/backup_kit_inner/BUILD.gn b/interfaces/inner_api/native/backup_kit_inner/BUILD.gn index 699a965c0ac0f57ee99924c273b0c7e44931dc65..70593df50e2cbcb94c6766ac0958a22b18cceb64 100644 --- a/interfaces/inner_api/native/backup_kit_inner/BUILD.gn +++ b/interfaces/inner_api/native/backup_kit_inner/BUILD.gn @@ -55,7 +55,6 @@ ohos_shared_library("backup_kit_inner") { "${path_backup}/frameworks/native/backup_kit_inner/src/service_client.cpp", "${path_backup}/frameworks/native/backup_kit_inner/src/service_incremental_reverse.cpp", "${path_backup}/frameworks/native/backup_kit_inner/src/service_reverse.cpp", - "${path_backup}/frameworks/native/backup_kit_inner/src/service_reverse_stub.cpp", ] defines = [ diff --git a/interfaces/inner_api/native/backup_kit_inner/impl/i_extension.h b/interfaces/inner_api/native/backup_kit_inner/impl/i_extension.h deleted file mode 100644 index 7ce72f1a3aaa28a87e7aaf04f84108617987e7ea..0000000000000000000000000000000000000000 --- a/interfaces/inner_api/native/backup_kit_inner/impl/i_extension.h +++ /dev/null @@ -1,47 +0,0 @@ -/* - * Copyright (c) 2022-2024 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. - */ - -#ifndef OHOS_FILEMGMT_BACKUP_I_EXTENSION_H -#define OHOS_FILEMGMT_BACKUP_I_EXTENSION_H - -#include "errors.h" -#include "i_extension_ipc_interface_code.h" -#include "iremote_broker.h" -#include "unique_fd.h" - -namespace OHOS::FileManagement::Backup { -class IExtension : public IRemoteBroker { -public: - DECLARE_INTERFACE_DESCRIPTOR(u"OHOS.FileManagement.Backup.IExtension"); - -public: - virtual ~IExtension() = default; - virtual UniqueFd GetFileHandle(const std::string &fileName, int32_t &errCode) = 0; - virtual ErrCode HandleClear() = 0; - virtual ErrCode HandleBackup(bool isClearData) = 0; - virtual ErrCode PublishFile(const std::string &fileName) = 0; - virtual ErrCode HandleRestore(bool isClearData) = 0; - virtual std::tuple GetIncrementalFileHandle(const std::string &fileName) = 0; - virtual ErrCode PublishIncrementalFile(const std::string &fileName) = 0; - virtual ErrCode HandleIncrementalBackup(UniqueFd incrementalFd, UniqueFd manifestFd) = 0; - virtual ErrCode IncrementalOnBackup(bool isClearData) = 0; - virtual std::tuple GetIncrementalBackupFileHandle() = 0; - virtual ErrCode GetBackupInfo(std::string &result) = 0; - virtual ErrCode UpdateFdSendRate(std::string &bundleName, int32_t sendRate) = 0; - virtual ErrCode User0OnBackup() = 0; -}; -} // namespace OHOS::FileManagement::Backup - -#endif // OHOS_FILEMGMT_BACKUP_I_EXTENSION_H \ No newline at end of file diff --git a/interfaces/inner_api/native/backup_kit_inner/impl/i_service_reverse_ipc_interface_code.h b/interfaces/inner_api/native/backup_kit_inner/impl/i_service_reverse_ipc_interface_code.h deleted file mode 100644 index cd06fa1d21beae4a7313b51616f109521339e66f..0000000000000000000000000000000000000000 --- a/interfaces/inner_api/native/backup_kit_inner/impl/i_service_reverse_ipc_interface_code.h +++ /dev/null @@ -1,52 +0,0 @@ -/* - * Copyright (c) 2024 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. - */ - -#ifndef OHOS_FILEMGMT_BACKUP_I_SERVICE_REVERSE_IPC_INTERFACE_CODE_H -#define OHOS_FILEMGMT_BACKUP_I_SERVICE_REVERSE_IPC_INTERFACE_CODE_H - -/*SAID: 5203*/ -namespace OHOS::FileManagement::Backup { -enum class IServiceReverseInterfaceCode { - SERVICER_BACKUP_ON_FILE_READY, - SERVICER_BACKUP_ON_SUB_TASK_STARTED, - SERVICER_BACKUP_ON_SUB_TASK_FINISHED, - SERVICER_BACKUP_ON_TASK_FINISHED, - SERVICER_BACKUP_ON_RESULT_REPORT, - SERVICER_BACKUP_ON_PROCESS_INFO, - SERVICER_BACKUP_ON_SCANNED_INFO, - SERVICER_RESTORE_ON_SUB_TASK_STARTED, - SERVICER_RESTORE_ON_SUB_TASK_FINISHED, - SERVICER_RESTORE_ON_TASK_FINISHED, - SERVICER_RESTORE_ON_FILE_READY, - SERVICER_RESTORE_ON_RESULT_REPORT, - SERVICER_RESTORE_ON_PROCESS_INFO, - SERVICER_INCREMENTAL_BACKUP_ON_FILE_READY, - SERVICER_INCREMENTAL_BACKUP_ON_SUB_TASK_STARTED, - SERVICER_INCREMENTAL_BACKUP_ON_SUB_TASK_FINISHED, - SERVICER_INCREMENTAL_BACKUP_ON_TASK_FINISHED, - SERVICER_INCREMENTAL_BACKUP_ON_RESULT_REPORT, - SERVICER_INCREMENTAL_BACKUP_ON_PROCESS_INFO, - SERVICER_INCREMENTAL_BACKUP_ON_SCANNED_INFO, - SERVICER_INCREMENTAL_RESTORE_ON_SUB_TASK_STARTED, - SERVICER_INCREMENTAL_RESTORE_ON_SUB_TASK_FINISHED, - SERVICER_INCREMENTAL_RESTORE_ON_TASK_FINISHED, - SERVICER_INCREMENTAL_RESTORE_ON_FILE_READY, - SERVICER_INCREMENTAL_RESTORE_ON_RESULT_REPORT, - SERVICER_INCREMENTAL_RESTORE_ON_PROCESS_INFO, -}; - -} // namespace OHOS::FileManagement::Backup - -#endif // OHOS_FILEMGMT_BACKUP_I_SERVICE_REVERSE_IPC_INTERFACE_CODE_H \ No newline at end of file diff --git a/interfaces/inner_api/native/backup_kit_inner/impl/iservice_reverse.h b/interfaces/inner_api/native/backup_kit_inner/impl/iservice_reverse.h deleted file mode 100644 index c91ca3d5b0150a892a48465d951a98a18a7f5451..0000000000000000000000000000000000000000 --- a/interfaces/inner_api/native/backup_kit_inner/impl/iservice_reverse.h +++ /dev/null @@ -1,76 +0,0 @@ -/* - * 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. - */ - -#ifndef OHOS_FILEMGMT_BACKUP_I_SERVICE_REVERSE_H -#define OHOS_FILEMGMT_BACKUP_I_SERVICE_REVERSE_H - -#include - -#include "i_service_reverse_ipc_interface_code.h" -#include "iremote_broker.h" - -namespace OHOS::FileManagement::Backup { -class IServiceReverse : public IRemoteBroker { -public: - enum class Scenario { - UNDEFINED, - BACKUP, - RESTORE, - CLEAN, - }; - -public: - virtual ~IServiceReverse() = default; - virtual void BackupOnBundleStarted(int32_t errCode, std::string bundleName) = 0; - virtual void BackupOnFileReady(std::string bundleName, std::string fileName, int fd, int32_t errCode) = 0; - virtual void BackupOnResultReport(std::string result, std::string bundleName) = 0; - virtual void BackupOnBundleFinished(int32_t errCode, std::string bundleName) = 0; - virtual void BackupOnAllBundlesFinished(int32_t errCode) = 0; - virtual void BackupOnProcessInfo(std::string bundleName, std::string processInfo) = 0; - virtual void BackupOnScanningInfo(std::string scannedInfo) = 0; - - virtual void RestoreOnBundleStarted(int32_t errCode, std::string bundleName) = 0; - virtual void RestoreOnFileReady(std::string bundleName, std::string fileName, int fd, int32_t errCode) = 0; - virtual void RestoreOnResultReport(std::string result, std::string bundleName, - ErrCode errCode = 0) = 0; - virtual void RestoreOnBundleFinished(int32_t errCode, std::string bundleName) = 0; - virtual void RestoreOnAllBundlesFinished(int32_t errCode) = 0; - virtual void RestoreOnProcessInfo(std::string bundleName, std::string processInfo) = 0; - - virtual void IncrementalBackupOnBundleStarted(int32_t errCode, std::string bundleName) = 0; - virtual void IncrementalBackupOnFileReady(std::string bundleName, std::string fileName, int fd, int manifestFd, - int32_t errCode) = 0; - virtual void IncrementalBackupOnResultReport(std::string result, std::string bundleName) = 0; - virtual void IncrementalBackupOnBundleFinished(int32_t errCode, std::string bundleName) = 0; - virtual void IncrementalBackupOnAllBundlesFinished(int32_t errCode) = 0; - virtual void IncrementalBackupOnProcessInfo(std::string bundleName, std::string processInfo) = 0; - virtual void IncrementalBackupOnScanningInfo(std::string scannedInfo) = 0; - - virtual void IncrementalRestoreOnBundleStarted(int32_t errCode, std::string bundleName) = 0; - virtual void IncrementalRestoreOnFileReady(std::string bundleName, - std::string fileName, - int fd, - int manifestFd, int32_t errCode) = 0; - virtual void IncrementalRestoreOnResultReport(std::string result, std::string bundleName, - ErrCode errCode = 0) = 0; - virtual void IncrementalRestoreOnBundleFinished(int32_t errCode, std::string bundleName) = 0; - virtual void IncrementalRestoreOnAllBundlesFinished(int32_t errCode) = 0; - virtual void IncrementalRestoreOnProcessInfo(const std::string bundleName, const std::string processInfo) = 0; - - DECLARE_INTERFACE_DESCRIPTOR(u"OHOS.FileManagement.Backup.IServiceReverse") -}; -} // namespace OHOS::FileManagement::Backup - -#endif // OHOS_FILEMGMT_BACKUP_I_SERVICE_REVERSE_H \ No newline at end of file diff --git a/services/backup_sa/BUILD.gn b/services/backup_sa/BUILD.gn index 48c023bafe28e1462984976f338e7ad188a8c779..d206052862a5b3fc95c9bd55752d446134b1f8c0 100644 --- a/services/backup_sa/BUILD.gn +++ b/services/backup_sa/BUILD.gn @@ -16,7 +16,16 @@ import("//build/ohos.gni") import("//foundation/filemanagement/app_file_service/backup.gni") idl_gen_interface("backup_idl") { - sources = [ "IService.idl" ] + sources = [ + "IExtension.idl", + "IService.idl", + "IServiceReverse.idl", + ] + sources_common = [ + "ExtensionType.idl", + "ServiceReverseType.idl", + "ServiceType.idl", + ] hitrace = "HITRACE_TAG_FILEMANAGEMENT" log_domainid = "0xD004313" log_tag = "AppFileService" @@ -110,7 +119,8 @@ ohos_source_set("backup_sa_ipc_stub") { sources = [] - sources += filter_include(output_values, []) + sources += filter_include(output_values, [ "*_type.cpp" ]) + sources += filter_include(output_values, [ "*_stub.cpp" ]) public_configs = [ ":public_idl_config" ] deps = [ ":backup_idl" ] @@ -126,6 +136,7 @@ ohos_source_set("backup_sa_ipc_stub") { include_dirs = [ ".", + "${path_backup}/interfaces/inner_api/native/backup_kit_inner/impl", "${target_gen_dir}/", ] @@ -161,12 +172,8 @@ ohos_shared_library("backup_sa") { "src/module_ipc/sa_backup_connection.cpp", "src/module_ipc/service.cpp", "src/module_ipc/service_incremental.cpp", - "src/module_ipc/service_incremental_reverse_proxy.cpp", - "src/module_ipc/service_reverse_proxy.cpp", "src/module_ipc/sub_service.cpp", "src/module_ipc/svc_backup_connection.cpp", - "src/module_ipc/svc_extension_incremental_proxy.cpp", - "src/module_ipc/svc_extension_proxy.cpp", "src/module_ipc/svc_restore_deps_manager.cpp", "src/module_ipc/svc_session_manager.cpp", "src/module_notify/notify_work_service.cpp", diff --git a/interfaces/inner_api/native/backup_kit_inner/impl/i_extension_ipc_interface_code.h b/services/backup_sa/IExtension.idl similarity index 33% rename from interfaces/inner_api/native/backup_kit_inner/impl/i_extension_ipc_interface_code.h rename to services/backup_sa/IExtension.idl index 40c2f120845951b4931cc39a33e58f5bae6afdef..ae259f3bf0ebde53a7d09d70d2266909af4440e8 100644 --- a/interfaces/inner_api/native/backup_kit_inner/impl/i_extension_ipc_interface_code.h +++ b/services/backup_sa/IExtension.idl @@ -1,38 +1,31 @@ -/* - * Copyright (c) 2023-2024 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. - */ - -#ifndef OHOS_FILEMGMT_BACKUP_I_EXTENSION_IPC_INTERFACE_CODE_H -#define OHOS_FILEMGMT_BACKUP_I_EXTENSION_IPC_INTERFACE_CODE_H - -/*SAID: 5203*/ -namespace OHOS::FileManagement::Backup { -enum class IExtensionInterfaceCode { - CMD_GET_FILE_HANDLE = 1, - CMD_HANDLE_CLAER, - CMD_PUBLISH_FILE, - CMD_HANDLE_BACKUP, - CMD_HANDLE_RESTORE, - CMD_GET_INCREMENTAL_FILE_HANDLE, - CMD_PUBLISH_INCREMENTAL_FILE, - CMD_HANDLE_INCREMENTAL_BACKUP, - CMD_GET_INCREMENTAL_BACKUP_FILE_HANDLE, - CMD_GET_BACKUP_INFO, - CMD_INCREMENTAL_ON_BACKUP, - CMD_UPDATE_FD_SENDRATE, - CMD_HANDLE_USER_0_BACKUP, -}; -} // namespace OHOS::FileManagement::Backup - -#endif // OHOS_FILEMGMT_BACKUP_I_EXTENSION_IPC_INTERFACE_CODE_H \ No newline at end of file +/* + * Copyright (c) 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. + */ + +import ExtensionType; +interface OHOS.FileManagement.Backup.IExtension{ + [ipccode 1] void GetFileHandleWithUniqueFd([in] String fileName, [out] int getFileHandleErrCode, [out] FileDescriptor fd); + [ipccode 2] void HandleClear(); + [ipccode 3] void HandleBackup([in] boolean isClearData); + [ipccode 4] void PublishFile([in] String fileName); + [ipccode 5] void HandleRestore([in] boolean isClearData); + [ipccode 6] void GetIncrementalFileHandle([in] String fileName, [out] UniqueFdGroup fdGroup); + [ipccode 7] void PublishIncrementalFile([in] String fileName); + [ipccode 8] void HandleIncrementalBackup([in] FileDescriptor incrementalFd, [in] FileDescriptor manifestFd); + [ipccode 9] void IncrementalOnBackup([in] boolean isClearData); + [ipccode 10] void GetIncrementalBackupFileHandle([out] UniqueFdGroup fdGroup); + [ipccode 11] void GetBackupInfo([out] String getBackupInfoResult); + [ipccode 12] void UpdateFdSendRate([in] String bundleName, [in] int sendRate); + [ipccode 13] void User0OnBackup(); +} \ No newline at end of file diff --git a/services/backup_sa/IServiceReverse.idl b/services/backup_sa/IServiceReverse.idl new file mode 100644 index 0000000000000000000000000000000000000000..3079109145798c48ca3577b0b650ffb300f6f619 --- /dev/null +++ b/services/backup_sa/IServiceReverse.idl @@ -0,0 +1,65 @@ +/* + * Copyright (c) 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. + */ + +package OHOS.FileManagement.Backup; + +import ServiceReverseType; +interface OHOS.FileManagement.Backup.IServiceReverse{ + [ipccode 999] void BackupOnBundleStarted([in] int backupOnBundleStartedErrCode, [in] String bundleName); + [ipccode 1] void BackupOnFileReady([in] String bundleName, [in] String fileName, [in] FileDescriptor fd, + [in] int backupOnFileReadyErrCode); + [ipccode 2] void BackupOnResultReport([in] String myResult, [in] String bundleName); + [ipccode 3] void BackupOnBundleFinished([in] int backupOnBundleFinishedErrCode, [in] String bundleName); + [ipccode 4] void BackupOnAllBundlesFinished([in] int backupOnAllBundlesFinishedErrCode); + [ipccode 5] void BackupOnProcessInfo([in] String bundleName, [in] String processInfo); + [ipccode 6] void BackupOnScanningInfo([in] String scannedInfo); + [ipccode 7] void RestoreOnBundleStarted([in] int restoreOnBundleStartedErrCode, [in] String bundleName); + [ipccode 8] void RestoreOnFileReady([in] String bundleName, [in] String fileName, [in] FileDescriptor fd, + [in] int restoreOnFileReadyErrCode); + [ipccode 9] void RestoreOnResultReport([in] String myResult, [in] String bundleName, + [in] int restoreOnResultReportErrCode); + [ipccode 10] void RestoreOnBundleFinished([in] int restoreOnBundleFinishedErrCode, [in] String bundleName); + [ipccode 11] void RestoreOnAllBundlesFinished([in] int restoreOnAllBundlesFinishedErrCode); + [ipccode 12] void RestoreOnProcessInfo([in] String bundleName, [in] String processInfo); + + [ipccode 13] void IncrementalBackupOnBundleStarted([in] int incrementalBackupOnBundleStartedErrCode, + [in] String bundleName); + [ipccode 14] void IncrementalBackupOnFileReady([in] String bundleName, + [in] String fileName, [in] FileDescriptor fd, + [in] FileDescriptor manifestFd, [in] int incrementalBackupOnFileReadyErrCode); + [ipccode 26] void IncrementalSaBackupOnFileReady([in] String bundleName, + [in] String fileName, [in] FileDescriptor fd, + [in] int incrementalBackupOnFileReadyErrCode); + [ipccode 15] void IncrementalBackupOnResultReport([in] String myResult, [in] String bundleName); + [ipccode 16] void IncrementalBackupOnBundleFinished([in] int incrementalBackupOnBundleFinishedErrCode, + [in] String bundleName); + [ipccode 17] void IncrementalBackupOnAllBundlesFinished([in] int incrementalBackupOnAllBundlesFinishedErrCode); + [ipccode 18] void IncrementalBackupOnProcessInfo([in] String bundleName, [in] String processInfo); + [ipccode 19] void IncrementalBackupOnScanningInfo([in] String scannedInfo); + + [ipccode 20] void IncrementalRestoreOnBundleStarted([in] int incrementalRestoreOnBundleStartedErrCode, + [in] String bundleName); + [ipccode 21] void IncrementalRestoreOnFileReady([in] String bundleName, + [in] String fileName, + [in] FileDescriptor fd, + [in] FileDescriptor manifestFd, + [in] int incrementalRestoreOnFileReadyErrCode); + [ipccode 22] void IncrementalRestoreOnResultReport([in] String myResult, [in] String bundleName, + [in] int incrementalRestoreOnResultReportErrCode); + [ipccode 23] void IncrementalRestoreOnBundleFinished([in] int incrementalRestoreOnBundleFinishedErrCode, + [in] String bundleName); + [ipccode 24] void IncrementalRestoreOnAllBundlesFinished([in] int incrementalRestoreOnAllBundlesFinishedErrCode); + [ipccode 25] void IncrementalRestoreOnProcessInfo( [in] String bundleName, [in] String processInfo); +} diff --git a/tests/mock/backup_ext/src/ext_extension_stub_mock.cpp b/services/backup_sa/ServiceReverseType.idl similarity index 56% rename from tests/mock/backup_ext/src/ext_extension_stub_mock.cpp rename to services/backup_sa/ServiceReverseType.idl index 6f9309402ea997eda574b45647462aa8f4c79bcd..2c5e336c3bd20a345154397ef9793d0692508007 100644 --- a/tests/mock/backup_ext/src/ext_extension_stub_mock.cpp +++ b/services/backup_sa/ServiceReverseType.idl @@ -1,28 +1,23 @@ -/* - * Copyright (c) 2024 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 "ext_extension_stub_mock.h" - -namespace OHOS::FileManagement::Backup { -ExtExtensionStub::ExtExtensionStub() -{ -} - -int32_t ExtExtensionStub::OnRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, - MessageOption &option) -{ - return static_cast(this)->OnRemoteRequest(code, data, reply, option); -} -} // namespace OHOS::FileManagement::Backup \ No newline at end of file +/* + * Copyright (c) 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. + */ + +package OHOS.FileManagement.Backup.IServiceReverseType; + +enum Scenario { + UNDEFINED, + BACKUP, + RESTORE, + CLEAN, +}; diff --git a/services/backup_sa/include/module_ipc/service.h b/services/backup_sa/include/module_ipc/service.h index 6ba8e73537016ea1a4ab859eefa1452306c2caf9..b846f83895f6d2201087532847ce1cacd60378ec 100644 --- a/services/backup_sa/include/module_ipc/service.h +++ b/services/backup_sa/include/module_ipc/service.h @@ -56,7 +56,7 @@ public: ErrCode InitBackupSessionWithErrMsg(const sptr& remote, std::string &errMsg) override; ErrCode Start() override; ErrCode GetLocalCapabilities(int& fd) override; - + ErrCode GetLocalCapabilitiesForBundleInfos(int& fd) override; ErrCode PublishFile(const BFileInfo &fileInfo) override; ErrCode AppFileReady(const std::string &fileName, int fd, int32_t errCode) override; @@ -64,7 +64,7 @@ public: ErrCode ServiceResultReport(const std::string& restoreRetInfo, BackupRestoreScenario sennario, ErrCode errCode) override; ErrCode GetFileHandle(const std::string &bundleName, const std::string &fileName) override; - + ErrCode AppendBundlesRestoreSessionDataByDetail( int fd, const std::vector& bundleNames, @@ -73,7 +73,7 @@ public: int32_t userId) override; ErrCode AppendBundlesRestoreSessionData(int fd, const std::vector& bundleNames, int32_t restoreType, int32_t userId) override; - + ErrCode AppendBundlesBackupSession(const std::vector &bundleNames) override; ErrCode AppendBundlesDetailsBackupSession(const std::vector &bundleNames, const std::vector &bundleInfos) override; @@ -317,7 +317,7 @@ public: string BundleNameWithUserId(const string& bundleName, const int32_t userId); std::tuple SplitBundleName(const string& bundleNameWithId); void AppendBundles(const std::vector &bundleNames); - void ReportOnBundleStarted(IServiceReverse::Scenario scenario, const std::string &bundleName); + void ReportOnBundleStarted(IServiceReverseType::Scenario scenario, const std::string &bundleName); ErrCode AppIncrementalFileReady(const std::string &bundleName, const std::string &fileName, UniqueFd fd, UniqueFd manifestFd, int32_t errCode); ErrCode SendFileHandle(const std::string &bundleName, const std::string &fileName); @@ -368,7 +368,7 @@ private: * * @param scenario Scenario状态 */ - ErrCode VerifyCaller(IServiceReverse::Scenario scenario); + ErrCode VerifyCaller(IServiceReverseType::Scenario scenario); /** * @brief 验证调用者并返回名称 @@ -559,7 +559,7 @@ private: */ void SetOccupySession(bool isOccupyingSession); - void ReportOnExtConnectFailed(const IServiceReverse::Scenario scenario, + void ReportOnExtConnectFailed(const IServiceReverseType::Scenario scenario, const std::string &bundleName, const ErrCode ret); void ReleaseOnException(); @@ -576,7 +576,7 @@ private: std::map> &bundleNameDetailMap, std::map &isClearDataFlags); - void TimeoutRadarReport(IServiceReverse::Scenario scenario, std::string &bundleName); + void TimeoutRadarReport(IServiceReverseType::Scenario scenario, std::string &bundleName); void OnBundleStarted(BError error, sptr session, const BundleName &bundleName); @@ -584,16 +584,16 @@ private: const vector &restoreBundleNames); void BundleBeginRadarReport(const std::string &bundleName, const ErrCode errCode, - const IServiceReverse::Scenario scenario); + const IServiceReverseType::Scenario scenario); void BundleEndRadarReport(const std::string &bundleName, ErrCode errCode, - const IServiceReverse::Scenario scenario); + const IServiceReverseType::Scenario scenario); void FileReadyRadarReport(const std::string &bundleName, const std::string &fileName, const ErrCode errCode, - const IServiceReverse::Scenario scenario); + const IServiceReverseType::Scenario scenario); void ExtensionConnectFailRadarReport(const std::string &bundleName, const ErrCode errCode, - const IServiceReverse::Scenario scenario); + const IServiceReverseType::Scenario scenario); void OnStartResRadarReport(const std::vector &bundleNameList, int32_t stage); @@ -678,6 +678,8 @@ private: UniqueFd GetLocalCapabilitiesIncremental(const std::vector &bundleNames); ErrCode AppendBundlesIncrementalBackupSession(const std::vector &bundlesToBackup, const std::vector &infos); + + ErrCode HelpToAppIncrementalFileReady(const string &bundleName, const string &fileName, sptr proxy); private: static sptr instance_; static std::mutex instanceLock_; diff --git a/services/backup_sa/include/module_ipc/service_reverse_proxy.h b/services/backup_sa/include/module_ipc/service_reverse_proxy.h deleted file mode 100644 index 567082b543570dda480616d6f96c2b39aab52883..0000000000000000000000000000000000000000 --- a/services/backup_sa/include/module_ipc/service_reverse_proxy.h +++ /dev/null @@ -1,68 +0,0 @@ -/* - * 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. - */ - -#ifndef OHOS_FILEMGMT_BACKUP_SERVICE_REVERSE_PROXY_H -#define OHOS_FILEMGMT_BACKUP_SERVICE_REVERSE_PROXY_H - -#include "iservice_reverse.h" -#include "iremote_proxy.h" - -namespace OHOS::FileManagement::Backup { -class ServiceReverseProxy final : public IRemoteProxy, protected NoCopyable { -public: - void BackupOnBundleStarted(int32_t errCode, std::string bundleName) override; - void BackupOnFileReady(std::string bundleName, std::string fileName, int fd, int32_t errCode) override; - void BackupOnResultReport(std::string result, std::string bundleName) override; - void BackupOnBundleFinished(int32_t errCode, std::string bundleName) override; - void BackupOnAllBundlesFinished(int32_t errCode) override; - void BackupOnProcessInfo(std::string bundleName, std::string processInfo) override; - void BackupOnScanningInfo(std::string scannedInfo) override; - - void RestoreOnBundleStarted(int32_t errCode, std::string bundleName) override; - void RestoreOnFileReady(std::string bundleName, std::string fileName, int fd, int32_t errCode) override; - void RestoreOnResultReport(std::string result, std::string bundleName, - ErrCode errCode = 0) override; - void RestoreOnBundleFinished(int32_t errCode, std::string bundleName) override; - void RestoreOnAllBundlesFinished(int32_t errCode) override; - void RestoreOnProcessInfo(std::string bundleName, std::string processInfo) override; - - void IncrementalBackupOnBundleStarted(int32_t errCode, std::string bundleName) override; - void IncrementalBackupOnFileReady(std::string bundleName, std::string fileName, int fd, int manifestFd, - int32_t errCode) override; - void IncrementalBackupOnResultReport(std::string result, std::string bundleName) override; - void IncrementalBackupOnBundleFinished(int32_t errCode, std::string bundleName) override; - void IncrementalBackupOnAllBundlesFinished(int32_t errCode) override; - void IncrementalBackupOnProcessInfo(std::string bundleName, std::string processInfo) override; - void IncrementalBackupOnScanningInfo(std::string scannedInfo) override; - - void IncrementalRestoreOnBundleStarted(int32_t errCode, std::string bundleName) override; - void IncrementalRestoreOnFileReady(std::string bundleName, std::string fileName, int fd, int manifestFd, - int32_t errCode) override; - void IncrementalRestoreOnResultReport(std::string result, std::string bundleName, - ErrCode errCode = 0) override; - void IncrementalRestoreOnBundleFinished(int32_t errCode, std::string bundleName) override; - void IncrementalRestoreOnAllBundlesFinished(int32_t errCode) override; - void IncrementalRestoreOnProcessInfo(std::string bundleName, std::string processInfo) override; - -public: - explicit ServiceReverseProxy(const sptr &impl) : IRemoteProxy(impl) {} - ~ServiceReverseProxy() override = default; - -private: - static inline BrokerDelegator delegator_; -}; -} // namespace OHOS::FileManagement::Backup - -#endif // OHOS_FILEMGMT_BACKUP_SERVICE_REVERSE_PROXY_H \ No newline at end of file diff --git a/services/backup_sa/include/module_ipc/svc_backup_connection.h b/services/backup_sa/include/module_ipc/svc_backup_connection.h index 8b6c2477c6b8966d77d0943a35ce5826bad7e03f..33c1c697887821af431d318db79b813c5244dc32 100644 --- a/services/backup_sa/include/module_ipc/svc_backup_connection.h +++ b/services/backup_sa/include/module_ipc/svc_backup_connection.h @@ -17,7 +17,7 @@ #define OHOS_FILEMGMT_BACKUP_SVC_BACKUP_CONNECTION_H #include "ability_connect_callback_stub.h" -#include "i_extension.h" +#include "iextension.h" namespace OHOS::FileManagement::Backup { class SvcBackupConnection : public AAFwk::AbilityConnectionStub { diff --git a/services/backup_sa/include/module_ipc/svc_extension_proxy.h b/services/backup_sa/include/module_ipc/svc_extension_proxy.h deleted file mode 100644 index dd38f936a2d9dd80175ec4d90f6ac35f33035ff5..0000000000000000000000000000000000000000 --- a/services/backup_sa/include/module_ipc/svc_extension_proxy.h +++ /dev/null @@ -1,48 +0,0 @@ -/* - * Copyright (c) 2022-2024 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. - */ - -#ifndef OHOS_FILEMGMT_BACKUP_SVC_EXTENSION_PROXY_H -#define OHOS_FILEMGMT_BACKUP_SVC_EXTENSION_PROXY_H - -#include "i_extension.h" -#include "iremote_proxy.h" -#include "unique_fd.h" - -namespace OHOS::FileManagement::Backup { -class SvcExtensionProxy : public IRemoteProxy { -public: - UniqueFd GetFileHandle(const std::string &fileName, int32_t &errCode) override; - ErrCode HandleClear() override; - ErrCode HandleBackup(bool isClearData) override; - ErrCode PublishFile(const std::string &fileName) override; - ErrCode HandleRestore(bool isClearData) override; - std::tuple GetIncrementalFileHandle(const std::string &fileName) override; - ErrCode PublishIncrementalFile(const std::string &fileName) override; - ErrCode HandleIncrementalBackup(UniqueFd incrementalFd, UniqueFd manifestFd) override; - ErrCode IncrementalOnBackup(bool isClearData) override; - std::tuple GetIncrementalBackupFileHandle() override; - ErrCode GetBackupInfo(std::string &result) override; - ErrCode UpdateFdSendRate(std::string &bundleName, int32_t sendRate) override; - ErrCode User0OnBackup() override; - -public: - explicit SvcExtensionProxy(const sptr &remote) : IRemoteProxy(remote) {} - -private: - static inline BrokerDelegator delegator_; -}; -} // namespace OHOS::FileManagement::Backup - -#endif // OHOS_FILEMGMT_BACKUP_SVC_EXTENSION_PROXY_H \ No newline at end of file diff --git a/services/backup_sa/include/module_ipc/svc_session_manager.h b/services/backup_sa/include/module_ipc/svc_session_manager.h index 3585fd62c93b903506a5099a697361e4b03cb70b..a639783181dadac692b9fa4e8b7cf3e6aace69ca 100644 --- a/services/backup_sa/include/module_ipc/svc_session_manager.h +++ b/services/backup_sa/include/module_ipc/svc_session_manager.h @@ -81,7 +81,7 @@ class SvcSessionManager : public virtual RefBase { public: struct Impl { uint32_t clientToken {0}; - IServiceReverse::Scenario scenario {IServiceReverse::Scenario::UNDEFINED}; + IServiceReverseType::Scenario scenario {IServiceReverseType::Scenario::UNDEFINED}; std::map backupExtNameMap; sptr clientProxy; bool isBackupStart {false}; @@ -107,7 +107,7 @@ public: * * @return ErrCode 错误码 */ - ErrCode VerifyCallerAndScenario(uint32_t clientToken, IServiceReverse::Scenario scenario) const; + ErrCode VerifyCallerAndScenario(uint32_t clientToken, IServiceReverseType::Scenario scenario) const; /** * @brief 激活会话 @@ -148,10 +148,10 @@ public: /** * @brief 获取Scenario * - * @return IServiceReverse::Scenario 返回scenario + * @return IServiceReverseType::Scenario 返回scenario * @throw BError::Codes::SA_INVAL_ARG 获取异常 */ - IServiceReverse::Scenario GetScenario(); + IServiceReverseType::Scenario GetScenario(); /** * @brief 获取当前处理事务会话对应的userId diff --git a/services/backup_sa/src/module_ipc/service.cpp b/services/backup_sa/src/module_ipc/service.cpp index e9ab1c1ae9add34b4fd448d449f55ac679e89f2f..ba1779f2cf1f23773e270de461eed50d6fa762b7 100644 --- a/services/backup_sa/src/module_ipc/service.cpp +++ b/services/backup_sa/src/module_ipc/service.cpp @@ -118,7 +118,7 @@ void Service::OnStartResRadarReport(const std::vector &bundleNameLi } void Service::BundleBeginRadarReport(const std::string &bundleName, const ErrCode errCode, - const IServiceReverse::Scenario scenario) + const IServiceReverseType::Scenario scenario) { if (errCode == ERR_OK || errCode == BError(BError::Codes::SA_BOOT_EXT_FAIL).GetCode()) { return; @@ -132,17 +132,17 @@ void Service::BundleBeginRadarReport(const std::string &bundleName, const ErrCod taskInfo.errCode = errCode; UpdateFailedBundles(bundleName, taskInfo); AppRadar::Info info(bundleName, "", ""); - if (scenario == IServiceReverse::Scenario::RESTORE) { - AppRadar::GetInstance().RecordRestoreFuncRes(info, "Service::BundleBeginRadarReport", GetUserIdDefault(), - BizStageRestore::BIZ_STAGE_APPEND_BUNDLES_FAIL, errCode); - } else if (scenario == IServiceReverse::Scenario::BACKUP) { - AppRadar::GetInstance().RecordBackupFuncRes(info, "Service::BundleBeginRadarReport", GetUserIdDefault(), - BizStageBackup::BIZ_STAGE_APPEND_BUNDLES_FAIL, errCode); + if (scenario == IServiceReverseType::Scenario::RESTORE) { + AppRadar::GetInstance().RecordRestoreFuncRes(info, "Service::BundleBeginRadarReport", + GetUserIdDefault(), BizStageRestore::BIZ_STAGE_APPEND_BUNDLES_FAIL, errCode); + } else if (scenario == IServiceReverseType::Scenario::BACKUP) { + AppRadar::GetInstance().RecordBackupFuncRes(info, "Service::BundleBeginRadarReport", + GetUserIdDefault(), BizStageBackup::BIZ_STAGE_APPEND_BUNDLES_FAIL, errCode); } } void Service::BundleEndRadarReport(const std::string &bundleName, ErrCode errCode, - const IServiceReverse::Scenario scenario) + const IServiceReverseType::Scenario scenario) { if (errCode == ERR_OK) { successBundlesNum_++; @@ -160,17 +160,17 @@ void Service::BundleEndRadarReport(const std::string &bundleName, ErrCode errCod taskInfo.errCode = errCode; UpdateFailedBundles(bundleName, taskInfo); AppRadar::Info info(bundleName, "", ""); - if (scenario == IServiceReverse::Scenario::RESTORE) { + if (scenario == IServiceReverseType::Scenario::RESTORE) { AppRadar::GetInstance().RecordRestoreFuncRes(info, "Service::BundleEndRadarReport", GetUserIdDefault(), BizStageRestore::BIZ_STAGE_EXECU_FAIL, errCode); - } else if (scenario == IServiceReverse::Scenario::BACKUP) { + } else if (scenario == IServiceReverseType::Scenario::BACKUP) { AppRadar::GetInstance().RecordBackupFuncRes(info, "Service::BundleEndRadarReport", GetUserIdDefault(), BizStageBackup::BIZ_STAGE_EXECU_FAIL, errCode); } } void Service::FileReadyRadarReport(const std::string &bundleName, const std::string &fileName, const ErrCode errCode, - const IServiceReverse::Scenario scenario) + const IServiceReverseType::Scenario scenario) { if (errCode == ERR_OK) { return; @@ -180,17 +180,17 @@ void Service::FileReadyRadarReport(const std::string &bundleName, const std::str } std::string fileNameReport = std::string("fileName:\"") + GetAnonyPath(fileName) + "\""; AppRadar::Info info(bundleName, "", fileNameReport); - if (scenario == IServiceReverse::Scenario::RESTORE) { + if (scenario == IServiceReverseType::Scenario::RESTORE) { AppRadar::GetInstance().RecordRestoreFuncRes(info, "Service::FileReadyRadarReport", GetUserIdDefault(), BizStageRestore::BIZ_STAGE_GET_FILE_HANDLE_FAIL, errCode); - } else if (scenario == IServiceReverse::Scenario::BACKUP) { + } else if (scenario == IServiceReverseType::Scenario::BACKUP) { AppRadar::GetInstance().RecordBackupFuncRes(info, "Service::FileReadyRadarReport", GetUserIdDefault(), BizStageBackup::BIZ_STAGE_DO_BACKUP, errCode); } } void Service::ExtensionConnectFailRadarReport(const std::string &bundleName, const ErrCode errCode, - const IServiceReverse::Scenario scenario) + const IServiceReverseType::Scenario scenario) { if (!IsReportBundleExecFail(bundleName)) { return; @@ -199,11 +199,11 @@ void Service::ExtensionConnectFailRadarReport(const std::string &bundleName, con std::stringstream ss; ss << "errCode:" << errCode; AppRadar::Info info(bundleName, "", ss.str()); - if (scenario == IServiceReverse::Scenario::RESTORE) { + if (scenario == IServiceReverseType::Scenario::RESTORE) { AppRadar::GetInstance().RecordRestoreFuncRes(info, "Service::ExtensionConnectFailRadarReport", GetUserIdDefault(), BizStageRestore::BIZ_STAGE_CONNECT_EXTENSION_FAIL, BError(BError::Codes::SA_BOOT_EXT_FAIL).GetCode()); - } else if (scenario == IServiceReverse::Scenario::BACKUP) { + } else if (scenario == IServiceReverseType::Scenario::BACKUP) { AppRadar::GetInstance().RecordBackupFuncRes(info, "Service::ExtensionConnectFailRadarReport", GetUserIdDefault(), BizStageBackup::BIZ_STAGE_CONNECT_EXTENSION_FAIL, BError(BError::Codes::SA_BOOT_EXT_FAIL).GetCode()); @@ -234,7 +234,7 @@ void Service::OnStart() session_->Active( { .clientToken = IPCSkeleton::GetCallingTokenID(), - .scenario = IServiceReverse::Scenario::CLEAN, + .scenario = IServiceReverseType::Scenario::CLEAN, .clientProxy = nullptr, .userId = GetUserIdDefault(), .callerName = "BackupSA", @@ -355,7 +355,7 @@ void Service::StopAll(const wptr &obj, bool force) ss << "}"; string resultInfo = ss.str(); AppRadar::StatInfo statInfo("", resultInfo); - IServiceReverse::Scenario scenario = session_->GetScenario(); + IServiceReverseType::Scenario scenario = session_->GetScenario(); AppRadar::GetInstance().RecordStatisticRes(statInfo, GetUserIdDefault(), scenario, successBundlesNum_.load(), fail_cnt, result); } @@ -456,7 +456,7 @@ ErrCode Service::VerifyCaller() return ret; } -ErrCode Service::VerifyCaller(IServiceReverse::Scenario scenario) +ErrCode Service::VerifyCaller(IServiceReverseType::Scenario scenario) { HITRACE_METER_NAME(HITRACE_TAG_FILEMANAGEMENT, __PRETTY_FUNCTION__); ErrCode ret = session_->VerifyCallerAndScenario(IPCSkeleton::GetCallingTokenID(), scenario); @@ -477,7 +477,7 @@ ErrCode Service::InitRestoreSession(const sptr &remote) } ret = session_->Active({ .clientToken = IPCSkeleton::GetCallingTokenID(), - .scenario = IServiceReverse::Scenario::RESTORE, + .scenario = IServiceReverseType::Scenario::RESTORE, .clientProxy = remote, .userId = GetUserIdDefault(), .callerName = GetCallerName(), @@ -512,7 +512,7 @@ ErrCode Service::InitBackupSession(const sptr &remote) session_->SetMemParaCurSize(oldSize); ret = session_->Active({ .clientToken = IPCSkeleton::GetCallingTokenID(), - .scenario = IServiceReverse::Scenario::BACKUP, + .scenario = IServiceReverseType::Scenario::BACKUP, .clientProxy = remote, .userId = GetUserIdDefault(), .callerName = GetCallerName(), @@ -564,11 +564,11 @@ static bool SpecialVersion(const string &versionName) void Service::OnBundleStarted(BError error, sptr session, const BundleName &bundleName) { - IServiceReverse::Scenario scenario = session->GetScenario(); - if (scenario == IServiceReverse::Scenario::RESTORE && BackupPara().GetBackupOverrideIncrementalRestore() && + IServiceReverseType::Scenario scenario = session->GetScenario(); + if (scenario == IServiceReverseType::Scenario::RESTORE && BackupPara().GetBackupOverrideIncrementalRestore() && session->ValidRestoreDataType(RestoreTypeEnum::RESTORE_DATA_WAIT_SEND)) { session->GetServiceReverseProxy()->IncrementalRestoreOnBundleStarted(error, bundleName); - } else if (scenario == IServiceReverse::Scenario::RESTORE) { + } else if (scenario == IServiceReverseType::Scenario::RESTORE) { session->GetServiceReverseProxy()->RestoreOnBundleStarted(error, bundleName); } BundleBeginRadarReport(bundleName, error.GetCode(), scenario); @@ -674,7 +674,7 @@ ErrCode Service::AppendBundlesRestoreSession(UniqueFd fd, } session_->IncreaseSessionCnt(__PRETTY_FUNCTION__); SetUserIdAndRestoreType(restoreType, userId); - ErrCode ret = VerifyCaller(IServiceReverse::Scenario::RESTORE); + ErrCode ret = VerifyCaller(IServiceReverseType::Scenario::RESTORE); if (ret != ERR_OK) { HILOGE("AppendBundles restore session with infos error, verify caller failed, ret:%{public}d", ret); HandleExceptionOnAppendBundles(session_, bundleNames, {}); @@ -776,7 +776,7 @@ ErrCode Service::AppendBundlesRestoreSession(UniqueFd fd, } session_->IncreaseSessionCnt(__PRETTY_FUNCTION__); SetUserIdAndRestoreType(restoreType, userId); - ErrCode ret = VerifyCaller(IServiceReverse::Scenario::RESTORE); + ErrCode ret = VerifyCaller(IServiceReverseType::Scenario::RESTORE); if (ret != ERR_OK) { HILOGE("AppendBundles restore session with infos error, verify caller failed, ret:%{public}d", ret); HandleExceptionOnAppendBundles(session_, bundleNames, {}); @@ -875,7 +875,7 @@ ErrCode Service::AppendBundlesBackupSession(const vector &bundleName return BError(BError::Codes::SA_INVAL_ARG); } session_->IncreaseSessionCnt(__PRETTY_FUNCTION__); // BundleMgrAdapter::GetBundleInfos可能耗时 - ErrCode ret = VerifyCaller(IServiceReverse::Scenario::BACKUP); + ErrCode ret = VerifyCaller(IServiceReverseType::Scenario::BACKUP); if (ret != ERR_OK) { HILOGE("AppendBundles backup session error, verify caller failed, ret:%{public}d", ret); HandleExceptionOnAppendBundles(session_, bundleNames, {}); @@ -914,7 +914,7 @@ ErrCode Service::AppendBundlesDetailsBackupSession(const vector &bun return BError(BError::Codes::SA_INVAL_ARG); } session_->IncreaseSessionCnt(__PRETTY_FUNCTION__); // BundleMgrAdapter::GetBundleInfos可能耗时 - ErrCode ret = VerifyCaller(IServiceReverse::Scenario::BACKUP); + ErrCode ret = VerifyCaller(IServiceReverseType::Scenario::BACKUP); if (ret != ERR_OK) { HILOGE("AppendBundles backup session with infos error, verify caller failed, ret:%{public}d", ret); HandleExceptionOnAppendBundles(session_, bundleNames, {}); @@ -1012,9 +1012,9 @@ ErrCode Service::SAResultReport(const std::string bundleName, const std::string { SADone(errCode, bundleName); if (sennario == BackupRestoreScenario::FULL_RESTORE) { - session_->GetServiceReverseProxy()->RestoreOnResultReport(restoreRetInfo, bundleName); + session_->GetServiceReverseProxy()->RestoreOnResultReport(restoreRetInfo, bundleName, ERR_OK); } else if (sennario == BackupRestoreScenario::INCREMENTAL_RESTORE) { - session_->GetServiceReverseProxy()->IncrementalRestoreOnResultReport(restoreRetInfo, bundleName); + session_->GetServiceReverseProxy()->IncrementalRestoreOnResultReport(restoreRetInfo, bundleName, ERR_OK); } else if (sennario == BackupRestoreScenario::FULL_BACKUP) { session_->GetServiceReverseProxy()->BackupOnResultReport(restoreRetInfo, bundleName); session_->GetServiceReverseProxy()->BackupOnBundleFinished(errCode, bundleName); @@ -1024,10 +1024,10 @@ ErrCode Service::SAResultReport(const std::string bundleName, const std::string } OnAllBundlesFinished(BError(BError::Codes::OK)); if (sennario == BackupRestoreScenario::FULL_RESTORE || sennario == BackupRestoreScenario::INCREMENTAL_RESTORE) { - BundleEndRadarReport(bundleName, errCode, IServiceReverse::Scenario::RESTORE); + BundleEndRadarReport(bundleName, errCode, IServiceReverseType::Scenario::RESTORE); } else if (sennario == BackupRestoreScenario::FULL_BACKUP || sennario == BackupRestoreScenario::INCREMENTAL_BACKUP) { - BundleEndRadarReport(bundleName, errCode, IServiceReverse::Scenario::BACKUP); + BundleEndRadarReport(bundleName, errCode, IServiceReverseType::Scenario::BACKUP); } return BError(BError::Codes::OK); } @@ -1072,7 +1072,7 @@ void Service::HandleCurBundleEndWork(std::string bundleName, const BackupRestore ErrCode Service::LaunchBackupSAExtension(const BundleName &bundleName) { string extInfo = session_->GetBackupExtInfo(bundleName); - IServiceReverse::Scenario scenario = session_->GetScenario(); + IServiceReverseType::Scenario scenario = session_->GetScenario(); if (SAUtils::IsSABundleName(bundleName)) { auto saBackUpConnection = session_->GetSAExtConnection(bundleName); std::shared_ptr saConnection = saBackUpConnection.lock(); @@ -1080,9 +1080,9 @@ ErrCode Service::LaunchBackupSAExtension(const BundleName &bundleName) HILOGE("lock sa connection ptr is nullptr"); return BError(BError::Codes::SA_INVAL_ARG); } - if (scenario == IServiceReverse::Scenario::BACKUP) { + if (scenario == IServiceReverseType::Scenario::BACKUP) { return saConnection->ConnectBackupSAExt(bundleName, BConstants::EXTENSION_BACKUP, extInfo); - } else if (scenario == IServiceReverse::Scenario::RESTORE) { + } else if (scenario == IServiceReverseType::Scenario::RESTORE) { return saConnection->ConnectBackupSAExt(bundleName, BConstants::EXTENSION_RESTORE, extInfo); } } @@ -1117,7 +1117,7 @@ void Service::ExtStart(const string &bundleName) void Service::StartCurBundleBackupOrRestore(const std::string &bundleName) { HILOGI("Begin handle current bundle full backup or full restore, bundleName:%{public}s", bundleName.c_str()); - IServiceReverse::Scenario scenario = session_->GetScenario(); + IServiceReverseType::Scenario scenario = session_->GetScenario(); auto backUpConnection = session_->GetExtConnection(bundleName); if (backUpConnection == nullptr) { HILOGE("Error, backUpConnection is empty, bundle:%{public}s", bundleName.c_str()); @@ -1130,7 +1130,7 @@ void Service::StartCurBundleBackupOrRestore(const std::string &bundleName) ReportOnBundleStarted(scenario, bundleName); return; } - if (scenario == IServiceReverse::Scenario::BACKUP) { + if (scenario == IServiceReverseType::Scenario::BACKUP) { auto ret = proxy->HandleBackup(session_->GetClearDataFlag(bundleName)); session_->GetServiceReverseProxy()->BackupOnBundleStarted(ret, bundleName); BundleBeginRadarReport(bundleName, ret, scenario); @@ -1139,7 +1139,7 @@ void Service::StartCurBundleBackupOrRestore(const std::string &bundleName) ClearSessionAndSchedInfo(bundleName); NoticeClientFinish(bundleName, BError(BError::Codes::SA_INVAL_ARG)); } - } else if (scenario == IServiceReverse::Scenario::RESTORE) { + } else if (scenario == IServiceReverseType::Scenario::RESTORE) { auto ret = proxy->HandleRestore(session_->GetClearDataFlag(bundleName)); session_->GetServiceReverseProxy()->RestoreOnBundleStarted(ret, bundleName); GetOldDeviceBackupVersion(); @@ -1147,7 +1147,9 @@ void Service::StartCurBundleBackupOrRestore(const std::string &bundleName) auto fileNameVec = session_->GetExtFileNameRequest(bundleName); for (const auto &fileName : fileNameVec) { int32_t errCode = 0; - UniqueFd fd = proxy->GetFileHandle(fileName, errCode); + int fdCode = 0; + proxy->GetFileHandleWithUniqueFd(fileName, errCode, fdCode); + UniqueFd fd(fdCode); session_->GetServiceReverseProxy()->RestoreOnFileReady(bundleName, fileName, move(fd), errCode); FileReadyRadarReport(bundleName, fileName, errCode, scenario); } @@ -1166,7 +1168,7 @@ int Service::Dump(int fd, const vector &args) return 0; } -void Service::ReportOnExtConnectFailed(const IServiceReverse::Scenario scenario, +void Service::ReportOnExtConnectFailed(const IServiceReverseType::Scenario scenario, const std::string &bundleName, const ErrCode ret) { try { @@ -1174,10 +1176,10 @@ void Service::ReportOnExtConnectFailed(const IServiceReverse::Scenario scenario, HILOGE("Report extConnectfailed error, session info is empty"); return; } - if (scenario == IServiceReverse::Scenario::BACKUP && session_->GetIsIncrementalBackup()) { + if (scenario == IServiceReverseType::Scenario::BACKUP && session_->GetIsIncrementalBackup()) { session_->GetServiceReverseProxy()->IncrementalBackupOnBundleStarted(ret, bundleName); BundleBeginRadarReport(bundleName, ret, scenario); - } else if (scenario == IServiceReverse::Scenario::RESTORE && + } else if (scenario == IServiceReverseType::Scenario::RESTORE && BackupPara().GetBackupOverrideIncrementalRestore() && session_->ValidRestoreDataType(RestoreTypeEnum::RESTORE_DATA_WAIT_SEND)) { session_->GetServiceReverseProxy()->IncrementalRestoreOnBundleStarted(ret, bundleName); @@ -1186,10 +1188,10 @@ void Service::ReportOnExtConnectFailed(const IServiceReverse::Scenario scenario, session_->GetBundleUserId(bundleName)); HILOGI("ExtConnectFailed EndRestore, code=%{public}d, bundleName=%{public}s", disposeErr, bundleName.c_str()); - } else if (scenario == IServiceReverse::Scenario::BACKUP) { + } else if (scenario == IServiceReverseType::Scenario::BACKUP) { session_->GetServiceReverseProxy()->BackupOnBundleStarted(ret, bundleName); BundleBeginRadarReport(bundleName, ret, scenario); - } else if (scenario == IServiceReverse::Scenario::RESTORE) { + } else if (scenario == IServiceReverseType::Scenario::RESTORE) { session_->GetServiceReverseProxy()->RestoreOnBundleStarted(ret, bundleName); BundleBeginRadarReport(bundleName, ret, scenario); DisposeErr disposeErr = AppGalleryDisposeProxy::GetInstance()->EndRestore(bundleName, @@ -1205,7 +1207,7 @@ void Service::ReportOnExtConnectFailed(const IServiceReverse::Scenario scenario, void Service::ExtConnectFailed(const string &bundleName, ErrCode ret) { HITRACE_METER_NAME(HITRACE_TAG_FILEMANAGEMENT, __PRETTY_FUNCTION__); - IServiceReverse::Scenario scenario = IServiceReverse::Scenario::UNDEFINED; + IServiceReverseType::Scenario scenario = IServiceReverseType::Scenario::UNDEFINED; try { HILOGE("begin %{public}s", bundleName.data()); scenario = session_->GetScenario(); @@ -1227,9 +1229,9 @@ void Service::StartRunningTimer(const std::string &bundleName) { auto timeoutCallback = TimeOutCallback(wptr(this), bundleName); auto scenario = session_->GetScenario(); - if (scenario == IServiceReverse::Scenario::BACKUP) { + if (scenario == IServiceReverseType::Scenario::BACKUP) { session_->StartExtTimer(bundleName, timeoutCallback); - } else if (scenario == IServiceReverse::Scenario::RESTORE) { + } else if (scenario == IServiceReverseType::Scenario::RESTORE) { session_->StartFwkTimer(bundleName, timeoutCallback); } } @@ -1303,7 +1305,7 @@ void Service::ClearSessionAndSchedInfo(const string &bundleName) void Service::HandleRestoreDepsBundle(const string &bundleName) { HITRACE_METER_NAME(HITRACE_TAG_FILEMANAGEMENT, __PRETTY_FUNCTION__); - if (session_->GetScenario() != IServiceReverse::Scenario::RESTORE) { + if (session_->GetScenario() != IServiceReverseType::Scenario::RESTORE) { return; } HILOGI("Begin, bundleName: %{public}s", bundleName.c_str()); @@ -1358,8 +1360,8 @@ void Service::SendStartAppGalleryNotify(const BundleName &bundleName) HILOGI("SA does not need to StartRestore"); return; } - IServiceReverse::Scenario scenario = session_->GetScenario(); - if (scenario != IServiceReverse::Scenario::RESTORE) { + IServiceReverseType::Scenario scenario = session_->GetScenario(); + if (scenario != IServiceReverseType::Scenario::RESTORE) { return; } int32_t userId = session_->GetBundleUserId(bundleName); @@ -1381,8 +1383,8 @@ void Service::SendEndAppGalleryNotify(const BundleName &bundleName) HILOGI("SA does not need to EndRestore"); return; } - IServiceReverse::Scenario scenario = session_->GetScenario(); - if (scenario != IServiceReverse::Scenario::RESTORE) { + IServiceReverseType::Scenario scenario = session_->GetScenario(); + if (scenario != IServiceReverseType::Scenario::RESTORE) { return; } int32_t userId = session_->GetBundleUserId(bundleName); @@ -1431,8 +1433,8 @@ void Service::TryToClearDispose(const BundleName &bundleName) void Service::SendErrAppGalleryNotify() { HITRACE_METER_NAME(HITRACE_TAG_FILEMANAGEMENT, __PRETTY_FUNCTION__); - IServiceReverse::Scenario scenario = session_->GetScenario(); - if (scenario != IServiceReverse::Scenario::RESTORE) { + IServiceReverseType::Scenario scenario = session_->GetScenario(); + if (scenario != IServiceReverseType::Scenario::RESTORE) { return; } vector bundleNameList = disposal_->GetBundleNameFromConfigFile(); @@ -1463,8 +1465,8 @@ void Service::ClearDisposalOnSaStart() void Service::DeleteDisConfigFile() { HITRACE_METER_NAME(HITRACE_TAG_FILEMANAGEMENT, __PRETTY_FUNCTION__); - IServiceReverse::Scenario scenario = session_->GetScenario(); - if (scenario != IServiceReverse::Scenario::RESTORE) { + IServiceReverseType::Scenario scenario = session_->GetScenario(); + if (scenario != IServiceReverseType::Scenario::RESTORE) { return; } vector bundleNameList = disposal_->GetBundleNameFromConfigFile(); @@ -1490,7 +1492,7 @@ void Service::SessionDeactive() } ErrCode ret = BError(BError::Codes::OK); std::vector bundleNameList; - if (session_->GetScenario() == IServiceReverse::Scenario::RESTORE && + if (session_->GetScenario() == IServiceReverseType::Scenario::RESTORE && session_->CleanAndCheckIfNeedWait(ret, bundleNameList)) { if (ret != ERR_OK) { isRmConfigFile_.store(false); @@ -1585,7 +1587,7 @@ ErrCode Service::ClearResidualBundleData(const std::string &bundleName) } ClearSessionAndSchedInfo(bundleName); // 非清理任务，需要上报 - if (session_->GetScenario() != IServiceReverse::Scenario::CLEAN) { + if (session_->GetScenario() != IServiceReverseType::Scenario::CLEAN) { OnAllBundlesFinished(BError(BError::Codes::OK)); } return res; @@ -1806,14 +1808,14 @@ AAFwk::Want Service::CreateConnectWant(const BundleName &bundleName) ErrCode Service::BackupSA(std::string bundleName) { HILOGI("BackupSA begin %{public}s", bundleName.c_str()); - IServiceReverse::Scenario scenario = session_->GetScenario(); + IServiceReverseType::Scenario scenario = session_->GetScenario(); auto backUpConnection = session_->GetSAExtConnection(bundleName); std::shared_ptr saConnection = backUpConnection.lock(); if (saConnection == nullptr) { HILOGE("lock sa connection ptr is nullptr"); return BError(BError::Codes::SA_INVAL_ARG); } - if (scenario == IServiceReverse::Scenario::BACKUP) { + if (scenario == IServiceReverseType::Scenario::BACKUP) { auto ret = saConnection->CallBackupSA(); session_->GetServiceReverseProxy()->BackupOnBundleStarted(ret, bundleName); BundleBeginRadarReport(bundleName, ret, scenario); @@ -1823,7 +1825,7 @@ ErrCode Service::BackupSA(std::string bundleName) NoticeClientFinish(bundleName, BError(BError::Codes::EXT_ABILITY_DIED)); return BError(ret); } - } else if (scenario == IServiceReverse::Scenario::RESTORE) { + } else if (scenario == IServiceReverseType::Scenario::RESTORE) { session_->GetServiceReverseProxy()->IncrementalRestoreOnBundleStarted(BError(BError::Codes::OK), bundleName); } return BError(BError::Codes::OK); @@ -1838,13 +1840,12 @@ void Service::OnSABackup(const std::string &bundleName, const int &fd, const std BackupRestoreScenario scenario = BackupRestoreScenario::FULL_BACKUP; if (session_->GetIsIncrementalBackup()) { scenario = BackupRestoreScenario::INCREMENTAL_BACKUP; - session_->GetServiceReverseProxy()->IncrementalBackupOnFileReady(bundleName, "", move(fd), INVALID_FD, - errCode); + session_->GetServiceReverseProxy()->IncrementalSaBackupOnFileReady(bundleName, "", move(fd), errCode); } else { scenario = BackupRestoreScenario::FULL_BACKUP; session_->GetServiceReverseProxy()->BackupOnFileReady(bundleName, "", move(fd), errCode); } - FileReadyRadarReport(bundleName, "", errCode, IServiceReverse::Scenario::BACKUP); + FileReadyRadarReport(bundleName, "", errCode, IServiceReverseType::Scenario::BACKUP); SAResultReport(bundleName, result, errCode, scenario); }; threadPool_.AddTask([task]() { @@ -1901,8 +1902,8 @@ ErrCode Service::SADone(ErrCode errCode, std::string bundleName) void Service::NotifyCallerCurAppDone(ErrCode errCode, const std::string &callerName) { - IServiceReverse::Scenario scenario = session_->GetScenario(); - if (scenario == IServiceReverse::Scenario::BACKUP) { + IServiceReverseType::Scenario scenario = session_->GetScenario(); + if (scenario == IServiceReverseType::Scenario::BACKUP) { HILOGI("will notify clone data, scenario is Backup"); session_->GetServiceReverseProxy()->BackupOnBundleFinished(errCode, callerName); auto now = std::chrono::system_clock::now(); @@ -1914,7 +1915,7 @@ void Service::NotifyCallerCurAppDone(ErrCode errCode, const std::string &callerN HiSysEventWrite(OHOS::HiviewDFX::HiSysEvent::Domain::FILEMANAGEMENT, FILE_BACKUP_EVENTS, OHOS::HiviewDFX::HiSysEvent::EventType::BEHAVIOR, "PROC_NAME", "ohos.appfileservice", "BUNDLENAME", callerName, "PID", getpid(), "TIME", strTime.str()); - } else if (scenario == IServiceReverse::Scenario::RESTORE) { + } else if (scenario == IServiceReverseType::Scenario::RESTORE) { HILOGI("will notify clone data, scenario is Restore"); session_->GetServiceReverseProxy()->RestoreOnBundleFinished(errCode, callerName); } @@ -1982,7 +1983,7 @@ void Service::DoTimeout(wptr ptr, std::string bundleName) HILOGE("SessionPtr is nullptr."); return; } - IServiceReverse::Scenario scenario = sessionPtr->GetScenario(); + IServiceReverseType::Scenario scenario = sessionPtr->GetScenario(); try { std::shared_ptr mutexPtr = GetExtensionMutex(bundleName); if (mutexPtr == nullptr) { @@ -2046,8 +2047,8 @@ void Service::DelClearBundleRecord(const std::vector &bundleNames) void Service::ReleaseOnException() { if (session_->IsOnAllBundlesFinished()) { - IServiceReverse::Scenario scenario = session_->GetScenario(); - if (isInRelease_.load() && (scenario == IServiceReverse::Scenario::RESTORE)) { + IServiceReverseType::Scenario scenario = session_->GetScenario(); + if (isInRelease_.load() && (scenario == IServiceReverseType::Scenario::RESTORE)) { HILOGI("Will execute destory session info"); SessionDeactive(); } diff --git a/services/backup_sa/src/module_ipc/service_incremental.cpp b/services/backup_sa/src/module_ipc/service_incremental.cpp index fd596c6f8e2e0de7e3bc937b6fefdadadcfe6f85..4eb82331a87e6d8378c315e7113b08a657e28c12 100644 --- a/services/backup_sa/src/module_ipc/service_incremental.cpp +++ b/services/backup_sa/src/module_ipc/service_incremental.cpp @@ -73,13 +73,13 @@ ErrCode Service::Release() HILOGE("Release error, session is empty"); return BError(BError::Codes::SA_INVAL_ARG); } - IServiceReverse::Scenario scenario = session_->GetScenario(); + IServiceReverseType::Scenario scenario = session_->GetScenario(); VerifyCaller(scenario); AppRadar::Info info("", "", "call release"); - if (scenario == IServiceReverse::Scenario::RESTORE) { + if (scenario == IServiceReverseType::Scenario::RESTORE) { AppRadar::GetInstance().RecordRestoreFuncRes(info, "Service::Release", session_->GetSessionUserId(), BizStageRestore::BIZ_STAGE_RELEASE, ERR_OK); - } else if (scenario == IServiceReverse::Scenario::BACKUP) { + } else if (scenario == IServiceReverseType::Scenario::BACKUP) { AppRadar::GetInstance().RecordBackupFuncRes(info, "Service::Release", session_->GetSessionUserId(), BizStageBackup::BIZ_STAGE_RELEASE, ERR_OK); } @@ -313,7 +313,7 @@ ErrCode Service::InitIncrementalBackupSession(const sptr& remot return BError(BError::Codes::SA_INVAL_ARG); } errCode = session_->Active({.clientToken = IPCSkeleton::GetCallingTokenID(), - .scenario = IServiceReverse::Scenario::BACKUP, + .scenario = IServiceReverseType::Scenario::BACKUP, .clientProxy = remote, .userId = GetUserIdDefault(), .isIncrementalBackup = true, @@ -348,7 +348,7 @@ ErrCode Service::InitIncrementalBackupSessionWithErrMsg(const sptrActive({.clientToken = IPCSkeleton::GetCallingTokenID(), - .scenario = IServiceReverse::Scenario::BACKUP, + .scenario = IServiceReverseType::Scenario::BACKUP, .clientProxy = remote, .userId = GetUserIdDefault(), .isIncrementalBackup = true, @@ -393,7 +393,7 @@ ErrCode Service::AppendBundlesIncrementalBackupSession(const std::vectorIncreaseSessionCnt(__PRETTY_FUNCTION__); // BundleMgrAdapter::GetBundleInfos可能耗时 bundleNames = GetBundleNameByDetails(bundlesToBackup); - ErrCode ret = VerifyCaller(IServiceReverse::Scenario::BACKUP); + ErrCode ret = VerifyCaller(IServiceReverseType::Scenario::BACKUP); if (ret != ERR_OK) { HILOGE("Append bundles incremental session failed, verify caller failed, ret:%{public}d", ret); HandleExceptionOnAppendBundles(session_, bundleNames, {}); @@ -440,7 +440,7 @@ ErrCode Service::AppendBundlesIncrementalBackupSession(const std::vectorIncreaseSessionCnt(__PRETTY_FUNCTION__); // BundleMgrAdapter::GetBundleInfos可能耗时 bundleNames = GetBundleNameByDetails(bundlesToBackup); - ErrCode ret = VerifyCaller(IServiceReverse::Scenario::BACKUP); + ErrCode ret = VerifyCaller(IServiceReverseType::Scenario::BACKUP); if (ret != ERR_OK) { HILOGE("Append bundles incremental session with infos failed, verify caller failed, ret:%{public}d", ret); session_->DecreaseSessionCnt(__PRETTY_FUNCTION__); @@ -498,7 +498,7 @@ void Service::HandleCurGroupIncBackupInfos(vector & ErrCode Service::PublishIncrementalFile(const BFileInfo &fileInfo) { HITRACE_METER_NAME(HITRACE_TAG_FILEMANAGEMENT, __PRETTY_FUNCTION__); - ErrCode ret = VerifyCaller(IServiceReverse::Scenario::RESTORE); + ErrCode ret = VerifyCaller(IServiceReverseType::Scenario::RESTORE); if (ret != ERR_OK) { HILOGE("Publish incremental file failed, bundleName:%{public}s", fileInfo.owner.c_str()); return ret; @@ -565,18 +565,18 @@ ErrCode Service::AppIncrementalFileReady(const std::string &bundleName, const st { HITRACE_METER_NAME(HITRACE_TAG_FILEMANAGEMENT, __PRETTY_FUNCTION__); try { - if (session_->GetScenario() == IServiceReverse::Scenario::RESTORE) { + if (session_->GetScenario() == IServiceReverseType::Scenario::RESTORE) { session_->GetServiceReverseProxy()->IncrementalRestoreOnFileReady(bundleName, fileName, move(fd), - move(manifestFd), errCode); - FileReadyRadarReport(bundleName, fileName, errCode, IServiceReverse::Scenario::RESTORE); + move(manifestFd), errCode); + FileReadyRadarReport(bundleName, fileName, errCode, IServiceReverseType::Scenario::RESTORE); return BError(BError::Codes::OK); } if (fileName == BConstants::EXT_BACKUP_MANAGE) { fd = session_->OnBundleExtManageInfo(bundleName, move(fd)); } session_->GetServiceReverseProxy()->IncrementalBackupOnFileReady(bundleName, fileName, move(fd), - move(manifestFd), errCode); - FileReadyRadarReport(bundleName, fileName, errCode, IServiceReverse::Scenario::BACKUP); + move(manifestFd), errCode); + FileReadyRadarReport(bundleName, fileName, errCode, IServiceReverseType::Scenario::BACKUP); if (session_->OnBundleFileReady(bundleName, fileName)) { ErrCode ret = HandleCurBundleFileReady(bundleName, fileName, true); if (ret != ERR_OK) { @@ -617,10 +617,10 @@ ErrCode Service::AppIncrementalFileReady(const std::string &fileName, UniqueFd f HILOGE("Verify caller failed, ret:%{public}d", ret); return ret; } - if (session_->GetScenario() == IServiceReverse::Scenario::RESTORE) { + if (session_->GetScenario() == IServiceReverseType::Scenario::RESTORE) { session_->GetServiceReverseProxy()->IncrementalRestoreOnFileReady(callerName, fileName, move(fd), move(manifestFd), errCode); - FileReadyRadarReport(callerName, fileName, errCode, IServiceReverse::Scenario::RESTORE); + FileReadyRadarReport(callerName, fileName, errCode, IServiceReverseType::Scenario::RESTORE); return BError(BError::Codes::OK); } if (fileName == BConstants::EXT_BACKUP_MANAGE) { @@ -628,7 +628,7 @@ ErrCode Service::AppIncrementalFileReady(const std::string &fileName, UniqueFd f } session_->GetServiceReverseProxy()->IncrementalBackupOnFileReady(callerName, fileName, move(fd), move(manifestFd), errCode); - FileReadyRadarReport(callerName, fileName, errCode, IServiceReverse::Scenario::BACKUP); + FileReadyRadarReport(callerName, fileName, errCode, IServiceReverseType::Scenario::BACKUP); if (session_->OnBundleFileReady(callerName, fileName)) { ErrCode ret = HandleCurBundleFileReady(callerName, fileName, true); if (ret != ERR_OK) { @@ -699,10 +699,10 @@ ErrCode Service::GetIncrementalFileHandle(const std::string &bundleName, const s HILOGE("GetIncrementalFileHandle error, session is empty"); return BError(BError::Codes::SA_INVAL_ARG); } - ErrCode ret = VerifyCaller(IServiceReverse::Scenario::RESTORE); + ErrCode ret = VerifyCaller(IServiceReverseType::Scenario::RESTORE); if (ret != ERR_OK) { HILOGE("Error, bundleName:%{public}s, fileName:%{public}s", bundleName.c_str(), - GetAnonyPath(fileName).c_str()); + GetAnonyPath(fileName).c_str()); return ret; } if (!BDir::IsFilePathValid(fileName)) { @@ -743,8 +743,11 @@ ErrCode Service::SendIncrementalFileHandle(const std::string &bundleName, const HILOGE("GetIncrementalFileHandle failed, bundleName:%{public}s", bundleName.c_str()); return BError(BError::Codes::SA_INVAL_ARG); } - auto[errCode, fd, reportFd] = proxy->GetIncrementalFileHandle(fileName); - auto err = AppIncrementalFileReady(bundleName, fileName, move(fd), move(reportFd), errCode); + UniqueFdGroup fdGroup; + proxy->GetIncrementalFileHandle(fileName, fdGroup); + UniqueFd fd(fdGroup.fd); + UniqueFd reportFd(fdGroup.reportFd); + auto err = AppIncrementalFileReady(bundleName, fileName, move(fd), move(reportFd), fdGroup.errCode); if (err != ERR_OK) { HILOGE("Failed to send file handle, bundleName:%{public}s, fileName:%{public}s", bundleName.c_str(), GetAnonyPath(fileName).c_str()); @@ -758,7 +761,7 @@ ErrCode Service::SendIncrementalFileHandle(const std::string &bundleName, const bool Service::IncrementalBackup(const string &bundleName) { HITRACE_METER_NAME(HITRACE_TAG_FILEMANAGEMENT, __PRETTY_FUNCTION__); - IServiceReverse::Scenario scenario = session_->GetScenario(); + IServiceReverseType::Scenario scenario = session_->GetScenario(); auto backUpConnection = session_->GetExtConnection(bundleName); if (backUpConnection == nullptr) { HILOGE("backUpConnection is empty, bundle:%{public}s", bundleName.c_str()); @@ -773,17 +776,18 @@ bool Service::IncrementalBackup(const string &bundleName) NoticeClientFinish(bundleName, BError(BError::Codes::EXT_ABILITY_DIED)); return true; } - if (scenario == IServiceReverse::Scenario::BACKUP && session_->GetIsIncrementalBackup()) { + if (scenario == IServiceReverseType::Scenario::BACKUP && session_->GetIsIncrementalBackup()) { auto ret = proxy->IncrementalOnBackup(session_->GetClearDataFlag(bundleName)); session_->GetServiceReverseProxy()->IncrementalBackupOnBundleStarted(ret, bundleName); - BundleBeginRadarReport(bundleName, ret, IServiceReverse::Scenario::BACKUP); + BundleBeginRadarReport(bundleName, ret, IServiceReverseType::Scenario::BACKUP); if (ret) { SendEndAppGalleryNotify(bundleName); ClearSessionAndSchedInfo(bundleName); NoticeClientFinish(bundleName, BError(BError::Codes::EXT_ABILITY_DIED)); } return true; - } else if (scenario == IServiceReverse::Scenario::RESTORE && BackupPara().GetBackupOverrideIncrementalRestore() && + } else if (scenario == IServiceReverseType::Scenario::RESTORE && + BackupPara().GetBackupOverrideIncrementalRestore() && session_->ValidRestoreDataType(RestoreTypeEnum::RESTORE_DATA_WAIT_SEND)) { auto ret = proxy->HandleRestore(session_->GetClearDataFlag(bundleName)); session_->GetServiceReverseProxy()->IncrementalRestoreOnBundleStarted(ret, bundleName); @@ -792,11 +796,10 @@ bool Service::IncrementalBackup(const string &bundleName) HILOGE("Failed to get backupVersion of old device"); } HILOGD("backupVersion of old device = %{public}s", oldBackupVersion.c_str()); - BundleBeginRadarReport(bundleName, ret, IServiceReverse::Scenario::RESTORE); + BundleBeginRadarReport(bundleName, ret, IServiceReverseType::Scenario::RESTORE); auto fileNameVec = session_->GetExtFileNameRequest(bundleName); for (const auto &fileName : fileNameVec) { - auto[errCode, fd, reportFd] = proxy->GetIncrementalFileHandle(fileName); - ret = AppIncrementalFileReady(bundleName, fileName, move(fd), move(reportFd), errCode); + ret = HelpToAppIncrementalFileReady(bundleName, fileName, proxy); if (ret) { HILOGE("Failed to send file handle %{public}s", GetAnonyString(fileName).c_str()); } @@ -805,18 +808,27 @@ bool Service::IncrementalBackup(const string &bundleName) } return false; } +ErrCode Service::HelpToAppIncrementalFileReady(const string &bundleName, const string &fileName, sptr proxy) +{ + UniqueFdGroup fdGroup; + proxy->GetIncrementalFileHandle(fileName, fdGroup); + UniqueFd fd(fdGroup.fd); + UniqueFd reportFd(fdGroup.reportFd); + auto ret = AppIncrementalFileReady(bundleName, fileName, move(fd), move(reportFd), fdGroup.errCode); + return ret; +} ErrCode Service::IncrementalBackupSA(std::string bundleName) { HILOGI("IncrementalBackupSA begin %{public}s", bundleName.c_str()); - IServiceReverse::Scenario scenario = session_->GetScenario(); + IServiceReverseType::Scenario scenario = session_->GetScenario(); auto backUpConnection = session_->GetSAExtConnection(bundleName); std::shared_ptr saConnection = backUpConnection.lock(); if (saConnection == nullptr) { HILOGE("lock sa connection ptr is nullptr"); return BError(BError::Codes::SA_INVAL_ARG); } - if (scenario == IServiceReverse::Scenario::BACKUP) { + if (scenario == IServiceReverseType::Scenario::BACKUP) { auto ret = saConnection->CallBackupSA(); session_->GetServiceReverseProxy()->IncrementalBackupOnBundleStarted(ret, bundleName); BundleBeginRadarReport(bundleName, ret, scenario); @@ -826,7 +838,7 @@ ErrCode Service::IncrementalBackupSA(std::string bundleName) NoticeClientFinish(bundleName, BError(BError::Codes::EXT_ABILITY_DIED)); return BError(ret); } - } else if (scenario == IServiceReverse::Scenario::RESTORE) { + } else if (scenario == IServiceReverseType::Scenario::RESTORE) { session_->GetServiceReverseProxy()->IncrementalRestoreOnBundleStarted(BError(BError::Codes::OK), bundleName); } return BError(BError::Codes::OK); @@ -834,8 +846,8 @@ ErrCode Service::IncrementalBackupSA(std::string bundleName) void Service::NotifyCallerCurAppIncrementDone(ErrCode errCode, const std::string &callerName) { - IServiceReverse::Scenario scenario = session_->GetScenario(); - if (scenario == IServiceReverse::Scenario::BACKUP) { + IServiceReverseType::Scenario scenario = session_->GetScenario(); + if (scenario == IServiceReverseType::Scenario::BACKUP) { HILOGI("will notify clone data, scenario is incremental backup"); session_->GetServiceReverseProxy()->IncrementalBackupOnBundleFinished(errCode, callerName); BundleEndRadarReport(callerName, errCode, scenario); @@ -852,7 +864,7 @@ void Service::NotifyCallerCurAppIncrementDone(ErrCode errCode, const std::string "PROC_NAME", "ohos.appfileservice", "BUNDLENAME", callerName, "PID", getpid(), "TIME", strTime.str() ); - } else if (scenario == IServiceReverse::Scenario::RESTORE) { + } else if (scenario == IServiceReverseType::Scenario::RESTORE) { HILOGI("will notify clone data, scenario is Restore"); session_->GetServiceReverseProxy()->IncrementalRestoreOnBundleFinished(errCode, callerName); BundleEndRadarReport(callerName, errCode, scenario); @@ -961,9 +973,9 @@ void Service::CancelTask(std::string bundleName, wptr ptr) session->StopExtTimer(bundleName); backUpConnection->DisconnectBackupExtAbility(); thisPtr->ClearSessionAndSchedInfo(bundleName); - IServiceReverse::Scenario scenario = session->GetScenario(); - if ((scenario == IServiceReverse::Scenario::BACKUP && session->GetIsIncrementalBackup()) || - (scenario == IServiceReverse::Scenario::RESTORE && + IServiceReverseType::Scenario scenario = session->GetScenario(); + if ((scenario == IServiceReverseType::Scenario::BACKUP && session->GetIsIncrementalBackup()) || + (scenario == IServiceReverseType::Scenario::RESTORE && session->ValidRestoreDataType(RestoreTypeEnum::RESTORE_DATA_WAIT_SEND))) { thisPtr->NotifyCallerCurAppIncrementDone(BError(BError::Codes::OK), bundleName); } else { @@ -982,7 +994,7 @@ ErrCode Service::Cancel(const std::string& bundleName, int32_t &result) HILOGE("Cancel error, session is null"); return BError(BError::BackupErrorCode::E_CANCEL_UNSTARTED_TASK); } - IServiceReverse::Scenario scenario = session_->GetScenario(); + IServiceReverseType::Scenario scenario = session_->GetScenario(); ErrCode ret = VerifyCaller(scenario); if (ret != ERR_OK) { HILOGE("Verify caller failed, bundleName:%{public}s, scenario:%{public}d", bundleName.c_str(), scenario); diff --git a/services/backup_sa/src/module_ipc/service_incremental_reverse_proxy.cpp b/services/backup_sa/src/module_ipc/service_incremental_reverse_proxy.cpp deleted file mode 100644 index 8aecf1ee6cb835def1c1844025a145b14f22ab37..0000000000000000000000000000000000000000 --- a/services/backup_sa/src/module_ipc/service_incremental_reverse_proxy.cpp +++ /dev/null @@ -1,280 +0,0 @@ -/* - * Copyright (c) 2024 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 "module_ipc/service_reverse_proxy.h" - -#include "b_error/b_error.h" -#include "b_error/b_excep_utils.h" -#include "filemgmt_libhilog.h" -#include "module_app_gallery/app_gallery_dispose_proxy.h" -#include "b_sa/b_sa_utils.h" - -namespace OHOS::FileManagement::Backup { -using namespace std; - -void ServiceReverseProxy::IncrementalBackupOnFileReady(string bundleName, string fileName, int fd, int manifestFd, - int32_t errCode) -{ - BExcepUltils::BAssert(Remote(), BError::Codes::SDK_INVAL_ARG, "Remote is nullptr"); - MessageParcel data; - bool appFlag = true; - if (SAUtils::IsSABundleName(bundleName)) { - appFlag = false; - } - - bool fdFlag = true; - if (fd < 0 || (appFlag && manifestFd < 0)) { - fdFlag = false; - } - if (!data.WriteInterfaceToken(GetDescriptor()) || !data.WriteString(bundleName) || - !data.WriteString(fileName) || !data.WriteBool(fdFlag) || - (fdFlag == true && (!data.WriteFileDescriptor(fd) || (!data.WriteFileDescriptor(manifestFd) && appFlag))) || - !data.WriteInt32(errCode)) { - throw BError(BError::Codes::SA_BROKEN_IPC); - } - - MessageParcel reply; - MessageOption option; - if (int err = Remote()->SendRequest( - static_cast(IServiceReverseInterfaceCode::SERVICER_INCREMENTAL_BACKUP_ON_FILE_READY), data, reply, - option); - err != ERR_OK) { - throw BError(BError::Codes::SA_BROKEN_IPC, to_string(err)); - } -} - -void ServiceReverseProxy::IncrementalBackupOnBundleStarted(int32_t errCode, string bundleName) -{ - BExcepUltils::BAssert(Remote(), BError::Codes::SDK_INVAL_ARG, "Remote is nullptr"); - MessageParcel data; - if (!data.WriteInterfaceToken(GetDescriptor()) || !data.WriteInt32(errCode) || !data.WriteString(bundleName)) { - throw BError(BError::Codes::SA_BROKEN_IPC); - }; - - MessageParcel reply; - MessageOption option; - if (int err = Remote()->SendRequest( - static_cast(IServiceReverseInterfaceCode::SERVICER_INCREMENTAL_BACKUP_ON_SUB_TASK_STARTED), data, - reply, option); - err != ERR_OK) { - throw BError(BError::Codes::SA_BROKEN_IPC, to_string(err)); - } -} - -void ServiceReverseProxy::IncrementalBackupOnResultReport(std::string result, std::string bundleName) -{ - BExcepUltils::BAssert(Remote(), BError::Codes::SDK_INVAL_ARG, "Remote is nullptr"); - MessageParcel data; - if (!data.WriteInterfaceToken(GetDescriptor()) || !data.WriteString(result) || !data.WriteString(bundleName)) { - throw BError(BError::Codes::SA_BROKEN_IPC); - }; - - MessageParcel reply; - MessageOption option; - if (int err = Remote()->SendRequest( - static_cast(IServiceReverseInterfaceCode::SERVICER_INCREMENTAL_BACKUP_ON_RESULT_REPORT), data, - reply, option); - err != ERR_OK) { - throw BError(BError::Codes::SA_BROKEN_IPC, to_string(err)); - } -} - -void ServiceReverseProxy::IncrementalBackupOnBundleFinished(int32_t errCode, string bundleName) -{ - BExcepUltils::BAssert(Remote(), BError::Codes::SDK_INVAL_ARG, "Remote is nullptr"); - MessageParcel data; - if (!data.WriteInterfaceToken(GetDescriptor()) || !data.WriteInt32(errCode) || !data.WriteString(bundleName)) { - throw BError(BError::Codes::SA_BROKEN_IPC); - } - - MessageParcel reply; - MessageOption option; - if (int err = Remote()->SendRequest( - static_cast(IServiceReverseInterfaceCode::SERVICER_INCREMENTAL_BACKUP_ON_SUB_TASK_FINISHED), data, - reply, option); - err != ERR_OK) { - throw BError(BError::Codes::SA_BROKEN_IPC, to_string(err)); - } -} - -void ServiceReverseProxy::IncrementalBackupOnAllBundlesFinished(int32_t errCode) -{ - BExcepUltils::BAssert(Remote(), BError::Codes::SDK_INVAL_ARG, "Remote is nullptr"); - MessageParcel data; - if (!data.WriteInterfaceToken(GetDescriptor()) || !data.WriteInt32(errCode)) { - throw BError(BError::Codes::SA_BROKEN_IPC); - } - - MessageParcel reply; - MessageOption option; - if (int err = Remote()->SendRequest( - static_cast(IServiceReverseInterfaceCode::SERVICER_INCREMENTAL_BACKUP_ON_TASK_FINISHED), data, - reply, option); - err != ERR_OK) { - throw BError(BError::Codes::SA_BROKEN_IPC, to_string(err)); - } -} - -void ServiceReverseProxy::IncrementalBackupOnProcessInfo(std::string bundleName, std::string processInfo) -{ - BExcepUltils::BAssert(Remote(), BError::Codes::SDK_INVAL_ARG, "Remote is nullptr"); - MessageParcel data; - if (!data.WriteInterfaceToken(GetDescriptor()) || !data.WriteString(bundleName) || !data.WriteString(processInfo)) { - throw BError(BError::Codes::SA_BROKEN_IPC); - } - - MessageParcel reply; - MessageOption option; - if (int err = Remote()->SendRequest( - static_cast(IServiceReverseInterfaceCode::SERVICER_INCREMENTAL_BACKUP_ON_PROCESS_INFO), data, - reply, option); - err != ERR_OK) { - throw BError(BError::Codes::SA_BROKEN_IPC, to_string(err)); - } -} - -void ServiceReverseProxy::IncrementalBackupOnScanningInfo(std::string scannedInfo) -{ - BExcepUltils::BAssert(Remote(), BError::Codes::SDK_INVAL_ARG, "Remote is nullptr"); - MessageParcel data; - if (!data.WriteInterfaceToken(GetDescriptor()) || !data.WriteString(scannedInfo)) { - throw BError(BError::Codes::SA_BROKEN_IPC); - } - - MessageParcel reply; - MessageOption option; - if (int err = Remote()->SendRequest( - static_cast(IServiceReverseInterfaceCode::SERVICER_INCREMENTAL_BACKUP_ON_SCANNED_INFO), data, - reply, option); - err != ERR_OK) { - throw BError(BError::Codes::SA_BROKEN_IPC, to_string(err)); - } -} - -void ServiceReverseProxy::IncrementalRestoreOnBundleStarted(int32_t errCode, string bundleName) -{ - BExcepUltils::BAssert(Remote(), BError::Codes::SDK_INVAL_ARG, "Remote is nullptr"); - MessageParcel data; - if (!data.WriteInterfaceToken(GetDescriptor()) || !data.WriteInt32(errCode) || !data.WriteString(bundleName)) { - throw BError(BError::Codes::SA_BROKEN_IPC); - } - - MessageParcel reply; - MessageOption option; - if (int err = Remote()->SendRequest( - static_cast(IServiceReverseInterfaceCode::SERVICER_INCREMENTAL_RESTORE_ON_SUB_TASK_STARTED), data, - reply, option); - err != ERR_OK) { - throw BError(BError::Codes::SA_BROKEN_IPC, to_string(err)); - } -} - -void ServiceReverseProxy::IncrementalRestoreOnBundleFinished(int32_t errCode, string bundleName) -{ - BExcepUltils::BAssert(Remote(), BError::Codes::SDK_INVAL_ARG, "Remote is nullptr"); - MessageParcel data; - if (!data.WriteInterfaceToken(GetDescriptor()) || !data.WriteInt32(errCode) || !data.WriteString(bundleName)) { - throw BError(BError::Codes::SA_BROKEN_IPC); - } - - MessageParcel reply; - MessageOption option; - if (int err = Remote()->SendRequest( - static_cast(IServiceReverseInterfaceCode::SERVICER_INCREMENTAL_RESTORE_ON_SUB_TASK_FINISHED), - data, reply, option); - err != ERR_OK) { - throw BError(BError::Codes::SA_BROKEN_IPC, to_string(err)); - } -} - -void ServiceReverseProxy::IncrementalRestoreOnAllBundlesFinished(int32_t errCode) -{ - BExcepUltils::BAssert(Remote(), BError::Codes::SDK_INVAL_ARG, "Remote is nullptr"); - MessageParcel data; - if (!data.WriteInterfaceToken(GetDescriptor()) || !data.WriteInt32(errCode)) { - throw BError(BError::Codes::SA_BROKEN_IPC); - } - - MessageParcel reply; - MessageOption option; - if (int err = Remote()->SendRequest( - static_cast(IServiceReverseInterfaceCode::SERVICER_INCREMENTAL_RESTORE_ON_TASK_FINISHED), data, - reply, option); - err != ERR_OK) { - throw BError(BError::Codes::SA_BROKEN_IPC, to_string(err)); - } -} - -void ServiceReverseProxy::IncrementalRestoreOnResultReport(std::string result, - std::string bundleName, ErrCode errCode) -{ - BExcepUltils::BAssert(Remote(), BError::Codes::SDK_INVAL_ARG, "Remote is nullptr"); - MessageParcel data; - if (!data.WriteInterfaceToken(GetDescriptor()) || !data.WriteString(result) || - !data.WriteString(bundleName) || !data.WriteInt32(errCode)) { - throw BError(BError::Codes::SA_BROKEN_IPC); - } - - MessageParcel reply; - MessageOption option; - if (int err = Remote()->SendRequest( - static_cast(IServiceReverseInterfaceCode::SERVICER_INCREMENTAL_RESTORE_ON_RESULT_REPORT), data, - reply, option); - err != ERR_OK) { - throw BError(BError::Codes::SA_BROKEN_IPC, to_string(err)); - } -} - -void ServiceReverseProxy::IncrementalRestoreOnFileReady(string bundleName, string fileName, int fd, int manifestFd, - int32_t errCode) -{ - BExcepUltils::BAssert(Remote(), BError::Codes::SDK_INVAL_ARG, "Remote is nullptr"); - MessageParcel data; - bool fdFlag = (fd < 0 || manifestFd < 0) ? false : true; - if (!data.WriteInterfaceToken(GetDescriptor()) || !data.WriteString(bundleName) || - !data.WriteString(fileName) || !data.WriteBool(fdFlag) || - (fdFlag == true && (!data.WriteFileDescriptor(fd) || !data.WriteFileDescriptor(manifestFd))) || - !data.WriteInt32(errCode)) { - throw BError(BError::Codes::SA_BROKEN_IPC); - } - - MessageParcel reply; - MessageOption option; - if (int err = Remote()->SendRequest( - static_cast(IServiceReverseInterfaceCode::SERVICER_INCREMENTAL_RESTORE_ON_FILE_READY), data, - reply, option); - err != ERR_OK) { - throw BError(BError::Codes::SA_BROKEN_IPC, to_string(err)); - } -} - -void ServiceReverseProxy::IncrementalRestoreOnProcessInfo(std::string bundleName, std::string processInfo) -{ - BExcepUltils::BAssert(Remote(), BError::Codes::SDK_INVAL_ARG, "Remote is nullptr"); - MessageParcel data; - if (!data.WriteInterfaceToken(GetDescriptor()) || !data.WriteString(bundleName) || !data.WriteString(processInfo)) { - throw BError(BError::Codes::SA_BROKEN_IPC); - } - - MessageParcel reply; - MessageOption option; - if (int err = Remote()->SendRequest( - static_cast(IServiceReverseInterfaceCode::SERVICER_INCREMENTAL_RESTORE_ON_PROCESS_INFO), data, - reply, option); - err != ERR_OK) { - throw BError(BError::Codes::SA_BROKEN_IPC, to_string(err)); - } -} -} // namespace OHOS::FileManagement::Backup \ No newline at end of file diff --git a/services/backup_sa/src/module_ipc/service_reverse_proxy.cpp b/services/backup_sa/src/module_ipc/service_reverse_proxy.cpp deleted file mode 100644 index 2d2dbab3691e26e870e2a75fcc33bd267fb89de2..0000000000000000000000000000000000000000 --- a/services/backup_sa/src/module_ipc/service_reverse_proxy.cpp +++ /dev/null @@ -1,259 +0,0 @@ -/* - * Copyright (c) 2022-2024 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 "module_ipc/service_reverse_proxy.h" - -#include "b_error/b_error.h" -#include "b_error/b_excep_utils.h" -#include "filemgmt_libhilog.h" - -namespace OHOS::FileManagement::Backup { -using namespace std; - -void ServiceReverseProxy::BackupOnFileReady(string bundleName, string fileName, int fd, int32_t errCode) -{ - BExcepUltils::BAssert(Remote(), BError::Codes::SDK_INVAL_ARG, "Remote is nullptr"); - MessageParcel data; - bool fdFlag = fd < 0 ? false : true; - if (!data.WriteInterfaceToken(GetDescriptor()) || !data.WriteString(bundleName) || !data.WriteString(fileName) || - !data.WriteBool(fdFlag) || (fdFlag == true && !data.WriteFileDescriptor(fd)) || !data.WriteInt32(errCode)) { - throw BError(BError::Codes::SA_BROKEN_IPC); - } - - MessageParcel reply; - MessageOption option; - if (int err = Remote()->SendRequest( - static_cast(IServiceReverseInterfaceCode::SERVICER_BACKUP_ON_FILE_READY), data, reply, option); - err != ERR_OK) { - throw BError(BError::Codes::SA_BROKEN_IPC, to_string(err)); - } -} - -void ServiceReverseProxy::BackupOnBundleStarted(int32_t errCode, string bundleName) -{ - BExcepUltils::BAssert(Remote(), BError::Codes::SDK_INVAL_ARG, "Remote is nullptr"); - MessageParcel data; - if (!data.WriteInterfaceToken(GetDescriptor()) || !data.WriteInt32(errCode) || !data.WriteString(bundleName)) { - throw BError(BError::Codes::SA_BROKEN_IPC); - }; - - MessageParcel reply; - MessageOption option; - if (int err = Remote()->SendRequest( - static_cast(IServiceReverseInterfaceCode::SERVICER_BACKUP_ON_SUB_TASK_STARTED), data, reply, - option); - err != ERR_OK) { - throw BError(BError::Codes::SA_BROKEN_IPC, to_string(err)); - } -} - -void ServiceReverseProxy::BackupOnResultReport(std::string result, std::string bundleName) -{ - BExcepUltils::BAssert(Remote(), BError::Codes::SDK_INVAL_ARG, "Remote is nullptr"); - MessageParcel data; - if (!data.WriteInterfaceToken(GetDescriptor()) || !data.WriteString(result) || !data.WriteString(bundleName)) { - throw BError(BError::Codes::SA_BROKEN_IPC); - }; - - MessageParcel reply; - MessageOption option; - if (int err = Remote()->SendRequest( - static_cast(IServiceReverseInterfaceCode::SERVICER_BACKUP_ON_RESULT_REPORT), data, reply, - option); - err != ERR_OK) { - throw BError(BError::Codes::SA_BROKEN_IPC, to_string(err)); - } -} - -void ServiceReverseProxy::BackupOnBundleFinished(int32_t errCode, string bundleName) -{ - BExcepUltils::BAssert(Remote(), BError::Codes::SDK_INVAL_ARG, "Remote is nullptr"); - MessageParcel data; - if (!data.WriteInterfaceToken(GetDescriptor()) || !data.WriteInt32(errCode) || !data.WriteString(bundleName)) { - throw BError(BError::Codes::SA_BROKEN_IPC); - } - - MessageParcel reply; - MessageOption option; - if (int err = Remote()->SendRequest( - static_cast(IServiceReverseInterfaceCode::SERVICER_BACKUP_ON_SUB_TASK_FINISHED), data, reply, - option); - err != ERR_OK) { - throw BError(BError::Codes::SA_BROKEN_IPC, to_string(err)); - } -} - -void ServiceReverseProxy::BackupOnAllBundlesFinished(int32_t errCode) -{ - BExcepUltils::BAssert(Remote(), BError::Codes::SDK_INVAL_ARG, "Remote is nullptr"); - MessageParcel data; - if (!data.WriteInterfaceToken(GetDescriptor()) || !data.WriteInt32(errCode)) { - throw BError(BError::Codes::SA_BROKEN_IPC); - } - - MessageParcel reply; - MessageOption option; - if (int err = Remote()->SendRequest( - static_cast(IServiceReverseInterfaceCode::SERVICER_BACKUP_ON_TASK_FINISHED), data, reply, option); - err != ERR_OK) { - throw BError(BError::Codes::SA_BROKEN_IPC, to_string(err)); - } -} - -void ServiceReverseProxy::BackupOnProcessInfo(std::string bundleName, std::string processInfo) -{ - BExcepUltils::BAssert(Remote(), BError::Codes::SDK_INVAL_ARG, "Remote is nullptr"); - MessageParcel data; - if (!data.WriteInterfaceToken(GetDescriptor()) || !data.WriteString(bundleName) || !data.WriteString(processInfo)) { - throw BError(BError::Codes::SA_BROKEN_IPC); - } - - MessageParcel reply; - MessageOption option; - if (int err = Remote()->SendRequest( - static_cast(IServiceReverseInterfaceCode::SERVICER_BACKUP_ON_PROCESS_INFO), data, reply, option); - err != ERR_OK) { - throw BError(BError::Codes::SA_BROKEN_IPC, to_string(err)); - } -} - -void ServiceReverseProxy::BackupOnScanningInfo(std::string scannedInfo) -{ - BExcepUltils::BAssert(Remote(), BError::Codes::SDK_INVAL_ARG, "Remote is nullptr"); - MessageParcel data; - if (!data.WriteInterfaceToken(GetDescriptor()) || !data.WriteString(scannedInfo)) { - throw BError(BError::Codes::SA_BROKEN_IPC); - } - - MessageParcel reply; - MessageOption option; - if (int err = Remote()->SendRequest( - static_cast(IServiceReverseInterfaceCode::SERVICER_BACKUP_ON_SCANNED_INFO), data, - reply, option); - err != ERR_OK) { - throw BError(BError::Codes::SA_BROKEN_IPC, to_string(err)); - } -} - -void ServiceReverseProxy::RestoreOnBundleStarted(int32_t errCode, string bundleName) -{ - BExcepUltils::BAssert(Remote(), BError::Codes::SDK_INVAL_ARG, "Remote is nullptr"); - MessageParcel data; - if (!data.WriteInterfaceToken(GetDescriptor()) || !data.WriteInt32(errCode) || !data.WriteString(bundleName)) { - throw BError(BError::Codes::SA_BROKEN_IPC); - } - - MessageParcel reply; - MessageOption option; - if (int err = Remote()->SendRequest( - static_cast(IServiceReverseInterfaceCode::SERVICER_RESTORE_ON_SUB_TASK_STARTED), data, reply, - option); - err != ERR_OK) { - throw BError(BError::Codes::SA_BROKEN_IPC, to_string(err)); - } -} - -void ServiceReverseProxy::RestoreOnBundleFinished(int32_t errCode, string bundleName) -{ - BExcepUltils::BAssert(Remote(), BError::Codes::SDK_INVAL_ARG, "Remote is nullptr"); - MessageParcel data; - if (!data.WriteInterfaceToken(GetDescriptor()) || !data.WriteInt32(errCode) || !data.WriteString(bundleName)) { - throw BError(BError::Codes::SA_BROKEN_IPC); - } - - MessageParcel reply; - MessageOption option; - if (int err = Remote()->SendRequest( - static_cast(IServiceReverseInterfaceCode::SERVICER_RESTORE_ON_SUB_TASK_FINISHED), data, reply, - option); - err != ERR_OK) { - throw BError(BError::Codes::SA_BROKEN_IPC, to_string(err)); - } -} - -void ServiceReverseProxy::RestoreOnAllBundlesFinished(int32_t errCode) -{ - BExcepUltils::BAssert(Remote(), BError::Codes::SDK_INVAL_ARG, "Remote is nullptr"); - MessageParcel data; - if (!data.WriteInterfaceToken(GetDescriptor()) || !data.WriteInt32(errCode)) { - throw BError(BError::Codes::SA_BROKEN_IPC); - } - - MessageParcel reply; - MessageOption option; - if (int err = Remote()->SendRequest( - static_cast(IServiceReverseInterfaceCode::SERVICER_RESTORE_ON_TASK_FINISHED), data, reply, - option); - err != ERR_OK) { - throw BError(BError::Codes::SA_BROKEN_IPC, to_string(err)); - } -} - -void ServiceReverseProxy::RestoreOnFileReady(string bundleName, string fileName, int fd, int32_t errCode) -{ - BExcepUltils::BAssert(Remote(), BError::Codes::SDK_INVAL_ARG, "Remote is nullptr"); - MessageParcel data; - bool fdFlag = fd < 0 ? false : true; - if (!data.WriteInterfaceToken(GetDescriptor()) || !data.WriteString(bundleName) || !data.WriteString(fileName) || - !data.WriteBool(fdFlag) || (fdFlag == true && !data.WriteFileDescriptor(fd)) || !data.WriteInt32(errCode)) { - throw BError(BError::Codes::SA_BROKEN_IPC); - } - - MessageParcel reply; - MessageOption option; - if (int err = Remote()->SendRequest( - static_cast(IServiceReverseInterfaceCode::SERVICER_RESTORE_ON_FILE_READY), data, reply, option); - err != ERR_OK) { - throw BError(BError::Codes::SA_BROKEN_IPC, to_string(err)); - } -} - -void ServiceReverseProxy::RestoreOnResultReport(string result, std::string bundleName, ErrCode errCode) -{ - HILOGI("ServiceReverseProxy::RestoreOnResultReport Begin with result: %s", result.c_str()); - BExcepUltils::BAssert(Remote(), BError::Codes::SDK_INVAL_ARG, "Remote is nullptr"); - MessageParcel data; - if (!data.WriteInterfaceToken(GetDescriptor()) || !data.WriteString(result) || - !data.WriteString(bundleName) || !data.WriteInt32(errCode)) { - throw BError(BError::Codes::SA_BROKEN_IPC); - } - - MessageParcel reply; - MessageOption option; - if (int err = Remote()->SendRequest( - static_cast(IServiceReverseInterfaceCode::SERVICER_RESTORE_ON_RESULT_REPORT), data, reply, - option); - err != ERR_OK) { - throw BError(BError::Codes::SA_BROKEN_IPC, to_string(err)); - } -} - -void ServiceReverseProxy::RestoreOnProcessInfo(std::string bundleName, std::string processInfo) -{ - BExcepUltils::BAssert(Remote(), BError::Codes::SDK_INVAL_ARG, "Remote is nullptr"); - MessageParcel data; - if (!data.WriteInterfaceToken(GetDescriptor()) || !data.WriteString(bundleName) || !data.WriteString(processInfo)) { - throw BError(BError::Codes::SA_BROKEN_IPC); - } - - MessageParcel reply; - MessageOption option; - if (int err = Remote()->SendRequest( - static_cast(IServiceReverseInterfaceCode::SERVICER_RESTORE_ON_PROCESS_INFO), data, reply, option); - err != ERR_OK) { - throw BError(BError::Codes::SA_BROKEN_IPC, to_string(err)); - } -} -} // namespace OHOS::FileManagement::Backup \ No newline at end of file diff --git a/services/backup_sa/src/module_ipc/sub_service.cpp b/services/backup_sa/src/module_ipc/sub_service.cpp index 99b728768e450d565512686100a7532b04e986df..1b83bbfa455eb08b04b7bdd6787282eab09f8a4a 100644 --- a/services/backup_sa/src/module_ipc/sub_service.cpp +++ b/services/backup_sa/src/module_ipc/sub_service.cpp @@ -84,11 +84,11 @@ void Service::AppendBundles(const std::vector &bundleNames) } } -void Service::ReportOnBundleStarted(IServiceReverse::Scenario scenario, const std::string &bundleName) +void Service::ReportOnBundleStarted(IServiceReverseType::Scenario scenario, const std::string &bundleName) { - if (scenario == IServiceReverse::Scenario::BACKUP) { + if (scenario == IServiceReverseType::Scenario::BACKUP) { session_->GetServiceReverseProxy()->BackupOnBundleStarted(BError(BError::Codes::SA_INVAL_ARG), bundleName); - } else if (scenario == IServiceReverse::Scenario::RESTORE) { + } else if (scenario == IServiceReverseType::Scenario::RESTORE) { session_->GetServiceReverseProxy()->RestoreOnBundleStarted(BError(BError::Codes::SA_INVAL_ARG), bundleName); } } @@ -165,7 +165,7 @@ bool Service::IsReportFileReadyFail(const std::string &bundleName) return true; } -void Service::TimeoutRadarReport(IServiceReverse::Scenario scenario, std::string &bundleName) +void Service::TimeoutRadarReport(IServiceReverseType::Scenario scenario, std::string &bundleName) { if (!IsReportBundleExecFail(bundleName)) { return; @@ -175,11 +175,11 @@ void Service::TimeoutRadarReport(IServiceReverse::Scenario scenario, std::string if (session_->GetTimeoutValue(bundleName) == 0) { errCode = BError::BackupErrorCode::E_FORCE_TIMEOUT; } - if (scenario == IServiceReverse::Scenario::BACKUP) { + if (scenario == IServiceReverseType::Scenario::BACKUP) { AppRadar::Info info(bundleName, "", "on backup timeout"); AppRadar::GetInstance().RecordBackupFuncRes(info, "Service::TimeOutCallback", GetUserIdDefault(), BizStageBackup::BIZ_STAGE_ON_BACKUP, errCode); - } else if (scenario == IServiceReverse::Scenario::RESTORE) { + } else if (scenario == IServiceReverseType::Scenario::RESTORE) { AppRadar::Info info(bundleName, "", "on restore timeout"); AppRadar::GetInstance().RecordRestoreFuncRes(info, "Service::TimeOutCallback", GetUserIdDefault(), BizStageRestore::BIZ_STAGE_ON_RESTORE, errCode); @@ -219,7 +219,7 @@ ErrCode Service::GetFileHandle(const string &bundleName, const string &fileName) HILOGE("GetFileHandle error, session is empty"); return BError(BError::Codes::SA_INVAL_ARG); } - ErrCode ret = VerifyCaller(IServiceReverse::Scenario::RESTORE); + ErrCode ret = VerifyCaller(IServiceReverseType::Scenario::RESTORE); if (ret != ERR_OK) { HILOGE("verify caller failed, bundleName:%{public}s", bundleName.c_str()); return ret; @@ -265,14 +265,16 @@ ErrCode Service::SendFileHandle(const std::string &bundleName, const std::string return BError(BError::Codes::SA_INVAL_ARG); } int32_t errCode = 0; - UniqueFd fd = proxy->GetFileHandle(fileName, errCode); + int32_t fdCode = 0; + proxy->GetFileHandleWithUniqueFd(fileName, errCode, fdCode); + UniqueFd fd(fdCode); if (errCode != ERR_OK) { AppRadar::Info info(bundleName, "", ""); AppRadar::GetInstance().RecordRestoreFuncRes(info, "Service::GetFileHandle", GetUserIdDefault(), BizStageRestore::BIZ_STAGE_GET_FILE_HANDLE_FAIL, errCode); } session_->GetServiceReverseProxy()->RestoreOnFileReady(bundleName, fileName, move(fd), errCode); - FileReadyRadarReport(bundleName, fileName, errCode, IServiceReverse::Scenario::RESTORE); + FileReadyRadarReport(bundleName, fileName, errCode, IServiceReverseType::Scenario::RESTORE); return BError(BError::Codes::OK); } @@ -283,7 +285,7 @@ ErrCode Service::PublishFile(const BFileInfo &fileInfo) HILOGE("PublishFile error, session is empty"); return BError(BError::Codes::SA_INVAL_ARG); } - ErrCode ret = VerifyCaller(IServiceReverse::Scenario::RESTORE); + ErrCode ret = VerifyCaller(IServiceReverseType::Scenario::RESTORE); if (ret != ERR_OK) { HILOGE("PublishFile error, verify caller by scenario failed, ret:%{public}d", ret); return ret; @@ -404,11 +406,11 @@ ErrCode Service::LaunchBackupExtension(const BundleName &bundleName) { HITRACE_METER_NAME(HITRACE_TAG_FILEMANAGEMENT, __PRETTY_FUNCTION__); HILOGI("begin %{public}s", bundleName.data()); - IServiceReverse::Scenario scenario = session_->GetScenario(); + IServiceReverseType::Scenario scenario = session_->GetScenario(); BConstants::ExtensionAction action; - if (scenario == IServiceReverse::Scenario::BACKUP || scenario == IServiceReverse::Scenario::CLEAN) { + if (scenario == IServiceReverseType::Scenario::BACKUP || scenario == IServiceReverseType::Scenario::CLEAN) { action = BConstants::ExtensionAction::BACKUP; - } else if (scenario == IServiceReverse::Scenario::RESTORE) { + } else if (scenario == IServiceReverseType::Scenario::RESTORE) { action = BConstants::ExtensionAction::RESTORE; } else { action = BConstants::ExtensionAction::INVALID; @@ -488,7 +490,7 @@ std::vector Service::GetSupportBackupBundleNames(vectorGetScenario(); - if (scenario == IServiceReverse::Scenario::BACKUP && session_->GetIsIncrementalBackup()) { + if (scenario == IServiceReverseType::Scenario::BACKUP && session_->GetIsIncrementalBackup()) { session_->GetServiceReverseProxy()->IncrementalBackupOnBundleFinished(errCode, bundleName); - } else if (scenario == IServiceReverse::Scenario::RESTORE && + } else if (scenario == IServiceReverseType::Scenario::RESTORE && BackupPara().GetBackupOverrideIncrementalRestore() && session_->ValidRestoreDataType(RestoreTypeEnum::RESTORE_DATA_WAIT_SEND)) { session_->GetServiceReverseProxy()->IncrementalRestoreOnBundleFinished(errCode, bundleName); - } else if (scenario == IServiceReverse::Scenario::BACKUP) { + } else if (scenario == IServiceReverseType::Scenario::BACKUP) { session_->GetServiceReverseProxy()->BackupOnBundleFinished(errCode, bundleName); - } else if (scenario == IServiceReverse::Scenario::RESTORE) { + } else if (scenario == IServiceReverseType::Scenario::RESTORE) { session_->GetServiceReverseProxy()->RestoreOnBundleFinished(errCode, bundleName); }; BundleEndRadarReport(bundleName, errCode, scenario); @@ -717,20 +719,20 @@ void Service::OnAllBundlesFinished(ErrCode errCode) HITRACE_METER_NAME(HITRACE_TAG_FILEMANAGEMENT, __PRETTY_FUNCTION__); HILOGI("called begin."); if (session_->IsOnAllBundlesFinished()) { - IServiceReverse::Scenario scenario = session_->GetScenario(); - if (isInRelease_.load() && (scenario == IServiceReverse::Scenario::RESTORE)) { + IServiceReverseType::Scenario scenario = session_->GetScenario(); + if (isInRelease_.load() && (scenario == IServiceReverseType::Scenario::RESTORE)) { HILOGI("Will destory session info"); SessionDeactive(); } - if (scenario == IServiceReverse::Scenario::BACKUP && session_->GetIsIncrementalBackup()) { + if (scenario == IServiceReverseType::Scenario::BACKUP && session_->GetIsIncrementalBackup()) { session_->GetServiceReverseProxy()->IncrementalBackupOnAllBundlesFinished(errCode); - } else if (scenario == IServiceReverse::Scenario::RESTORE && + } else if (scenario == IServiceReverseType::Scenario::RESTORE && BackupPara().GetBackupOverrideIncrementalRestore() && session_->ValidRestoreDataType(RestoreTypeEnum::RESTORE_DATA_WAIT_SEND)) { session_->GetServiceReverseProxy()->IncrementalRestoreOnAllBundlesFinished(errCode); - } else if (scenario == IServiceReverse::Scenario::BACKUP) { + } else if (scenario == IServiceReverseType::Scenario::BACKUP) { session_->GetServiceReverseProxy()->BackupOnAllBundlesFinished(errCode); - } else if (scenario == IServiceReverse::Scenario::RESTORE) { + } else if (scenario == IServiceReverseType::Scenario::RESTORE) { session_->GetServiceReverseProxy()->RestoreOnAllBundlesFinished(errCode); } if (!BackupPara().GetBackupOverrideBackupSARelease()) { @@ -748,8 +750,8 @@ ErrCode Service::VerifySendRateParam() HILOGE("Update send rate fail, verify caller failed, ret:%{public}d", ret); return ret; } - IServiceReverse::Scenario scenario = session_ -> GetScenario(); - if (scenario != IServiceReverse::Scenario::BACKUP) { + IServiceReverseType::Scenario scenario = session_ -> GetScenario(); + if (scenario != IServiceReverseType::Scenario::BACKUP) { HILOGE("This method is applicable to the backup scenario"); return BError(BError::Codes::SA_INVAL_ARG); } @@ -777,7 +779,7 @@ ErrCode Service::HandleCurBundleFileReady(const std::string &bundleName, const s if (isIncBackup) { session_->GetServiceReverseProxy()->IncrementalBackupOnBundleFinished(BError(BError::Codes::OK), bundleName); - BundleEndRadarReport(bundleName, BError(BError::Codes::OK), IServiceReverse::Scenario::BACKUP); + BundleEndRadarReport(bundleName, BError(BError::Codes::OK), IServiceReverseType::Scenario::BACKUP); } else { session_->GetServiceReverseProxy()->BackupOnBundleFinished(BError(BError::Codes::OK), bundleName); BundleEndRadarReport(bundleName, BError(BError::Codes::OK), session_->GetScenario()); @@ -865,7 +867,7 @@ ErrCode Service::InitRestoreSession(const sptr& remote, std::st } ret = session_->Active({ .clientToken = IPCSkeleton::GetCallingTokenID(), - .scenario = IServiceReverse::Scenario::RESTORE, + .scenario = IServiceReverseType::Scenario::RESTORE, .clientProxy = remote, .userId = GetUserIdDefault(), .callerName = GetCallerName(), @@ -903,7 +905,7 @@ ErrCode Service::InitBackupSessionWithErrMsg(const sptr& remote session_->SetMemParaCurSize(oldSize); ret = session_->Active({ .clientToken = IPCSkeleton::GetCallingTokenID(), - .scenario = IServiceReverse::Scenario::BACKUP, + .scenario = IServiceReverseType::Scenario::BACKUP, .clientProxy = remote, .userId = GetUserIdDefault(), .callerName = GetCallerName(), @@ -1220,7 +1222,7 @@ void Service::SendScannedInfo(const string&scannendInfos, sptrGetScenario() == IServiceReverse::Scenario::BACKUP && session->GetIsIncrementalBackup()) { + if (session->GetScenario() == IServiceReverseType::Scenario::BACKUP && session->GetIsIncrementalBackup()) { HILOGI("this is incremental backup sending info"); session->GetServiceReverseProxy()->IncrementalBackupOnScanningInfo(scannendInfos); return; diff --git a/services/backup_sa/src/module_ipc/svc_backup_connection.cpp b/services/backup_sa/src/module_ipc/svc_backup_connection.cpp index 7dc6d5eecb0f91ca6fd159f26b2c994270c13b0f..58bdb61583facaf12e4f6783289b0e50e7df5290 100644 --- a/services/backup_sa/src/module_ipc/svc_backup_connection.cpp +++ b/services/backup_sa/src/module_ipc/svc_backup_connection.cpp @@ -21,7 +21,7 @@ #include "ability_manager_client.h" #include "filemgmt_libhilog.h" #include "hisysevent.h" -#include "module_ipc/svc_extension_proxy.h" +#include "extension_proxy.h" #include "module_ipc/svc_session_manager.h" namespace OHOS::FileManagement::Backup { @@ -40,7 +40,7 @@ void SvcBackupConnection::OnAbilityConnectDone(const AppExecFwk::ElementName &el HILOGE("Failed to ability connect done, remote is nullptr"); return; } - backupProxy_ = iface_cast(remoteObject); + backupProxy_ = iface_cast(remoteObject); if (backupProxy_ == nullptr) { HILOGE("Failed to ability connect done, backupProxy_ is nullptr"); return; diff --git a/services/backup_sa/src/module_ipc/svc_extension_incremental_proxy.cpp b/services/backup_sa/src/module_ipc/svc_extension_incremental_proxy.cpp deleted file mode 100644 index c29b0e72b97fcb2584cb6eaba098c7b1751942ca..0000000000000000000000000000000000000000 --- a/services/backup_sa/src/module_ipc/svc_extension_incremental_proxy.cpp +++ /dev/null @@ -1,173 +0,0 @@ -/* - * Copyright (c) 2024 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 "module_ipc/svc_extension_proxy.h" - -#include "b_error/b_error.h" -#include "b_error/b_excep_utils.h" -#include "filemgmt_libhilog.h" -#include "iservice_registry.h" -#include "system_ability_definition.h" -#include "hitrace_meter.h" - -namespace OHOS::FileManagement::Backup { -using namespace std; - -std::tuple SvcExtensionProxy::GetIncrementalFileHandle(const string &fileName) -{ - HITRACE_METER_NAME(HITRACE_TAG_FILEMANAGEMENT, __PRETTY_FUNCTION__); - HILOGD("Start"); - BExcepUltils::BAssert(Remote(), BError::Codes::SDK_INVAL_ARG, "Remote is nullptr"); - MessageParcel data; - data.WriteInterfaceToken(GetDescriptor()); - - if (!data.WriteString(fileName)) { - BError(BError::Codes::SDK_INVAL_ARG, "Failed to send the fileName"); - return {ErrCode(EPERM), UniqueFd(-1), UniqueFd(-1)}; - } - - MessageParcel reply; - MessageOption option; - int32_t ret = Remote()->SendRequest(static_cast(IExtensionInterfaceCode::CMD_GET_INCREMENTAL_FILE_HANDLE), - data, reply, option); - if (ret != NO_ERROR) { - HILOGE("Received error %{public}d when doing IPC", ret); - return {ErrCode(ret), UniqueFd(-1), UniqueFd(-1)}; - } - - HILOGD("Successful"); - ErrCode err(reply.ReadInt32()); - UniqueFd fd(reply.ReadFileDescriptor()); - UniqueFd reportFd(reply.ReadFileDescriptor()); - return {err, move(fd), move(reportFd)}; -} - -ErrCode SvcExtensionProxy::PublishIncrementalFile(const string &fileName) -{ - HITRACE_METER_NAME(HITRACE_TAG_FILEMANAGEMENT, __PRETTY_FUNCTION__); - HILOGD("Start"); - BExcepUltils::BAssert(Remote(), BError::Codes::SDK_INVAL_ARG, "Remote is nullptr"); - MessageParcel data; - data.WriteInterfaceToken(GetDescriptor()); - - if (!data.WriteString(fileName)) { - BError(BError::Codes::SDK_INVAL_ARG, "Failed to send the fileName"); - return ErrCode(EPERM); - } - - MessageParcel reply; - MessageOption option; - int32_t ret = Remote()->SendRequest(static_cast(IExtensionInterfaceCode::CMD_PUBLISH_INCREMENTAL_FILE), - data, reply, option); - if (ret != NO_ERROR) { - HILOGE("Received error %{public}d when doing IPC", ret); - return ErrCode(ret); - } - - HILOGD("Successful"); - return reply.ReadInt32(); -} - -ErrCode SvcExtensionProxy::HandleIncrementalBackup(UniqueFd incrementalFd, UniqueFd manifestFd) -{ - HITRACE_METER_NAME(HITRACE_TAG_FILEMANAGEMENT, __PRETTY_FUNCTION__); - HILOGD("Start"); - BExcepUltils::BAssert(Remote(), BError::Codes::SDK_INVAL_ARG, "Remote is nullptr"); - MessageParcel data; - data.WriteInterfaceToken(GetDescriptor()); - - data.WriteFileDescriptor(incrementalFd); - data.WriteFileDescriptor(manifestFd); - - MessageParcel reply; - MessageOption option; - int32_t ret = Remote()->SendRequest(static_cast(IExtensionInterfaceCode::CMD_HANDLE_INCREMENTAL_BACKUP), - data, reply, option); - if (ret != NO_ERROR) { - HILOGE("Received error %{public}d when doing IPC", ret); - return ErrCode(ret); - } - - HILOGD("Successful"); - return reply.ReadInt32(); -} - -ErrCode SvcExtensionProxy::IncrementalOnBackup(bool isClearData) -{ - HITRACE_METER_NAME(HITRACE_TAG_FILEMANAGEMENT, __PRETTY_FUNCTION__); - HILOGD("Start"); - BExcepUltils::BAssert(Remote(), BError::Codes::SDK_INVAL_ARG, "Remote is nullptr"); - MessageParcel data; - if (!data.WriteInterfaceToken(GetDescriptor()) || !data.WriteBool(isClearData)) { - return BError(BError::Codes::SDK_INVAL_ARG, "build param fail."); - } - - MessageParcel reply; - MessageOption option; - int32_t ret = Remote()->SendRequest(static_cast(IExtensionInterfaceCode::CMD_INCREMENTAL_ON_BACKUP), - data, reply, option); - if (ret != NO_ERROR) { - HILOGE("Received error %{public}d when doing IPC", ret); - return ErrCode(ret); - } - - HILOGD("Successful"); - return BError(BError::Codes::OK); -} - -ErrCode SvcExtensionProxy::User0OnBackup() -{ - HITRACE_METER_NAME(HITRACE_TAG_FILEMANAGEMENT, __PRETTY_FUNCTION__); - HILOGD("Start"); - BExcepUltils::BAssert(Remote(), BError::Codes::SDK_INVAL_ARG, "Remote is nullptr"); - MessageParcel data; - data.WriteInterfaceToken(GetDescriptor()); - - MessageParcel reply; - MessageOption option; - int32_t ret = Remote()->SendRequest(static_cast(IExtensionInterfaceCode::CMD_HANDLE_USER_0_BACKUP), - data, reply, option); - if (ret != NO_ERROR) { - HILOGE("Received error %{public}d when doing IPC", ret); - return ErrCode(ret); - } - - HILOGD("Successful"); - return reply.ReadInt32(); -} - -tuple SvcExtensionProxy::GetIncrementalBackupFileHandle() -{ - HITRACE_METER_NAME(HITRACE_TAG_FILEMANAGEMENT, __PRETTY_FUNCTION__); - HILOGD("Start"); - BExcepUltils::BAssert(Remote(), BError::Codes::SDK_INVAL_ARG, "Remote is nullptr"); - MessageParcel data; - data.WriteInterfaceToken(GetDescriptor()); - - MessageParcel reply; - MessageOption option; - int32_t ret = Remote()->SendRequest( - static_cast(IExtensionInterfaceCode::CMD_GET_INCREMENTAL_BACKUP_FILE_HANDLE), data, reply, option); - if (ret != NO_ERROR) { - HILOGE("Received error %{public}d when doing IPC", ret); - return {UniqueFd(-1), UniqueFd(-1)}; - } - - HILOGD("Successful"); - UniqueFd incrementalFd(reply.ReadFileDescriptor()); - UniqueFd manifestFd(reply.ReadFileDescriptor()); - return {move(incrementalFd), move(manifestFd)}; -} -} // namespace OHOS::FileManagement::Backup \ No newline at end of file diff --git a/services/backup_sa/src/module_ipc/svc_extension_proxy.cpp b/services/backup_sa/src/module_ipc/svc_extension_proxy.cpp index ce2bfcc36b75865ade94bba5f7cac9cd889af247..bd0d8e8a01b1c75a1ae5989e40d6ced0dbb0e411 100644 --- a/services/backup_sa/src/module_ipc/svc_extension_proxy.cpp +++ b/services/backup_sa/src/module_ipc/svc_extension_proxy.cpp @@ -13,7 +13,7 @@ * limitations under the License. */ -#include "module_ipc/svc_extension_proxy.h" +#include "extension_proxy.h" #include "b_error/b_error.h" #include "b_error/b_excep_utils.h" diff --git a/services/backup_sa/src/module_ipc/svc_session_manager.cpp b/services/backup_sa/src/module_ipc/svc_session_manager.cpp index d04fea23f5fd42018d3a15dab2a52bdba838d188..8a79ef9820b8a8c7375a5a748cb22f3e29b9f394 100644 --- a/services/backup_sa/src/module_ipc/svc_session_manager.cpp +++ b/services/backup_sa/src/module_ipc/svc_session_manager.cpp @@ -40,7 +40,7 @@ namespace OHOS::FileManagement::Backup { using namespace std; -ErrCode SvcSessionManager::VerifyCallerAndScenario(uint32_t clientToken, IServiceReverse::Scenario scenario) const +ErrCode SvcSessionManager::VerifyCallerAndScenario(uint32_t clientToken, IServiceReverseType::Scenario scenario) const { shared_lock lock(lock_); if (impl_.scenario != scenario) { @@ -88,7 +88,7 @@ ErrCode SvcSessionManager::Active(Impl newImpl, bool isOccupyingSession) HILOGE("Active session fail, No caller token was specified"); return BError(BError::Codes::SA_INVAL_ARG); } - if (!isOccupyingSession && newImpl.scenario == IServiceReverse::Scenario::UNDEFINED) { + if (!isOccupyingSession && newImpl.scenario == IServiceReverseType::Scenario::UNDEFINED) { HILOGE("Active session fail, No scenario was specified"); return BError(BError::Codes::SA_INVAL_ARG); } @@ -124,10 +124,10 @@ ErrCode SvcSessionManager::Deactive(const wptr &remoteInAction, b deathRecipient_ = nullptr; AppRadar::Info info("", "", "deactive session success"); - if (impl_.scenario == IServiceReverse::Scenario::RESTORE) { + if (impl_.scenario == IServiceReverseType::Scenario::RESTORE) { AppRadar::GetInstance().RecordRestoreFuncRes(info, "SvcSessionManager::Deactive", impl_.userId, BizStageRestore::BIZ_STAGE_DEACTIVE_SESSION, ERR_OK); - } else if (impl_.scenario == IServiceReverse::Scenario::BACKUP) { + } else if (impl_.scenario == IServiceReverseType::Scenario::BACKUP) { AppRadar::GetInstance().RecordBackupFuncRes(info, "SvcSessionManager::Deactive", impl_.userId, BizStageBackup::BIZ_STAGE_DEACTIVE_SESSION, ERR_OK); } @@ -163,12 +163,12 @@ sptr SvcSessionManager::GetServiceReverseProxy() return impl_.clientProxy; } -IServiceReverse::Scenario SvcSessionManager::GetScenario() +IServiceReverseType::Scenario SvcSessionManager::GetScenario() { shared_lock lock(lock_); if (!impl_.clientToken) { HILOGE("Get scenario failed, No caller token was specified"); - return IServiceReverse::Scenario::UNDEFINED; + return IServiceReverseType::Scenario::UNDEFINED; } return impl_.scenario; } @@ -217,10 +217,10 @@ bool SvcSessionManager::OnBundleFileReady(const string &bundleName, const string return false; } // 判断是否结束 通知EXTENTION清理资源 TOOL应用完成备份 - if (impl_.scenario == IServiceReverse::Scenario::RESTORE || SAUtils::IsSABundleName(bundleName)) { + if (impl_.scenario == IServiceReverseType::Scenario::RESTORE || SAUtils::IsSABundleName(bundleName)) { it->second.isBundleFinished = true; return true; - } else if (impl_.scenario == IServiceReverse::Scenario::BACKUP) { + } else if (impl_.scenario == IServiceReverseType::Scenario::BACKUP) { if (!fileName.empty() && fileName != BConstants::EXT_BACKUP_MANAGE) { auto ret = it->second.fileNameInfo.emplace(fileName); if (!ret.second) { @@ -246,7 +246,7 @@ UniqueFd SvcSessionManager::OnBundleExtManageInfo(const string &bundleName, Uniq HILOGE("No caller token was specified, bundleName:%{public}s", bundleName.c_str()); return UniqueFd(-EPERM); } - if (impl_.scenario != IServiceReverse::Scenario::BACKUP) { + if (impl_.scenario != IServiceReverseType::Scenario::BACKUP) { HILOGE("Invalid Scenario, bundleName:%{public}s", bundleName.c_str()); return UniqueFd(-EPERM); } @@ -436,10 +436,10 @@ ErrCode SvcSessionManager::InitClient(Impl &newImpl) deathRecipient_ = sptr(new SvcDeathRecipient(callback)); remoteObj->AddDeathRecipient(deathRecipient_); AppRadar::Info info("", "", "active session success"); - if (newImpl.scenario == IServiceReverse::Scenario::RESTORE) { + if (newImpl.scenario == IServiceReverseType::Scenario::RESTORE) { AppRadar::GetInstance().RecordRestoreFuncRes(info, "SvcSessionManager::InitClient", newImpl.userId, BizStageRestore::BIZ_STAGE_ACTIVE_SESSION, ERR_OK); - } else if (newImpl.scenario == IServiceReverse::Scenario::BACKUP) { + } else if (newImpl.scenario == IServiceReverseType::Scenario::BACKUP) { AppRadar::GetInstance().RecordBackupFuncRes(info, "SvcSessionManager::InitClient", newImpl.userId, BizStageBackup::BIZ_STAGE_ACTIVE_SESSION, ERR_OK); } @@ -470,7 +470,7 @@ std::set SvcSessionManager::GetExtFileNameRequest(const std::string return std::set(); } - if (impl_.scenario != IServiceReverse::Scenario::RESTORE) { + if (impl_.scenario != IServiceReverseType::Scenario::RESTORE) { HILOGE("Invalid Scenario, bundleName:%{public}s", bundleName.c_str()); return std::set(); } @@ -718,7 +718,7 @@ bool SvcSessionManager::IsOnAllBundlesFinished() return false; } bool isAllBundlesFinished = !impl_.backupExtNameMap.size(); - if (impl_.scenario == IServiceReverse::Scenario::RESTORE) { + if (impl_.scenario == IServiceReverseType::Scenario::RESTORE) { bool isAllBundlesRestored = SvcRestoreDepsManager::GetInstance().IsAllBundlesRestored(); isAllBundlesFinished = (isAllBundlesFinished && isAllBundlesRestored); } @@ -748,7 +748,7 @@ bool SvcSessionManager::NeedToUnloadService() return false; } bool isNeedToUnloadService = (!impl_.backupExtNameMap.size() && (sessionCnt_.load() <= 0)); - if (impl_.scenario == IServiceReverse::Scenario::RESTORE) { + if (impl_.scenario == IServiceReverseType::Scenario::RESTORE) { bool isAllBundlesRestored = SvcRestoreDepsManager::GetInstance().IsAllBundlesRestored(); isNeedToUnloadService = (isNeedToUnloadService && isAllBundlesRestored); } diff --git a/services/backup_sa/src/module_sched/sched_scheduler.cpp b/services/backup_sa/src/module_sched/sched_scheduler.cpp index 5c8b5de7a58f9c8294a19690e129761ea8376874..ebdf00c284ae8e221fb35c7aee26ce25197da34e 100644 --- a/services/backup_sa/src/module_sched/sched_scheduler.cpp +++ b/services/backup_sa/src/module_sched/sched_scheduler.cpp @@ -40,16 +40,16 @@ namespace OHOS::FileManagement::Backup { using namespace std; -void ExtDiedClearFailRadarReport(const string& bundleName, IServiceReverse::Scenario scenario, ErrCode res) +void ExtDiedClearFailRadarReport(const string& bundleName, IServiceReverseType::Scenario scenario, ErrCode res) { if (res == ERR_OK) { return; } AppRadar::Info info(bundleName, "", ""); - if (scenario == IServiceReverse::Scenario::RESTORE) { + if (scenario == IServiceReverseType::Scenario::RESTORE) { AppRadar::GetInstance().RecordRestoreFuncRes(info, "SchedScheduler::ExecutingQueueTasks", AppRadar::GetInstance().GetUserId(), BizStageRestore::BIZ_STAGE_EXTENSION_ABNORMAL_EXIT_CLEAR_FAIL, res); - } else if (scenario == IServiceReverse::Scenario::BACKUP) { + } else if (scenario == IServiceReverseType::Scenario::BACKUP) { AppRadar::GetInstance().RecordBackupFuncRes(info, "SchedScheduler::ExecutingQueueTasks", AppRadar::GetInstance().GetUserId(), BizStageBackup::BIZ_STAGE_EXTENSION_ABNORMAL_EXIT_CLEAR_FAIL, res); } @@ -240,7 +240,7 @@ void SchedScheduler::StartExecuteBundleTask(const std::string &bundleName, BCons } else if (action == BConstants::ServiceSchedAction::CLEAN) { HILOGI("Current bundle %{public}s process is cleaning", bundleName.data()); ErrCode res = reversePtr_->ClearResidualBundleData(bundleName); - IServiceReverse::Scenario scenario = sessionPtr_->GetScenario(); + IServiceReverseType::Scenario scenario = sessionPtr_->GetScenario(); ExtDiedClearFailRadarReport(bundleName, scenario, res); } } diff --git a/test/fuzztest/backupext_fuzzer/BUILD.gn b/test/fuzztest/backupext_fuzzer/BUILD.gn index a3772fd762dcb9622fe72f0f780f26c893d6c312..319f0ebd5e05fb2c551c15f6794f19145a6711e1 100644 --- a/test/fuzztest/backupext_fuzzer/BUILD.gn +++ b/test/fuzztest/backupext_fuzzer/BUILD.gn @@ -26,6 +26,9 @@ ohos_fuzztest("BackupExtFuzzTest") { "${path_backup}/interfaces/inner_api/native/backup_kit_inner/impl", "${path_backup}/utils/include", ] + + public_configs = [ "${path_backup}/services/backup_sa:public_idl_config" ] + cflags = [ "-g", "-O0", @@ -39,7 +42,6 @@ ohos_fuzztest("BackupExtFuzzTest") { "${path_backup}/frameworks/native/backup_ext/src/ext_backup_js.cpp", "${path_backup}/frameworks/native/backup_ext/src/ext_backup_loader.cpp", "${path_backup}/frameworks/native/backup_ext/src/ext_extension.cpp", - "${path_backup}/frameworks/native/backup_ext/src/ext_extension_stub.cpp", "${path_backup}/frameworks/native/backup_ext/src/sub_ext_extension.cpp", "${path_backup}/frameworks/native/backup_ext/src/tar_file.cpp", "${path_backup}/frameworks/native/backup_ext/src/untar_file.cpp", @@ -49,7 +51,6 @@ ohos_fuzztest("BackupExtFuzzTest") { deps = [ "${path_backup}/interfaces/inner_api/native/backup_kit_inner:backup_kit_inner", "${path_backup}/interfaces/innerkits/native:sandbox_helper_native", - "${path_backup}/services/backup_sa:backup_sa_ipc_stub", "${path_backup}/utils:backup_utils", ] diff --git a/test/fuzztest/backupext_fuzzer/backupext_fuzzer.cpp b/test/fuzztest/backupext_fuzzer/backupext_fuzzer.cpp index 19065f4cc8d4489e8871ad4f6028ce64fedc592b..33f5a4c93cac0d16f958bdc4d521f830eb7961ad 100644 --- a/test/fuzztest/backupext_fuzzer/backupext_fuzzer.cpp +++ b/test/fuzztest/backupext_fuzzer/backupext_fuzzer.cpp @@ -13,46 +13,23 @@ * limitations under the License. */ #include "backupext_fuzzer.h" - #include -#include "message_parcel.h" -#include "ext_extension.h" #include "ext_backup.h" +#include "ext_extension.h" +#include "message_parcel.h" namespace OHOS { using namespace std; using namespace OHOS::FileManagement::Backup; -constexpr uint8_t MAX_CALL_TRANSACTION = 10; - -template +template T TypeCast(const uint8_t *data, int *pos = nullptr) { if (pos) { *pos += sizeof(T); } - return *(reinterpret_cast(data)); -} - -bool OnRemoteRequestFuzzTest(shared_ptr extension, const uint8_t *data, size_t size) -{ - if (data == nullptr || size < sizeof(uint32_t)) { - return true; - } - - MessageParcel msg; - MessageParcel reply; - MessageOption option; - - int pos = 0; - uint32_t code = TypeCast(data, &pos); - msg.WriteInterfaceToken(ExtExtensionStub::GetDescriptor()); - msg.WriteBuffer(data + pos, size - pos); - msg.RewindRead(0); - - extension->OnRemoteRequest(code % MAX_CALL_TRANSACTION, msg, reply, option); - return true; + return *(reinterpret_cast(data)); } bool InitFuzzTest(shared_ptr backup, const uint8_t *data, size_t size) @@ -77,8 +54,8 @@ bool OnCommandFuzzTest(shared_ptr backup, const uint8_t *data, size_t int startId = TypeCast(data + pos, &pos); int len = (size - pos) >> 1; AAFwk::Want want; - want.SetElementName(string(reinterpret_cast(data + pos), len), - string(reinterpret_cast(data + pos + len), len)); + want.SetElementName(string(reinterpret_cast(data + pos), len), + string(reinterpret_cast(data + pos + len), len)); backup->OnCommand(want, restart, startId); return true; @@ -88,8 +65,8 @@ bool OnConnectFuzzTest(shared_ptr backup, const uint8_t *data, size_t { int len = size >> 1; AAFwk::Want want; - want.SetElementName(string(reinterpret_cast(data), len), - string(reinterpret_cast(data + len), size - len)); + want.SetElementName(string(reinterpret_cast(data), len), + string(reinterpret_cast(data + len), size - len)); backup->OnConnect(want); return true; @@ -148,7 +125,7 @@ bool RestoreDataReadyFuzzTest(shared_ptr backup, const uint8_t *data, bool InvokeAppExtMethodFuzzTest(shared_ptr backup, const uint8_t *data, size_t size) { - string result = string(reinterpret_cast(data), size); + string result = string(reinterpret_cast(data), size); backup->InvokeAppExtMethod(BError(BError::Codes::OK), result); return true; } @@ -165,9 +142,10 @@ bool CmdGetFileHandleFuzzTest(shared_ptr extension, const ui { MessageParcel msg; MessageParcel reply; - - msg.WriteString(string(reinterpret_cast(data), size)); - extension->CmdGetFileHandle(msg, reply); + MessageOption option; + uint32_t code = static_cast(IExtensionIpcCode::COMMAND_GET_FILE_HANDLE_WITH_UNIQUE_FD); + msg.WriteString(string(reinterpret_cast(data), size)); + extension->OnRemoteRequest(code, msg, reply, option); return true; } @@ -175,9 +153,10 @@ bool CmdHandleClearFuzzTest(shared_ptr extension, const uint { MessageParcel msg; MessageParcel reply; - + MessageOption option; + uint32_t code = static_cast(IExtensionIpcCode::COMMAND_HANDLE_CLEAR); msg.WriteBuffer(data, size); - extension->CmdHandleClear(msg, reply); + extension->OnRemoteRequest(code, msg, reply, option); return true; } @@ -185,9 +164,10 @@ bool CmdHandleUser0BackupFuzzTest(shared_ptr extension, cons { MessageParcel msg; MessageParcel reply; - + MessageOption option; + uint32_t code = static_cast(IExtensionIpcCode::COMMAND_USER0_ON_BACKUP); msg.WriteBuffer(data, size); - extension->CmdHandleUser0Backup(msg, reply); + extension->OnRemoteRequest(code, msg, reply, option); return true; } @@ -199,9 +179,10 @@ bool CmdHandleBackupFuzzTest(shared_ptr extension, const uin MessageParcel msg; MessageParcel reply; - - msg.WriteBool(*reinterpret_cast(data)); - extension->CmdHandleBackup(msg, reply); + MessageOption option; + uint32_t code = static_cast(IExtensionIpcCode::COMMAND_HANDLE_BACKUP); + msg.WriteBool(*reinterpret_cast(data)); + extension->OnRemoteRequest(code, msg, reply, option); return true; } @@ -209,9 +190,10 @@ bool CmdPublishFileFuzzTest(shared_ptr extension, const uint { MessageParcel msg; MessageParcel reply; - - msg.WriteString(string(reinterpret_cast(data), size)); - extension->CmdPublishFile(msg, reply); + MessageOption option; + uint32_t code = static_cast(IExtensionIpcCode::COMMAND_PUBLISH_FILE); + msg.WriteString(string(reinterpret_cast(data), size)); + extension->OnRemoteRequest(code, msg, reply, option); return true; } @@ -223,9 +205,10 @@ bool CmdHandleRestoreFuzzTest(shared_ptr extension, const ui MessageParcel msg; MessageParcel reply; - - msg.WriteBool(*reinterpret_cast(data)); - extension->CmdHandleRestore(msg, reply); + MessageOption option; + uint32_t code = static_cast(IExtensionIpcCode::COMMAND_HANDLE_RESTORE); + msg.WriteBool(*reinterpret_cast(data)); + extension->OnRemoteRequest(code, msg, reply, option); return true; } @@ -233,9 +216,10 @@ bool CmdGetIncrementalFileHandleFuzzTest(shared_ptr extensio { MessageParcel msg; MessageParcel reply; - - msg.WriteString(string(reinterpret_cast(data), size)); - extension->CmdGetIncrementalFileHandle(msg, reply); + MessageOption option; + uint32_t code = static_cast(IExtensionIpcCode::COMMAND_GET_INCREMENTAL_FILE_HANDLE); + msg.WriteString(string(reinterpret_cast(data), size)); + extension->OnRemoteRequest(code, msg, reply, option); return true; } @@ -243,9 +227,10 @@ bool CmdPublishIncrementalFileFuzzTest(shared_ptr extension, { MessageParcel msg; MessageParcel reply; - - msg.WriteString(string(reinterpret_cast(data), size)); - extension->CmdPublishIncrementalFile(msg, reply); + MessageOption option; + uint32_t code = static_cast(IExtensionIpcCode::COMMAND_PUBLISH_INCREMENTAL_FILE); + msg.WriteString(string(reinterpret_cast(data), size)); + extension->OnRemoteRequest(code, msg, reply, option); return true; } @@ -257,13 +242,14 @@ bool CmdHandleIncrementalBackupFuzzTest(shared_ptr extension MessageParcel msg; MessageParcel reply; - + MessageOption option; int pos = 0; int incrementalFd = TypeCast(data, &pos); int manifestFd = TypeCast(data + pos); + uint32_t code = static_cast(IExtensionIpcCode::COMMAND_HANDLE_INCREMENTAL_BACKUP); msg.WriteFileDescriptor(incrementalFd); msg.WriteFileDescriptor(manifestFd); - extension->CmdPublishIncrementalFile(msg, reply); + extension->OnRemoteRequest(code, msg, reply, option); return true; } @@ -275,20 +261,23 @@ bool CmdIncrementalOnBackupFuzzTest(shared_ptr extension, co MessageParcel msg; MessageParcel reply; - - msg.WriteBool(*reinterpret_cast(data)); - extension->CmdIncrementalOnBackup(msg, reply); + MessageOption option; + uint32_t code = static_cast(IExtensionIpcCode::COMMAND_INCREMENTAL_ON_BACKUP); + msg.WriteBool(*reinterpret_cast(data)); + extension->OnRemoteRequest(code, msg, reply, option); return true; } -bool CmdGetIncrementalBackupFileHandleFuzzTest(shared_ptr extension, const uint8_t *data, - size_t size) +bool CmdGetIncrementalBackupFileHandleFuzzTest(shared_ptr extension, + const uint8_t *data, + size_t size) { MessageParcel msg; MessageParcel reply; - + MessageOption option; + uint32_t code = static_cast(IExtensionIpcCode::COMMAND_GET_INCREMENTAL_BACKUP_FILE_HANDLE); msg.WriteBuffer(data, size); - extension->CmdGetIncrementalBackupFileHandle(msg, reply); + extension->OnRemoteRequest(code, msg, reply, option); return true; } } // namespace OHOS @@ -300,7 +289,6 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) auto extBackup = std::make_shared(); auto extension = std::make_shared(extBackup, ""); - OHOS::OnRemoteRequestFuzzTest(extension, data, size); OHOS::InitFuzzTest(extBackup, data, size); OHOS::OnCommandFuzzTest(extBackup, data, size); OHOS::OnConnectFuzzTest(extBackup, data, size); @@ -329,6 +317,5 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) } catch (OHOS::FileManagement::Backup::BError &err) { // Only filter BError errors, Other results are not expected. } - return 0; } diff --git a/test/fuzztest/backupsa_fuzzer/BUILD.gn b/test/fuzztest/backupsa_fuzzer/BUILD.gn index 160de50ee42349eaf8a0b734babf651c1e436b08..be88b3013f4f1385709f65caff196f589d4547b7 100644 --- a/test/fuzztest/backupsa_fuzzer/BUILD.gn +++ b/test/fuzztest/backupsa_fuzzer/BUILD.gn @@ -36,11 +36,12 @@ ohos_fuzztest("BackupSaFuzzTest") { deps = [ "${app_file_service_path}/services/backup_sa:backup_sa", - "${app_file_service_path}/services/backup_sa:backup_sa_ipc_stub", "${path_backup}/interfaces/inner_api/native/backup_kit_inner:backup_kit_inner", "${path_backup}/utils:backup_utils", ] + public_configs = [ "${path_backup}/services/backup_sa:public_idl_config" ] + external_deps = [ "ability_runtime:ability_manager", "ability_runtime:abilitykit_native", diff --git a/test/fuzztest/backupsaanother_fuzzer/BUILD.gn b/test/fuzztest/backupsaanother_fuzzer/BUILD.gn index 8331e81a8c3bae640731b6750fb8d72ea5b5089b..764660d8d3b3117a2d690dafd64805838e79c25a 100644 --- a/test/fuzztest/backupsaanother_fuzzer/BUILD.gn +++ b/test/fuzztest/backupsaanother_fuzzer/BUILD.gn @@ -38,11 +38,12 @@ ohos_fuzztest("BackupSaAnotherFuzzTest") { deps = [ "${app_file_service_path}/services/backup_sa:backup_sa", - "${app_file_service_path}/services/backup_sa:backup_sa_ipc_stub", "${path_backup}/interfaces/inner_api/native/backup_kit_inner:backup_kit_inner", "${path_backup}/utils:backup_utils", ] + public_configs = [ "${path_backup}/services/backup_sa:public_idl_config" ] + external_deps = [ "ability_runtime:ability_manager", "ability_runtime:abilitykit_native", diff --git a/test/fuzztest/backupsaappend_fuzzer/BUILD.gn b/test/fuzztest/backupsaappend_fuzzer/BUILD.gn index ebeaa43a7cc13463faf4483db0e0c71c44ae2249..410ead2a27573f5b26ef45e0eac52f0b52156143 100644 --- a/test/fuzztest/backupsaappend_fuzzer/BUILD.gn +++ b/test/fuzztest/backupsaappend_fuzzer/BUILD.gn @@ -38,11 +38,10 @@ ohos_fuzztest("BackupSaAppendFuzzTest") { deps = [ "${app_file_service_path}/services/backup_sa:backup_sa", - "${app_file_service_path}/services/backup_sa:backup_sa_ipc_stub", "${path_backup}/interfaces/inner_api/native/backup_kit_inner:backup_kit_inner", "${path_backup}/utils:backup_utils", ] - + public_configs = [ "${path_backup}/services/backup_sa:public_idl_config" ] external_deps = [ "ability_runtime:ability_manager", "ability_runtime:abilitykit_native", diff --git a/test/fuzztest/backupservicestub_fuzzer/BUILD.gn b/test/fuzztest/backupservicestub_fuzzer/BUILD.gn index f32d8aa3dd31323e65252a867735e003ee74cc3a..c4d813425e931dac0be9584059ad4d61eacd529f 100644 --- a/test/fuzztest/backupservicestub_fuzzer/BUILD.gn +++ b/test/fuzztest/backupservicestub_fuzzer/BUILD.gn @@ -38,10 +38,11 @@ ohos_fuzztest("BackupServiceStubFuzzTest") { ] sources = [ "backupservicestub_fuzzer.cpp" ] + public_configs = [ "${path_backup}/services/backup_sa:public_idl_config" ] + deps = [ "${app_file_service_path}/interfaces/inner_api/native/backup_kit_inner:backup_kit_inner", "${app_file_service_path}/services/backup_sa:backup_sa", - "${app_file_service_path}/services/backup_sa:backup_sa_ipc_stub", "${app_file_service_path}/utils:backup_utils", ] diff --git a/test/fuzztest/backupservicestubbranch_fuzzer/service.h b/test/fuzztest/backupservicestubbranch_fuzzer/service.h deleted file mode 100644 index 7848c335af7266825fa552c331b42fa1fd05bffc..0000000000000000000000000000000000000000 --- a/test/fuzztest/backupservicestubbranch_fuzzer/service.h +++ /dev/null @@ -1,93 +0,0 @@ -/* - * Copyright (c) 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. - */ - -#ifndef OHOS_FILEMGMT_BACKUP_SERVICE_H -#define OHOS_FILEMGMT_BACKUP_SERVICE_H - -#include -#include - -#include "b_error/b_error.h" -#include "iservice_reverse.h" -#include "iremote_stub.h" -#include "service_stub.h" -#include "service_common.h" - -namespace OHOS::FileManagement::Backup { -class Service : public ServiceStub { -public: - ErrCode InitRestoreSession(const sptr&) { return BError(BError::Codes::OK); } - ErrCode InitRestoreSessionWithErrMsg(const sptr&, - std::string&) { return BError(BError::Codes::OK); } - ErrCode InitBackupSession(const sptr&) { return BError(BError::Codes::OK); } - ErrCode InitBackupSessionWithErrMsg(const sptr&, - std::string&) { return BError(BError::Codes::OK); } - ErrCode Start() { return BError(BError::Codes::OK); } - ErrCode GetLocalCapabilities(int&) { return BError(BError::Codes::OK); } - ErrCode GetLocalCapabilitiesForBundleInfos(int&) { return BError(BError::Codes::OK); } - ErrCode PublishFile(const BFileInfo&) { return BError(BError::Codes::OK); } - ErrCode AppFileReady(const std::string&, int, int32_t) { return BError(BError::Codes::OK); } - ErrCode AppDone(ErrCode) { return BError(BError::Codes::OK); } - ErrCode ServiceResultReport(const std::string&, - BackupRestoreScenario, ErrCode) { return BError(BError::Codes::OK); } - ErrCode GetFileHandle(const std::string&, const std::string&) { return BError(BError::Codes::OK); } - ErrCode AppendBundlesRestoreSessionDataByDetail(int, - const std::vector&, - const std::vector&, - int32_t, - int32_t) { return BError(BError::Codes::OK); } - ErrCode AppendBundlesRestoreSessionData(int, - const std::vector&, - int32_t, - int32_t) { return BError(BError::Codes::OK); } - ErrCode AppendBundlesBackupSession(const std::vector&) { return BError(BError::Codes::OK); } - ErrCode AppendBundlesDetailsBackupSession(const std::vector&, - const std::vector&) { return BError(BError::Codes::OK); } - ErrCode Finish() { return BError(BError::Codes::OK); } - ErrCode Release() { return BError(BError::Codes::OK); } - ErrCode Cancel(const std::string&, int32_t&) { return BError(BError::Codes::OK); } - ErrCode GetLocalCapabilitiesIncremental(const std::vector&, - int&) { return BError(BError::Codes::OK); } - ErrCode GetAppLocalListAndDoIncrementalBackup() { return BError(BError::Codes::OK); } - ErrCode InitIncrementalBackupSession(const sptr&) { return BError(BError::Codes::OK); } - ErrCode InitIncrementalBackupSessionWithErrMsg(const sptr&, - std::string&) { return BError(BError::Codes::OK); } - ErrCode AppendBundlesIncrementalBackupSession(const std::vector&) - { return BError(BError::Codes::OK); } - ErrCode AppendBundlesIncrementalBackupSessionWithBundleInfos(const std::vector&, - const std::vector&) - { return BError(BError::Codes::OK); } - ErrCode PublishIncrementalFile(const BFileInfo&) { return BError(BError::Codes::OK); } - ErrCode PublishSAIncrementalFile(const BFileInfo&, int) { return BError(BError::Codes::OK); } - ErrCode AppIncrementalFileReady(const std::string&, int, int, int32_t) - { return BError(BError::Codes::OK); } - ErrCode AppIncrementalDone(ErrCode) { return BError(BError::Codes::OK); } - ErrCode GetIncrementalFileHandle(const std::string&, const std::string&) { return BError(BError::Codes::OK); } - ErrCode GetBackupInfo(const BundleName&, std::string&) { return BError(BError::Codes::OK); } - ErrCode UpdateTimer(const BundleName&, uint32_t, bool&) { return BError(BError::Codes::OK); } - ErrCode UpdateSendRate(const std::string&, int32_t, bool&) { return BError(BError::Codes::OK); } - ErrCode ReportAppProcessInfo(const std::string&, BackupRestoreScenario) { return BError(BError::Codes::OK); } - ErrCode StartExtTimer(bool&) { return BError(BError::Codes::OK); } - ErrCode StartFwkTimer(bool&) { return BError(BError::Codes::OK); } - ErrCode StopExtTimer(bool&) { return BError(BError::Codes::OK); } - ErrCode RefreshDataSize(int64_t) { return BError(BError::Codes::OK); } - - ErrCode SAResultReport(const std::string, const std::string, - const ErrCode, const BackupRestoreScenario) { return BError(BError::Codes::OK); } - ErrCode GetBackupDataSize(bool, const std::vector&) { return BError(BError::Codes::OK); } -}; -} // namespace OHOS::FileManagement::Backup - -#endif // OHOS_FILEMGMT_BACKUP_SERVICE_H \ No newline at end of file diff --git a/test/fuzztest/servicereverse_fuzzer/BUILD.gn b/test/fuzztest/servicereverse_fuzzer/BUILD.gn index 63cc84ab698f6408462a49dc6d5804c1d5024df2..53c825efbcb4804630305b61cad1c7403912059b 100644 --- a/test/fuzztest/servicereverse_fuzzer/BUILD.gn +++ b/test/fuzztest/servicereverse_fuzzer/BUILD.gn @@ -27,6 +27,9 @@ ohos_fuzztest("ServiceReverseFuzzTest") { "${path_backup}/interfaces/inner_api/native/backup_kit_inner/impl", "${path_backup}/utils/include", ] + + public_configs = [ "${path_backup}/services/backup_sa:public_idl_config" ] + cflags = [ "-g", "-O0", @@ -37,6 +40,7 @@ ohos_fuzztest("ServiceReverseFuzzTest") { deps = [ "${path_backup}/interfaces/inner_api/native/backup_kit_inner:backup_kit_inner", + "${path_backup}/services/backup_sa:backup_sa_ipc", "${path_backup}/utils:backup_utils", ] diff --git a/test/fuzztest/servicereverse_fuzzer/servicereverse_fuzzer.cpp b/test/fuzztest/servicereverse_fuzzer/servicereverse_fuzzer.cpp index 271813d4aa5a1aed6eb4db18d88bb2efaa948fb7..fe1d613a26a0d6fb848c7c7f12281c7d08c936e2 100644 --- a/test/fuzztest/servicereverse_fuzzer/servicereverse_fuzzer.cpp +++ b/test/fuzztest/servicereverse_fuzzer/servicereverse_fuzzer.cpp @@ -47,6 +47,8 @@ bool BackupOnFileReadyFuzzTest(sptr service, const uint8_t *data MessageParcel msg; MessageParcel reply; + MessageOption option; + uint32_t code = static_cast(IServiceReverseIpcCode::COMMAND_BACKUP_ON_FILE_READY); try { int pos = 0; @@ -59,7 +61,7 @@ bool BackupOnFileReadyFuzzTest(sptr service, const uint8_t *data if (fdFlag) { msg.WriteFileDescriptor(fd); } - service->CmdBackupOnFileReady(msg, reply); + service->OnRemoteRequest(code, msg, reply, option); } catch (BError &err) { // Only filter BError errors, Other results are not expected. } @@ -74,13 +76,15 @@ bool BackupOnBundleStartedFuzzTest(sptr service, const uint8_t * MessageParcel msg; MessageParcel reply; + MessageOption option; + uint32_t code = static_cast(IServiceReverseIpcCode::COMMAND_BACKUP_ON_BUNDLE_STARTED); try { int pos = 0; int32_t errCode = TypeCast(data, &pos); msg.WriteInt32(errCode); msg.WriteString(string(reinterpret_cast(data + pos), size - pos)); - service->CmdBackupOnBundleStarted(msg, reply); + service->OnRemoteRequest(code, msg, reply, option); } catch (BError &err) { // Only filter BError errors, Other results are not expected. } @@ -95,12 +99,14 @@ bool BackupOnResultReportFuzzTest(sptr service, const uint8_t *d MessageParcel msg; MessageParcel reply; + MessageOption option; + uint32_t code = static_cast(IServiceReverseIpcCode::COMMAND_BACKUP_ON_RESULT_REPORT); try { int len = (size >> 1); msg.WriteString(string(reinterpret_cast(data), len)); msg.WriteString(string(reinterpret_cast(data + len), size - len)); - service->CmdBackupOnResultReport(msg, reply); + service->OnRemoteRequest(code, msg, reply, option); } catch (BError &err) { // Only filter BError errors, Other results are not expected. } @@ -115,13 +121,15 @@ bool BackupOnBundleFinishedFuzzTest(sptr service, const uint8_t MessageParcel msg; MessageParcel reply; + MessageOption option; + uint32_t code = static_cast(IServiceReverseIpcCode::COMMAND_BACKUP_ON_BUNDLE_FINISHED); try { int pos = 0; int32_t errCode = TypeCast(data, &pos); msg.WriteInt32(errCode); msg.WriteString(string(reinterpret_cast(data + pos), size - pos)); - service->CmdBackupOnBundleFinished(msg, reply); + service->OnRemoteRequest(code, msg, reply, option); } catch (BError &err) { // Only filter BError errors, Other results are not expected. } @@ -136,11 +144,13 @@ bool BackupOnAllBundlesFinishedFuzzTest(sptr service, const uint MessageParcel msg; MessageParcel reply; + MessageOption option; + uint32_t code = static_cast(IServiceReverseIpcCode::COMMAND_BACKUP_ON_ALL_BUNDLES_FINISHED); try { int32_t errCode = TypeCast(data); msg.WriteInt32(errCode); - service->CmdBackupOnAllBundlesFinished(msg, reply); + service->OnRemoteRequest(code, msg, reply, option); } catch (BError &err) { // Only filter BError errors, Other results are not expected. } @@ -155,12 +165,14 @@ bool BackupOnProcessInfoFuzzTest(sptr service, const uint8_t *da MessageParcel msg; MessageParcel reply; + MessageOption option; + uint32_t code = static_cast(IServiceReverseIpcCode::COMMAND_BACKUP_ON_PROCESS_INFO); try { int len = (size >> 1); msg.WriteString(string(reinterpret_cast(data), len)); msg.WriteString(string(reinterpret_cast(data + len), size - len)); - service->CmdBackupOnProcessInfo(msg, reply); + service->OnRemoteRequest(code, msg, reply, option); } catch (BError &err) { // Only filter BError errors, Other results are not expected. } @@ -175,10 +187,12 @@ bool BackupOnScanningInfoFuzzTest(sptr service, const uint8_t *d MessageParcel msg; MessageParcel reply; + MessageOption option; + uint32_t code = static_cast(IServiceReverseIpcCode::COMMAND_BACKUP_ON_SCANNING_INFO); try { msg.WriteString(string(reinterpret_cast(data), size)); - service->CmdBackupOnScanningInfo(msg, reply); + service->OnRemoteRequest(code, msg, reply, option); } catch (BError &err) { // Only filter BError errors, Other results are not expected. } @@ -193,13 +207,15 @@ bool RestoreOnBundleStartedFuzzTest(sptr service, const uint8_t MessageParcel msg; MessageParcel reply; + MessageOption option; + uint32_t code = static_cast(IServiceReverseIpcCode::COMMAND_RESTORE_ON_BUNDLE_STARTED); try { int pos = 0; int32_t errCode = TypeCast(data, &pos); msg.WriteInt32(errCode); msg.WriteString(string(reinterpret_cast(data + pos), size - pos)); - service->CmdRestoreOnBundleStarted(msg, reply); + service->OnRemoteRequest(code, msg, reply, option); } catch (BError &err) { // Only filter BError errors, Other results are not expected. } @@ -214,13 +230,15 @@ bool RestoreOnBundleFinishedFuzzTest(sptr service, const uint8_t MessageParcel msg; MessageParcel reply; + MessageOption option; + uint32_t code = static_cast(IServiceReverseIpcCode::COMMAND_RESTORE_ON_BUNDLE_FINISHED); try { int pos = 0; int32_t errCode = TypeCast(data, &pos); msg.WriteInt32(errCode); msg.WriteString(string(reinterpret_cast(data + pos), size - pos)); - service->CmdRestoreOnBundleFinished(msg, reply); + service->OnRemoteRequest(code, msg, reply, option); } catch (BError &err) { // Only filter BError errors, Other results are not expected. } @@ -235,11 +253,13 @@ bool RestoreOnAllBundlesFinishedFuzzTest(sptr service, const uin MessageParcel msg; MessageParcel reply; + MessageOption option; + uint32_t code = static_cast(IServiceReverseIpcCode::COMMAND_RESTORE_ON_ALL_BUNDLES_FINISHED); try { int32_t errCode = TypeCast(data); msg.WriteInt32(errCode); - service->CmdRestoreOnAllBundlesFinished(msg, reply); + service->OnRemoteRequest(code, msg, reply, option); } catch (BError &err) { // Only filter BError errors, Other results are not expected. } @@ -254,6 +274,8 @@ bool RestoreOnFileReadyFuzzTest(sptr service, const uint8_t *dat MessageParcel msg; MessageParcel reply; + MessageOption option; + uint32_t code = static_cast(IServiceReverseIpcCode::COMMAND_RESTORE_ON_FILE_READY); try { int pos = 0; @@ -268,7 +290,7 @@ bool RestoreOnFileReadyFuzzTest(sptr service, const uint8_t *dat msg.WriteFileDescriptor(fd); } msg.WriteInt32(errCode); - service->CmdRestoreOnFileReady(msg, reply); + service->OnRemoteRequest(code, msg, reply, option); } catch (BError &err) { // Only filter BError errors, Other results are not expected. } @@ -283,6 +305,8 @@ bool RestoreOnResultReportFuzzTest(sptr service, const uint8_t * MessageParcel msg; MessageParcel reply; + MessageOption option; + uint32_t code = static_cast(IServiceReverseIpcCode::COMMAND_RESTORE_ON_RESULT_REPORT); try { int pos = 0; @@ -291,7 +315,7 @@ bool RestoreOnResultReportFuzzTest(sptr service, const uint8_t * msg.WriteString(string(reinterpret_cast(data + pos), len)); msg.WriteString(string(reinterpret_cast(data + pos + len), size - pos - len)); msg.WriteInt32(errCode); - service->CmdRestoreOnResultReport(msg, reply); + service->OnRemoteRequest(code, msg, reply, option); } catch (BError &err) { // Only filter BError errors, Other results are not expected. } @@ -306,12 +330,14 @@ bool RestoreOnProcessInfoFuzzTest(sptr service, const uint8_t *d MessageParcel msg; MessageParcel reply; + MessageOption option; + uint32_t code = static_cast(IServiceReverseIpcCode::COMMAND_RESTORE_ON_PROCESS_INFO); try { int len = (size >> 1); msg.WriteString(string(reinterpret_cast(data), len)); msg.WriteString(string(reinterpret_cast(data + len), size - len)); - service->CmdRestoreOnProcessInfo(msg, reply); + service->OnRemoteRequest(code, msg, reply, option); } catch (BError &err) { // Only filter BError errors, Other results are not expected. } @@ -326,6 +352,8 @@ bool IncrementalBackupOnFileReadyFuzzTest(sptr service, const ui MessageParcel msg; MessageParcel reply; + MessageOption option; + uint32_t code = static_cast(IServiceReverseIpcCode::COMMAND_INCREMENTAL_BACKUP_ON_FILE_READY); try { int pos = 0; @@ -342,7 +370,7 @@ bool IncrementalBackupOnFileReadyFuzzTest(sptr service, const ui msg.WriteFileDescriptor(manifestFd); } msg.WriteInt32(errCode); - service->CmdIncrementalBackupOnFileReady(msg, reply); + service->OnRemoteRequest(code, msg, reply, option); } catch (BError &err) { // Only filter BError errors, Other results are not expected. } @@ -357,13 +385,15 @@ bool IncrementalBackupOnBundleStartedFuzzTest(sptr service, cons MessageParcel msg; MessageParcel reply; + MessageOption option; + uint32_t code = static_cast(IServiceReverseIpcCode::COMMAND_INCREMENTAL_BACKUP_ON_BUNDLE_STARTED); try { int pos = 0; int32_t errCode = TypeCast(data, &pos); msg.WriteInt32(errCode); msg.WriteString(string(reinterpret_cast(data + pos), size - pos)); - service->CmdIncrementalBackupOnBundleStarted(msg, reply); + service->OnRemoteRequest(code, msg, reply, option); } catch (BError &err) { // Only filter BError errors, Other results are not expected. } @@ -378,12 +408,14 @@ bool IncrementalBackupOnResultReportFuzzTest(sptr service, const MessageParcel msg; MessageParcel reply; + MessageOption option; + uint32_t code = static_cast(IServiceReverseIpcCode::COMMAND_INCREMENTAL_BACKUP_ON_RESULT_REPORT); try { int len = (size >> 1); msg.WriteString(string(reinterpret_cast(data), len)); msg.WriteString(string(reinterpret_cast(data + len), size - len)); - service->CmdIncrementalBackupOnResultReport(msg, reply); + service->OnRemoteRequest(code, msg, reply, option); } catch (BError &err) { // Only filter BError errors, Other results are not expected. } @@ -398,13 +430,15 @@ bool IncrementalBackupOnBundleFinishedFuzzTest(sptr service, con MessageParcel msg; MessageParcel reply; + MessageOption option; + uint32_t code = static_cast(IServiceReverseIpcCode::COMMAND_INCREMENTAL_BACKUP_ON_BUNDLE_FINISHED); try { int pos = 0; int32_t errCode = TypeCast(data, &pos); msg.WriteInt32(errCode); msg.WriteString(string(reinterpret_cast(data + pos), size - pos)); - service->CmdIncrementalBackupOnBundleFinished(msg, reply); + service->OnRemoteRequest(code, msg, reply, option); } catch (BError &err) { // Only filter BError errors, Other results are not expected. } @@ -419,11 +453,13 @@ bool IncrementalBackupOnAllBundlesFinishedFuzzTest(sptr service, MessageParcel msg; MessageParcel reply; + MessageOption option; + uint32_t code = static_cast(IServiceReverseIpcCode::COMMAND_INCREMENTAL_BACKUP_ON_ALL_BUNDLES_FINISHED); try { int32_t errCode = TypeCast(data); msg.WriteInt32(errCode); - service->CmdIncrementalBackupOnAllBundlesFinished(msg, reply); + service->OnRemoteRequest(code, msg, reply, option); } catch (BError &err) { // Only filter BError errors, Other results are not expected. } @@ -438,12 +474,14 @@ bool IncrementalBackupOnProcessInfoFuzzTest(sptr service, const MessageParcel msg; MessageParcel reply; + MessageOption option; + uint32_t code = static_cast(IServiceReverseIpcCode::COMMAND_INCREMENTAL_BACKUP_ON_PROCESS_INFO); try { int len = (size >> 1); msg.WriteString(string(reinterpret_cast(data), len)); msg.WriteString(string(reinterpret_cast(data + len), size - len)); - service->CmdIncrementalBackupOnProcessInfo(msg, reply); + service->OnRemoteRequest(code, msg, reply, option); } catch (BError &err) { // Only filter BError errors, Other results are not expected. } @@ -458,10 +496,12 @@ bool IncrementalBackupOnScanningInfoFuzzTest(sptr service, const MessageParcel msg; MessageParcel reply; + MessageOption option; + uint32_t code = static_cast(IServiceReverseIpcCode::COMMAND_INCREMENTAL_BACKUP_ON_SCANNING_INFO); try { msg.WriteString(string(reinterpret_cast(data), size)); - service->CmdIncrementalBackupOnScanningInfo(msg, reply); + service->OnRemoteRequest(code, msg, reply, option); } catch (BError &err) { // Only filter BError errors, Other results are not expected. } @@ -476,13 +516,15 @@ bool IncrementalRestoreOnBundleStartedFuzzTest(sptr service, con MessageParcel msg; MessageParcel reply; + MessageOption option; + uint32_t code = static_cast(IServiceReverseIpcCode::COMMAND_INCREMENTAL_RESTORE_ON_BUNDLE_STARTED); try { int pos = 0; int32_t errCode = TypeCast(data, &pos); msg.WriteInt32(errCode); msg.WriteString(string(reinterpret_cast(data + pos), size - pos)); - service->CmdIncrementalRestoreOnBundleStarted(msg, reply); + service->OnRemoteRequest(code, msg, reply, option); } catch (BError &err) { // Only filter BError errors, Other results are not expected. } @@ -497,13 +539,15 @@ bool IncrementalRestoreOnBundleFinishedFuzzTest(sptr service, co MessageParcel msg; MessageParcel reply; + MessageOption option; + uint32_t code = static_cast(IServiceReverseIpcCode::COMMAND_INCREMENTAL_RESTORE_ON_BUNDLE_FINISHED); try { int pos = 0; int32_t errCode = TypeCast(data, &pos); msg.WriteInt32(errCode); msg.WriteString(string(reinterpret_cast(data + pos), size - pos)); - service->CmdIncrementalRestoreOnBundleFinished(msg, reply); + service->OnRemoteRequest(code, msg, reply, option); } catch (BError &err) { // Only filter BError errors, Other results are not expected. } @@ -518,11 +562,13 @@ bool IncrementalRestoreOnAllBundlesFinishedFuzzTest(sptr service MessageParcel msg; MessageParcel reply; + MessageOption option; + uint32_t code = static_cast(IServiceReverseIpcCode::COMMAND_INCREMENTAL_RESTORE_ON_ALL_BUNDLES_FINISHED); try { int32_t errCode = TypeCast(data); msg.WriteInt32(errCode); - service->CmdIncrementalRestoreOnAllBundlesFinished(msg, reply); + service->OnRemoteRequest(code, msg, reply, option); } catch (BError &err) { // Only filter BError errors, Other results are not expected. } @@ -537,6 +583,8 @@ bool IncrementalRestoreOnFileReadyFuzzTest(sptr service, const u MessageParcel msg; MessageParcel reply; + MessageOption option; + uint32_t code = static_cast(IServiceReverseIpcCode::COMMAND_INCREMENTAL_RESTORE_ON_FILE_READY); try { int pos = 0; @@ -553,7 +601,7 @@ bool IncrementalRestoreOnFileReadyFuzzTest(sptr service, const u msg.WriteFileDescriptor(manifestFd); } msg.WriteInt32(errCode); - service->CmdIncrementalRestoreOnFileReady(msg, reply); + service->OnRemoteRequest(code, msg, reply, option); } catch (BError &err) { // Only filter BError errors, Other results are not expected. } @@ -568,6 +616,8 @@ bool IncrementalRestoreOnResultReportFuzzTest(sptr service, cons MessageParcel msg; MessageParcel reply; + MessageOption option; + uint32_t code = static_cast(IServiceReverseIpcCode::COMMAND_INCREMENTAL_RESTORE_ON_RESULT_REPORT); try { int pos = 0; @@ -576,7 +626,7 @@ bool IncrementalRestoreOnResultReportFuzzTest(sptr service, cons msg.WriteString(string(reinterpret_cast(data + pos), len)); msg.WriteString(string(reinterpret_cast(data + pos + len), size - pos - len)); msg.WriteInt32(errCode); - service->CmdIncrementalRestoreOnResultReport(msg, reply); + service->OnRemoteRequest(code, msg, reply, option); } catch (BError &err) { // Only filter BError errors, Other results are not expected. } @@ -591,12 +641,14 @@ bool IncrementalRestoreOnProcessInfoFuzzTest(sptr service, const MessageParcel msg; MessageParcel reply; + MessageOption option; + uint32_t code = static_cast(IServiceReverseIpcCode::COMMAND_INCREMENTAL_RESTORE_ON_PROCESS_INFO); try { int len = (size >> 1); msg.WriteString(string(reinterpret_cast(data), len)); msg.WriteString(string(reinterpret_cast(data + len), size - len)); - service->CmdIncrementalRestoreOnProcessInfo(msg, reply); + service->OnRemoteRequest(code, msg, reply, option); } catch (BError &err) { // Only filter BError errors, Other results are not expected. } diff --git a/tests/mock/backup_ext/include/ext_extension_stub_mock.h b/tests/mock/backup_ext/include/ext_extension_stub_mock.h deleted file mode 100644 index 6cc34071e33779c3add99786ca7a6e7a592ac6da..0000000000000000000000000000000000000000 --- a/tests/mock/backup_ext/include/ext_extension_stub_mock.h +++ /dev/null @@ -1,41 +0,0 @@ -/* - * Copyright (c) 2024 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. - */ - -#ifndef OHOS_FILEMGMT_BACKUP_EXT_EXTENSION_STUB_MOCK_H -#define OHOS_FILEMGMT_BACKUP_EXT_EXTENSION_STUB_MOCK_H - -#include - -#include "ext_extension_stub.h" - -namespace OHOS::FileManagement::Backup { -class ExtExtensionStubMock : public ExtExtensionStub { -public: - MOCK_METHOD(int, OnRemoteRequest, (uint32_t, MessageParcel &, MessageParcel &, MessageOption &)); - MOCK_METHOD(ErrCode, CmdGetFileHandle, (MessageParcel &, MessageParcel &)); - MOCK_METHOD(ErrCode, CmdHandleClear, (MessageParcel &, MessageParcel &)); - MOCK_METHOD(ErrCode, CmdHandleBackup, (MessageParcel &, MessageParcel &)); - MOCK_METHOD(ErrCode, CmdPublishFile, (MessageParcel &, MessageParcel &)); - MOCK_METHOD(ErrCode, CmdHandleRestore, (MessageParcel &, MessageParcel &)); - MOCK_METHOD(ErrCode, CmdGetIncrementalFileHandle, (MessageParcel &, MessageParcel &)); - MOCK_METHOD(ErrCode, CmdPublishIncrementalFile, (MessageParcel &, MessageParcel &)); - MOCK_METHOD(ErrCode, CmdHandleIncrementalBackup, (MessageParcel &, MessageParcel &)); - MOCK_METHOD(ErrCode, CmdIncrementalOnBackup, (MessageParcel &, MessageParcel &)); - MOCK_METHOD(ErrCode, CmdGetIncrementalBackupFileHandle, (MessageParcel &, MessageParcel &)); - MOCK_METHOD(ErrCode, CmdGetBackupInfo, (MessageParcel &, MessageParcel &)); - MOCK_METHOD(ErrCode, CmdUpdateFdSendRate, (MessageParcel &, MessageParcel &)); -}; -} // namespace OHOS::FileManagement::Backup -#endif // OHOS_FILEMGMT_BACKUP_EXT_EXTENSION_STUB_MOCK_H diff --git a/tests/mock/module_ipc/include/service_reverse_proxy_mock.h b/tests/mock/module_ipc/include/service_reverse_proxy_mock.h index a0dc2113707d45dd2293474218427096ecc10bf3..8e6b6b17fa7273d210951476b1443fd95f7ca400 100644 --- a/tests/mock/module_ipc/include/service_reverse_proxy_mock.h +++ b/tests/mock/module_ipc/include/service_reverse_proxy_mock.h @@ -24,36 +24,39 @@ namespace OHOS::FileManagement::Backup { class ServiceReverseProxyMock : public IRemoteProxy { public: - MOCK_METHOD(int, SendRequest, (uint32_t, MessageParcel&, MessageParcel&, MessageOption&)); - MOCK_METHOD(void, BackupOnFileReady, (std::string, std::string, int, int32_t)); - MOCK_METHOD(void, BackupOnBundleStarted, (int32_t, std::string)); - MOCK_METHOD(void, BackupOnResultReport, (std::string, std::string));; - MOCK_METHOD(void, BackupOnBundleFinished, (int32_t, std::string)); - MOCK_METHOD(void, BackupOnAllBundlesFinished, (int32_t)); - MOCK_METHOD(void, BackupOnProcessInfo, (std::string, std::string)); - MOCK_METHOD(void, BackupOnScanningInfo, (std::string)); - - MOCK_METHOD(void, RestoreOnBundleStarted, (int32_t, std::string)); - MOCK_METHOD(void, RestoreOnBundleFinished, (int32_t, std::string)); - MOCK_METHOD(void, RestoreOnAllBundlesFinished, (int32_t)); - MOCK_METHOD(void, RestoreOnFileReady, (std::string, std::string, int, int32_t)); - MOCK_METHOD(void, RestoreOnResultReport, (std::string, std::string, ErrCode)); - MOCK_METHOD(void, RestoreOnProcessInfo, (std::string, std::string)); - - MOCK_METHOD(void, IncrementalBackupOnFileReady, (std::string, std::string, int, int, int32_t)); - MOCK_METHOD(void, IncrementalBackupOnBundleStarted, (int32_t, std::string)); - MOCK_METHOD(void, IncrementalBackupOnResultReport, (std::string, std::string)); - MOCK_METHOD(void, IncrementalBackupOnBundleFinished, (int32_t, std::string)); - MOCK_METHOD(void, IncrementalBackupOnAllBundlesFinished, (int32_t)); - MOCK_METHOD(void, IncrementalBackupOnProcessInfo, (std::string, std::string)); - MOCK_METHOD(void, IncrementalBackupOnScanningInfo, (std::string)); - - MOCK_METHOD(void, IncrementalRestoreOnBundleStarted, (int32_t, std::string)); - MOCK_METHOD(void, IncrementalRestoreOnBundleFinished, (int32_t, std::string)); - MOCK_METHOD(void, IncrementalRestoreOnAllBundlesFinished, (int32_t)); - MOCK_METHOD(void, IncrementalRestoreOnFileReady, (std::string, std::string, int, int, int32_t)); - MOCK_METHOD(void, IncrementalRestoreOnResultReport, (std::string, std::string, ErrCode));; - MOCK_METHOD(void, IncrementalRestoreOnProcessInfo, (std::string, std::string)); + MOCK_METHOD(int, SendRequest, (uint32_t, MessageParcel &, MessageParcel &, MessageOption &)); + MOCK_METHOD(ErrCode, BackupOnFileReady, (const std::string &, const std::string &, int, int32_t)); + MOCK_METHOD(ErrCode, BackupOnBundleStarted, (int32_t, const std::string &)); + MOCK_METHOD(ErrCode, BackupOnResultReport, (const std::string &, const std::string &)); + ; + MOCK_METHOD(ErrCode, BackupOnBundleFinished, (int32_t, const std::string &)); + MOCK_METHOD(ErrCode, BackupOnAllBundlesFinished, (int32_t)); + MOCK_METHOD(ErrCode, BackupOnProcessInfo, (const std::string &, const std::string &)); + MOCK_METHOD(ErrCode, BackupOnScanningInfo, (const std::string &)); + + MOCK_METHOD(ErrCode, RestoreOnBundleStarted, (int32_t, const std::string &)); + MOCK_METHOD(ErrCode, RestoreOnBundleFinished, (int32_t, const std::string &)); + MOCK_METHOD(ErrCode, RestoreOnAllBundlesFinished, (int32_t)); + MOCK_METHOD(ErrCode, RestoreOnFileReady, (const std::string &, const std::string &, int32_t, int32_t)); + MOCK_METHOD(ErrCode, RestoreOnResultReport, (const std::string &, const std::string &, ErrCode)); + MOCK_METHOD(ErrCode, RestoreOnProcessInfo, (const std::string &, const std::string &)); + + MOCK_METHOD(ErrCode, IncrementalBackupOnFileReady, (const std::string &, const std::string &, int, int, int32_t)); + MOCK_METHOD(ErrCode, IncrementalSaBackupOnFileReady, (const std::string &, const std::string &, int, int32_t)); + MOCK_METHOD(ErrCode, IncrementalBackupOnBundleStarted, (int32_t, const std::string &)); + MOCK_METHOD(ErrCode, IncrementalBackupOnResultReport, (const std::string &, const std::string &)); + MOCK_METHOD(ErrCode, IncrementalBackupOnBundleFinished, (int32_t, const std::string &)); + MOCK_METHOD(ErrCode, IncrementalBackupOnAllBundlesFinished, (int32_t)); + MOCK_METHOD(ErrCode, IncrementalBackupOnProcessInfo, (const std::string &, const std::string &)); + MOCK_METHOD(ErrCode, IncrementalBackupOnScanningInfo, (const std::string &)); + + MOCK_METHOD(ErrCode, IncrementalRestoreOnBundleStarted, (int32_t, const std::string &)); + MOCK_METHOD(ErrCode, IncrementalRestoreOnBundleFinished, (int32_t, const std::string &)); + MOCK_METHOD(ErrCode, IncrementalRestoreOnAllBundlesFinished, (int32_t)); + MOCK_METHOD(ErrCode, IncrementalRestoreOnFileReady, (const std::string &, const std::string &, int, int, int32_t)); + MOCK_METHOD(ErrCode, IncrementalRestoreOnResultReport, (const std::string &, const std::string &, ErrCode)); + ; + MOCK_METHOD(ErrCode, IncrementalRestoreOnProcessInfo, (const std::string &, const std::string &)); public: ServiceReverseProxyMock() : IRemoteProxy(nullptr) {} diff --git a/tests/mock/module_ipc/include/svc_extension_proxy_mock.h b/tests/mock/module_ipc/include/svc_extension_proxy_mock.h index a042be3abb0f31dccf745a9fa158b9bb2b45e7b8..f1b41eec837b865f49c9e0c6cbd704b5559046f4 100644 --- a/tests/mock/module_ipc/include/svc_extension_proxy_mock.h +++ b/tests/mock/module_ipc/include/svc_extension_proxy_mock.h @@ -18,26 +18,26 @@ #include -#include "module_ipc/svc_extension_proxy.h" +#include "extension_proxy.h" namespace OHOS::FileManagement::Backup { -class SvcExtensionProxyMock : public SvcExtensionProxy { +class SvcExtensionProxyMock : public ExtensionProxy { public: - SvcExtensionProxyMock() : SvcExtensionProxy(nullptr) {}; + SvcExtensionProxyMock() : ExtensionProxy(nullptr) {}; public: - MOCK_METHOD(UniqueFd, GetFileHandle, (const std::string&, int32_t&)); - MOCK_METHOD(ErrCode, HandleClear, ()); - MOCK_METHOD(ErrCode, HandleBackup, (bool)); - MOCK_METHOD(ErrCode, PublishFile, (const std::string&)); - MOCK_METHOD(ErrCode, HandleRestore, (bool)); - MOCK_METHOD((std::tuple), GetIncrementalFileHandle, (const std::string&)); - MOCK_METHOD(ErrCode, PublishIncrementalFile, (const std::string&)); - MOCK_METHOD(ErrCode, HandleIncrementalBackup, (UniqueFd, UniqueFd)); - MOCK_METHOD(ErrCode, IncrementalOnBackup, (bool)); - MOCK_METHOD((std::tuple), GetIncrementalBackupFileHandle, ()); - MOCK_METHOD(ErrCode, GetBackupInfo, (std::string&)); - MOCK_METHOD(ErrCode, UpdateFdSendRate, (std::string&, int32_t)); - MOCK_METHOD(ErrCode, User0OnBackup, ()); +MOCK_METHOD(ErrCode, GetFileHandleWithUniqueFd, (const std::string &, int32_t &, int32_t &)); +MOCK_METHOD(ErrCode, HandleClear, ()); +MOCK_METHOD(ErrCode, HandleBackup, (bool)); +MOCK_METHOD(ErrCode, PublishFile, (const std::string &)); +MOCK_METHOD(ErrCode, HandleRestore, (bool)); +MOCK_METHOD(ErrCode, GetIncrementalFileHandle, (const std::string &, UniqueFdGroup &)); +MOCK_METHOD(ErrCode, PublishIncrementalFile, (const std::string &)); +MOCK_METHOD(ErrCode, HandleIncrementalBackup, (int32_t, int32_t)); +MOCK_METHOD(ErrCode, IncrementalOnBackup, (bool)); +MOCK_METHOD(ErrCode, GetIncrementalBackupFileHandle, (UniqueFdGroup &)); +MOCK_METHOD(ErrCode, GetBackupInfo, (std::string &)); +MOCK_METHOD(ErrCode, UpdateFdSendRate, (const std::string &, int32_t)); +MOCK_METHOD(ErrCode, User0OnBackup, ()); }; } // namespace OHOS::FileManagement::Backup #endif // OHOS_FILEMGMT_BACKUP_SVC_BACKUP_CONNECTION_MOCK_H \ No newline at end of file diff --git a/tests/mock/module_ipc/include/svc_session_manager_mock.h b/tests/mock/module_ipc/include/svc_session_manager_mock.h index 89912684875bdfca04a869bd68875213e94c739b..83d363ceb8a1a19521ee45d4eb1252acfefb230b 100644 --- a/tests/mock/module_ipc/include/svc_session_manager_mock.h +++ b/tests/mock/module_ipc/include/svc_session_manager_mock.h @@ -25,7 +25,7 @@ class BSvcSessionManager { public: virtual ErrCode Active(struct SvcSessionManager::Impl, bool) = 0; virtual sptr GetServiceReverseProxy() = 0; - virtual IServiceReverse::Scenario GetScenario() = 0; + virtual IServiceReverseType::Scenario GetScenario() = 0; virtual int32_t GetSessionUserId() = 0; virtual std::string GetSessionCallerName() = 0; virtual std::string GetSessionActiveTime() = 0; @@ -73,7 +73,7 @@ class SvcSessionManagerMock : public BSvcSessionManager { public: MOCK_METHOD(ErrCode, Active, (struct SvcSessionManager::Impl, bool)); MOCK_METHOD((sptr), GetServiceReverseProxy, ()); - MOCK_METHOD(IServiceReverse::Scenario, GetScenario, ()); + MOCK_METHOD(IServiceReverseType::Scenario, GetScenario, ()); MOCK_METHOD(int32_t, GetSessionUserId, ()); MOCK_METHOD(std::string, GetSessionCallerName, ()); MOCK_METHOD(std::string, GetSessionActiveTime, ()); diff --git a/tests/mock/module_ipc/service_mock.cpp b/tests/mock/module_ipc/service_mock.cpp index 9dff4f224372db24995785b7652d4919a9633d46..34fb24895ccb5e2838014409265445f7c4554163 100644 --- a/tests/mock/module_ipc/service_mock.cpp +++ b/tests/mock/module_ipc/service_mock.cpp @@ -171,7 +171,7 @@ ErrCode Service::VerifyCaller() return BError(BError::Codes::OK); } -ErrCode Service::VerifyCaller(IServiceReverse::Scenario scenario) +ErrCode Service::VerifyCaller(IServiceReverseType::Scenario scenario) { return BError(BError::Codes::OK); } @@ -324,16 +324,16 @@ void Service::HandleExceptionOnAppendBundles(sptr session, const vector &appendBundleNames, const vector &restoreBundleNames) {} void Service::BundleBeginRadarReport(const std::string &bundleName, const ErrCode errCode, - const IServiceReverse::Scenario scenario) {} + const IServiceReverseType::Scenario scenario) {} void Service::BundleEndRadarReport(const std::string &bundleName, ErrCode errCode, - const IServiceReverse::Scenario scenario) {} + const IServiceReverseType::Scenario scenario) {} void Service::FileReadyRadarReport(const std::string &bundleName, const std::string &fileName, const ErrCode errCode, - const IServiceReverse::Scenario scenario) {} + const IServiceReverseType::Scenario scenario) {} void Service::ExtensionConnectFailRadarReport(const std::string &bundleName, const ErrCode errCode, - const IServiceReverse::Scenario scenario) {} + const IServiceReverseType::Scenario scenario) {} void Service::PermissionCheckFailRadar(const std::string &info, const std::string &func) {} diff --git a/tests/mock/module_ipc/service_reverse_proxy_mock.cpp b/tests/mock/module_ipc/service_reverse_proxy_mock.cpp index ee7e924e040e6393b37e09aa80f5535726eec329..bfba0234869306450774c5e72f2965688b082f0a 100644 --- a/tests/mock/module_ipc/service_reverse_proxy_mock.cpp +++ b/tests/mock/module_ipc/service_reverse_proxy_mock.cpp @@ -13,64 +13,159 @@ * limitations under the License. */ -#include "module_ipc/service_reverse_proxy.h" +#include "service_reverse_proxy.h" #include "b_error/b_error.h" namespace OHOS::FileManagement::Backup { using namespace std; - -void ServiceReverseProxy::BackupOnFileReady(string bundleName, string fileName, int fd, int32_t errCode) {} - -void ServiceReverseProxy::BackupOnBundleStarted(int32_t errCode, string bundleName) {} - -void ServiceReverseProxy::BackupOnResultReport(string result, std::string bundleName) {} - -void ServiceReverseProxy::BackupOnBundleFinished(int32_t errCode, string bundleName) {} - -void ServiceReverseProxy::BackupOnAllBundlesFinished(int32_t errCode) {} - -void ServiceReverseProxy::BackupOnProcessInfo(std::string bundleName, std::string processInfo) {} - -void ServiceReverseProxy::BackupOnScanningInfo(std::string scannedInfo) {} - -void ServiceReverseProxy::RestoreOnBundleStarted(int32_t errCode, string bundleName) {} - -void ServiceReverseProxy::RestoreOnBundleFinished(int32_t errCode, string bundleName) {} - -void ServiceReverseProxy::RestoreOnAllBundlesFinished(int32_t errCode) {} - -void ServiceReverseProxy::RestoreOnFileReady(string bundleName, string fileName, int fd, int32_t errCode) {} - -void ServiceReverseProxy::RestoreOnResultReport(string result, string bundleName, ErrCode errCode) {} - -void ServiceReverseProxy::RestoreOnProcessInfo(std::string bundleName, std::string processInfo) {} - -void ServiceReverseProxy::IncrementalBackupOnFileReady(string bundleName, string fileName, int fd, int manifestFd, - int32_t errCode) {} - -void ServiceReverseProxy::IncrementalBackupOnBundleStarted(int32_t errCode, string bundleName) {} - -void ServiceReverseProxy::IncrementalBackupOnResultReport(string result, std::string bundleName) {} - -void ServiceReverseProxy::IncrementalBackupOnBundleFinished(int32_t errCode, string bundleName) {} - -void ServiceReverseProxy::IncrementalBackupOnAllBundlesFinished(int32_t errCode) {} - -void ServiceReverseProxy::IncrementalBackupOnProcessInfo(std::string bundleName, std::string processInfo) {} - -void ServiceReverseProxy::IncrementalBackupOnScanningInfo(std::string scannedInfo) {} - -void ServiceReverseProxy::IncrementalRestoreOnBundleStarted(int32_t errCode, string bundleName) {} - -void ServiceReverseProxy::IncrementalRestoreOnBundleFinished(int32_t errCode, string bundleName) {} - -void ServiceReverseProxy::IncrementalRestoreOnAllBundlesFinished(int32_t errCode) {} - -void ServiceReverseProxy::IncrementalRestoreOnFileReady(string bundleName, string fileName, int fd, int manifestFd, - int32_t errCode) {} - -void ServiceReverseProxy::IncrementalRestoreOnResultReport(string result, string bundleName, ErrCode errCode) {} - -void ServiceReverseProxy::IncrementalRestoreOnProcessInfo(std::string bundleName, std::string processInfo) {} +ErrCode ServiceReverseProxy::BackupOnFileReady(const std::string &bundleName, + const std::string &fileName, + int fd, + int32_t errCode) +{ + return BError(BError::Codes::OK); +} + +ErrCode ServiceReverseProxy::BackupOnBundleStarted(int32_t errCode, const std::string &bundleName) +{ + return BError(BError::Codes::OK); +} + +ErrCode ServiceReverseProxy::BackupOnResultReport(const std::string &result, const std::string &bundleName) +{ + return BError(BError::Codes::OK); +} + +ErrCode ServiceReverseProxy::BackupOnBundleFinished(int32_t errCode, const std::string &bundleName) +{ + return BError(BError::Codes::OK); +} + +ErrCode ServiceReverseProxy::BackupOnAllBundlesFinished(int32_t errCode) +{ + return BError(BError::Codes::OK); +} + +ErrCode ServiceReverseProxy::BackupOnProcessInfo(const std::string &bundleName, const std::string &processInfo) +{ + return BError(BError::Codes::OK); +} + +ErrCode ServiceReverseProxy::BackupOnScanningInfo(const std::string &scannedInfo) +{ + return BError(BError::Codes::OK); +} + +ErrCode ServiceReverseProxy::RestoreOnBundleStarted(int32_t errCode, const std::string &bundleName) +{ + return BError(BError::Codes::OK); +} + +ErrCode ServiceReverseProxy::RestoreOnBundleFinished(int32_t errCode, const std::string &bundleName) +{ + return BError(BError::Codes::OK); +} + +ErrCode ServiceReverseProxy::RestoreOnAllBundlesFinished(int32_t errCode) +{ + return BError(BError::Codes::OK); +} + +ErrCode ServiceReverseProxy::RestoreOnFileReady(const std::string &bundleName, + const std::string &fileName, + int fd, + int32_t errCode) +{ + return BError(BError::Codes::OK); +} + +ErrCode ServiceReverseProxy::RestoreOnResultReport(const std::string &result, + const std::string &bundleName, + int32_t errCode) +{ + return BError(BError::Codes::OK); +} + +ErrCode ServiceReverseProxy::RestoreOnProcessInfo(const std::string &bundleName, const std::string &processInfo) +{ + return BError(BError::Codes::OK); +} + +ErrCode ServiceReverseProxy::IncrementalBackupOnFileReady(const std::string &bundleName, + const std::string &fileName, + int fd, + int manifestFd, + int32_t errCode) +{ + return BError(BError::Codes::OK); +} + +ErrCode ServiceReverseProxy::IncrementalBackupOnBundleStarted(int32_t errCode, const std::string &bundleName) +{ + return BError(BError::Codes::OK); +} + +ErrCode ServiceReverseProxy::IncrementalBackupOnResultReport(const std::string &result, const std::string &bundleName) +{ + return BError(BError::Codes::OK); +} + +ErrCode ServiceReverseProxy::IncrementalBackupOnBundleFinished(int32_t errCode, const std::string &bundleName) +{ + return BError(BError::Codes::OK); +} + +ErrCode ServiceReverseProxy::IncrementalBackupOnAllBundlesFinished(int32_t errCode) +{ + return BError(BError::Codes::OK); +} + +ErrCode ServiceReverseProxy::IncrementalBackupOnProcessInfo(const std::string &bundleName, + const std::string &processInfo) +{ + return BError(BError::Codes::OK); +} + +ErrCode ServiceReverseProxy::IncrementalBackupOnScanningInfo(const std::string &scannedInfo) +{ + return BError(BError::Codes::OK); +} + +ErrCode ServiceReverseProxy::IncrementalRestoreOnBundleStarted(int32_t errCode, const std::string &bundleName) +{ + return BError(BError::Codes::OK); +} + +ErrCode ServiceReverseProxy::IncrementalRestoreOnBundleFinished(int32_t errCode, const std::string &bundleName) +{ + return BError(BError::Codes::OK); +} + +ErrCode ServiceReverseProxy::IncrementalRestoreOnAllBundlesFinished(int32_t errCode) +{ + return BError(BError::Codes::OK); +} + +ErrCode ServiceReverseProxy::IncrementalRestoreOnFileReady(const std::string &bundleName, + const std::string &fileName, + int fd, + int manifestFd, + int32_t errCode) +{ + return BError(BError::Codes::OK); +} + +ErrCode ServiceReverseProxy::IncrementalRestoreOnResultReport(const std::string &result, + const std::string &bundleName, + int32_t errCode) +{ + return BError(BError::Codes::OK); +} + +ErrCode ServiceReverseProxy::IncrementalRestoreOnProcessInfo(const std::string &bundleName, + const std::string &processInfo) +{ + return BError(BError::Codes::OK); +} } // namespace OHOS::FileManagement::Backup \ No newline at end of file diff --git a/tests/mock/module_ipc/src/svc_session_manager_mock.cpp b/tests/mock/module_ipc/src/svc_session_manager_mock.cpp index 7f4bcf07002f78370d6f8941a4538c43e92f2d7e..017a8e9b48d43aa9a0f600eea4d8db4695ed13f7 100644 --- a/tests/mock/module_ipc/src/svc_session_manager_mock.cpp +++ b/tests/mock/module_ipc/src/svc_session_manager_mock.cpp @@ -21,7 +21,7 @@ namespace OHOS::FileManagement::Backup { using namespace std; -ErrCode SvcSessionManager::VerifyCallerAndScenario(uint32_t, IServiceReverse::Scenario) const +ErrCode SvcSessionManager::VerifyCallerAndScenario(uint32_t, IServiceReverseType::Scenario) const { return BError(BError::Codes::OK); } @@ -46,7 +46,7 @@ sptr SvcSessionManager::GetServiceReverseProxy() return BSvcSessionManager::sessionManager->GetServiceReverseProxy(); } -IServiceReverse::Scenario SvcSessionManager::GetScenario() +IServiceReverseType::Scenario SvcSessionManager::GetScenario() { return BSvcSessionManager::sessionManager->GetScenario(); } diff --git a/tests/mock/module_ipc/svc_backup_connection_mock.cpp b/tests/mock/module_ipc/svc_backup_connection_mock.cpp index 001f3dee2bc2017512ae9c6a415310bfbdbe57b4..061ded0a612e5fc779b5395359cd4fbfb3f54165 100644 --- a/tests/mock/module_ipc/svc_backup_connection_mock.cpp +++ b/tests/mock/module_ipc/svc_backup_connection_mock.cpp @@ -17,7 +17,7 @@ #include -#include "module_ipc/svc_extension_proxy.h" +#include "extension_proxy.h" #include "module_ipc/svc_session_manager.h" namespace OHOS::FileManagement::Backup { diff --git a/tests/mock/module_ipc/svc_extension_proxy_mock.cpp b/tests/mock/module_ipc/svc_extension_proxy_mock.cpp index a2534d899d00a0718fcd3e3007a7a963d6a26b2e..3b8ae2212175aa1f385487764f473ebce7eca3f1 100644 --- a/tests/mock/module_ipc/svc_extension_proxy_mock.cpp +++ b/tests/mock/module_ipc/svc_extension_proxy_mock.cpp @@ -13,73 +13,73 @@ * limitations under the License. */ -#include "module_ipc/svc_extension_proxy.h" +#include "extension_proxy.h" namespace OHOS::FileManagement::Backup { using namespace std; -UniqueFd SvcExtensionProxy::GetFileHandle(const string &fileName, int32_t &errCode) +ErrCode ExtensionProxy::GetFileHandleWithUniqueFd(const string &fileName, int32_t &errCode, int &fd) { - return UniqueFd(-1); + return 0; } -ErrCode SvcExtensionProxy::HandleClear() +ErrCode ExtensionProxy::HandleClear() { return 0; } -ErrCode SvcExtensionProxy::HandleBackup(bool isClearData) +ErrCode ExtensionProxy::HandleBackup(bool isClearData) { return 0; } -ErrCode SvcExtensionProxy::PublishFile(const string &fileName) +ErrCode ExtensionProxy::PublishFile(const string &fileName) { return 0; } -ErrCode SvcExtensionProxy::HandleRestore(bool isClearData) +ErrCode ExtensionProxy::HandleRestore(bool isClearData) { return 0; } -ErrCode SvcExtensionProxy::GetBackupInfo(std::string &result) +ErrCode ExtensionProxy::GetBackupInfo(std::string &result) { return 0; } -std::tuple SvcExtensionProxy::GetIncrementalFileHandle(const string &fileName) +ErrCode ExtensionProxy::GetIncrementalFileHandle(const string &fileName, UniqueFdGroup &fdGroup) { - return {0, UniqueFd(-1), UniqueFd(-1)}; + return 0; } -ErrCode SvcExtensionProxy::PublishIncrementalFile(const string &fileName) +ErrCode ExtensionProxy::PublishIncrementalFile(const string &fileName) { return 0; } -ErrCode SvcExtensionProxy::HandleIncrementalBackup(UniqueFd incrementalFd, UniqueFd manifestFd) +ErrCode ExtensionProxy::HandleIncrementalBackup(int incrementalFd, int manifestFd) { return 0; } -ErrCode SvcExtensionProxy::IncrementalOnBackup(bool isClearData) +ErrCode ExtensionProxy::IncrementalOnBackup(bool isClearData) { return 0; } -ErrCode SvcExtensionProxy::UpdateFdSendRate(std::string &bundleName, int32_t sendRate) +ErrCode ExtensionProxy::UpdateFdSendRate(const std::string &bundleName, int32_t sendRate) { return 0; } -ErrCode SvcExtensionProxy::User0OnBackup() +ErrCode ExtensionProxy::User0OnBackup() { return 0; } -tuple SvcExtensionProxy::GetIncrementalBackupFileHandle() +ErrCode ExtensionProxy::GetIncrementalBackupFileHandle(UniqueFdGroup &fdGroup) { - return {UniqueFd(-1), UniqueFd(-1)}; + return 0; } } // namespace OHOS::FileManagement::Backup \ No newline at end of file diff --git a/tests/mock/module_ipc/svc_session_manager_mock.cpp b/tests/mock/module_ipc/svc_session_manager_mock.cpp index 06f5a60911b5829073f3f5311b66ccf96334f950..61a2c2eb7c9102ec6a0eae38f4b063b169862571 100644 --- a/tests/mock/module_ipc/svc_session_manager_mock.cpp +++ b/tests/mock/module_ipc/svc_session_manager_mock.cpp @@ -36,7 +36,7 @@ static int32_t g_nFileReadyNum = 0; static int32_t g_nAllBundlesFinished = 0; } // namespace -ErrCode SvcSessionManager::VerifyCallerAndScenario(uint32_t clientToken, IServiceReverse::Scenario scenario) const +ErrCode SvcSessionManager::VerifyCallerAndScenario(uint32_t clientToken, IServiceReverseType::Scenario scenario) const { GTEST_LOG_(INFO) << "VerifyCallerAndScenario"; return BError(BError::Codes::OK); @@ -68,7 +68,7 @@ sptr SvcSessionManager::GetServiceReverseProxy() return impl_.clientProxy; } -IServiceReverse::Scenario SvcSessionManager::GetScenario() +IServiceReverseType::Scenario SvcSessionManager::GetScenario() { GTEST_LOG_(INFO) << "GetScenario"; return impl_.scenario; diff --git a/tests/mock/module_ipc/svc_session_manager_throw_mock.cpp b/tests/mock/module_ipc/svc_session_manager_throw_mock.cpp index f9e091a9867f47d04a1b586e07b0bff84276a9c6..fdec296b7af220f226c3d3a00790ad1ba36e068b 100644 --- a/tests/mock/module_ipc/svc_session_manager_throw_mock.cpp +++ b/tests/mock/module_ipc/svc_session_manager_throw_mock.cpp @@ -19,7 +19,7 @@ namespace OHOS::FileManagement::Backup { using namespace std; -ErrCode SvcSessionManager::VerifyCallerAndScenario(uint32_t clientToken, IServiceReverse::Scenario scenario) const +ErrCode SvcSessionManager::VerifyCallerAndScenario(uint32_t clientToken, IServiceReverseType::Scenario scenario) const { return BackupSvcSessionManager::session->VerifyCallerAndScenario(clientToken, scenario); } @@ -44,7 +44,7 @@ sptr SvcSessionManager::GetServiceReverseProxy() return BackupSvcSessionManager::session->GetServiceReverseProxy(); } -IServiceReverse::Scenario SvcSessionManager::GetScenario() +IServiceReverseType::Scenario SvcSessionManager::GetScenario() { return BackupSvcSessionManager::session->GetScenario(); } diff --git a/tests/mock/module_ipc/svc_session_manager_throw_mock.h b/tests/mock/module_ipc/svc_session_manager_throw_mock.h index 79306695a521b3927e094ef2a3f5c9be840a9995..effea305098cac5c3dd1db8c14ea80cd4d3d3556 100644 --- a/tests/mock/module_ipc/svc_session_manager_throw_mock.h +++ b/tests/mock/module_ipc/svc_session_manager_throw_mock.h @@ -27,12 +27,12 @@ class BackupSvcSessionManager { public: virtual ~BackupSvcSessionManager() = default; public: - virtual ErrCode VerifyCallerAndScenario(uint32_t, IServiceReverse::Scenario) = 0; + virtual ErrCode VerifyCallerAndScenario(uint32_t, IServiceReverseType::Scenario) = 0; virtual ErrCode Active(SvcSessionManager::Impl) = 0; virtual ErrCode Deactive(const wptr &, bool) = 0; virtual ErrCode VerifyBundleName(std::string &) = 0; virtual sptr GetServiceReverseProxy() = 0; - virtual IServiceReverse::Scenario GetScenario() = 0; + virtual IServiceReverseType::Scenario GetScenario() = 0; virtual bool OnBundleFileReady(const std::string &, const std::string &) = 0; virtual UniqueFd OnBundleExtManageInfo(const std::string &, UniqueFd) = 0; virtual void RemoveExtInfo(const std::string &) = 0; @@ -104,12 +104,12 @@ public: class SvcSessionManagerMock : public BackupSvcSessionManager { public: - MOCK_METHOD(ErrCode, VerifyCallerAndScenario, (uint32_t, IServiceReverse::Scenario)); + MOCK_METHOD(ErrCode, VerifyCallerAndScenario, (uint32_t, IServiceReverseType::Scenario)); MOCK_METHOD(ErrCode, Active, (SvcSessionManager::Impl)); MOCK_METHOD(ErrCode, Deactive, (const wptr &, bool)); MOCK_METHOD(ErrCode, VerifyBundleName, (std::string &)); MOCK_METHOD(sptr, GetServiceReverseProxy, ()); - MOCK_METHOD(IServiceReverse::Scenario, GetScenario, ()); + MOCK_METHOD(IServiceReverseType::Scenario, GetScenario, ()); MOCK_METHOD(bool, OnBundleFileReady, (const std::string &, const std::string &)); MOCK_METHOD(UniqueFd, OnBundleExtManageInfo, (const std::string &, UniqueFd)); MOCK_METHOD(void, RemoveExtInfo, (const std::string &)); diff --git a/tests/moduletests/backup_kit_inner/BUILD.gn b/tests/moduletests/backup_kit_inner/BUILD.gn index e19cf37c5deb230443663fb0e88f610507626ddf..dd14e6d8b57013dc8e1c05210531ef973cd9fe03 100644 --- a/tests/moduletests/backup_kit_inner/BUILD.gn +++ b/tests/moduletests/backup_kit_inner/BUILD.gn @@ -25,7 +25,6 @@ ohos_unittest("b_session_test") { "${path_backup}/frameworks/native/backup_kit_inner/src/b_session_restore_async.cpp", "${path_backup}/frameworks/native/backup_kit_inner/src/service_incremental_reverse.cpp", "${path_backup}/frameworks/native/backup_kit_inner/src/service_reverse.cpp", - "${path_backup}/frameworks/native/backup_kit_inner/src/service_reverse_stub.cpp", "${path_backup}/tests/mock/backup_kit_inner/service_client_mock.cpp", "b_session_backup_test.cpp", "b_session_restore_async_test.cpp", @@ -33,6 +32,8 @@ ohos_unittest("b_session_test") { ] sources += backup_mock_proxy_src + public_configs = [ "${path_backup}/services/backup_sa:public_idl_config" ] + include_dirs = [ "${path_backup}/interfaces/inner_api/native/backup_kit_inner/", "${path_backup}/interfaces/inner_api/native/backup_kit_inner/impl", diff --git a/tests/unittests/backup_api/backup_impl/BUILD.gn b/tests/unittests/backup_api/backup_impl/BUILD.gn index a932d6b43160f9d3850ff9665f59ae3007078344..f0ca34c4ecae0005340f19f392fed6b5143534c2 100644 --- a/tests/unittests/backup_api/backup_impl/BUILD.gn +++ b/tests/unittests/backup_api/backup_impl/BUILD.gn @@ -53,7 +53,6 @@ ohos_unittest("backup_sa_impl_test") { sources = [ "${path_backup_mock}/system_ability_manager/service_registry_mock.cpp", "${path_backup_mock}/utils_mock/src/utils_mock_global_variable.cpp", - "service_reverse_stub_test.cpp", "service_reverse_test.cpp", "svc_death_recipient_test.cpp", ] @@ -68,6 +67,7 @@ ohos_unittest("backup_sa_impl_test") { deps = [ "${path_backup}/interfaces/inner_api/native/backup_kit_inner:backup_kit_inner", + "${path_backup}/services/backup_sa:backup_sa_ipc", "${path_backup}/tests/utils:backup_test_utils", "${path_backup}/utils:backup_utils", ] diff --git a/tests/unittests/backup_api/backup_impl/include/ext_extension_mock.h b/tests/unittests/backup_api/backup_impl/include/ext_extension_mock.h index 3399bc312d7e0747aa06365fc881ab46e5f40ff8..614905b0ea1f34641f750be5cc25566beae847b1 100644 --- a/tests/unittests/backup_api/backup_impl/include/ext_extension_mock.h +++ b/tests/unittests/backup_api/backup_impl/include/ext_extension_mock.h @@ -20,9 +20,9 @@ #include #include #include - +#include "unique_fd.h" #include "b_error/b_error.h" -#include "i_extension.h" +#include "iextension.h" #include "iremote_stub.h" #include "test_manager.h" @@ -51,9 +51,16 @@ public: reply.WriteInt32(0); reply.WriteFileDescriptor(fd); return BError(BError::Codes::OK); - } + }; + + ErrCode GetFileHandleWithUniqueFd(const std::string &fileName, int32_t &getFileHandleErrCode, int &fd) override + { + UniqueFd fdResult = GetFileHandle(fileName, getFileHandleErrCode); + fd = fdResult.Release(); + return ERR_OK; + }; - UniqueFd GetFileHandle(const std::string &fileName, int32_t &errCode) override + UniqueFd GetFileHandle(const std::string &fileName, int32_t &errCode) { GTEST_LOG_(INFO) << "GetFileHandle" << fileName; if (fileName == "testName") { @@ -104,7 +111,11 @@ public: return BError(BError::Codes::OK); }; - std::tuple GetIncrementalFileHandle(const std::string &fileName) override + ErrCode GetIncrementalFileHandle(const std::string &fileName, UniqueFdGroup &fdGroup) override + { + return BError(BError::Codes::OK); + } + std::tuple GetIncrementalFileHandle(const std::string &fileName) { return {BError(BError::Codes::OK), UniqueFd(-1), UniqueFd(-1)}; }; @@ -114,7 +125,11 @@ public: return BError(BError::Codes::OK); }; - ErrCode HandleIncrementalBackup(UniqueFd incrementalFd, UniqueFd manifestFd) override + ErrCode HandleIncrementalBackup(int incrementalFd, int manifestFd) override + { + return BError(BError::Codes::OK); + }; + ErrCode HandleIncrementalBackup(UniqueFd incrementalFd, UniqueFd manifestFd) { return BError(BError::Codes::OK); }; @@ -124,7 +139,12 @@ public: return BError(BError::Codes::OK); }; - std::tuple GetIncrementalBackupFileHandle() override + ErrCode GetIncrementalBackupFileHandle(UniqueFdGroup &fdGroup) override + { + return BError(BError::Codes::OK); + }; + + std::tuple GetIncrementalBackupFileHandle() { return {UniqueFd(-1), UniqueFd(-1)}; }; @@ -134,7 +154,7 @@ public: return BError(BError::Codes::OK); }; - ErrCode UpdateFdSendRate(std::string &bundleName, int32_t sendRate) override + ErrCode UpdateFdSendRate(const std::string &bundleName, int32_t sendRate) override { return BError(BError::Codes::OK); }; diff --git a/tests/unittests/backup_api/backup_impl/include/service_reverse_mock.h b/tests/unittests/backup_api/backup_impl/include/service_reverse_mock.h index a61dcc03b6103b5be3948632b9172420d299808e..3a0474f0ccd6d56e99c1eb716da375decb08f02f 100644 --- a/tests/unittests/backup_api/backup_impl/include/service_reverse_mock.h +++ b/tests/unittests/backup_api/backup_impl/include/service_reverse_mock.h @@ -36,37 +36,159 @@ public: code_ = code; return BError(BError::Codes::OK); } - void BackupOnFileReady(std::string bundleName, std::string fileName, int fd, int32_t errCode) override {} - void BackupOnBundleStarted(int32_t errCode, std::string bundleName) override {} - void BackupOnResultReport(std::string result, std::string bundleName) override {}; - void BackupOnBundleFinished(int32_t errCode, std::string bundleName) override {} - void BackupOnAllBundlesFinished(int32_t errCode) override {} - void BackupOnProcessInfo(std::string bundleName, std::string processInfo) override {} - void BackupOnScanningInfo(std::string scannedInfo) override {} - - void RestoreOnBundleStarted(int32_t errCode, std::string bundleName) override {} - void RestoreOnBundleFinished(int32_t errCode, std::string bundleName) override {} - void RestoreOnAllBundlesFinished(int32_t errCode) override {} - void RestoreOnFileReady(std::string bundleName, std::string fileName, int fd, int32_t errCode) override {} - void RestoreOnResultReport(std::string result, std::string bundleName, ErrCode errCode) override {} - void RestoreOnProcessInfo(std::string bundleName, std::string processInfo) override {} - - void IncrementalBackupOnFileReady(std::string bundleName, std::string fileName, int fd, int manifestFd, - int32_t errCode) override {} - void IncrementalBackupOnBundleStarted(int32_t errCode, std::string bundleName) override {} - void IncrementalBackupOnResultReport(std::string result, std::string bundleName) override {} - void IncrementalBackupOnBundleFinished(int32_t errCode, std::string bundleName) override {} - void IncrementalBackupOnAllBundlesFinished(int32_t errCode) override {} - void IncrementalBackupOnProcessInfo(std::string bundleName, std::string processInfo) override {} - void IncrementalBackupOnScanningInfo(std::string scannedInfo) override {} - - void IncrementalRestoreOnBundleStarted(int32_t errCode, std::string bundleName) override {} - void IncrementalRestoreOnBundleFinished(int32_t errCode, std::string bundleName) override {} - void IncrementalRestoreOnAllBundlesFinished(int32_t errCode) override {} - void IncrementalRestoreOnFileReady(std::string bundleName, std::string fileName, int fd, int manifestFd, - int32_t errCode) override {} - void IncrementalRestoreOnResultReport(std::string result, std::string bundleName, ErrCode errCode) override {}; - void IncrementalRestoreOnProcessInfo(std::string bundleName, std::string processInfo) override {} + ErrCode BackupOnFileReady(const std::string &bundleName, + const std::string &fileName, + int fd, + int32_t errCode) override + { + return BError(BError::Codes::OK); + } + + ErrCode BackupOnBundleStarted(int32_t errCode, const std::string &bundleName) override + { + return BError(BError::Codes::OK); + } + + ErrCode BackupOnResultReport(const std::string &result, const std::string &bundleName) override + { + return BError(BError::Codes::OK); + }; + + ErrCode BackupOnBundleFinished(int32_t errCode, const std::string &bundleName) override + { + return BError(BError::Codes::OK); + } + + ErrCode BackupOnAllBundlesFinished(int32_t errCode) override + { + return BError(BError::Codes::OK); + } + + ErrCode BackupOnProcessInfo(const std::string &bundleName, const std::string &processInfo) override + { + return BError(BError::Codes::OK); + } + + ErrCode BackupOnScanningInfo(const std::string &scannedInfo) override + { + return BError(BError::Codes::OK); + } + + ErrCode RestoreOnBundleStarted(int32_t errCode, const std::string &bundleName) override + { + return BError(BError::Codes::OK); + } + + ErrCode RestoreOnBundleFinished(int32_t errCode, const std::string &bundleName) override + { + return BError(BError::Codes::OK); + } + + ErrCode RestoreOnAllBundlesFinished(int32_t errCode) override + { + return BError(BError::Codes::OK); + } + + ErrCode RestoreOnFileReady(const std::string &bundleName, + const std::string &fileName, + int fd, + int32_t errCode) override + { + return BError(BError::Codes::OK); + } + + ErrCode RestoreOnResultReport(const std::string &result, const std::string &bundleName, ErrCode errCode) override + { + return BError(BError::Codes::OK); + } + + ErrCode RestoreOnProcessInfo(const std::string &bundleName, const std::string &processInfo) override + { + return BError(BError::Codes::OK); + } + + ErrCode IncrementalBackupOnFileReady(const std::string &bundleName, + const std::string &fileName, + int fd, + int manifestFd, + int32_t errCode) override + { + return BError(BError::Codes::OK); + } + + ErrCode IncrementalSaBackupOnFileReady(const std::string &bundleName, + const std::string &fileName, + int fd, + int32_t errCode) override + { + return BError(BError::Codes::OK); + } + + ErrCode IncrementalBackupOnBundleStarted(int32_t errCode, const std::string &bundleName) override + { + return BError(BError::Codes::OK); + } + + ErrCode IncrementalBackupOnResultReport(const std::string &result, const std::string &bundleName) override + { + return BError(BError::Codes::OK); + } + + ErrCode IncrementalBackupOnBundleFinished(int32_t errCode, const std::string &bundleName) override + { + return BError(BError::Codes::OK); + } + + ErrCode IncrementalBackupOnAllBundlesFinished(int32_t errCode) override + { + return BError(BError::Codes::OK); + } + + ErrCode IncrementalBackupOnProcessInfo(const std::string &bundleName, const std::string &processInfo) override + { + return BError(BError::Codes::OK); + } + + ErrCode IncrementalBackupOnScanningInfo(const std::string &scannedInfo) override + { + return BError(BError::Codes::OK); + } + + ErrCode IncrementalRestoreOnBundleStarted(int32_t errCode, const std::string &bundleName) override + { + return BError(BError::Codes::OK); + } + + ErrCode IncrementalRestoreOnBundleFinished(int32_t errCode, const std::string &bundleName) override + { + return BError(BError::Codes::OK); + } + + ErrCode IncrementalRestoreOnAllBundlesFinished(int32_t errCode) override + { + return BError(BError::Codes::OK); + } + + ErrCode IncrementalRestoreOnFileReady(const std::string &bundleName, + const std::string &fileName, + int fd, + int manifestFd, + int32_t errCode) override + { + return BError(BError::Codes::OK); + } + + ErrCode IncrementalRestoreOnResultReport(const std::string &result, + const std::string &bundleName, + int32_t errCode) override + { + return BError(BError::Codes::OK); + } + + ErrCode IncrementalRestoreOnProcessInfo(const std::string &bundleName, const std::string &processInfo) override + { + return BError(BError::Codes::OK); + } }; } // namespace OHOS::FileManagement::Backup #endif // MOCK_SERVICE_REVERSE_MOCK_H \ No newline at end of file diff --git a/tests/unittests/backup_api/backup_impl/service_reverse_stub_test.cpp b/tests/unittests/backup_api/backup_impl/service_reverse_stub_test.cpp deleted file mode 100644 index 79540e8f652af280fc1cc91230ebcd614a760aae..0000000000000000000000000000000000000000 --- a/tests/unittests/backup_api/backup_impl/service_reverse_stub_test.cpp +++ /dev/null @@ -1,960 +0,0 @@ -/* - * 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 "b_error/b_error.h" -#include "iservice_reverse.h" -#include "service_reverse_stub.h" -#include "test_manager.h" -#include "unique_fd.h" - -namespace OHOS::FileManagement::Backup { -using namespace std; -using namespace testing; - -namespace { -const string BUNDLE_NAME = "com.example.app2backup"; -const string FILE_NAME = "1.tar"; -const string FILE_NAME_MANIFEST = "1.fr"; -} // namespace - -class MockServiceReverse final : public ServiceReverseStub { -public: - MOCK_METHOD4(BackupOnFileReady, void(string bundleName, string fileName, int fd, int32_t errCode)); - MOCK_METHOD2(BackupOnBundleStarted, void(int32_t errCode, string bundleName)); - MOCK_METHOD2(BackupOnResultReport, void(string result, std::string bundleName)); - MOCK_METHOD2(BackupOnBundleFinished, void(int32_t errCode, string bundleName)); - MOCK_METHOD1(BackupOnAllBundlesFinished, void(int32_t errCode)); - MOCK_METHOD2(BackupOnProcessInfo, void(std::string bundleName, std::string processInfo)); - MOCK_METHOD1(BackupOnScanningInfo, void(std::string scannedInfo)); - - MOCK_METHOD2(RestoreOnBundleStarted, void(int32_t errCode, std::string bundleName)); - MOCK_METHOD2(RestoreOnBundleFinished, void(int32_t errCode, string bundleName)); - MOCK_METHOD1(RestoreOnAllBundlesFinished, void(int32_t errCode)); - MOCK_METHOD4(RestoreOnFileReady, void(string bundleName, string fileName, int fd, int32_t errCode)); - MOCK_METHOD3(RestoreOnResultReport, void(string result, string bundleName, ErrCode errCode)); - MOCK_METHOD2(RestoreOnProcessInfo, void(std::string bundleName, std::string processInfo)); - - MOCK_METHOD5(IncrementalBackupOnFileReady, - void(string bundleName, string fileName, int fd, int manifestFd, int32_t errCode)); - MOCK_METHOD2(IncrementalBackupOnBundleStarted, void(int32_t errCode, string bundleName)); - MOCK_METHOD2(IncrementalBackupOnResultReport, void(string result, std::string bundleName)); - MOCK_METHOD2(IncrementalBackupOnBundleFinished, void(int32_t errCode, string bundleName)); - MOCK_METHOD1(IncrementalBackupOnAllBundlesFinished, void(int32_t errCode)); - MOCK_METHOD2(IncrementalBackupOnProcessInfo, void(std::string bundleName, std::string processInfo)); - MOCK_METHOD1(IncrementalBackupOnScanningInfo, void(std::string scannedInfo)); - - MOCK_METHOD2(IncrementalRestoreOnBundleStarted, void(int32_t errCode, std::string bundleName)); - MOCK_METHOD2(IncrementalRestoreOnBundleFinished, void(int32_t errCode, string bundleName)); - MOCK_METHOD1(IncrementalRestoreOnAllBundlesFinished, void(int32_t errCode)); - MOCK_METHOD5(IncrementalRestoreOnFileReady, - void(string bundleName, string fileName, int fd, int manifestFd, int32_t errCode)); - MOCK_METHOD3(IncrementalRestoreOnResultReport, void(string result, string bundleName, ErrCode errCode)); - MOCK_METHOD2(IncrementalRestoreOnProcessInfo, void(std::string bundleName, std::string processInfo)); -}; - -class ServiceReverseStubTest : public testing::Test { -public: - static void SetUpTestCase(void) {}; - static void TearDownTestCase() {}; - void SetUp() override {}; - void TearDown() override {}; -}; - -/** - * @tc.number: SUB_backup_ServiceReverseStub_BackupOnFileReady_0100 - * @tc.name: SUB_backup_ServiceReverseStub_BackupOnFileReady_0100 - * @tc.desc: Test function of BackupOnFileReady interface for SUCCESS. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I6F3GV - */ -HWTEST_F(ServiceReverseStubTest, SUB_backup_ServiceReverseStub_BackupOnFileReady_0100, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "ServiceReverseStubTest-begin SUB_backup_ServiceReverseStub_BackupOnFileReady_0100"; - try { - MockServiceReverse service; - EXPECT_CALL(service, BackupOnFileReady(_, _, _, _)).WillOnce(Return()); - MessageParcel data; - MessageParcel reply; - MessageOption option; - - EXPECT_TRUE(data.WriteInterfaceToken(IServiceReverse::GetDescriptor())); - EXPECT_TRUE(data.WriteString(BUNDLE_NAME)); - EXPECT_TRUE(data.WriteString(FILE_NAME)); - TestManager tm("ServiceReverseStub_0100"); - string filePath = tm.GetRootDirCurTest().append(FILE_NAME); - UniqueFd fd(open(filePath.data(), O_RDONLY | O_CREAT, S_IRUSR | S_IWUSR)); - data.WriteFileDescriptor(fd); - data.WriteInt32(0); - - EXPECT_EQ( - BError(BError::Codes::OK), - service.OnRemoteRequest(static_cast(IServiceReverseInterfaceCode::SERVICER_BACKUP_ON_FILE_READY), - data, reply, option)); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ServiceReverseStubTest-an exception occurred by BackupOnFileReady."; - } - GTEST_LOG_(INFO) << "ServiceReverseStubTest-end SUB_backup_ServiceReverseStub_BackupOnFileReady_0100"; -} - -/** - * @tc.number: SUB_backup_ServiceReverseStub_BackupOnBundleStarted_0100 - * @tc.name: SUB_backup_ServiceReverseStub_BackupOnBundleStarted_0100 - * @tc.desc: Test function of BackupOnBundleStarted interface for SUCCESS. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I6F3GV - */ -HWTEST_F(ServiceReverseStubTest, - SUB_backup_ServiceReverseStub_BackupOnBundleStarted_0100, - testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "ServiceReverseStubTest-begin SUB_backup_ServiceReverseStub_BackupOnBundleStarted_0100"; - try { - MockServiceReverse service; - EXPECT_CALL(service, BackupOnBundleStarted(_, _)).WillOnce(Return()); - MessageParcel data; - MessageParcel reply; - MessageOption option; - - EXPECT_TRUE(data.WriteInterfaceToken(IServiceReverse::GetDescriptor())); - EXPECT_TRUE(data.WriteInt32(BError(BError::Codes::OK))); - EXPECT_TRUE(data.WriteString(BUNDLE_NAME)); - - EXPECT_EQ(BError(BError::Codes::OK), - service.OnRemoteRequest( - static_cast(IServiceReverseInterfaceCode::SERVICER_BACKUP_ON_SUB_TASK_STARTED), data, - reply, option)); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ServiceReverseStubTest-an exception occurred by BackupOnBundleStarted."; - } - GTEST_LOG_(INFO) << "ServiceReverseStubTest-end SUB_backup_ServiceReverseStub_BackupOnBundleStarted_0100"; -} - -/** - * @tc.number: SUB_backup_ServiceReverseStub_BackupOnResultReport_0100 - * @tc.name: SUB_backup_ServiceReverseStub_BackupOnResultReport_0100 - * @tc.desc: Test function of BackupOnResultReport interface for SUCCESS. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I6F3GV - */ -HWTEST_F(ServiceReverseStubTest, - SUB_backup_ServiceReverseStub_BackupOnResultReport_0100, - testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "ServiceReverseStubTest-begin SUB_backup_ServiceReverseStub_BackupOnResultReport_0100"; - try { - MockServiceReverse service; - EXPECT_CALL(service, BackupOnResultReport(_, _)).WillOnce(Return()); - MessageParcel data; - MessageParcel reply; - MessageOption option; - - EXPECT_TRUE(data.WriteInterfaceToken(IServiceReverse::GetDescriptor())); - EXPECT_TRUE(data.WriteString(BUNDLE_NAME)); - - EXPECT_EQ(BError(BError::Codes::OK), - service.OnRemoteRequest( - static_cast(IServiceReverseInterfaceCode::SERVICER_BACKUP_ON_RESULT_REPORT), data, - reply, option)); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ServiceReverseStubTest-an exception occurred by BackupOnResultReport."; - } - GTEST_LOG_(INFO) << "ServiceReverseStubTest-end SUB_backup_ServiceReverseStub_BackupOnResultReport_0100"; -} - -/** - * @tc.number: SUB_backup_ServiceReverseStub_BackupOnBundleFinished_0100 - * @tc.name: SUB_backup_ServiceReverseStub_BackupOnBundleFinished_0100 - * @tc.desc: Test function of BackupOnBundleFinished interface for SUCCESS. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I6F3GV - */ -HWTEST_F(ServiceReverseStubTest, - SUB_backup_ServiceReverseStub_BackupOnBundleFinished_0100, - testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "ServiceReverseStubTest-begin SUB_backup_ServiceReverseStub_BackupOnBundleFinished_0100"; - try { - MockServiceReverse service; - EXPECT_CALL(service, BackupOnBundleFinished(_, _)).WillOnce(Return()); - MessageParcel data; - MessageParcel reply; - MessageOption option; - - EXPECT_TRUE(data.WriteInterfaceToken(IServiceReverse::GetDescriptor())); - EXPECT_TRUE(data.WriteInt32(BError(BError::Codes::OK))); - EXPECT_TRUE(data.WriteString(BUNDLE_NAME)); - - EXPECT_EQ(BError(BError::Codes::OK), - service.OnRemoteRequest( - static_cast(IServiceReverseInterfaceCode::SERVICER_BACKUP_ON_SUB_TASK_FINISHED), data, - reply, option)); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ServiceReverseStubTest-an exception occurred by BackupOnBundleFinished."; - } - GTEST_LOG_(INFO) << "ServiceReverseStubTest-end SUB_backup_ServiceReverseStub_BackupOnBundleFinished_0100"; -} - -/** - * @tc.number: SUB_backup_ServiceReverseStub_BackupOnAllBundlesFinished_0100 - * @tc.name: SUB_backup_ServiceReverseStub_BackupOnAllBundlesFinished_0100 - * @tc.desc: Test function of BackupOnAllBundlesFinished interface for SUCCESS. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I6F3GV - */ -HWTEST_F(ServiceReverseStubTest, - SUB_backup_ServiceReverseStub_BackupOnAllBundlesFinished_0100, - testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "ServiceReverseStubTest-begin SUB_backup_ServiceReverseStub_BackupOnAllBundlesFinished_0100"; - try { - MockServiceReverse service; - EXPECT_CALL(service, BackupOnAllBundlesFinished(_)).WillOnce(Return()); - MessageParcel data; - MessageParcel reply; - MessageOption option; - - EXPECT_TRUE(data.WriteInterfaceToken(IServiceReverse::GetDescriptor())); - EXPECT_TRUE(data.WriteInt32(BError(BError::Codes::OK))); - - EXPECT_EQ(BError(BError::Codes::OK), - service.OnRemoteRequest( - static_cast(IServiceReverseInterfaceCode::SERVICER_BACKUP_ON_TASK_FINISHED), data, - reply, option)); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ServiceReverseStubTest-an exception occurred by BackupOnAllBundlesFinished."; - } - GTEST_LOG_(INFO) << "ServiceReverseStubTest-end SUB_backup_ServiceReverseStub_BackupOnAllBundlesFinished_0100"; -} - -/** - * @tc.number: SUB_backup_ServiceReverseStub_RestoreOnBundleStarted_0100 - * @tc.name: SUB_backup_ServiceReverseStub_RestoreOnBundleStarted_0100 - * @tc.desc: Test function of RestoreOnBundleStarted interface for SUCCESS. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I6F3GV - */ -HWTEST_F(ServiceReverseStubTest, - SUB_backup_ServiceReverseStub_RestoreOnBundleStarted_0100, - testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "ServiceReverseStubTest-begin SUB_backup_ServiceReverseStub_RestoreOnBundleStarted_0100"; - try { - MockServiceReverse service; - EXPECT_CALL(service, RestoreOnBundleStarted(_, _)).WillOnce(Return()); - MessageParcel data; - MessageParcel reply; - MessageOption option; - - EXPECT_TRUE(data.WriteInterfaceToken(IServiceReverse::GetDescriptor())); - EXPECT_TRUE(data.WriteInt32(BError(BError::Codes::OK))); - EXPECT_TRUE(data.WriteString(BUNDLE_NAME)); - - EXPECT_EQ(BError(BError::Codes::OK), - service.OnRemoteRequest( - static_cast(IServiceReverseInterfaceCode::SERVICER_RESTORE_ON_SUB_TASK_STARTED), data, - reply, option)); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ServiceReverseStubTest-an exception occurred by RestoreOnBundleStarted."; - } - GTEST_LOG_(INFO) << "ServiceReverseStubTest-end SUB_backup_ServiceReverseStub_RestoreOnBundleStarted_0100"; -} - -/** - * @tc.number: SUB_backup_ServiceReverseStub_RestoreOnBundleFinished_0100 - * @tc.name: SUB_backup_ServiceReverseStub_RestoreOnBundleFinished_0100 - * @tc.desc: Test function of RestoreOnBundleFinished interface for SUCCESS. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I6F3GV - */ -HWTEST_F(ServiceReverseStubTest, - SUB_backup_ServiceReverseStub_RestoreOnBundleFinished_0100, - testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "ServiceReverseStubTest-begin SUB_backup_ServiceReverseStub_RestoreOnBundleFinished_0100"; - try { - MockServiceReverse service; - EXPECT_CALL(service, RestoreOnBundleFinished(_, _)).WillOnce(Return()); - MessageParcel data; - MessageParcel reply; - MessageOption option; - - EXPECT_TRUE(data.WriteInterfaceToken(IServiceReverse::GetDescriptor())); - EXPECT_TRUE(data.WriteInt32(BError(BError::Codes::OK))); - EXPECT_TRUE(data.WriteString(BUNDLE_NAME)); - - EXPECT_EQ(BError(BError::Codes::OK), - service.OnRemoteRequest( - static_cast(IServiceReverseInterfaceCode::SERVICER_RESTORE_ON_SUB_TASK_FINISHED), data, - reply, option)); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ServiceReverseStubTest-an exception occurred by RestoreOnBundleFinished."; - } - GTEST_LOG_(INFO) << "ServiceReverseStubTest-end SUB_backup_ServiceReverseStub_RestoreOnBundleFinished_0100"; -} - -/** - * @tc.number: SUB_backup_ServiceReverseStub_RestoreOnAllBundlesFinished_0100 - * @tc.name: SUB_backup_ServiceReverseStub_RestoreOnAllBundlesFinished_0100 - * @tc.desc: Test function of RestoreOnBundleStarted interface for SUCCESS. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I6F3GV - */ -HWTEST_F(ServiceReverseStubTest, - SUB_backup_ServiceReverseStub_RestoreOnAllBundlesFinished_0100, - testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "ServiceReverseStubTest-begin SUB_backup_ServiceReverseStub_RestoreOnAllBundlesFinished_0100"; - try { - MockServiceReverse service; - EXPECT_CALL(service, RestoreOnAllBundlesFinished(_)).WillOnce(Return()); - MessageParcel data; - MessageParcel reply; - MessageOption option; - - EXPECT_TRUE(data.WriteInterfaceToken(IServiceReverse::GetDescriptor())); - EXPECT_TRUE(data.WriteInt32(BError(BError::Codes::OK))); - - EXPECT_EQ(BError(BError::Codes::OK), - service.OnRemoteRequest( - static_cast(IServiceReverseInterfaceCode::SERVICER_RESTORE_ON_TASK_FINISHED), data, - reply, option)); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ServiceReverseStubTest-an exception occurred by RestoreOnAllBundlesFinished."; - } - GTEST_LOG_(INFO) << "ServiceReverseStubTest-end SUB_backup_ServiceReverseStub_RestoreOnAllBundlesFinished_0100"; -} - -/** - * @tc.number: SUB_backup_ServiceReverseStub_RestoreOnFileReady_0100 - * @tc.name: SUB_backup_ServiceReverseStub_RestoreOnFileReady_0100 - * @tc.desc: Test function of RestoreOnFileReady interface for SUCCESS. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I6F3GV - */ -HWTEST_F(ServiceReverseStubTest, SUB_backup_ServiceReverseStub_RestoreOnFileReady_0100, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "ServiceReverseStubTest-begin SUB_backup_ServiceReverseStub_RestoreOnFileReady_0100"; - try { - MockServiceReverse service; - EXPECT_CALL(service, RestoreOnFileReady(_, _, _, _)).WillOnce(Return()); - MessageParcel data; - MessageParcel reply; - MessageOption option; - int32_t errCode = 0; - bool fdFlag = true; - - EXPECT_TRUE(data.WriteInterfaceToken(IServiceReverse::GetDescriptor())); - EXPECT_TRUE(data.WriteString(BUNDLE_NAME)); - EXPECT_TRUE(data.WriteString(FILE_NAME)); - - TestManager tm("ServiceReverseStub_0200"); - string filePath = tm.GetRootDirCurTest().append(FILE_NAME); - UniqueFd fd(open(filePath.data(), O_RDONLY | O_CREAT, S_IRUSR | S_IWUSR)); - if (fd < 0) { - errCode = BError::GetCodeByErrno(errno); - fdFlag = false; - } - data.WriteBool(fdFlag); - if (fdFlag == true) { - data.WriteFileDescriptor(fd); - } - data.WriteInt32(errCode); - - EXPECT_EQ( - BError(BError::Codes::OK), - service.OnRemoteRequest(static_cast(IServiceReverseInterfaceCode::SERVICER_RESTORE_ON_FILE_READY), - data, reply, option)); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ServiceReverseStubTest-an exception occurred by RestoreOnFileReady."; - } - GTEST_LOG_(INFO) << "ServiceReverseStubTest-end SUB_backup_ServiceReverseStub_RestoreOnFileReady_0100"; -} - -/** - * @tc.number: SUB_backup_ServiceReverseStub_error_0100 - * @tc.name: SUB_backup_ServiceReverseStub_error_0100 - * @tc.desc: Test function of RestoreOnFileReady interface for SUCCESS. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I6F3GV - */ -HWTEST_F(ServiceReverseStubTest, SUB_backup_ServiceReverseStub_error_0100, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "ServiceReverseStubTest-begin SUB_backup_ServiceReverseStub_error_0100"; - try { - MockServiceReverse service; - MessageParcel data; - MessageParcel reply; - MessageOption option; - EXPECT_TRUE(data.WriteInterfaceToken(Str8ToStr16("test"))); - - EXPECT_NE(BError(BError::Codes::OK), service.OnRemoteRequest(3333, data, reply, option)); - EXPECT_NE( - BError(BError::Codes::OK), - service.OnRemoteRequest(static_cast(IServiceReverseInterfaceCode::SERVICER_RESTORE_ON_FILE_READY), - data, reply, option)); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ServiceReverseStubTest-an exception occurred."; - } - GTEST_LOG_(INFO) << "ServiceReverseStubTest-end SUB_backup_ServiceReverseStub_error_0100"; -} - -/** - * @tc.number: SUB_backup_ServiceReverseStub_IncrementalBackupOnFileReady_0100 - * @tc.name: SUB_backup_ServiceReverseStub_IncrementalBackupOnFileReady_0100 - * @tc.desc: Test function of IncrementalBackupOnFileReady interface for SUCCESS. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I90ZZX - */ -HWTEST_F(ServiceReverseStubTest, - SUB_backup_ServiceReverseStub_IncrementalBackupOnFileReady_0100, - testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "ServiceReverseStubTest-begin SUB_backup_ServiceReverseStub_IncrementalBackupOnFileReady_0100"; - try { - MockServiceReverse service; - EXPECT_CALL(service, IncrementalBackupOnFileReady(_, _, _, _, _)).WillOnce(Return()); - MessageParcel data; - MessageParcel reply; - MessageOption option; - - EXPECT_TRUE(data.WriteInterfaceToken(IServiceReverse::GetDescriptor())); - EXPECT_TRUE(data.WriteString(BUNDLE_NAME)); - EXPECT_TRUE(data.WriteString(FILE_NAME)); - TestManager tm("ServiceReverseStub_0300"); - string filePath = tm.GetRootDirCurTest().append(FILE_NAME); - UniqueFd fd(open(filePath.data(), O_RDONLY | O_CREAT, S_IRUSR | S_IWUSR)); - data.WriteFileDescriptor(fd); - TestManager tm2("ServiceReverseStub_0301"); - string filePathManifest = tm2.GetRootDirCurTest().append(FILE_NAME_MANIFEST); - UniqueFd fdManifest(open(filePathManifest.data(), O_RDONLY | O_CREAT, S_IRUSR | S_IWUSR)); - data.WriteFileDescriptor(fdManifest); - data.WriteInt32(0); - - EXPECT_EQ(BError(BError::Codes::OK), - service.OnRemoteRequest( - static_cast(IServiceReverseInterfaceCode::SERVICER_INCREMENTAL_BACKUP_ON_FILE_READY), - data, reply, option)); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ServiceReverseStubTest-an exception occurred by IncrementalBackupOnFileReady."; - } - GTEST_LOG_(INFO) << "ServiceReverseStubTest-end SUB_backup_ServiceReverseStub_IncrementalBackupOnFileReady_0100"; -} - -/** - * @tc.number: SUB_backup_ServiceReverseStub_IncrementalBackupOnBundleStarted_0100 - * @tc.name: SUB_backup_ServiceReverseStub_IncrementalBackupOnBundleStarted_0100 - * @tc.desc: Test function of IncrementalBackupOnBundleStarted interface for SUCCESS. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I90ZZX - */ -HWTEST_F(ServiceReverseStubTest, - SUB_backup_ServiceReverseStub_IncrementalBackupOnBundleStarted_0100, - testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) - << "ServiceReverseStubTest-begin SUB_backup_ServiceReverseStub_IncrementalBackupOnBundleStarted_0100"; - try { - MockServiceReverse service; - EXPECT_CALL(service, IncrementalBackupOnBundleStarted(_, _)).WillOnce(Return()); - MessageParcel data; - MessageParcel reply; - MessageOption option; - - EXPECT_TRUE(data.WriteInterfaceToken(IServiceReverse::GetDescriptor())); - EXPECT_TRUE(data.WriteInt32(BError(BError::Codes::OK))); - EXPECT_TRUE(data.WriteString(BUNDLE_NAME)); - - EXPECT_EQ( - BError(BError::Codes::OK), - service.OnRemoteRequest( - static_cast(IServiceReverseInterfaceCode::SERVICER_INCREMENTAL_BACKUP_ON_SUB_TASK_STARTED), - data, reply, option)); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ServiceReverseStubTest-an exception occurred by IncrementalBackupOnBundleStarted."; - } - GTEST_LOG_(INFO) - << "ServiceReverseStubTest-end SUB_backup_ServiceReverseStub_IncrementalBackupOnBundleStarted_0100"; -} - -/** - * @tc.number: SUB_backup_ServiceReverseStub_IncrementalBackupOnResultReport_0100 - * @tc.name: SUB_backup_ServiceReverseStub_IncrementalBackupOnResultReport_0100 - * @tc.desc: Test function of IncrementalBackupOnResultReport interface for SUCCESS. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I90ZZX - */ -HWTEST_F(ServiceReverseStubTest, - SUB_backup_ServiceReverseStub_IncrementalBackupOnResultReport_0100, - testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) - << "ServiceReverseStubTest-begin SUB_backup_ServiceReverseStub_IncrementalBackupOnResultReport_0100"; - try { - MockServiceReverse service; - EXPECT_CALL(service, IncrementalBackupOnResultReport(_, _)).WillOnce(Return()); - MessageParcel data; - MessageParcel reply; - MessageOption option; - - EXPECT_TRUE(data.WriteInterfaceToken(IServiceReverse::GetDescriptor())); - EXPECT_TRUE(data.WriteString(BUNDLE_NAME)); - - EXPECT_EQ( - BError(BError::Codes::OK), - service.OnRemoteRequest( - static_cast(IServiceReverseInterfaceCode::SERVICER_INCREMENTAL_BACKUP_ON_RESULT_REPORT), - data, reply, option)); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ServiceReverseStubTest-an exception occurred by IncrementalBackupOnResultReport."; - } - GTEST_LOG_(INFO) - << "ServiceReverseStubTest-end SUB_backup_ServiceReverseStub_IncrementalBackupOnResultReport_0100"; -} - -/** - * @tc.number: SUB_backup_ServiceReverseStub_IncrementalBackupOnBundleFinished_0100 - * @tc.name: SUB_backup_ServiceReverseStub_IncrementalBackupOnBundleFinished_0100 - * @tc.desc: Test function of IncrementalBackupOnBundleFinished interface for SUCCESS. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I90ZZX - */ -HWTEST_F(ServiceReverseStubTest, - SUB_backup_ServiceReverseStub_IncrementalBackupOnBundleFinished_0100, - testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) - << "ServiceReverseStubTest-begin SUB_backup_ServiceReverseStub_IncrementalBackupOnBundleFinished_0100"; - try { - MockServiceReverse service; - EXPECT_CALL(service, IncrementalBackupOnBundleFinished(_, _)).WillOnce(Return()); - MessageParcel data; - MessageParcel reply; - MessageOption option; - - EXPECT_TRUE(data.WriteInterfaceToken(IServiceReverse::GetDescriptor())); - EXPECT_TRUE(data.WriteInt32(BError(BError::Codes::OK))); - EXPECT_TRUE(data.WriteString(BUNDLE_NAME)); - - EXPECT_EQ( - BError(BError::Codes::OK), - service.OnRemoteRequest( - static_cast(IServiceReverseInterfaceCode::SERVICER_INCREMENTAL_BACKUP_ON_SUB_TASK_FINISHED), - data, reply, option)); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ServiceReverseStubTest-an exception occurred by IncrementalBackupOnBundleFinished."; - } - GTEST_LOG_(INFO) - << "ServiceReverseStubTest-end SUB_backup_ServiceReverseStub_IncrementalBackupOnBundleFinished_0100"; -} - -/** - * @tc.number: SUB_backup_ServiceReverseStub_IncrementalBackupOnAllBundlesFinished_0100 - * @tc.name: SUB_backup_ServiceReverseStub_IncrementalBackupOnAllBundlesFinished_0100 - * @tc.desc: Test function of IncrementalBackupOnAllBundlesFinished interface for SUCCESS. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I90ZZX - */ - -HWTEST_F(ServiceReverseStubTest, - SUB_backup_ServiceReverseStub_IncrementalBackupOnAllBundlesFinished_0100, - testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) - << "ServiceReverseStubTest-begin SUB_backup_ServiceReverseStub_IncrementalBackupOnAllBundlesFinished_0100"; - try { - MockServiceReverse service; - EXPECT_CALL(service, IncrementalBackupOnAllBundlesFinished(_)).WillOnce(Return()); - MessageParcel data; - MessageParcel reply; - MessageOption option; - - EXPECT_TRUE(data.WriteInterfaceToken(IServiceReverse::GetDescriptor())); - EXPECT_TRUE(data.WriteInt32(BError(BError::Codes::OK))); - - EXPECT_EQ(BError(BError::Codes::OK), - service.OnRemoteRequest( - static_cast(IServiceReverseInterfaceCode::SERVICER_INCREMENTAL_BACKUP_ON_TASK_FINISHED), - data, reply, option)); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ServiceReverseStubTest-an exception occurred by IncrementalBackupOnAllBundlesFinished."; - } - GTEST_LOG_(INFO) - << "ServiceReverseStubTest-end SUB_backup_ServiceReverseStub_IncrementalBackupOnAllBundlesFinished_0100"; -} - -/** - * @tc.number: SUB_backup_ServiceReverseStub_IncrementalRestoreOnBundleStarted_0100 - * @tc.name: SUB_backup_ServiceReverseStub_IncrementalRestoreOnBundleStarted_0100 - * @tc.desc: Test function of IncrementalRestoreOnBundleStarted interface for SUCCESS. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I90ZZX - */ -HWTEST_F(ServiceReverseStubTest, - SUB_backup_ServiceReverseStub_IncrementalRestoreOnBundleStarted_0100, - testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) - << "ServiceReverseStubTest-begin SUB_backup_ServiceReverseStub_IncrementalRestoreOnBundleStarted_0100"; - try { - MockServiceReverse service; - EXPECT_CALL(service, IncrementalRestoreOnBundleStarted(_, _)).WillOnce(Return()); - MessageParcel data; - MessageParcel reply; - MessageOption option; - - EXPECT_TRUE(data.WriteInterfaceToken(IServiceReverse::GetDescriptor())); - EXPECT_TRUE(data.WriteInt32(BError(BError::Codes::OK))); - EXPECT_TRUE(data.WriteString(BUNDLE_NAME)); - - EXPECT_EQ( - BError(BError::Codes::OK), - service.OnRemoteRequest( - static_cast(IServiceReverseInterfaceCode::SERVICER_INCREMENTAL_RESTORE_ON_SUB_TASK_STARTED), - data, reply, option)); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ServiceReverseStubTest-an exception occurred by IncrementalRestoreOnBundleStarted."; - } - GTEST_LOG_(INFO) - << "ServiceReverseStubTest-end SUB_backup_ServiceReverseStub_IncrementalRestoreOnBundleStarted_0100"; -} - -/** - * @tc.number: SUB_backup_ServiceReverseStub_IncrementalRestoreOnBundleFinished_0100 - * @tc.name: SUB_backup_ServiceReverseStub_IncrementalRestoreOnBundleFinished_0100 - * @tc.desc: Test function of IncrementalRestoreOnBundleFinished interface for SUCCESS. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I90ZZX - */ -HWTEST_F(ServiceReverseStubTest, - SUB_backup_ServiceReverseStub_IncrementalRestoreOnBundleFinished_0100, - testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) - << "ServiceReverseStubTest-begin SUB_backup_ServiceReverseStub_IncrementalRestoreOnBundleFinished_0100"; - try { - MockServiceReverse service; - EXPECT_CALL(service, IncrementalRestoreOnBundleFinished(_, _)).WillOnce(Return()); - MessageParcel data; - MessageParcel reply; - MessageOption option; - - EXPECT_TRUE(data.WriteInterfaceToken(IServiceReverse::GetDescriptor())); - EXPECT_TRUE(data.WriteInt32(BError(BError::Codes::OK))); - EXPECT_TRUE(data.WriteString(BUNDLE_NAME)); - - EXPECT_EQ( - BError(BError::Codes::OK), - service.OnRemoteRequest( - static_cast(IServiceReverseInterfaceCode::SERVICER_INCREMENTAL_RESTORE_ON_SUB_TASK_FINISHED), - data, reply, option)); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ServiceReverseStubTest-an exception occurred by IncrementalRestoreOnBundleFinished."; - } - GTEST_LOG_(INFO) - << "ServiceReverseStubTest-end SUB_backup_ServiceReverseStub_IncrementalRestoreOnBundleFinished_0100"; -} - -/** - * @tc.number: SUB_backup_ServiceReverseStub_IncrementalRestoreOnAllBundlesFinished_0100 - * @tc.name: SUB_backup_ServiceReverseStub_IncrementalRestoreOnAllBundlesFinished_0100 - * @tc.desc: Test function of IncrementalRestoreOnAllBundlesFinished interface for SUCCESS. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I90ZZX - */ -HWTEST_F(ServiceReverseStubTest, - SUB_backup_ServiceReverseStub_IncrementalRestoreOnAllBundlesFinished_0100, - testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) - << "ServiceReverseStubTest-begin SUB_backup_ServiceReverseStub_IncrementalRestoreOnAllBundlesFinished_0100"; - try { - MockServiceReverse service; - EXPECT_CALL(service, IncrementalRestoreOnAllBundlesFinished(_)).WillOnce(Return()); - MessageParcel data; - MessageParcel reply; - MessageOption option; - - EXPECT_TRUE(data.WriteInterfaceToken(IServiceReverse::GetDescriptor())); - EXPECT_TRUE(data.WriteInt32(BError(BError::Codes::OK))); - - EXPECT_EQ( - BError(BError::Codes::OK), - service.OnRemoteRequest( - static_cast(IServiceReverseInterfaceCode::SERVICER_INCREMENTAL_RESTORE_ON_TASK_FINISHED), - data, reply, option)); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ServiceReverseStubTest-an exception occurred by IncrementalRestoreOnAllBundlesFinished."; - } - GTEST_LOG_(INFO) - << "ServiceReverseStubTest-end SUB_backup_ServiceReverseStub_IncrementalRestoreOnAllBundlesFinished_0100"; -} - -/** - * @tc.number: SUB_backup_ServiceReverseStub_IncrementalRestoreOnFileReady_0100 - * @tc.name: SUB_backup_ServiceReverseStub_IncrementalRestoreOnFileReady_0100 - * @tc.desc: Test function of IncrementalRestoreOnFileReady interface for SUCCESS. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I90ZZX - */ -HWTEST_F(ServiceReverseStubTest, - SUB_backup_ServiceReverseStub_IncrementalRestoreOnFileReady_0100, - testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "ServiceReverseStubTest-begin SUB_backup_ServiceReverseStub_IncrementalRestoreOnFileReady_0100"; - try { - MockServiceReverse service; - EXPECT_CALL(service, IncrementalRestoreOnFileReady(_, _, _, _, _)).WillOnce(Return()); - MessageParcel data; - MessageParcel reply; - MessageOption option; - - EXPECT_TRUE(data.WriteInterfaceToken(IServiceReverse::GetDescriptor())); - EXPECT_TRUE(data.WriteString(BUNDLE_NAME)); - EXPECT_TRUE(data.WriteString(FILE_NAME)); - TestManager tm("ServiceReverseStub_0400"); - string filePath = tm.GetRootDirCurTest().append(FILE_NAME); - UniqueFd fd(open(filePath.data(), O_RDONLY | O_CREAT, S_IRUSR | S_IWUSR)); - data.WriteFileDescriptor(fd); - TestManager tm2("ServiceReverseStub_0401"); - string filePathManifest = tm2.GetRootDirCurTest().append(FILE_NAME_MANIFEST); - UniqueFd fdManifest(open(filePathManifest.data(), O_RDONLY | O_CREAT, S_IRUSR | S_IWUSR)); - data.WriteFileDescriptor(fdManifest); - - EXPECT_EQ(BError(BError::Codes::OK), - service.OnRemoteRequest( - static_cast(IServiceReverseInterfaceCode::SERVICER_INCREMENTAL_RESTORE_ON_FILE_READY), - data, reply, option)); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ServiceReverseStubTest-an exception occurred by IncrementalRestoreOnFileReady."; - } - GTEST_LOG_(INFO) << "ServiceReverseStubTest-end SUB_backup_ServiceReverseStub_IncrementalRestoreOnFileReady_0100"; -} - -/** - * @tc.number: SUB_backup_ServiceReverseStub_RestoreOnResultReport_0100 - * @tc.name: SUB_backup_ServiceReverseStub_RestoreOnResultReport_0100 - * @tc.desc: Test function of RestoreOnResultReport interface for SUCCESS. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I90ZZX - */ -HWTEST_F(ServiceReverseStubTest, - SUB_backup_ServiceReverseStub_RestoreOnResultReport_0100, - testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) - << "ServiceReverseStubTest-begin SUB_backup_ServiceReverseStub_RestoreOnResultReport_0100"; - try { - MockServiceReverse service; - EXPECT_CALL(service, RestoreOnResultReport(_, _, _)).WillOnce(Return()); - MessageParcel data; - MessageParcel reply; - MessageOption option; - std::string resultReport = "result_report"; - EXPECT_TRUE(data.WriteInterfaceToken(IServiceReverse::GetDescriptor())); - EXPECT_TRUE(data.WriteString(resultReport)); - EXPECT_TRUE(data.WriteString(BUNDLE_NAME)); - EXPECT_TRUE(data.WriteInt32(0)); - - EXPECT_EQ( - BError(BError::Codes::OK), - service.OnRemoteRequest( - static_cast(IServiceReverseInterfaceCode::SERVICER_RESTORE_ON_RESULT_REPORT), - data, reply, option)); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ServiceReverseStubTest-an exception occurred by RestoreOnResultReport."; - } - GTEST_LOG_(INFO) - << "ServiceReverseStubTest-end SUB_backup_ServiceReverseStub_RestoreOnResultReport_0100"; -} - -/** - * @tc.number: SUB_backup_ServiceReverseStub_IncrementalRestoreOnResultReport_0100 - * @tc.name: SUB_backup_ServiceReverseStub_IncrementalRestoreOnResultReport_0100 - * @tc.desc: Test function of IncrementalRestoreOnResultReport interface for SUCCESS. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I90ZZX - */ -HWTEST_F(ServiceReverseStubTest, - SUB_backup_ServiceReverseStub_IncrementalRestoreOnResultReport_0100, - testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) - << "ServiceReverseStubTest-begin SUB_backup_ServiceReverseStub_RestoreOnResultReport_0100"; - try { - MockServiceReverse service; - EXPECT_CALL(service, IncrementalRestoreOnResultReport(_, _, _)).WillOnce(Return()); - MessageParcel data; - MessageParcel reply; - MessageOption option; - std::string resultReport = "result_report"; - EXPECT_TRUE(data.WriteInterfaceToken(IServiceReverse::GetDescriptor())); - EXPECT_TRUE(data.WriteString(resultReport)); - EXPECT_TRUE(data.WriteInt32(0)); - - EXPECT_EQ( - BError(BError::Codes::OK), - service.OnRemoteRequest( - static_cast(IServiceReverseInterfaceCode::SERVICER_INCREMENTAL_RESTORE_ON_RESULT_REPORT), - data, reply, option)); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ServiceReverseStubTest-an exception occurred by RestoreOnResultReport."; - } - GTEST_LOG_(INFO) - << "ServiceReverseStubTest-end SUB_backup_ServiceReverseStub_IncrementalRestoreOnResultReport_0100"; -} - -/** - * @tc.number: SUB_backup_ServiceReverseStub_BackupOnScanningInfo_0100 - * @tc.name: SUB_backup_ServiceReverseStub_BackupOnScanningInfo_0100 - * @tc.desc: Test function of BackupOnScanningInfo interface for SUCCESS. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I6F3GV - */ -HWTEST_F(ServiceReverseStubTest, - SUB_backup_ServiceReverseStub_BackupOnScanningInfo_0100, - testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "ServiceReverseStubTest-begin SUB_backup_ServiceReverseStub_BackupOnScanningInfo_0100"; - try { - MockServiceReverse service; - EXPECT_CALL(service, BackupOnScanningInfo(_)).WillOnce(Return()); - MessageParcel data; - MessageParcel reply; - MessageOption option; - - EXPECT_TRUE(data.WriteInterfaceToken(IServiceReverse::GetDescriptor())); - EXPECT_TRUE(data.WriteString(BUNDLE_NAME)); - - EXPECT_EQ(BError(BError::Codes::OK), - service.OnRemoteRequest( - static_cast(IServiceReverseInterfaceCode::SERVICER_BACKUP_ON_SCANNED_INFO), data, - reply, option)); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ServiceReverseStubTest-an exception occurred by BackupOnScanningInfo."; - } - GTEST_LOG_(INFO) << "ServiceReverseStubTest-end SUB_backup_ServiceReverseStub_BackupOnScanningInfo_0100"; -} - -/** - * @tc.number: SUB_backup_ServiceReverseStub_IncrementalBackupOnScanningInfo_0100 - * @tc.name: SUB_backup_ServiceReverseStub_IncrementalBackupOnScanningInfo_0100 - * @tc.desc: Test function of IncrementalBackupOnScanningInfo interface for SUCCESS. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I6F3GV - */ -HWTEST_F(ServiceReverseStubTest, - SUB_backup_ServiceReverseStub_IncrementalBackupOnScanningInfo_0100, - testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << - "ServiceReverseStubTest-begin SUB_backup_ServiceReverseStub_IncrementalBackupOnScanningInfo_0100"; - try { - MockServiceReverse service; - MessageParcel data; - MessageParcel reply; - MessageOption option; - EXPECT_TRUE(data.WriteInterfaceToken(IServiceReverse::GetDescriptor())); - EXPECT_TRUE(data.WriteString(BUNDLE_NAME)); - - EXPECT_CALL(service, IncrementalBackupOnScanningInfo(_)).WillOnce(Return()); - EXPECT_EQ(BError(BError::Codes::OK), - service.OnRemoteRequest( - static_cast( - IServiceReverseInterfaceCode::SERVICER_INCREMENTAL_BACKUP_ON_SCANNED_INFO), - data, reply, option)); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ServiceReverseStubTest-an exception occurred by BackupOnScanningInfo."; - } - GTEST_LOG_(INFO) << "ServiceReverseStubTest-end SUB_backup_ServiceReverseStub_IncrementalBackupOnScanningInfo_0100"; -} -} // namespace OHOS::FileManagement::Backup \ No newline at end of file diff --git a/tests/unittests/backup_api/backup_impl/service_reverse_test.cpp b/tests/unittests/backup_api/backup_impl/service_reverse_test.cpp index 1f5cb90e6929ad24009cf74e2da5f9b975478333..1c91772409fd719d5296f0b152fc4bdee1f68540 100644 --- a/tests/unittests/backup_api/backup_impl/service_reverse_test.cpp +++ b/tests/unittests/backup_api/backup_impl/service_reverse_test.cpp @@ -45,8 +45,8 @@ public: void SetUp() override {}; void TearDown() override; - void Init(IServiceReverse::Scenario scenario, int nType = 0); - void IncrementalInit(IServiceReverse::Scenario scenario, int nType = 0); + void Init(IServiceReverseType::Scenario scenario, int nType = 0); + void IncrementalInit(IServiceReverseType::Scenario scenario, int nType = 0); sptr service_ = nullptr; }; @@ -89,9 +89,9 @@ void ServiceReverseTest::TearDown() service_ = nullptr; } -void ServiceReverseTest::Init(IServiceReverse::Scenario scenario, int nType) +void ServiceReverseTest::Init(IServiceReverseType::Scenario scenario, int nType) { - if (scenario == IServiceReverse::Scenario::BACKUP) { + if (scenario == IServiceReverseType::Scenario::BACKUP) { if (nType) { service_ = new ServiceReverse(BSessionBackup::Callbacks {.onFileReady = nullptr, .onBundleStarted = nullptr, @@ -128,9 +128,9 @@ void ServiceReverseTest::Init(IServiceReverse::Scenario scenario, int nType) } } -void ServiceReverseTest::IncrementalInit(IServiceReverse::Scenario scenario, int nType) +void ServiceReverseTest::IncrementalInit(IServiceReverseType::Scenario scenario, int nType) { - if (scenario == IServiceReverse::Scenario::BACKUP) { + if (scenario == IServiceReverseType::Scenario::BACKUP) { if (nType) { service_ = new ServiceReverse(BIncrementalBackupSession::Callbacks {.onFileReady = nullptr, .onBundleStarted = nullptr, @@ -179,7 +179,7 @@ HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_BackupOnFileReady_0100, t { GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_BackupOnFileReady_0100"; try { - Init(IServiceReverse::Scenario::BACKUP); + Init(IServiceReverseType::Scenario::BACKUP); if (service_ == nullptr) { GTEST_LOG_(INFO) << "SUB_backup_ServiceReverse_BackupOnFileReady_0100 service_ == nullptr"; @@ -207,7 +207,7 @@ HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_BackupOnFileReady_0101, t { GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_BackupOnFileReady_0101"; try { - Init(IServiceReverse::Scenario::RESTORE); + Init(IServiceReverseType::Scenario::RESTORE); if (service_ == nullptr) { GTEST_LOG_(INFO) << "SUB_backup_ServiceReverse_BackupOnFileReady_0101 service_ == nullptr"; @@ -234,7 +234,7 @@ HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_BackupOnFileReady_0102, t { GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_BackupOnFileReady_0102"; try { - Init(IServiceReverse::Scenario::BACKUP, 1); + Init(IServiceReverseType::Scenario::BACKUP, 1); if (service_ == nullptr) { GTEST_LOG_(INFO) << "SUB_backup_ServiceReverse_BackupOnFileReady_0102 service_ == nullptr"; @@ -261,7 +261,7 @@ HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_BackupOnBundleStarted_010 { GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_BackupOnBundleStarted_0100"; try { - Init(IServiceReverse::Scenario::BACKUP); + Init(IServiceReverseType::Scenario::BACKUP); if (service_ == nullptr) { GTEST_LOG_(INFO) << "SUB_backup_ServiceReverse_BackupOnBundleStarted_0100 service_ == nullptr"; @@ -289,7 +289,7 @@ HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_BackupOnBundleStarted_010 { GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_BackupOnBundleStarted_0101"; try { - Init(IServiceReverse::Scenario::RESTORE); + Init(IServiceReverseType::Scenario::RESTORE); if (service_ == nullptr) { GTEST_LOG_(INFO) << "SUB_backup_ServiceReverse_BackupOnBundleStarted_0101 service_ == nullptr"; @@ -316,7 +316,7 @@ HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_BackupOnBundleStarted_010 { GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_BackupOnBundleStarted_0102"; try { - Init(IServiceReverse::Scenario::BACKUP, 1); + Init(IServiceReverseType::Scenario::BACKUP, 1); if (service_ == nullptr) { GTEST_LOG_(INFO) << "SUB_backup_ServiceReverse_BackupOnBundleStarted_0102 service_ == nullptr"; @@ -343,7 +343,7 @@ HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_BackupOnBundleFinished_01 { GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_BackupOnBundleFinished_0100"; try { - Init(IServiceReverse::Scenario::BACKUP); + Init(IServiceReverseType::Scenario::BACKUP); if (service_ == nullptr) { GTEST_LOG_(INFO) << "SUB_backup_ServiceReverse_BackupOnBundleFinished_0100 service_ == nullptr"; @@ -371,7 +371,7 @@ HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_BackupOnBundleFinished_01 { GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_BackupOnBundleFinished_0101"; try { - Init(IServiceReverse::Scenario::RESTORE); + Init(IServiceReverseType::Scenario::RESTORE); if (service_ == nullptr) { GTEST_LOG_(INFO) << "SUB_backup_ServiceReverse_BackupOnBundleFinished_0101 service_ == nullptr"; @@ -398,7 +398,7 @@ HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_BackupOnBundleFinished_01 { GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_BackupOnBundleFinished_0102"; try { - Init(IServiceReverse::Scenario::BACKUP, 1); + Init(IServiceReverseType::Scenario::BACKUP, 1); if (service_ == nullptr) { GTEST_LOG_(INFO) << "SUB_backup_ServiceReverse_BackupOnBundleFinished_0102 service_ == nullptr"; @@ -425,7 +425,7 @@ HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_BackupOnAllBundlesFinishe { GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_BackupOnAllBundlesFinished_0100"; try { - Init(IServiceReverse::Scenario::BACKUP); + Init(IServiceReverseType::Scenario::BACKUP); if (service_ == nullptr) { GTEST_LOG_(INFO) << "SUB_backup_ServiceReverse_BackupOnAllBundlesFinished_0100 service_ == nullptr"; @@ -453,7 +453,7 @@ HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_BackupOnAllBundlesFinishe { GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_BackupOnAllBundlesFinished_0101"; try { - Init(IServiceReverse::Scenario::RESTORE); + Init(IServiceReverseType::Scenario::RESTORE); if (service_ == nullptr) { GTEST_LOG_(INFO) << "SUB_backup_ServiceReverse_BackupOnAllBundlesFinished_0101 service_ == nullptr"; @@ -480,7 +480,7 @@ HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_BackupOnAllBundlesFinishe { GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_BackupOnAllBundlesFinished_0102"; try { - Init(IServiceReverse::Scenario::BACKUP, 1); + Init(IServiceReverseType::Scenario::BACKUP, 1); if (service_ == nullptr) { GTEST_LOG_(INFO) << "SUB_backup_ServiceReverse_BackupOnAllBundlesFinished_0102 service_ == nullptr"; @@ -507,7 +507,7 @@ HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_RestoreOnFileReady_0100, { GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_RestoreOnFileReady_0100"; try { - Init(IServiceReverse::Scenario::RESTORE); + Init(IServiceReverseType::Scenario::RESTORE); if (service_ == nullptr) { GTEST_LOG_(INFO) << "SUB_backup_ServiceReverse_RestoreOnFileReady_0100 service_ == nullptr"; @@ -535,7 +535,7 @@ HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_RestoreOnFileReady_0101, { GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_RestoreOnFileReady_0101"; try { - Init(IServiceReverse::Scenario::BACKUP); + Init(IServiceReverseType::Scenario::BACKUP); if (service_ == nullptr) { GTEST_LOG_(INFO) << "SUB_backup_ServiceReverse_RestoreOnFileReady_0101 service_ == nullptr"; @@ -562,7 +562,7 @@ HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_RestoreOnFileReady_0102, { GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_RestoreOnFileReady_0102"; try { - Init(IServiceReverse::Scenario::RESTORE, 1); + Init(IServiceReverseType::Scenario::RESTORE, 1); if (service_ == nullptr) { GTEST_LOG_(INFO) << "SUB_backup_ServiceReverse_RestoreOnFileReady_0102 service_ == nullptr"; @@ -589,7 +589,7 @@ HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_RestoreOnBundleStarted_01 { GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_RestoreOnBundleStarted_0100"; try { - Init(IServiceReverse::Scenario::RESTORE); + Init(IServiceReverseType::Scenario::RESTORE); if (service_ == nullptr) { GTEST_LOG_(INFO) << "SUB_backup_ServiceReverse_RestoreOnBundleStarted_0100 service_ == nullptr"; @@ -617,7 +617,7 @@ HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_RestoreOnBundleStarted_01 { GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_RestoreOnBundleStarted_0101"; try { - Init(IServiceReverse::Scenario::BACKUP); + Init(IServiceReverseType::Scenario::BACKUP); if (service_ == nullptr) { GTEST_LOG_(INFO) << "SUB_backup_ServiceReverse_RestoreOnBundleStarted_0101 service_ == nullptr"; @@ -644,7 +644,7 @@ HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_RestoreOnBundleStarted_01 { GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_RestoreOnBundleStarted_0102"; try { - Init(IServiceReverse::Scenario::RESTORE, 1); + Init(IServiceReverseType::Scenario::RESTORE, 1); if (service_ == nullptr) { GTEST_LOG_(INFO) << "SUB_backup_ServiceReverse_RestoreOnBundleStarted_0102 service_ == nullptr"; @@ -671,7 +671,7 @@ HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_RestoreOnBundleFinished_0 { GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_RestoreOnBundleFinished_0100"; try { - Init(IServiceReverse::Scenario::RESTORE); + Init(IServiceReverseType::Scenario::RESTORE); if (service_ == nullptr) { GTEST_LOG_(INFO) << "SUB_backup_ServiceReverse_RestoreOnBundleFinished_0100 service_ == nullptr"; @@ -699,7 +699,7 @@ HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_RestoreOnBundleFinished_0 { GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_RestoreOnBundleFinished_0101"; try { - Init(IServiceReverse::Scenario::BACKUP); + Init(IServiceReverseType::Scenario::BACKUP); if (service_ == nullptr) { GTEST_LOG_(INFO) << "SUB_backup_ServiceReverse_RestoreOnBundleFinished_0101 service_ == nullptr"; @@ -726,7 +726,7 @@ HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_RestoreOnBundleFinished_0 { GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_RestoreOnBundleFinished_0102"; try { - Init(IServiceReverse::Scenario::RESTORE, 1); + Init(IServiceReverseType::Scenario::RESTORE, 1); if (service_ == nullptr) { GTEST_LOG_(INFO) << "SUB_backup_ServiceReverse_RestoreOnBundleFinished_0102 service_ == nullptr"; @@ -753,7 +753,7 @@ HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_RestoreOnAllBundlesFinish { GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_RestoreOnAllBundlesFinished_0100"; try { - Init(IServiceReverse::Scenario::RESTORE); + Init(IServiceReverseType::Scenario::RESTORE); if (service_ == nullptr) { GTEST_LOG_(INFO) << "SUB_backup_ServiceReverse_RestoreOnAllBundlesFinished_0100 service_ == nullptr"; @@ -781,7 +781,7 @@ HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_RestoreOnAllBundlesFinish { GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_RestoreOnAllBundlesFinished_0101"; try { - Init(IServiceReverse::Scenario::BACKUP); + Init(IServiceReverseType::Scenario::BACKUP); if (service_ == nullptr) { GTEST_LOG_(INFO) << "SUB_backup_ServiceReverse_RestoreOnAllBundlesFinished_0101 service_ == nullptr"; @@ -808,7 +808,7 @@ HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_RestoreOnAllBundlesFinish { GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_RestoreOnAllBundlesFinished_0102"; try { - Init(IServiceReverse::Scenario::RESTORE, 1); + Init(IServiceReverseType::Scenario::RESTORE, 1); if (service_ == nullptr) { GTEST_LOG_(INFO) << "SUB_backup_ServiceReverse_RestoreOnAllBundlesFinished_0102 service_ == nullptr"; @@ -835,7 +835,7 @@ HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_BackupOnProcessInfo_0100, { GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_BackupOnProcessInfo_0100"; try { - Init(IServiceReverse::Scenario::BACKUP); + Init(IServiceReverseType::Scenario::BACKUP); if (service_ == nullptr) { GTEST_LOG_(INFO) << "SUB_backup_ServiceReverse_BackupOnProcessInfo_0100 service_ == nullptr"; @@ -865,7 +865,7 @@ HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_BackupOnProcessInfo_0101, { GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_BackupOnProcessInfo_0101"; try { - Init(IServiceReverse::Scenario::RESTORE); + Init(IServiceReverseType::Scenario::RESTORE); if (service_ == nullptr) { GTEST_LOG_(INFO) << "SUB_backup_ServiceReverse_BackupOnProcessInfo_0101 service_ == nullptr"; @@ -894,7 +894,7 @@ HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_BackupOnProcessInfo_0102, { GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_BackupOnProcessInfo_0102"; try { - Init(IServiceReverse::Scenario::BACKUP, 1); + Init(IServiceReverseType::Scenario::BACKUP, 1); if (service_ == nullptr) { GTEST_LOG_(INFO) << "SUB_backup_ServiceReverse_BackupOnProcessInfo_0102 service_ == nullptr"; @@ -923,7 +923,7 @@ HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_0200, testing::ext::TestS { GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_0200"; try { - Init(IServiceReverse::Scenario::RESTORE, 1); + Init(IServiceReverseType::Scenario::RESTORE, 1); if (service_ == nullptr) { GTEST_LOG_(INFO) << "SUB_backup_ServiceReverse_0200 service_ == nullptr"; @@ -953,7 +953,7 @@ HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_0201, testing::ext::TestS { GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_0201"; try { - Init(IServiceReverse::Scenario::RESTORE, 0); + Init(IServiceReverseType::Scenario::RESTORE, 0); if (service_ == nullptr) { GTEST_LOG_(INFO) << "SUB_backup_ServiceReverse_0201 service_ == nullptr"; @@ -983,7 +983,7 @@ HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_0300, testing::ext::TestS { GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_0300"; try { - Init(IServiceReverse::Scenario::BACKUP, 1); + Init(IServiceReverseType::Scenario::BACKUP, 1); if (service_ == nullptr) { GTEST_LOG_(INFO) << "SUB_backup_ServiceReverse_0300 service_ == nullptr"; @@ -1013,7 +1013,7 @@ HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_0301, testing::ext::TestS { GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_0301"; try { - Init(IServiceReverse::Scenario::BACKUP, 0); + Init(IServiceReverseType::Scenario::BACKUP, 0); if (service_ == nullptr) { GTEST_LOG_(INFO) << "SUB_backup_ServiceReverse_0301 service_ == nullptr"; @@ -1043,7 +1043,7 @@ HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_IncrementalBackupOnFileRe { GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalBackupOnFileReady_0100"; try { - IncrementalInit(IServiceReverse::Scenario::BACKUP); + IncrementalInit(IServiceReverseType::Scenario::BACKUP); if (service_ == nullptr) { GTEST_LOG_(INFO) << "SUB_backup_ServiceReverse_IncrementalBackupOnFileReady_0100 service_ == nullptr"; @@ -1071,7 +1071,7 @@ HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_IncrementalBackupOnFileRe { GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalBackupOnFileReady_0101"; try { - IncrementalInit(IServiceReverse::Scenario::RESTORE); + IncrementalInit(IServiceReverseType::Scenario::RESTORE); if (service_ == nullptr) { GTEST_LOG_(INFO) << "SUB_backup_ServiceReverse_IncrementalBackupOnFileReady_0101 service_ == nullptr"; @@ -1079,7 +1079,7 @@ HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_IncrementalBackupOnFileRe } service_->IncrementalBackupOnFileReady(BUNDLE_NAME, FILE_NAME, -1, -1, 0); - IncrementalInit(IServiceReverse::Scenario::BACKUP, 1); + IncrementalInit(IServiceReverseType::Scenario::BACKUP, 1); service_->IncrementalBackupOnFileReady(BUNDLE_NAME, FILE_NAME, -1, -1, 0); } catch (...) { EXPECT_TRUE(false); @@ -1103,7 +1103,7 @@ HWTEST_F(ServiceReverseTest, { GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalBackupOnBundleStarted_0100"; try { - IncrementalInit(IServiceReverse::Scenario::BACKUP); + IncrementalInit(IServiceReverseType::Scenario::BACKUP); if (service_ == nullptr) { GTEST_LOG_(INFO) << "SUB_backup_ServiceReverse_IncrementalBackupOnBundleStarted_0100 service_ == nullptr"; @@ -1133,7 +1133,7 @@ HWTEST_F(ServiceReverseTest, { GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalBackupOnBundleStarted_0101"; try { - IncrementalInit(IServiceReverse::Scenario::RESTORE); + IncrementalInit(IServiceReverseType::Scenario::RESTORE); if (service_ == nullptr) { GTEST_LOG_(INFO) << "SUB_backup_ServiceReverse_IncrementalBackupOnBundleStarted_0101 service_ == nullptr"; @@ -1141,7 +1141,7 @@ HWTEST_F(ServiceReverseTest, } service_->IncrementalBackupOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME); - IncrementalInit(IServiceReverse::Scenario::BACKUP, 1); + IncrementalInit(IServiceReverseType::Scenario::BACKUP, 1); service_->IncrementalBackupOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME); } catch (...) { EXPECT_TRUE(false); @@ -1165,7 +1165,7 @@ HWTEST_F(ServiceReverseTest, { GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalBackupOnBundleFinished_0100"; try { - IncrementalInit(IServiceReverse::Scenario::BACKUP); + IncrementalInit(IServiceReverseType::Scenario::BACKUP); if (service_ == nullptr) { GTEST_LOG_(INFO) << "SUB_backup_ServiceReverse_IncrementalBackupOnBundleFinished_0100 service_ == nullptr"; @@ -1195,7 +1195,7 @@ HWTEST_F(ServiceReverseTest, { GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalBackupOnBundleFinished_0101"; try { - IncrementalInit(IServiceReverse::Scenario::RESTORE); + IncrementalInit(IServiceReverseType::Scenario::RESTORE); if (service_ == nullptr) { GTEST_LOG_(INFO) << "SUB_backup_ServiceReverse_IncrementalBackupOnBundleFinished_0101 service_ == nullptr"; @@ -1203,7 +1203,7 @@ HWTEST_F(ServiceReverseTest, } service_->IncrementalBackupOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME); - IncrementalInit(IServiceReverse::Scenario::BACKUP, 1); + IncrementalInit(IServiceReverseType::Scenario::BACKUP, 1); service_->IncrementalBackupOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME); } catch (...) { EXPECT_TRUE(false); @@ -1227,7 +1227,7 @@ HWTEST_F(ServiceReverseTest, { GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalBackupOnAllBundlesFinished_0100"; try { - IncrementalInit(IServiceReverse::Scenario::BACKUP); + IncrementalInit(IServiceReverseType::Scenario::BACKUP); if (service_ == nullptr) { GTEST_LOG_(INFO) << "SUB_backup_ServiceReverse_IncrementalBackupOnAllBundlesFinished_0100 service_ == nullptr"; @@ -1257,7 +1257,7 @@ HWTEST_F(ServiceReverseTest, { GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalBackupOnAllBundlesFinished_0101"; try { - IncrementalInit(IServiceReverse::Scenario::RESTORE); + IncrementalInit(IServiceReverseType::Scenario::RESTORE); if (service_ == nullptr) { GTEST_LOG_(INFO) << "SUB_backup_ServiceReverse_IncrementalBackupOnAllBundlesFinished_0101 service_ == nullptr"; @@ -1265,7 +1265,7 @@ HWTEST_F(ServiceReverseTest, } service_->IncrementalBackupOnAllBundlesFinished(BError(BError::Codes::OK)); - IncrementalInit(IServiceReverse::Scenario::BACKUP, 1); + IncrementalInit(IServiceReverseType::Scenario::BACKUP, 1); service_->IncrementalBackupOnAllBundlesFinished(BError(BError::Codes::OK)); } catch (...) { EXPECT_TRUE(false); @@ -1289,7 +1289,7 @@ HWTEST_F(ServiceReverseTest, { GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalRestoreOnFileReady_0100"; try { - IncrementalInit(IServiceReverse::Scenario::RESTORE); + IncrementalInit(IServiceReverseType::Scenario::RESTORE); if (service_ == nullptr) { GTEST_LOG_(INFO) << "SUB_backup_ServiceReverse_IncrementalRestoreOnFileReady_0100 service_ == nullptr"; @@ -1319,7 +1319,7 @@ HWTEST_F(ServiceReverseTest, { GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalRestoreOnFileReady_0101"; try { - IncrementalInit(IServiceReverse::Scenario::BACKUP); + IncrementalInit(IServiceReverseType::Scenario::BACKUP); if (service_ == nullptr) { GTEST_LOG_(INFO) << "SUB_backup_ServiceReverse_IncrementalRestoreOnFileReady_0101 service_ == nullptr"; @@ -1327,7 +1327,7 @@ HWTEST_F(ServiceReverseTest, } service_->IncrementalRestoreOnFileReady(BUNDLE_NAME, FILE_NAME, -1, -1, 0); - IncrementalInit(IServiceReverse::Scenario::RESTORE, 1); + IncrementalInit(IServiceReverseType::Scenario::RESTORE, 1); service_->IncrementalRestoreOnFileReady(BUNDLE_NAME, FILE_NAME, -1, -1, 0); } catch (...) { EXPECT_TRUE(false); @@ -1351,7 +1351,7 @@ HWTEST_F(ServiceReverseTest, { GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalRestoreOnBundleStarted_0100"; try { - IncrementalInit(IServiceReverse::Scenario::RESTORE); + IncrementalInit(IServiceReverseType::Scenario::RESTORE); if (service_ == nullptr) { GTEST_LOG_(INFO) << "SUB_backup_ServiceReverse_IncrementalRestoreOnBundleStarted_0100 service_ == nullptr"; @@ -1381,7 +1381,7 @@ HWTEST_F(ServiceReverseTest, { GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalRestoreOnBundleStarted_0101"; try { - IncrementalInit(IServiceReverse::Scenario::BACKUP); + IncrementalInit(IServiceReverseType::Scenario::BACKUP); if (service_ == nullptr) { GTEST_LOG_(INFO) << "SUB_backup_ServiceReverse_IncrementalRestoreOnBundleStarted_0101 service_ == nullptr"; @@ -1389,7 +1389,7 @@ HWTEST_F(ServiceReverseTest, } service_->IncrementalRestoreOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME); - IncrementalInit(IServiceReverse::Scenario::RESTORE, 1); + IncrementalInit(IServiceReverseType::Scenario::RESTORE, 1); service_->IncrementalRestoreOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME); } catch (...) { EXPECT_TRUE(false); @@ -1413,7 +1413,7 @@ HWTEST_F(ServiceReverseTest, { GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalRestoreOnBundleFinished_0100"; try { - IncrementalInit(IServiceReverse::Scenario::RESTORE); + IncrementalInit(IServiceReverseType::Scenario::RESTORE); if (service_ == nullptr) { GTEST_LOG_(INFO) << "SUB_backup_ServiceReverse_IncrementalRestoreOnBundleFinished_0100 service_ == nullptr"; @@ -1443,7 +1443,7 @@ HWTEST_F(ServiceReverseTest, { GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalRestoreOnBundleFinished_0101"; try { - IncrementalInit(IServiceReverse::Scenario::BACKUP); + IncrementalInit(IServiceReverseType::Scenario::BACKUP); if (service_ == nullptr) { GTEST_LOG_(INFO) << "SUB_backup_ServiceReverse_IncrementalRestoreOnBundleFinished_0101 service_ == nullptr"; @@ -1451,7 +1451,7 @@ HWTEST_F(ServiceReverseTest, } service_->IncrementalRestoreOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME); - IncrementalInit(IServiceReverse::Scenario::RESTORE, 1); + IncrementalInit(IServiceReverseType::Scenario::RESTORE, 1); service_->IncrementalRestoreOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME); } catch (...) { EXPECT_TRUE(false); @@ -1476,7 +1476,7 @@ HWTEST_F(ServiceReverseTest, GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalRestoreOnAllBundlesFinished_0100"; try { - IncrementalInit(IServiceReverse::Scenario::RESTORE); + IncrementalInit(IServiceReverseType::Scenario::RESTORE); if (service_ == nullptr) { GTEST_LOG_(INFO) << "SUB_backup_ServiceReverse_IncrementalRestoreOnAllBundlesFinished_0100 service_ == nullptr"; @@ -1507,7 +1507,7 @@ HWTEST_F(ServiceReverseTest, GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalRestoreOnAllBundlesFinished_0101"; try { - IncrementalInit(IServiceReverse::Scenario::BACKUP); + IncrementalInit(IServiceReverseType::Scenario::BACKUP); if (service_ == nullptr) { GTEST_LOG_(INFO) << "SUB_backup_ServiceReverse_IncrementalRestoreOnAllBundlesFinished_0101 service_ == nullptr"; @@ -1515,7 +1515,7 @@ HWTEST_F(ServiceReverseTest, } service_->IncrementalRestoreOnAllBundlesFinished(BError(BError::Codes::OK)); - IncrementalInit(IServiceReverse::Scenario::RESTORE, 1); + IncrementalInit(IServiceReverseType::Scenario::RESTORE, 1); service_->IncrementalRestoreOnAllBundlesFinished(BError(BError::Codes::OK)); } catch (...) { EXPECT_TRUE(false); @@ -1537,7 +1537,7 @@ HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_RestoreOnResultReport_010 { GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_RestoreOnResultReport_0100"; try { - Init(IServiceReverse::Scenario::RESTORE); + Init(IServiceReverseType::Scenario::RESTORE); if (service_ == nullptr) { GTEST_LOG_(INFO) << "SUB_backup_ServiceReverse_RestoreOnResultReport_0100 service_ == nullptr"; return; @@ -1565,7 +1565,7 @@ HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_RestoreOnResultReport_010 { GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_RestoreOnResultReport_0101"; try { - Init(IServiceReverse::Scenario::RESTORE, 1); + Init(IServiceReverseType::Scenario::RESTORE, 1); if (service_ == nullptr) { GTEST_LOG_(INFO) << "SUB_backup_ServiceReverse_RestoreOnResultReport_0101 service_ == nullptr"; return; @@ -1594,14 +1594,14 @@ HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_IncrementalRestoreOnResul { GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalRestoreOnResultReport_0100"; try { - IncrementalInit(IServiceReverse::Scenario::RESTORE); + IncrementalInit(IServiceReverseType::Scenario::RESTORE); if (service_ == nullptr) { GTEST_LOG_(INFO) << "SUB_backup_ServiceReverse_IncrementalRestoreOnResultReport_0100 service_ == nullptr"; return; } std::string resultReport = "result_report"; std::string bundleName = BUNDLE_NAME; - service_->IncrementalRestoreOnResultReport(resultReport, bundleName); + service_->IncrementalRestoreOnResultReport(resultReport, bundleName, 0); } catch (...) { EXPECT_TRUE(false); GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by IncrementalRestoreOnResultReport."; @@ -1623,14 +1623,14 @@ HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_IncrementalRestoreOnResul { GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalRestoreOnResultReport_0101"; try { - IncrementalInit(IServiceReverse::Scenario::RESTORE, 1); + IncrementalInit(IServiceReverseType::Scenario::RESTORE, 1); if (service_ == nullptr) { GTEST_LOG_(INFO) << "SUB_backup_ServiceReverse_IncrementalRestoreOnResultReport_0101 service_ == nullptr"; return; } std::string resultReport = "result_report"; std::string bundleName = BUNDLE_NAME; - service_->IncrementalRestoreOnResultReport(resultReport, bundleName); + service_->IncrementalRestoreOnResultReport(resultReport, bundleName, 0); } catch (...) { EXPECT_TRUE(false); GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by IncrementalRestoreOnResultReport."; @@ -1651,7 +1651,7 @@ HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_BackupOnResultReport_0100 { GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_BackupOnResultReport_0100"; try { - Init(IServiceReverse::Scenario::BACKUP); + Init(IServiceReverseType::Scenario::BACKUP); std::string resultReport = "result_report"; std::string bundleName = BUNDLE_NAME; if (service_ == nullptr) { @@ -1679,7 +1679,7 @@ HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_BackupOnResultReport_0101 { GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_BackupOnResultReport_0101"; try { - Init(IServiceReverse::Scenario::BACKUP, 1); + Init(IServiceReverseType::Scenario::BACKUP, 1); std::string resultReport = "result_report"; std::string bundleName = BUNDLE_NAME; if (service_ == nullptr) { @@ -1708,7 +1708,7 @@ HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_IncrementalBackupOnResult { GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalBackupOnResultReport_0100"; try { - IncrementalInit(IServiceReverse::Scenario::BACKUP); + IncrementalInit(IServiceReverseType::Scenario::BACKUP); std::string resultReport = "result_report"; std::string bundleName = BUNDLE_NAME; if (service_ == nullptr) { @@ -1737,7 +1737,7 @@ HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_IncrementalBackupOnResult { GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalBackupOnResultReport_0101"; try { - IncrementalInit(IServiceReverse::Scenario::BACKUP, 1); + IncrementalInit(IServiceReverseType::Scenario::BACKUP, 1); std::string resultReport = "result_report"; std::string bundleName = BUNDLE_NAME; if (service_ == nullptr) { @@ -1765,7 +1765,7 @@ HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_BackupOnScanningInfo_0100 { GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_BackupOnScanningInfo_0100"; try { - Init(IServiceReverse::Scenario::BACKUP); + Init(IServiceReverseType::Scenario::BACKUP); if (service_ == nullptr) { GTEST_LOG_(INFO) << "SUB_backup_ServiceReverse_BackupOnScanningInfo_0100 service_ == nullptr"; @@ -1793,7 +1793,7 @@ HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_BackupOnScanningInfo_0101 { GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_BackupOnScanningInfo_0101"; try { - Init(IServiceReverse::Scenario::RESTORE); + Init(IServiceReverseType::Scenario::RESTORE); if (service_ == nullptr) { GTEST_LOG_(INFO) << "SUB_backup_ServiceReverse_BackupOnScanningInfo_0101 service_ == nullptr"; @@ -1822,7 +1822,7 @@ HWTEST_F(ServiceReverseTest, { GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalBackupOnScanningInfo_0100"; try { - Init(IServiceReverse::Scenario::RESTORE); + Init(IServiceReverseType::Scenario::RESTORE); if (service_ == nullptr) { GTEST_LOG_(INFO) << "SUB_backup_ServiceReverse_IncrementalBackupOnScanningInfo_0100 service_ == nullptr"; @@ -1851,7 +1851,7 @@ HWTEST_F(ServiceReverseTest, { GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalBackupOnScanningInfo_0101"; try { - Init(IServiceReverse::Scenario::BACKUP); + Init(IServiceReverseType::Scenario::BACKUP); if (service_ == nullptr) { GTEST_LOG_(INFO) << "SUB_backup_ServiceReverse_IncrementalBackupOnScanningInfo_0101 service_ == nullptr"; diff --git a/tests/unittests/backup_ext/BUILD.gn b/tests/unittests/backup_ext/BUILD.gn index 3257f81f003da9ce5bdfcf3256c5b00b9729a685..6c3468b7ef394ed59f2d79ecf98d63aa473f684f 100644 --- a/tests/unittests/backup_ext/BUILD.gn +++ b/tests/unittests/backup_ext/BUILD.gn @@ -135,7 +135,6 @@ ohos_unittest("tar_file_test") { "${path_backup}/frameworks/native/backup_ext/src/ext_backup_js.cpp", "${path_backup}/frameworks/native/backup_ext/src/ext_backup_loader.cpp", "${path_backup}/frameworks/native/backup_ext/src/ext_extension.cpp", - "${path_backup}/frameworks/native/backup_ext/src/ext_extension_stub.cpp", "${path_backup}/frameworks/native/backup_ext/src/sub_ext_extension.cpp", "${path_backup}/frameworks/native/backup_ext/src/tar_file.cpp", "${path_backup}/frameworks/native/backup_ext/src/untar_file.cpp", @@ -208,7 +207,6 @@ ohos_unittest("untar_file_sup_test") { "${path_backup}/frameworks/native/backup_ext/src/ext_backup_js.cpp", "${path_backup}/frameworks/native/backup_ext/src/ext_backup_loader.cpp", "${path_backup}/frameworks/native/backup_ext/src/ext_extension.cpp", - "${path_backup}/frameworks/native/backup_ext/src/ext_extension_stub.cpp", "${path_backup}/frameworks/native/backup_ext/src/sub_ext_extension.cpp", "${path_backup}/frameworks/native/backup_ext/src/tar_file.cpp", "${path_backup}/tests/mock/library_func_mock/library_func_mock.cpp", @@ -216,12 +214,15 @@ ohos_unittest("untar_file_sup_test") { ] sources += backup_mock_proxy_src + 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}/interfaces/inner_api/native/backup_kit_inner/", "${path_backup}/interfaces/inner_api/native/backup_kit_inner/impl", "${path_backup}/frameworks/native/backup_kit_inner/include", + "${path_backup}/services/backup_sa:backup_sa_ipc", "${path_backup}/tests/mock/library_func_mock", "${path_backup}/utils/include", ] @@ -282,7 +283,6 @@ ohos_unittest("untar_file_test") { "${path_backup}/frameworks/native/backup_ext/src/ext_backup_js.cpp", "${path_backup}/frameworks/native/backup_ext/src/ext_backup_loader.cpp", "${path_backup}/frameworks/native/backup_ext/src/ext_extension.cpp", - "${path_backup}/frameworks/native/backup_ext/src/ext_extension_stub.cpp", "${path_backup}/frameworks/native/backup_ext/src/sub_ext_extension.cpp", "${path_backup}/frameworks/native/backup_ext/src/tar_file.cpp", "${path_backup}/frameworks/native/backup_ext/src/untar_file.cpp", @@ -339,6 +339,17 @@ ohos_unittest("untar_file_test") { ohos_unittest("ext_backup_js_test") { module_out_path = path_module_out_tests + sanitize = { + integer_overflow = true + ubsan = true + boundary_sanitize = true + cfi = true + cfi_cross_dso = true + cfi_vcall_icall_only = true + debug = false + blocklist = "${path_backup}/cfi_blocklist.txt" + } + sources = [ "${path_backup}/tests/mock/backup_ext/src/ext_backup_mock.cpp", "${path_backup}/tests/mock/napi/src/napi_mock.cpp", @@ -436,7 +447,6 @@ group("backup_ext_test") { if (!use_libfuzzer) { deps = [ ":ext_backup_js_test", - ":ext_extension_stub_test", ":ext_extension_test", ":tar_file_sub_test", ":tar_file_test", diff --git a/tests/unittests/backup_ext/ext_extension_stub_test.cpp b/tests/unittests/backup_ext/ext_extension_stub_test.cpp deleted file mode 100644 index 6e07ddd4d1ccb59e9d565c239926e9b31462c8c6..0000000000000000000000000000000000000000 --- a/tests/unittests/backup_ext/ext_extension_stub_test.cpp +++ /dev/null @@ -1,606 +0,0 @@ -/* - * Copyright (c) 2024 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 "b_error/b_error.h" -#include "ext_extension_stub.h" -#include "message_parcel_mock.h" - -namespace OHOS::FileManagement::Backup { -using namespace std; -using namespace testing; - -class ExtExtensionStubMock : public ExtExtensionStub { -public: - MOCK_METHOD(UniqueFd, GetFileHandle, (const std::string &fileName, int32_t &errCode)); - MOCK_METHOD(ErrCode, HandleClear, ()); - MOCK_METHOD(ErrCode, HandleBackup, (bool isClearData)); - MOCK_METHOD(ErrCode, PublishFile, (const std::string &fileName)); - MOCK_METHOD(ErrCode, HandleRestore, (bool isClearData)); - MOCK_METHOD((std::tuple), GetIncrementalFileHandle, (const std::string &fileName)); - MOCK_METHOD(ErrCode, PublishIncrementalFile, (const std::string &fileName)); - MOCK_METHOD(ErrCode, HandleIncrementalBackup, (UniqueFd incrementalFd, UniqueFd manifestFd)); - MOCK_METHOD(ErrCode, IncrementalOnBackup, (bool isClearData)); - MOCK_METHOD((std::tuple), GetIncrementalBackupFileHandle, ()); - MOCK_METHOD(ErrCode, GetBackupInfo, (std::string &result)); - MOCK_METHOD(ErrCode, UpdateFdSendRate, (std::string &bundleName, int32_t sendRate)); - MOCK_METHOD(ErrCode, User0OnBackup, ()); -}; - -class ExtExtensionStubTest : public testing::Test { -public: - //所有测试用例执行之前执行 - static void SetUpTestCase(void); - //所有测试用例执行之后执行 - static void TearDownTestCase(void); - //每次测试用例执行之前执行 - void SetUp() {}; - //每次测试用例执行之后执行 - void TearDown() {}; -public: - static inline shared_ptr stub = nullptr; - static inline shared_ptr messageParcelMock = nullptr; -}; - -void ExtExtensionStubTest::SetUpTestCase() -{ - stub = make_shared(); - messageParcelMock = make_shared(); - MessageParcelMock::messageParcel = messageParcelMock; -} - -void ExtExtensionStubTest::TearDownTestCase() -{ - stub = nullptr; - MessageParcelMock::messageParcel = nullptr; - messageParcelMock = nullptr; -} - -/** - * @tc.number: SUB_backup_ext_ExtExtensionStub_OnRemoteRequest_0100 - * @tc.name: SUB_backup_ext_ExtExtensionStub_OnRemoteRequest_0100 - * @tc.desc: 测试 OnRemoteRequest 各个分支成功与失败 - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: issuesI9QWK5 - */ -HWTEST_F(ExtExtensionStubTest, SUB_backup_ext_ExtExtensionStub_OnRemoteRequest_0100, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "ExtExtensionStubTest-begin SUB_backup_ext_ExtExtensionStub_OnRemoteRequest_0100"; - try { - ASSERT_TRUE(stub != nullptr); - uint32_t code = 0; - MessageParcel data; - MessageParcel reply; - MessageOption option; - EXPECT_CALL(*messageParcelMock, ReadInterfaceToken()).WillOnce(Return(u16string())); - auto err = stub->OnRemoteRequest(code, data, reply, option); - EXPECT_EQ(err, BError(BError::Codes::EXT_INVAL_ARG)); - - const std::u16string descriptor = ExtExtensionStub::GetDescriptor(); - EXPECT_CALL(*messageParcelMock, ReadInterfaceToken()).WillOnce(Return(descriptor)); - EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(false)); - err = stub->OnRemoteRequest(static_cast(IExtensionInterfaceCode::CMD_GET_FILE_HANDLE), - data, reply, option); - EXPECT_EQ(err, BError(BError::Codes::EXT_INVAL_ARG)); - - EXPECT_CALL(*messageParcelMock, ReadInterfaceToken()).WillOnce(Return(descriptor)); - auto ret = stub->OnRemoteRequest(-1, data, reply, option); - EXPECT_EQ(ret, IPC_STUB_UNKNOW_TRANS_ERR); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ExtExtensionStubTest-an exception occurred by OnRemoteRequest."; - } - GTEST_LOG_(INFO) << "ExtExtensionStubTest-end SUB_backup_ext_ExtExtensionStub_OnRemoteRequest_0100"; -} - -/** - * @tc.number: SUB_backup_ext_ExtExtensionStub_CmdGetFileHandle_0100 - * @tc.name: SUB_backup_ext_ExtExtensionStub_CmdGetFileHandle_0100 - * @tc.desc: 测试 CmdGetFileHandle 各个分支成功与失败 - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: issuesI9QWK5 - */ -HWTEST_F(ExtExtensionStubTest, SUB_backup_ext_ExtExtensionStub_CmdGetFileHandle_0100, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "ExtExtensionStubTest-begin SUB_backup_ext_ExtExtensionStub_CmdGetFileHandle_0100"; - try { - ASSERT_TRUE(stub != nullptr); - MessageParcel data; - MessageParcel reply; - EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(false)); - auto err = stub->CmdGetFileHandle(data, reply); - EXPECT_EQ(err, BError(BError::Codes::EXT_INVAL_ARG)); - - EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true)); - EXPECT_CALL(*stub, GetFileHandle(_, _)).WillOnce(Return(UniqueFd(-1))); - EXPECT_CALL(*messageParcelMock, WriteBool(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(true)); - err = stub->CmdGetFileHandle(data, reply); - EXPECT_EQ(err, BError(BError::Codes::OK)); - - EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true)); - EXPECT_CALL(*stub, GetFileHandle(_, _)).WillOnce(Return(UniqueFd(0))); - EXPECT_CALL(*messageParcelMock, WriteBool(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock, WriteFileDescriptor(_)).WillOnce(Return(false)); - err = stub->CmdGetFileHandle(data, reply); - EXPECT_EQ(err, BError(BError::Codes::EXT_BROKEN_IPC)); - - EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true)); - EXPECT_CALL(*stub, GetFileHandle(_, _)).WillOnce(Return(UniqueFd(0))); - EXPECT_CALL(*messageParcelMock, WriteBool(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock, WriteFileDescriptor(_)).WillOnce(Return(true)); - err = stub->CmdGetFileHandle(data, reply); - EXPECT_EQ(err, BError(BError::Codes::OK)); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ExtExtensionStubTest-an exception occurred by CmdGetFileHandle."; - } - GTEST_LOG_(INFO) << "ExtExtensionStubTest-end SUB_backup_ext_ExtExtensionStub_CmdGetFileHandle_0100"; -} - -/** - * @tc.number: SUB_backup_ext_ExtExtensionStub_CmdHandleClear_0100 - * @tc.name: SUB_backup_ext_ExtExtensionStub_CmdHandleClear_0100 - * @tc.desc: 测试 CmdHandleClear 各个分支成功与失败 - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: issuesI9QWK5 - */ -HWTEST_F(ExtExtensionStubTest, SUB_backup_ext_ExtExtensionStub_CmdHandleClear_0100, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "ExtExtensionStubTest-begin SUB_backup_ext_ExtExtensionStub_CmdHandleClear_0100"; - try { - ASSERT_TRUE(stub != nullptr); - MessageParcel data; - MessageParcel reply; - EXPECT_CALL(*stub, HandleClear()).WillOnce(Return(0)); - EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(false)); - auto err = stub->CmdHandleClear(data, reply); - EXPECT_EQ(err, BError(BError::Codes::EXT_BROKEN_IPC)); - - EXPECT_CALL(*stub, HandleClear()).WillOnce(Return(0)); - EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(true)); - err = stub->CmdHandleClear(data, reply); - EXPECT_EQ(err, BError(BError::Codes::OK)); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ExtExtensionStubTest-an exception occurred by CmdHandleClear."; - } - GTEST_LOG_(INFO) << "ExtExtensionStubTest-end SUB_backup_ext_ExtExtensionStub_CmdHandleClear_0100"; -} - -/** - * @tc.number: SUB_backup_ext_ExtExtensionStub_CmdHandleBackup_0100 - * @tc.name: SUB_backup_ext_ExtExtensionStub_CmdHandleBackup_0100 - * @tc.desc: 测试 CmdHandleBackup 各个分支成功与失败 - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: issuesI9QWK5 - */ -HWTEST_F(ExtExtensionStubTest, SUB_backup_ext_ExtExtensionStub_CmdHandleBackup_0100, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "ExtExtensionStubTest-begin SUB_backup_ext_ExtExtensionStub_CmdHandleBackup_0100"; - try { - ASSERT_TRUE(stub != nullptr); - MessageParcel data; - MessageParcel reply; - EXPECT_CALL(*messageParcelMock, ReadBool()).WillOnce(Return(true)); - EXPECT_CALL(*stub, HandleBackup(_)).WillOnce(Return(0)); - EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(false)); - auto err = stub->CmdHandleBackup(data, reply); - EXPECT_EQ(err, BError(BError::Codes::EXT_BROKEN_IPC)); - - EXPECT_CALL(*messageParcelMock, ReadBool()).WillOnce(Return(true)); - EXPECT_CALL(*stub, HandleBackup(_)).WillOnce(Return(0)); - EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(true)); - err = stub->CmdHandleBackup(data, reply); - EXPECT_EQ(err, BError(BError::Codes::OK)); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ExtExtensionStubTest-an exception occurred by CmdHandleBackup."; - } - GTEST_LOG_(INFO) << "ExtExtensionStubTest-end SUB_backup_ext_ExtExtensionStub_CmdHandleBackup_0100"; -} - -/** - * @tc.number: SUB_backup_ext_ExtExtensionStub_CmdPublishFile_0100 - * @tc.name: SUB_backup_ext_ExtExtensionStub_CmdPublishFile_0100 - * @tc.desc: 测试 CmdPublishFile 各个分支成功与失败 - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: issuesI9QWK5 - */ -HWTEST_F(ExtExtensionStubTest, SUB_backup_ext_ExtExtensionStub_CmdPublishFile_0100, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "ExtExtensionStubTest-begin SUB_backup_ext_ExtExtensionStub_CmdPublishFile_0100"; - try { - ASSERT_TRUE(stub != nullptr); - MessageParcel data; - MessageParcel reply; - EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(false)); - auto err = stub->CmdPublishFile(data, reply); - EXPECT_EQ(err, BError(BError::Codes::EXT_INVAL_ARG)); - - EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true)); - EXPECT_CALL(*stub, PublishFile(_)).WillOnce(Return(0)); - EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(false)); - err = stub->CmdPublishFile(data, reply); - EXPECT_EQ(err, BError(BError::Codes::EXT_BROKEN_IPC)); - - EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true)); - EXPECT_CALL(*stub, PublishFile(_)).WillOnce(Return(0)); - EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(true)); - err = stub->CmdPublishFile(data, reply); - EXPECT_EQ(err, BError(BError::Codes::OK)); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ExtExtensionStubTest-an exception occurred by CmdPublishFile."; - } - GTEST_LOG_(INFO) << "ExtExtensionStubTest-end SUB_backup_ext_ExtExtensionStub_CmdPublishFile_0100"; -} - -/** - * @tc.number: SUB_backup_ext_ExtExtensionStub_CmdHandleRestore_0100 - * @tc.name: SUB_backup_ext_ExtExtensionStub_CmdHandleRestore_0100 - * @tc.desc: 测试 CmdHandleRestore 各个分支成功与失败 - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: issuesI9QWK5 - */ -HWTEST_F(ExtExtensionStubTest, SUB_backup_ext_ExtExtensionStub_CmdHandleRestore_0100, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "ExtExtensionStubTest-begin SUB_backup_ext_ExtExtensionStub_CmdHandleRestore_0100"; - try { - ASSERT_TRUE(stub != nullptr); - MessageParcel data; - MessageParcel reply; - EXPECT_CALL(*messageParcelMock, ReadBool()).WillOnce(Return(true)); - EXPECT_CALL(*stub, HandleRestore(_)).WillOnce(Return(0)); - EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(false)); - auto err = stub->CmdHandleRestore(data, reply); - EXPECT_EQ(err, BError(BError::Codes::EXT_BROKEN_IPC)); - - EXPECT_CALL(*messageParcelMock, ReadBool()).WillOnce(Return(true)); - EXPECT_CALL(*stub, HandleRestore(_)).WillOnce(Return(0)); - EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(true)); - err = stub->CmdHandleRestore(data, reply); - EXPECT_EQ(err, BError(BError::Codes::OK)); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ExtExtensionStubTest-an exception occurred by CmdHandleRestore."; - } - GTEST_LOG_(INFO) << "ExtExtensionStubTest-end SUB_backup_ext_ExtExtensionStub_CmdHandleRestore_0100"; -} - -/** - * @tc.number: SUB_backup_ext_ExtExtensionStub_CmdGetIncrementalFileHandle_0100 - * @tc.name: SUB_backup_ext_ExtExtensionStub_CmdGetIncrementalFileHandle_0100 - * @tc.desc: 测试 CmdGetIncrementalFileHandle 各个分支成功与失败 - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: issuesI9QWK5 - */ -HWTEST_F(ExtExtensionStubTest, SUB_backup_ext_ExtExtensionStub_CmdGetIncrementalFileHandle_0100, - testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "ExtExtensionStubTest-begin SUB_backup_ext_ExtExtensionStub_CmdGetIncrementalFileHandle_0100"; - try { - ASSERT_TRUE(stub != nullptr); - MessageParcel data; - MessageParcel reply; - EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(false)); - auto err = stub->CmdGetIncrementalFileHandle(data, reply); - EXPECT_EQ(err, BError(BError::Codes::EXT_INVAL_ARG)); - - EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true)); - EXPECT_CALL(*stub, GetIncrementalFileHandle(_)).WillOnce(Return(make_tuple(0, UniqueFd(-1), UniqueFd(-1)))); - EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(false)); - err = stub->CmdGetIncrementalFileHandle(data, reply); - EXPECT_EQ(err, BError(BError::Codes::EXT_BROKEN_IPC)); - - EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true)); - EXPECT_CALL(*stub, GetIncrementalFileHandle(_)).WillOnce(Return(make_tuple(0, UniqueFd(-1), UniqueFd(-1)))); - EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock, WriteFileDescriptor(_)).WillOnce(Return(true)).WillOnce(Return(true)); - err = stub->CmdGetIncrementalFileHandle(data, reply); - EXPECT_EQ(err, BError(BError::Codes::OK)); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ExtExtensionStubTest-an exception occurred by CmdGetIncrementalFileHandle."; - } - GTEST_LOG_(INFO) << "ExtExtensionStubTest-end SUB_backup_ext_ExtExtensionStub_CmdGetIncrementalFileHandle_0100"; -} - -/** - * @tc.number: SUB_backup_ext_ExtExtensionStub_CmdPublishIncrementalFile_0100 - * @tc.name: SUB_backup_ext_ExtExtensionStub_CmdPublishIncrementalFile_0100 - * @tc.desc: 测试 CmdPublishIncrementalFile 各个分支成功与失败 - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: issuesI9QWK5 - */ -HWTEST_F(ExtExtensionStubTest, SUB_backup_ext_ExtExtensionStub_CmdPublishIncrementalFile_0100, - testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "ExtExtensionStubTest-begin SUB_backup_ext_ExtExtensionStub_CmdPublishIncrementalFile_0100"; - try { - ASSERT_TRUE(stub != nullptr); - MessageParcel data; - MessageParcel reply; - EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(false)); - auto err = stub->CmdPublishIncrementalFile(data, reply); - EXPECT_EQ(err, BError(BError::Codes::EXT_INVAL_ARG)); - - EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true)); - EXPECT_CALL(*stub, PublishIncrementalFile(_)).WillOnce(Return(0)); - EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(false)); - err = stub->CmdPublishIncrementalFile(data, reply); - EXPECT_EQ(err, BError(BError::Codes::EXT_BROKEN_IPC)); - - EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true)); - EXPECT_CALL(*stub, PublishIncrementalFile(_)).WillOnce(Return(0)); - EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(true)); - err = stub->CmdPublishIncrementalFile(data, reply); - EXPECT_EQ(err, BError(BError::Codes::OK)); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ExtExtensionStubTest-an exception occurred by CmdPublishIncrementalFile."; - } - GTEST_LOG_(INFO) << "ExtExtensionStubTest-end SUB_backup_ext_ExtExtensionStub_CmdPublishIncrementalFile_0100"; -} - -/** - * @tc.number: SUB_backup_ext_ExtExtensionStub_CmdHandleIncrementalBackup_0100 - * @tc.name: SUB_backup_ext_ExtExtensionStub_CmdHandleIncrementalBackup_0100 - * @tc.desc: 测试 CmdHandleIncrementalBackup 各个分支成功与失败 - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: issuesI9QWK5 - */ -HWTEST_F(ExtExtensionStubTest, SUB_backup_ext_ExtExtensionStub_CmdHandleIncrementalBackup_0100, - testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "ExtExtensionStubTest-begin SUB_backup_ext_ExtExtensionStub_CmdHandleIncrementalBackup_0100"; - try { - ASSERT_TRUE(stub != nullptr); - MessageParcel data; - MessageParcel reply; - EXPECT_CALL(*messageParcelMock, ReadFileDescriptor()).WillOnce(Return(0)).WillOnce(Return(0)); - EXPECT_CALL(*stub, HandleIncrementalBackup(_, _)).WillOnce(Return(0)); - EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(false)); - auto err = stub->CmdHandleIncrementalBackup(data, reply); - EXPECT_EQ(err, BError(BError::Codes::EXT_BROKEN_IPC)); - - EXPECT_CALL(*messageParcelMock, ReadFileDescriptor()).WillOnce(Return(0)).WillOnce(Return(0)); - EXPECT_CALL(*stub, HandleIncrementalBackup(_, _)).WillOnce(Return(0)); - EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(true)); - err = stub->CmdHandleIncrementalBackup(data, reply); - EXPECT_EQ(err, BError(BError::Codes::OK)); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ExtExtensionStubTest-an exception occurred by CmdHandleIncrementalBackup."; - } - GTEST_LOG_(INFO) << "ExtExtensionStubTest-end SUB_backup_ext_ExtExtensionStub_CmdHandleIncrementalBackup_0100"; -} - -/** - * @tc.number: SUB_backup_ext_ExtExtensionStub_CmdIncrementalOnBackup_0100 - * @tc.name: SUB_backup_ext_ExtExtensionStub_CmdIncrementalOnBackup_0100 - * @tc.desc: 测试 CmdIncrementalOnBackup 各个分支成功与失败 - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: issuesI9QWK5 - */ -HWTEST_F(ExtExtensionStubTest, SUB_backup_ext_ExtExtensionStub_CmdIncrementalOnBackup_0100, - testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "ExtExtensionStubTest-begin SUB_backup_ext_ExtExtensionStub_CmdIncrementalOnBackup_0100"; - try { - ASSERT_TRUE(stub != nullptr); - MessageParcel data; - MessageParcel reply; - EXPECT_CALL(*messageParcelMock, ReadBool()).WillOnce(Return(true)); - EXPECT_CALL(*stub, IncrementalOnBackup(_)).WillOnce(Return(0)); - EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(false)); - auto err = stub->CmdIncrementalOnBackup(data, reply); - EXPECT_EQ(err, BError(BError::Codes::EXT_BROKEN_IPC)); - - EXPECT_CALL(*messageParcelMock, ReadBool()).WillOnce(Return(true)); - EXPECT_CALL(*stub, IncrementalOnBackup(_)).WillOnce(Return(0)); - EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(true)); - err = stub->CmdIncrementalOnBackup(data, reply); - EXPECT_EQ(err, BError(BError::Codes::OK)); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ExtExtensionStubTest-an exception occurred by CmdIncrementalOnBackup."; - } - GTEST_LOG_(INFO) << "ExtExtensionStubTest-end SUB_backup_ext_ExtExtensionStub_CmdIncrementalOnBackup_0100"; -} - -/** - * @tc.number: SUB_backup_ext_ExtExtensionStub_CmdGetIncrementalBackupFileHandle_0100 - * @tc.name: SUB_backup_ext_ExtExtensionStub_CmdGetIncrementalBackupFileHandle_0100 - * @tc.desc: 测试 CmdGetIncrementalBackupFileHandle 各个分支成功与失败 - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: issuesI9QWK5 - */ -HWTEST_F(ExtExtensionStubTest, SUB_backup_ext_ExtExtensionStub_CmdGetIncrementalBackupFileHandle_0100, - testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << - "ExtExtensionStubTest-begin SUB_backup_ext_ExtExtensionStub_CmdGetIncrementalBackupFileHandle_0100"; - try { - ASSERT_TRUE(stub != nullptr); - MessageParcel data; - MessageParcel reply; - EXPECT_CALL(*stub, GetIncrementalBackupFileHandle()) - .WillOnce(Return(std::tuple(UniqueFd(-1), UniqueFd(-1)))); - EXPECT_CALL(*messageParcelMock, WriteFileDescriptor(_)).WillOnce(Return(false)); - auto err = stub->CmdGetIncrementalBackupFileHandle(data, reply); - EXPECT_EQ(err, BError(BError::Codes::EXT_BROKEN_IPC)); - - EXPECT_CALL(*stub, GetIncrementalBackupFileHandle()) - .WillOnce(Return(std::tuple(UniqueFd(-1), UniqueFd(-1)))); - EXPECT_CALL(*messageParcelMock, WriteFileDescriptor(_)).WillOnce(Return(true)).WillOnce(Return(false)); - err = stub->CmdGetIncrementalBackupFileHandle(data, reply); - EXPECT_EQ(err, BError(BError::Codes::EXT_BROKEN_IPC)); - - EXPECT_CALL(*stub, GetIncrementalBackupFileHandle()) - .WillOnce(Return(std::tuple(UniqueFd(-1), UniqueFd(-1)))); - EXPECT_CALL(*messageParcelMock, WriteFileDescriptor(_)).WillOnce(Return(true)).WillOnce(Return(true)); - err = stub->CmdGetIncrementalBackupFileHandle(data, reply); - EXPECT_EQ(err, BError(BError::Codes::OK)); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ExtExtensionStubTest-an exception occurred by CmdGetIncrementalBackupFileHandle."; - } - GTEST_LOG_(INFO) << - "ExtExtensionStubTest-end SUB_backup_ext_ExtExtensionStub_CmdGetIncrementalBackupFileHandle_0100"; -} - -/** - * @tc.number: SUB_backup_ext_ExtExtensionStub_CmdGetBackupInfo_0100 - * @tc.name: SUB_backup_ext_ExtExtensionStub_CmdGetBackupInfo_0100 - * @tc.desc: 测试 CmdGetBackupInfo 各个分支成功与失败 - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: issuesI9QWK5 - */ -HWTEST_F(ExtExtensionStubTest, SUB_backup_ext_ExtExtensionStub_CmdGetBackupInfo_0100, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "ExtExtensionStubTest-begin SUB_backup_ext_ExtExtensionStub_CmdGetBackupInfo_0100"; - try { - ASSERT_TRUE(stub != nullptr); - MessageParcel data; - MessageParcel reply; - EXPECT_CALL(*stub, GetBackupInfo(_)).WillOnce(Return(0)); - EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(false)); - auto err = stub->CmdGetBackupInfo(data, reply); - EXPECT_EQ(err, BError(BError::Codes::EXT_BROKEN_IPC)); - - EXPECT_CALL(*stub, GetBackupInfo(_)).WillOnce(Return(0)); - EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock, WriteString(_)).WillOnce(Return(false)); - err = stub->CmdGetBackupInfo(data, reply); - EXPECT_EQ(err, BError(BError::Codes::EXT_BROKEN_IPC)); - - EXPECT_CALL(*stub, GetBackupInfo(_)).WillOnce(Return(0)); - EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock, WriteString(_)).WillOnce(Return(true)); - err = stub->CmdGetBackupInfo(data, reply); - EXPECT_EQ(err, BError(BError::Codes::OK)); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ExtExtensionStubTest-an exception occurred by CmdGetBackupInfo."; - } - GTEST_LOG_(INFO) << "ExtExtensionStubTest-end SUB_backup_ext_ExtExtensionStub_CmdGetBackupInfo_0100"; -} - -/** - * @tc.number: SUB_backup_ext_ExtExtensionStub_CmdUpdateSendRate_0100 - * @tc.name: SUB_backup_ext_ExtExtensionStub_CmdUpdateSendRate_0100 - * @tc.desc: 测试 CmdUpdateSendRate 各个分支成功与失败 - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: issuesI9QWK5 - */ -HWTEST_F(ExtExtensionStubTest, SUB_backup_ext_ExtExtensionStub_CmdUpdateSendRate_0100, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "ExtExtensionStubTest-begin SUB_backup_ext_ExtExtensionStub_CmdUpdateSendRate_0100"; - try { - ASSERT_TRUE(stub != nullptr); - MessageParcel data; - MessageParcel reply; - EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(false)); - auto err = stub->CmdUpdateFdSendRate(data, reply); - EXPECT_EQ(err, BError(BError::Codes::EXT_INVAL_ARG)); - - EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock, ReadInt32(_)).WillOnce(Return(false)); - err = stub->CmdUpdateFdSendRate(data, reply); - EXPECT_EQ(err, BError(BError::Codes::EXT_INVAL_ARG)); - - EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock, ReadInt32(_)).WillOnce(Return(true)); - EXPECT_CALL(*stub, UpdateFdSendRate(_, _)).WillOnce(Return(0)); - EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(false)); - err = stub->CmdUpdateFdSendRate(data, reply); - EXPECT_EQ(err, BError(BError::Codes::EXT_BROKEN_IPC)); - - EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock, ReadInt32(_)).WillOnce(Return(true)); - EXPECT_CALL(*stub, UpdateFdSendRate(_, _)).WillOnce(Return(0)); - EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(true)); - err = stub->CmdUpdateFdSendRate(data, reply); - EXPECT_EQ(err, BError(BError::Codes::OK)); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ExtExtensionStubTest-an exception occurred by CmdUpdateSendRate."; - } - GTEST_LOG_(INFO) << "ExtExtensionStubTest-end SUB_backup_ext_ExtExtensionStub_CmdUpdateSendRate_0100"; -} - -/** - * @tc.number: SUB_backup_ext_ExtExtensionStub_CmdUser0_0100 - * @tc.name: SUB_backup_ext_ExtExtensionStub_CmdUser0_0100 - * @tc.desc: 测试 CmdHandleUser0Backup 各个分支成功与失败 - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: issues - */ -HWTEST_F(ExtExtensionStubTest, SUB_backup_ext_ExtExtensionStub_CmdUser0_0100, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "ExtExtensionStubTest-begin SUB_backup_ext_ExtExtensionStub_CmdUser0_0100"; - try { - MessageParcel data; - MessageParcel reply; - EXPECT_CALL(*stub, User0OnBackup()).WillOnce(Return(0)); - EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(false)); - EXPECT_TRUE(stub != nullptr); - auto err = stub->CmdHandleUser0Backup(data, reply); - EXPECT_EQ(err, BError(BError::Codes::EXT_BROKEN_IPC)); - - EXPECT_CALL(*stub, User0OnBackup()).WillOnce(Return(0)); - EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(true)); - err = stub->CmdHandleUser0Backup(data, reply); - EXPECT_EQ(err, BError(BError::Codes::OK)); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ExtExtensionStubTest-an exception occurred by CmdHandleClear."; - } - GTEST_LOG_(INFO) << "ExtExtensionStubTest-end SUB_backup_ext_ExtExtensionStub_CmdUser0_0100"; -} -} // namespace OHOS::FileManagement::Backup \ No newline at end of file diff --git a/tests/unittests/backup_sa/module_app_gallery/BUILD.gn b/tests/unittests/backup_sa/module_app_gallery/BUILD.gn index 24d57884cc146425f1aa3c41ee1cbf93c2c4c106..c0bde1a20604e21b35fccd35c9c69f7257c76751 100644 --- a/tests/unittests/backup_sa/module_app_gallery/BUILD.gn +++ b/tests/unittests/backup_sa/module_app_gallery/BUILD.gn @@ -35,6 +35,7 @@ ohos_unittest("app_gallery_dispose_proxy_test") { deps = [ "${path_backup}/interfaces/inner_api/native/backup_kit_inner:backup_kit_inner", + "${path_backup}/services/backup_sa:backup_sa_ipc", "${path_backup}/tests/utils:backup_test_utils", "${path_backup}/utils:backup_utils", ] diff --git a/tests/unittests/backup_sa/module_ipc/BUILD.gn b/tests/unittests/backup_sa/module_ipc/BUILD.gn index 997f3c46c42f3a98d4033d13d71345645f597ffd..9fec3e0118b11666578da9882a6913635f74e363 100644 --- a/tests/unittests/backup_sa/module_ipc/BUILD.gn +++ b/tests/unittests/backup_sa/module_ipc/BUILD.gn @@ -25,16 +25,8 @@ ohos_unittest("module_ipc_test") { "${path_backup_mock}/module_ipc/message_parcel_mock.cpp", "${path_backup_mock}/timer/timer_mock.cpp", "${path_backup}/frameworks/native/backup_kit_inner/src/service_incremental_reverse.cpp", - "${path_backup}/services/backup_sa/src/module_ipc/sa_backup_connection.cpp", - "${path_backup}/services/backup_sa/src/module_ipc/service_incremental_reverse_proxy.cpp", - "${path_backup}/services/backup_sa/src/module_ipc/service_reverse_proxy.cpp", "${path_backup}/services/backup_sa/src/module_ipc/svc_backup_connection.cpp", - "${path_backup}/services/backup_sa/src/module_ipc/svc_extension_incremental_proxy.cpp", - "${path_backup}/services/backup_sa/src/module_ipc/svc_extension_proxy.cpp", - "sa_backup_connection_test.cpp", - "service_reverse_proxy_test.cpp", "svc_backup_connection_test.cpp", - "svc_extension_proxy_test.cpp", ] include_dirs = [ @@ -104,6 +96,8 @@ ohos_unittest("backup_service_test") { sources += backup_mock_scheduler_src sources += backup_mock_module_external_src + public_configs = [ "${path_backup}/services/backup_sa:public_idl_config" ] + include_dirs = [ "${path_backup}/services/backup_sa/include", "${path_backup}/interfaces/inner_api/native/backup_kit_inner/impl", @@ -114,7 +108,6 @@ ohos_unittest("backup_service_test") { deps = [ "${path_backup}/interfaces/inner_api/native/backup_kit_inner:backup_kit_inner", - "${path_backup}/services/backup_sa:backup_sa_ipc_stub", "${path_backup}/tests/utils:backup_test_utils", "${path_backup}/utils:backup_utils", ] @@ -184,6 +177,8 @@ ohos_unittest("backup_service_throw_test") { sources += backup_mock_scheduler_src sources += backup_mock_module_external_src + public_configs = [ "${path_backup}/services/backup_sa:public_idl_config" ] + include_dirs = [ "${path_backup}/services/backup_sa/include", "${path_backup}/interfaces/inner_api/native/backup_kit_inner/impl", @@ -197,7 +192,6 @@ ohos_unittest("backup_service_throw_test") { deps = [ "${path_backup}/interfaces/inner_api/native/backup_kit_inner:backup_kit_inner", - "${path_backup}/services/backup_sa:backup_sa_ipc_stub", "${path_backup}/tests/utils:backup_test_utils", "${path_backup}/utils:backup_utils", ] @@ -257,6 +251,8 @@ ohos_unittest("backup_service_session_test") { sources += backup_mock_service_src sources += backup_mock_module_external_src + public_configs = [ "${path_backup}/services/backup_sa:public_idl_config" ] + include_dirs = [ "${path_backup}/services/backup_sa/include", "${path_backup}/interfaces/inner_api/native/backup_kit_inner/impl", @@ -267,7 +263,6 @@ ohos_unittest("backup_service_session_test") { deps = [ "${app_file_service_path}/services/backup_sa:backup_sa", "${path_backup}/interfaces/inner_api/native/backup_kit_inner:backup_kit_inner", - "${path_backup}/services/backup_sa:backup_sa_ipc_stub", "${path_backup}/tests/utils:backup_test_utils", "${path_backup}/utils:backup_utils", ] @@ -314,6 +309,8 @@ ohos_unittest("backup_service_scheduler_test") { sources += backup_mock_session_manager_src sources += backup_mock_module_external_src + public_configs = [ "${path_backup}/services/backup_sa:public_idl_config" ] + include_dirs = [ "${path_backup}/services/backup_sa/include", "${path_backup}/interfaces/inner_api/native/backup_kit_inner/impl", @@ -322,7 +319,6 @@ ohos_unittest("backup_service_scheduler_test") { deps = [ "${path_backup}/interfaces/inner_api/native/backup_kit_inner:backup_kit_inner", - "${path_backup}/services/backup_sa:backup_sa_ipc_stub", "${path_backup}/tests/utils:backup_test_utils", "${path_backup}/utils:backup_utils", ] @@ -379,6 +375,8 @@ ohos_unittest("backup_restore_deps_manager_test") { sources += backup_mock_scheduler_src sources += backup_mock_module_external_src + public_configs = [ "${path_backup}/services/backup_sa:public_idl_config" ] + include_dirs = [ "${path_backup}/services/backup_sa/include", "${path_backup}/interfaces/inner_api/native/backup_kit_inner/impl", @@ -388,7 +386,6 @@ ohos_unittest("backup_restore_deps_manager_test") { deps = [ "${path_backup}/interfaces/inner_api/native/backup_kit_inner:backup_kit_inner", - "${path_backup}/services/backup_sa:backup_sa_ipc_stub", "${path_backup}/tests/utils:backup_test_utils", "${path_backup}/utils:backup_utils", ] @@ -419,6 +416,17 @@ ohos_unittest("backup_restore_deps_manager_test") { ohos_unittest("backup_service_incremental_test") { module_out_path = path_module_out_tests + sanitize = { + integer_overflow = true + ubsan = true + boundary_sanitize = true + cfi = true + cfi_cross_dso = true + cfi_vcall_icall_only = true + debug = false + blocklist = "${path_backup}/cfi_blocklist.txt" + } + sources = [ "${path_backup_mock}/accesstoken/accesstoken_kit_mock.cpp", "${path_backup_mock}/module_external/src/bms_adapter_mock.cpp", @@ -432,11 +440,11 @@ ohos_unittest("backup_service_incremental_test") { "${path_backup_mock}/utils_mock/src/b_jsonutil_mock.cpp", "${path_backup_mock}/utils_mock/src/backup_para_mock.cpp", "${path_backup}/frameworks/native/backup_kit_inner/src/service_client.cpp", - "${path_backup}/services/backup_sa/src/module_ipc/svc_extension_incremental_proxy.cpp", - "${path_backup}/services/backup_sa/src/module_ipc/svc_extension_proxy.cpp", "service_incremental_test.cpp", ] + public_configs = [ "${path_backup}/services/backup_sa:public_idl_config" ] + include_dirs = [ "${path_backup}/interfaces/inner_api/native/backup_kit_inner/impl", "${path_backup}/services/backup_sa/include", @@ -451,7 +459,6 @@ ohos_unittest("backup_service_incremental_test") { deps = [ "${path_backup}/interfaces/inner_api/native/backup_kit_inner:backup_kit_inner", - "${path_backup}/services/backup_sa:backup_sa_ipc_stub", "${path_backup}/tests/utils:backup_test_utils", "${path_backup}/utils:backup_utils", ] @@ -483,6 +490,16 @@ ohos_unittest("backup_service_incremental_test") { ohos_unittest("backup_service_other_test") { module_out_path = path_module_out_tests + sanitize = { + integer_overflow = true + ubsan = true + boundary_sanitize = true + cfi = true + cfi_cross_dso = true + cfi_vcall_icall_only = true + debug = false + blocklist = "${path_backup}/cfi_blocklist.txt" + } sources = [ "${path_backup_mock}/accesstoken/src/accesstoken_kit_mock.cpp", "${path_backup_mock}/module_external/src/bms_adapter_mock.cpp", @@ -502,8 +519,6 @@ ohos_unittest("backup_service_other_test") { "${path_backup_mock}/utils_mock/src/b_jsonutil_mock.cpp", "${path_backup_mock}/utils_mock/src/b_sa_utils_mock.cpp", "${path_backup_mock}/utils_mock/src/backup_para_mock.cpp", - "${path_backup}/services/backup_sa/src/module_ipc/svc_extension_incremental_proxy.cpp", - "${path_backup}/services/backup_sa/src/module_ipc/svc_extension_proxy.cpp", "service_other_test.cpp", ] @@ -522,9 +537,10 @@ ohos_unittest("backup_service_other_test") { "${path_backup_mock}/utils_mock/include", ] + public_configs = [ "${path_backup}/services/backup_sa:public_idl_config" ] + deps = [ "${path_backup}/interfaces/inner_api/native/backup_kit_inner:backup_kit_inner", - "${path_backup}/services/backup_sa:backup_sa_ipc_stub", "${path_backup}/tests/utils:backup_test_utils", "${path_backup}/utils:backup_utils", ] diff --git a/tests/unittests/backup_sa/module_ipc/sched_scheduler_test.cpp b/tests/unittests/backup_sa/module_ipc/sched_scheduler_test.cpp index 505e0eb577076c7510f55349b957c7e1164d4034..788616b821116ef47a81915196441e250d9222a3 100644 --- a/tests/unittests/backup_sa/module_ipc/sched_scheduler_test.cpp +++ b/tests/unittests/backup_sa/module_ipc/sched_scheduler_test.cpp @@ -42,7 +42,7 @@ public: static void TearDownTestCase(); void SetUp() override {}; void TearDown() override {}; - void Init(IServiceReverse::Scenario scenario); + void Init(IServiceReverseType::Scenario scenario); static inline sptr schedPtr_ = nullptr; static inline sptr sessionManagerPtr_ = nullptr; @@ -63,7 +63,7 @@ void SchedSchedulerTest::TearDownTestCase() sessionManagerPtr_ = nullptr; } -void SchedSchedulerTest::Init(IServiceReverse::Scenario scenario) +void SchedSchedulerTest::Init(IServiceReverseType::Scenario scenario) { vector bundleNames; map backupExtNameMap; @@ -99,7 +99,7 @@ HWTEST_F(SchedSchedulerTest, SUB_Service_Sched_0100, testing::ext::TestSize.Leve { GTEST_LOG_(INFO) << "SchedSchedulerTest-begin SUB_Service_Sched_0100"; try { - Init(IServiceReverse::Scenario::BACKUP); + Init(IServiceReverseType::Scenario::BACKUP); EXPECT_TRUE(schedPtr_ != nullptr); schedPtr_->Sched(); GTEST_LOG_(INFO) << "SchedSchedulerTest-Sched Branches"; diff --git a/tests/unittests/backup_sa/module_ipc/service_incremental_test.cpp b/tests/unittests/backup_sa/module_ipc/service_incremental_test.cpp index 83c6b708a81216617b9db7a75394b3197859751b..3a9f94ffbe4e8e44067fbb138384e548f69bc62b 100644 --- a/tests/unittests/backup_sa/module_ipc/service_incremental_test.cpp +++ b/tests/unittests/backup_sa/module_ipc/service_incremental_test.cpp @@ -56,7 +56,7 @@ public: virtual ErrCode GetFileHandle(const string&, const string&) = 0; virtual int Dump(int, const vector&) = 0; virtual ErrCode VerifyCaller() = 0; - virtual ErrCode VerifyCaller(IServiceReverse::Scenario) = 0; + virtual ErrCode VerifyCaller(IServiceReverseType::Scenario) = 0; virtual int32_t GetUserIdDefault() = 0; virtual ErrCode GetBackupInfo(const BundleName&, std::string&) = 0; virtual ErrCode UpdateTimer(const BundleName&, uint32_t, bool&) = 0; @@ -110,7 +110,7 @@ public: MOCK_METHOD(ErrCode, GetFileHandle, (const string&, const string&)); MOCK_METHOD(int, Dump, (int, const vector&)); MOCK_METHOD(ErrCode, VerifyCaller, ()); - MOCK_METHOD(ErrCode, VerifyCaller, (IServiceReverse::Scenario)); + MOCK_METHOD(ErrCode, VerifyCaller, (IServiceReverseType::Scenario)); MOCK_METHOD(int32_t, GetUserIdDefault, ()); MOCK_METHOD(ErrCode, GetBackupInfo, (const BundleName&, std::string&)); MOCK_METHOD(ErrCode, UpdateTimer, (const BundleName&, uint32_t, bool&)); @@ -270,7 +270,7 @@ ErrCode Service::VerifyCaller() return BService::serviceMock->VerifyCaller(); } -ErrCode Service::VerifyCaller(IServiceReverse::Scenario scenario) +ErrCode Service::VerifyCaller(IServiceReverseType::Scenario scenario) { return BService::serviceMock->VerifyCaller(scenario); } @@ -365,14 +365,14 @@ void Service::OnBundleStarted(BError, sptr, const BundleName& void Service::HandleExceptionOnAppendBundles(sptr, const vector&, const vector&) {} -void Service::BundleBeginRadarReport(const std::string&, const ErrCode, const IServiceReverse::Scenario) {} +void Service::BundleBeginRadarReport(const std::string&, const ErrCode, const IServiceReverseType::Scenario) {} -void Service::BundleEndRadarReport(const std::string&, const ErrCode, const IServiceReverse::Scenario) {} +void Service::BundleEndRadarReport(const std::string&, const ErrCode, const IServiceReverseType::Scenario) {} void Service::FileReadyRadarReport(const std::string&, const std::string&, const ErrCode, - const IServiceReverse::Scenario) {} + const IServiceReverseType::Scenario) {} -void Service::ExtensionConnectFailRadarReport(const std::string&, const ErrCode, const IServiceReverse::Scenario) {} +void Service::ExtensionConnectFailRadarReport(const std::string&, const ErrCode, const IServiceReverseType::Scenario) {} void Service::PermissionCheckFailRadar(const std::string&, const std::string&) {} @@ -1057,17 +1057,17 @@ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_AppIncrementalFileReady_ int32_t errCode = 0; EXPECT_CALL(*srvMock, VerifyCallerAndGetCallerName(_)) .WillOnce(Return(BError(BError::Codes::OK).GetCode())); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::RESTORE)); EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); - EXPECT_CALL(*srProxy, IncrementalRestoreOnFileReady(_, _, _, _, _)).WillOnce(Return()); + EXPECT_CALL(*srProxy, IncrementalRestoreOnFileReady(_, _, _, _, _)).WillOnce(Return(0)); auto ret = service->AppIncrementalFileReady(fileName, UniqueFd(-1), UniqueFd(-1), errCode); EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode()); EXPECT_CALL(*srvMock, VerifyCallerAndGetCallerName(_)) .WillOnce(Return(BError(BError::Codes::OK).GetCode())); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::BACKUP)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::BACKUP)); EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); - EXPECT_CALL(*srProxy, IncrementalBackupOnFileReady(_, _, _, _, _)).WillOnce(Return()); + EXPECT_CALL(*srProxy, IncrementalBackupOnFileReady(_, _, _, _, _)).WillOnce(Return(0)); EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(false)); ret = service->AppIncrementalFileReady(fileName, UniqueFd(-1), UniqueFd(-1), errCode); EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode()); @@ -1075,10 +1075,10 @@ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_AppIncrementalFileReady_ fileName = BConstants::EXT_BACKUP_MANAGE; EXPECT_CALL(*srvMock, VerifyCallerAndGetCallerName(_)) .WillOnce(Return(BError(BError::Codes::OK).GetCode())); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::BACKUP)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::BACKUP)); EXPECT_CALL(*session, OnBundleExtManageInfo(_, _)).WillOnce(Return(UniqueFd(-1))); EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); - EXPECT_CALL(*srProxy, IncrementalBackupOnFileReady(_, _, _, _, _)).WillOnce(Return()); + EXPECT_CALL(*srProxy, IncrementalBackupOnFileReady(_, _, _, _, _)).WillOnce(Return(0)); EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(false)); ret = service->AppIncrementalFileReady(fileName, UniqueFd(-1), UniqueFd(-1), errCode); EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode()); @@ -1107,9 +1107,9 @@ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_AppIncrementalFileReady_ int32_t errCode = 0; EXPECT_CALL(*srvMock, VerifyCallerAndGetCallerName(_)) .WillOnce(Return(BError(BError::Codes::SA_INVAL_ARG).GetCode())); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::BACKUP)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::BACKUP)); EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); - EXPECT_CALL(*srProxy, IncrementalBackupOnFileReady(_, _, _, _, _)).WillOnce(Return()); + EXPECT_CALL(*srProxy, IncrementalBackupOnFileReady(_, _, _, _, _)).WillOnce(Return(0)); EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(true)); EXPECT_CALL(*srvMock, HandleCurBundleFileReady(_, _, _)) .WillOnce(Return(BError(BError::Codes::SA_INVAL_ARG).GetCode())); @@ -1119,10 +1119,10 @@ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_AppIncrementalFileReady_ fileName = BConstants::EXT_BACKUP_MANAGE; EXPECT_CALL(*srvMock, VerifyCallerAndGetCallerName(_)) .WillOnce(Return(BError(BError::Codes::OK).GetCode())); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::BACKUP)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::BACKUP)); EXPECT_CALL(*session, OnBundleExtManageInfo(_, _)).WillOnce(Return(UniqueFd(-1))); EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); - EXPECT_CALL(*srProxy, IncrementalBackupOnFileReady(_, _, _, _, _)).WillOnce(Return()); + EXPECT_CALL(*srProxy, IncrementalBackupOnFileReady(_, _, _, _, _)).WillOnce(Return(0)); EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(true)); EXPECT_CALL(*srvMock, HandleCurBundleFileReady(_, _, _)).WillOnce(Return(BError(BError::Codes::OK).GetCode())); ret = service->AppIncrementalFileReady(fileName, UniqueFd(-1), UniqueFd(-1), errCode); @@ -1155,26 +1155,26 @@ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_AppIncrementalFileReady_ EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode()); EXPECT_CALL(*srvMock, VerifyCallerAndGetCallerName(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode())); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::RESTORE)); EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); - EXPECT_CALL(*srProxy, IncrementalRestoreOnFileReady(_, _, _, _, _)).WillOnce(Return()); + EXPECT_CALL(*srProxy, IncrementalRestoreOnFileReady(_, _, _, _, _)).WillOnce(Return(0)); ret = service->AppIncrementalFileReady(fileName, UniqueFd(-1), UniqueFd(-1), errCode); EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode()); EXPECT_CALL(*srvMock, VerifyCallerAndGetCallerName(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode())); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::BACKUP)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::BACKUP)); EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); - EXPECT_CALL(*srProxy, IncrementalBackupOnFileReady(_, _, _, _, _)).WillOnce(Return()); + EXPECT_CALL(*srProxy, IncrementalBackupOnFileReady(_, _, _, _, _)).WillOnce(Return(0)); EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(false)); ret = service->AppIncrementalFileReady(fileName, UniqueFd(-1), UniqueFd(-1), errCode); EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode()); fileName = BConstants::EXT_BACKUP_MANAGE; EXPECT_CALL(*srvMock, VerifyCallerAndGetCallerName(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode())); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::BACKUP)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::BACKUP)); EXPECT_CALL(*session, OnBundleExtManageInfo(_, _)).WillOnce(Return(UniqueFd(-1))); EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); - EXPECT_CALL(*srProxy, IncrementalBackupOnFileReady(_, _, _, _, _)).WillOnce(Return()); + EXPECT_CALL(*srProxy, IncrementalBackupOnFileReady(_, _, _, _, _)).WillOnce(Return(0)); EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(false)); ret = service->AppIncrementalFileReady(fileName, UniqueFd(-1), UniqueFd(-1), errCode); EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode()); @@ -1201,9 +1201,9 @@ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_AppIncrementalFileReady_ string fileName; int32_t errCode = 0; EXPECT_CALL(*srvMock, VerifyCallerAndGetCallerName(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode())); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::BACKUP)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::BACKUP)); EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); - EXPECT_CALL(*srProxy, IncrementalBackupOnFileReady(_, _, _, _, _)).WillOnce(Return()); + EXPECT_CALL(*srProxy, IncrementalBackupOnFileReady(_, _, _, _, _)).WillOnce(Return(0)); EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(true)); EXPECT_CALL(*srvMock, HandleCurBundleFileReady(_, _, _)) .WillOnce(Return(BError(BError::Codes::SA_INVAL_ARG).GetCode())); @@ -1212,10 +1212,10 @@ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_AppIncrementalFileReady_ fileName = BConstants::EXT_BACKUP_MANAGE; EXPECT_CALL(*srvMock, VerifyCallerAndGetCallerName(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode())); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::BACKUP)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::BACKUP)); EXPECT_CALL(*session, OnBundleExtManageInfo(_, _)).WillOnce(Return(UniqueFd(-1))); EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); - EXPECT_CALL(*srProxy, IncrementalBackupOnFileReady(_, _, _, _, _)).WillOnce(Return()); + EXPECT_CALL(*srProxy, IncrementalBackupOnFileReady(_, _, _, _, _)).WillOnce(Return(0)); EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(true)); EXPECT_CALL(*srvMock, HandleCurBundleFileReady(_, _, _)).WillOnce(Return(BError(BError::Codes::OK).GetCode())); ret = service->AppIncrementalFileReady(fileName, UniqueFd(-1), UniqueFd(-1), errCode); @@ -1352,10 +1352,10 @@ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_GetIncrementalFileHandle EXPECT_CALL(*session, GetServiceSchedAction(_)).WillOnce(Return(BConstants::ServiceSchedAction::RUNNING)); EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect)); EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy)); - EXPECT_CALL(*svcProxy, GetIncrementalFileHandle(_)).WillOnce(Return(make_tuple(0, UniqueFd(-1), UniqueFd(-1)))); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::BACKUP)); + EXPECT_CALL(*svcProxy, GetIncrementalFileHandle(_, _)).WillOnce(Return(0)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::BACKUP)); EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); - EXPECT_CALL(*srProxy, IncrementalBackupOnFileReady(_, _, _, _, _)).WillOnce(Return()); + EXPECT_CALL(*srProxy, IncrementalBackupOnFileReady(_, _, _, _, _)).WillOnce(Return(0)); EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(true)); EXPECT_CALL(*srvMock, HandleCurBundleFileReady(_, _, _)) .WillOnce(Return(BError(BError::Codes::SA_INVAL_ARG).GetCode())); @@ -1367,10 +1367,10 @@ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_GetIncrementalFileHandle EXPECT_CALL(*session, GetServiceSchedAction(_)).WillOnce(Return(BConstants::ServiceSchedAction::RUNNING)); EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect)); EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy)); - EXPECT_CALL(*svcProxy, GetIncrementalFileHandle(_)).WillOnce(Return(make_tuple(0, UniqueFd(-1), UniqueFd(-1)))); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); + EXPECT_CALL(*svcProxy, GetIncrementalFileHandle(_, _)).WillOnce(Return(0)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::RESTORE)); EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); - EXPECT_CALL(*srProxy, IncrementalRestoreOnFileReady(_, _, _, _, _)).WillOnce(Return()); + EXPECT_CALL(*srProxy, IncrementalRestoreOnFileReady(_, _, _, _, _)).WillOnce(Return(0)); ret = service->GetIncrementalFileHandle(bundleName, fileName); EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode()); @@ -1400,41 +1400,41 @@ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_IncrementalBackup_0000, GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_IncrementalBackup_0000"; try { string bundleName; - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)); EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(nullptr)); EXPECT_TRUE(service->IncrementalBackup(bundleName)); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)); EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect)); EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(nullptr)); EXPECT_TRUE(service->IncrementalBackup(bundleName)); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)); EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect)); EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy)); EXPECT_FALSE(service->IncrementalBackup(bundleName)); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::BACKUP)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::BACKUP)); EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect)); EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy)); EXPECT_CALL(*session, GetIsIncrementalBackup()).WillOnce(Return(true)); EXPECT_CALL(*session, GetClearDataFlag(_)).WillOnce(Return(false)); EXPECT_CALL(*svcProxy, IncrementalOnBackup(_)).WillOnce(Return(0)); EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); - EXPECT_CALL(*srProxy, IncrementalBackupOnBundleStarted(_, _)).WillOnce(Return()); + EXPECT_CALL(*srProxy, IncrementalBackupOnBundleStarted(_, _)).WillOnce(Return(0)); EXPECT_TRUE(service->IncrementalBackup(bundleName)); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::BACKUP)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::BACKUP)); EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect)); EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy)); EXPECT_CALL(*session, GetIsIncrementalBackup()).WillOnce(Return(true)); EXPECT_CALL(*session, GetClearDataFlag(_)).WillOnce(Return(false)); EXPECT_CALL(*svcProxy, IncrementalOnBackup(_)).WillOnce(Return(1)); EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); - EXPECT_CALL(*srProxy, IncrementalBackupOnBundleStarted(_, _)).WillOnce(Return()); + EXPECT_CALL(*srProxy, IncrementalBackupOnBundleStarted(_, _)).WillOnce(Return(0)); EXPECT_TRUE(service->IncrementalBackup(bundleName)); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::BACKUP)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::BACKUP)); EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect)); EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy)); EXPECT_CALL(*session, GetIsIncrementalBackup()).WillOnce(Return(false)); @@ -1460,13 +1460,13 @@ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_IncrementalBackup_0100, GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_IncrementalBackup_0100"; try { string bundleName; - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::RESTORE)); EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect)); EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy)); EXPECT_CALL(*param, GetBackupOverrideIncrementalRestore()).WillOnce(Return(false)); EXPECT_FALSE(service->IncrementalBackup(bundleName)); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::RESTORE)); EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect)); EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy)); EXPECT_CALL(*param, GetBackupOverrideIncrementalRestore()).WillOnce(Return(true)); @@ -1474,8 +1474,8 @@ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_IncrementalBackup_0100, EXPECT_FALSE(service->IncrementalBackup(bundleName)); set fileNameVec { "fileName" }; - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)) - .WillOnce(Return(IServiceReverse::Scenario::RESTORE)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::RESTORE)) + .WillOnce(Return(IServiceReverseType::Scenario::RESTORE)); EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect)); EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy)); EXPECT_CALL(*param, GetBackupOverrideIncrementalRestore()).WillOnce(Return(true)); @@ -1483,12 +1483,11 @@ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_IncrementalBackup_0100, EXPECT_CALL(*session, GetClearDataFlag(_)).WillOnce(Return(false)); EXPECT_CALL(*svcProxy, HandleRestore(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode())); EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)).WillOnce(Return(srProxy)); - EXPECT_CALL(*srProxy, IncrementalRestoreOnBundleStarted(_, _)).WillOnce(Return()); + EXPECT_CALL(*srProxy, IncrementalRestoreOnBundleStarted(_, _)).WillOnce(Return(0)); EXPECT_CALL(*session, GetOldBackupVersion()).WillOnce(Return("")); EXPECT_CALL(*session, GetExtFileNameRequest(_)).WillOnce(Return(fileNameVec)); - EXPECT_CALL(*svcProxy, GetIncrementalFileHandle(_)) - .WillOnce(Return(make_tuple(BError(BError::Codes::OK).GetCode(), UniqueFd(-1), UniqueFd(-1)))); - EXPECT_CALL(*srProxy, IncrementalRestoreOnFileReady(_, _, _, _, _)).WillOnce(Return()); + EXPECT_CALL(*svcProxy, GetIncrementalFileHandle(_, _)).WillOnce(Return(0)); + EXPECT_CALL(*srProxy, IncrementalRestoreOnFileReady(_, _, _, _, _)).WillOnce(Return(0)); EXPECT_TRUE(service->IncrementalBackup(bundleName)); } catch (...) { EXPECT_TRUE(false); @@ -1512,8 +1511,8 @@ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_IncrementalBackup_0200, try { string bundleName; set fileNameVec { "fileName" }; - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)) - .WillOnce(Return(IServiceReverse::Scenario::RESTORE)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::RESTORE)) + .WillOnce(Return(IServiceReverseType::Scenario::RESTORE)); EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect)); EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy)); EXPECT_CALL(*param, GetBackupOverrideIncrementalRestore()).WillOnce(Return(true)); @@ -1521,15 +1520,14 @@ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_IncrementalBackup_0200, EXPECT_CALL(*session, GetClearDataFlag(_)).WillOnce(Return(false)); EXPECT_CALL(*svcProxy, HandleRestore(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode())); EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)).WillOnce(Return(srProxy)); - EXPECT_CALL(*srProxy, IncrementalRestoreOnBundleStarted(_, _)).WillOnce(Return()); + EXPECT_CALL(*srProxy, IncrementalRestoreOnBundleStarted(_, _)).WillOnce(Return(0)); EXPECT_CALL(*session, GetOldBackupVersion()).WillOnce(Return("1.0.0")); EXPECT_CALL(*session, GetExtFileNameRequest(_)).WillOnce(Return(fileNameVec)); - EXPECT_CALL(*svcProxy, GetIncrementalFileHandle(_)) - .WillOnce(Return(make_tuple(BError(BError::Codes::SA_INVAL_ARG).GetCode(), UniqueFd(-1), UniqueFd(-1)))); - EXPECT_CALL(*srProxy, IncrementalRestoreOnFileReady(_, _, _, _, _)).WillOnce(Return()); + EXPECT_CALL(*svcProxy, GetIncrementalFileHandle(_, _)).WillOnce(Return(0)); + EXPECT_CALL(*srProxy, IncrementalRestoreOnFileReady(_, _, _, _, _)).WillOnce(Return(0)); EXPECT_TRUE(service->IncrementalBackup(bundleName)); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)); EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect)); EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy)); EXPECT_FALSE(service->IncrementalBackup(bundleName)); @@ -1555,19 +1553,19 @@ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_NotifyCallerCurAppIncrem try { ErrCode errCode = 0; string callerName; - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)); service->NotifyCallerCurAppIncrementDone(errCode, callerName); EXPECT_TRUE(true); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::BACKUP)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::BACKUP)); EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); - EXPECT_CALL(*srProxy, IncrementalBackupOnBundleFinished(_, _)).WillOnce(Return()); + EXPECT_CALL(*srProxy, IncrementalBackupOnBundleFinished(_, _)).WillOnce(Return(0)); service->NotifyCallerCurAppIncrementDone(errCode, callerName); EXPECT_TRUE(true); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::RESTORE)); EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); - EXPECT_CALL(*srProxy, IncrementalRestoreOnBundleFinished(_, _)).WillOnce(Return()); + EXPECT_CALL(*srProxy, IncrementalRestoreOnBundleFinished(_, _)).WillOnce(Return(0)); service->NotifyCallerCurAppIncrementDone(errCode, callerName); EXPECT_TRUE(true); } catch (...) { @@ -1681,20 +1679,20 @@ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_Release_0000, TestSize.L EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode()); service->session_ = session_; - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::RESTORE)); EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode())); EXPECT_CALL(*session, GetSessionUserId()).WillOnce(Return(0)); ret = service->Release(); EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode()); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::BACKUP)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::BACKUP)); EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode())); EXPECT_CALL(*session, GetSessionUserId()).WillOnce(Return(0)); ret = service->Release(); EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode()); EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode())); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)); ret = service->Release(); EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode()); } catch (...) { @@ -1775,7 +1773,7 @@ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_CancelTask_0000, TestSiz EXPECT_CALL(*session, StopFwkTimer(_)).WillOnce(Return(false)); EXPECT_CALL(*session, StopExtTimer(_)).WillOnce(Return(false)); EXPECT_CALL(*connect, DisconnectBackupExtAbility()).WillOnce(Return(BError(BError::Codes::OK).GetCode())); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)); service->CancelTask("", service); EXPECT_TRUE(true); @@ -1785,7 +1783,7 @@ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_CancelTask_0000, TestSiz EXPECT_CALL(*session, StopFwkTimer(_)).WillOnce(Return(false)); EXPECT_CALL(*session, StopExtTimer(_)).WillOnce(Return(false)); EXPECT_CALL(*connect, DisconnectBackupExtAbility()).WillOnce(Return(BError(BError::Codes::OK).GetCode())); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::BACKUP)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::BACKUP)); EXPECT_CALL(*session, GetIsIncrementalBackup()).WillOnce(Return(false)); service->CancelTask("", service); EXPECT_TRUE(true); @@ -1815,8 +1813,8 @@ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_CancelTask_0100, TestSiz EXPECT_CALL(*session, StopFwkTimer(_)).WillOnce(Return(false)); EXPECT_CALL(*session, StopExtTimer(_)).WillOnce(Return(false)); EXPECT_CALL(*connect, DisconnectBackupExtAbility()).WillOnce(Return(BError(BError::Codes::OK).GetCode())); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::BACKUP)) - .WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::BACKUP)) + .WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)); EXPECT_CALL(*session, GetIsIncrementalBackup()).WillOnce(Return(true)); service->CancelTask("", service); EXPECT_TRUE(true); @@ -1827,7 +1825,7 @@ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_CancelTask_0100, TestSiz EXPECT_CALL(*session, StopFwkTimer(_)).WillOnce(Return(false)); EXPECT_CALL(*session, StopExtTimer(_)).WillOnce(Return(false)); EXPECT_CALL(*connect, DisconnectBackupExtAbility()).WillOnce(Return(BError(BError::Codes::OK).GetCode())); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::RESTORE)); EXPECT_CALL(*session, ValidRestoreDataType(_)).WillOnce(Return(false)); service->CancelTask("", service); EXPECT_TRUE(true); @@ -1838,8 +1836,8 @@ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_CancelTask_0100, TestSiz EXPECT_CALL(*session, StopFwkTimer(_)).WillOnce(Return(false)); EXPECT_CALL(*session, StopExtTimer(_)).WillOnce(Return(false)); EXPECT_CALL(*connect, DisconnectBackupExtAbility()).WillOnce(Return(BError(BError::Codes::OK).GetCode())); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)) - .WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::RESTORE)) + .WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)); EXPECT_CALL(*session, ValidRestoreDataType(_)).WillOnce(Return(true)); service->CancelTask("", service); EXPECT_TRUE(true); @@ -1875,26 +1873,26 @@ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_Cancel_0000, TestSize.Le BError(BError::BackupErrorCode::E_CANCEL_UNSTARTED_TASK).GetCode()); service->session_ = session_; - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::RESTORE)); EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::EXT_INVAL_ARG).GetCode())); auto ret = service->Cancel(bundleName, result); EXPECT_EQ(ret, BError(BError::BackupErrorCode::E_CANCEL_UNSTARTED_TASK).GetCode()); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::RESTORE)); EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode())); EXPECT_CALL(*session, GetImpl()).WillOnce(Return(impl)); service->Cancel(bundleName, result); EXPECT_EQ(result, BError(BError::BackupErrorCode::E_CANCEL_NO_TASK).GetCode()); impl.backupExtNameMap.insert(make_pair(bundleName, info)); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::RESTORE)); EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode())); EXPECT_CALL(*session, GetImpl()).WillOnce(Return(impl)); EXPECT_CALL(*session, GetServiceSchedAction(_)).WillOnce(Return(BConstants::ServiceSchedAction::UNKNOWN)); service->Cancel(bundleName, result); EXPECT_EQ(result, BError(BError::BackupErrorCode::E_CANCEL_NO_TASK).GetCode()); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::RESTORE)); EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode())); EXPECT_CALL(*session, GetImpl()).WillOnce(Return(impl)); EXPECT_CALL(*session, GetServiceSchedAction(_)).WillOnce(Return(BConstants::ServiceSchedAction::CLEAN)); @@ -1927,14 +1925,14 @@ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_Cancel_0100, TestSize.Le int32_t result; impl.backupExtNameMap.insert(make_pair(bundleName, info)); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::RESTORE)); EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode())); EXPECT_CALL(*session, GetImpl()).WillOnce(Return(impl)); EXPECT_CALL(*session, GetServiceSchedAction(_)).WillOnce(Return(BConstants::ServiceSchedAction::START)); service->Cancel(bundleName, result); EXPECT_EQ(result, BError(BError::BackupErrorCode::E_CANCEL_UNSTARTED_TASK).GetCode()); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::RESTORE)); EXPECT_CALL(*srvMock, VerifyCaller(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode())); EXPECT_CALL(*session, GetImpl()).WillOnce(Return(impl)); EXPECT_CALL(*session, GetServiceSchedAction(_)).WillOnce(Return(BConstants::ServiceSchedAction::RUNNING)); diff --git a/tests/unittests/backup_sa/module_ipc/service_other_test.cpp b/tests/unittests/backup_sa/module_ipc/service_other_test.cpp index 6bd257715aeea809b03c612c078616e6c00b73c7..db6367853b289724b9f0cc308597b049f8d2a18e 100644 --- a/tests/unittests/backup_sa/module_ipc/service_other_test.cpp +++ b/tests/unittests/backup_sa/module_ipc/service_other_test.cpp @@ -718,30 +718,30 @@ HWTEST_F(ServiceTest, SUB_Service_OnBundleStarted_0100, TestSize.Level1) BError error(BError::Codes::OK); sptr session_ = service->session_; BundleName bundleName; - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)); service->OnBundleStarted(error, session_, bundleName); EXPECT_TRUE(true); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::RESTORE)); EXPECT_CALL(*param, GetBackupOverrideIncrementalRestore()).WillOnce(Return(false)); EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); - EXPECT_CALL(*srProxy, RestoreOnBundleStarted(_, _)).WillOnce(Return()); + EXPECT_CALL(*srProxy, RestoreOnBundleStarted(_, _)).WillOnce(Return(0)); service->OnBundleStarted(error, session_, bundleName); EXPECT_TRUE(true); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::RESTORE)); EXPECT_CALL(*param, GetBackupOverrideIncrementalRestore()).WillOnce(Return(true)); EXPECT_CALL(*session, ValidRestoreDataType(_)).WillOnce(Return(false)); EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); - EXPECT_CALL(*srProxy, RestoreOnBundleStarted(_, _)).WillOnce(Return()); + EXPECT_CALL(*srProxy, RestoreOnBundleStarted(_, _)).WillOnce(Return(0)); service->OnBundleStarted(error, session_, bundleName); EXPECT_TRUE(true); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::RESTORE)); EXPECT_CALL(*param, GetBackupOverrideIncrementalRestore()).WillOnce(Return(true)); EXPECT_CALL(*session, ValidRestoreDataType(_)).WillOnce(Return(true)); EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); - EXPECT_CALL(*srProxy, IncrementalRestoreOnBundleStarted(_, _)).WillOnce(Return()); + EXPECT_CALL(*srProxy, IncrementalRestoreOnBundleStarted(_, _)).WillOnce(Return(0)); service->OnBundleStarted(error, session_, bundleName); EXPECT_TRUE(true); } catch (...) { @@ -792,7 +792,7 @@ HWTEST_F(ServiceTest, SUB_Service_HandleExceptionOnAppendBundles_0100, TestSize. try { vector appendBundleNames { "bundleName" }; vector restoreBundleNames; - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)); service->HandleExceptionOnAppendBundles(service->session_, appendBundleNames, restoreBundleNames); EXPECT_TRUE(true); @@ -973,7 +973,7 @@ HWTEST_F(ServiceTest, SUB_Service_SetCurrentSessProperties_0200, TestSize.Level1 restoreBundleNames.emplace_back("bundleName"); EXPECT_CALL(*jsonUtil, BuildBundleNameIndexInfo(_, _)).WillOnce(Return("bundleName")) .WillOnce(Return("bundleName")); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)); service->SetCurrentSessProperties(restoreBundleInfos, restoreBundleNames, bundleNameDetailMap, isClearDataFlags, restoreType, backupVersion); EXPECT_TRUE(true); @@ -981,7 +981,7 @@ HWTEST_F(ServiceTest, SUB_Service_SetCurrentSessProperties_0200, TestSize.Level1 restoreBundleInfos[0].allToBackup = true; EXPECT_CALL(*jsonUtil, BuildBundleNameIndexInfo(_, _)).WillOnce(Return("bundleName")) .WillOnce(Return("bundleName")); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)); EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(false)); service->SetCurrentSessProperties(restoreBundleInfos, restoreBundleNames, bundleNameDetailMap, isClearDataFlags, restoreType, backupVersion); @@ -991,7 +991,7 @@ HWTEST_F(ServiceTest, SUB_Service_SetCurrentSessProperties_0200, TestSize.Level1 restoreBundleInfos[0].versionName = string(BConstants::DEFAULT_VERSION_NAME); EXPECT_CALL(*jsonUtil, BuildBundleNameIndexInfo(_, _)).WillOnce(Return("bundleName")) .WillOnce(Return("bundleName")); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)); EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(false)); service->SetCurrentSessProperties(restoreBundleInfos, restoreBundleNames, bundleNameDetailMap, isClearDataFlags, restoreType, backupVersion); @@ -1379,12 +1379,12 @@ HWTEST_F(ServiceTest, SUB_Service_LaunchBackupExtension_0100, TestSize.Level1) try { ASSERT_TRUE(service != nullptr); std::string bundleName = ""; - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)); auto ret = service->LaunchBackupExtension(bundleName); EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG)); BJsonUtil::BundleDetailInfo info; - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::RESTORE)); EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(false)); EXPECT_CALL(*jsonUtil, ParseBundleNameIndexStr(_)).WillOnce(Return(info)); EXPECT_CALL(*session, GetBackupExtName(_)).WillOnce(Return("")); @@ -1396,7 +1396,7 @@ HWTEST_F(ServiceTest, SUB_Service_LaunchBackupExtension_0100, TestSize.Level1) ret = service->LaunchBackupExtension(bundleName); EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG)); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::RESTORE)); EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(false)); EXPECT_CALL(*jsonUtil, ParseBundleNameIndexStr(_)).WillOnce(Return(info)); EXPECT_CALL(*session, GetBackupExtName(_)).WillOnce(Return("")); @@ -1432,7 +1432,7 @@ HWTEST_F(ServiceTest, SUB_Service_LaunchBackupExtension_0200, TestSize.Level1) ASSERT_TRUE(service != nullptr); string bundleName = ""; BJsonUtil::BundleDetailInfo info; - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::RESTORE)); EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(false)); EXPECT_CALL(*jsonUtil, ParseBundleNameIndexStr(_)).WillOnce(Return(info)); EXPECT_CALL(*session, GetBackupExtName(_)).WillOnce(Return("")); @@ -1449,7 +1449,7 @@ HWTEST_F(ServiceTest, SUB_Service_LaunchBackupExtension_0200, TestSize.Level1) auto ret = service->LaunchBackupExtension(bundleName); EXPECT_EQ(ret, BError(BError::Codes::SA_BOOT_EXT_FAIL)); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::RESTORE)); EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(false)); EXPECT_CALL(*jsonUtil, ParseBundleNameIndexStr(_)).WillOnce(Return(info)); EXPECT_CALL(*session, GetBackupExtName(_)).WillOnce(Return("")); @@ -1616,14 +1616,14 @@ HWTEST_F(ServiceTest, SUB_Service_UpdateSendRate_0000, TestSize.Level1) EXPECT_CALL(*skeleton, GetCallingUid()).WillOnce(Return(BConstants::SYSTEM_UID)); EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0)); EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_SHELL)); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)); ret = service->UpdateSendRate(bundleName, 0, result); EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode()); EXPECT_CALL(*skeleton, GetCallingUid()).WillOnce(Return(BConstants::SYSTEM_UID)); EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0)); EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_SHELL)); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::BACKUP)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::BACKUP)); EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect)); EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(nullptr)); ret = service->UpdateSendRate(bundleName, 0, result); @@ -1654,7 +1654,7 @@ HWTEST_F(ServiceTest, SUB_Service_UpdateSendRate_0100, TestSize.Level1) EXPECT_CALL(*skeleton, GetCallingUid()).WillOnce(Return(BConstants::SYSTEM_UID)); EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0)); EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_SHELL)); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::BACKUP)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::BACKUP)); EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect)); EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy)); EXPECT_CALL(*svcProxy, UpdateFdSendRate(_, _)).WillOnce(Return(EPERM)); @@ -1664,7 +1664,7 @@ HWTEST_F(ServiceTest, SUB_Service_UpdateSendRate_0100, TestSize.Level1) EXPECT_CALL(*skeleton, GetCallingUid()).WillOnce(Return(BConstants::SYSTEM_UID)); EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0)); EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_SHELL)); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::BACKUP)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::BACKUP)); EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect)); EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy)); EXPECT_CALL(*svcProxy, UpdateFdSendRate(_, _)).WillOnce(Return(NO_ERROR)); @@ -1692,42 +1692,42 @@ HWTEST_F(ServiceTest, SUB_Service_BackupSA_0000, TestSize.Level1) try { string bundleName; shared_ptr sa = nullptr; - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)); EXPECT_CALL(*session, GetSAExtConnection(_)).WillOnce(Return(sa)); auto ret = service->BackupSA(bundleName); EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode()); sa = make_shared(nullptr, nullptr, nullptr, nullptr); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)); EXPECT_CALL(*session, GetSAExtConnection(_)).WillOnce(Return(sa)); ret = service->BackupSA(bundleName); EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode()); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::BACKUP)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::BACKUP)); EXPECT_CALL(*session, GetSAExtConnection(_)).WillOnce(Return(sa)); EXPECT_CALL(*saConnect, CallBackupSA()).WillOnce(Return(BError(BError::Codes::OK).GetCode())); EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); - EXPECT_CALL(*srProxy, BackupOnBundleStarted(_, _)).WillOnce(Return()); + EXPECT_CALL(*srProxy, BackupOnBundleStarted(_, _)).WillOnce(Return(0)); ret = service->BackupSA(bundleName); EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode()); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::BACKUP)) - .WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)) - .WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::BACKUP)) + .WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)) + .WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)); EXPECT_CALL(*session, GetSAExtConnection(_)).WillOnce(Return(sa)); EXPECT_CALL(*saConnect, CallBackupSA()).WillOnce(Return(BError(BError::Codes::SA_BOOT_EXT_FAIL).GetCode())); EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); - EXPECT_CALL(*srProxy, BackupOnBundleStarted(_, _)).WillOnce(Return()); + EXPECT_CALL(*srProxy, BackupOnBundleStarted(_, _)).WillOnce(Return(0)); EXPECT_CALL(*cdConfig, DeleteClearBundleRecord(_)).WillOnce(Return(false)); EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(true)); EXPECT_CALL(*session, IsOnAllBundlesFinished()).WillOnce(Return(false)); ret = service->BackupSA(bundleName); EXPECT_EQ(ret, BError(BError::Codes::SA_BOOT_EXT_FAIL).GetCode()); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::RESTORE)); EXPECT_CALL(*session, GetSAExtConnection(_)).WillOnce(Return(sa)); EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); - EXPECT_CALL(*srProxy, IncrementalRestoreOnBundleStarted(_, _)).WillOnce(Return()); + EXPECT_CALL(*srProxy, IncrementalRestoreOnBundleStarted(_, _)).WillOnce(Return(0)); ret = service->BackupSA(bundleName); EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode()); } catch (...) { @@ -1767,7 +1767,7 @@ HWTEST_F(ServiceTest, SUB_Service_SADone_0000, TestSize.Level1) EXPECT_CALL(*saConnect, DisconnectBackupSAExt()).WillOnce(Return(BError(BError::Codes::OK).GetCode())); EXPECT_CALL(*session, StopFwkTimer(_)).WillOnce(Return(true)); EXPECT_CALL(*session, StopExtTimer(_)).WillOnce(Return(true)); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)); EXPECT_CALL(*cdConfig, DeleteClearBundleRecord(_)).WillOnce(Return(false)); ret = service->SADone(0, ""); EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode()); @@ -1791,19 +1791,19 @@ HWTEST_F(ServiceTest, SUB_Service_NotifyCallerCurAppDone_0000, TestSize.Level1) { GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_NotifyCallerCurAppDone_0000"; try { - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)); service->NotifyCallerCurAppDone(0, ""); EXPECT_TRUE(true); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::BACKUP)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::BACKUP)); EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); - EXPECT_CALL(*srProxy, BackupOnBundleFinished(_, _)).WillOnce(Return()); + EXPECT_CALL(*srProxy, BackupOnBundleFinished(_, _)).WillOnce(Return(0)); service->NotifyCallerCurAppDone(0, ""); EXPECT_TRUE(true); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::RESTORE)); EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); - EXPECT_CALL(*srProxy, RestoreOnBundleFinished(_, _)).WillOnce(Return()); + EXPECT_CALL(*srProxy, RestoreOnBundleFinished(_, _)).WillOnce(Return(0)); service->NotifyCallerCurAppDone(0, ""); EXPECT_TRUE(true); } catch (...) { @@ -1832,7 +1832,7 @@ HWTEST_F(ServiceTest, SUB_Service_ReportAppProcessInfo_0000, TestSize.Level1) EXPECT_CALL(*token, GetHapTokenInfo(_, _)).WillOnce(Return(0)); EXPECT_CALL(*jsonUtil, BuildBundleNameIndexInfo(_, _)).WillOnce(Return("")); EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); - EXPECT_CALL(*srProxy, RestoreOnProcessInfo(_, _)).WillOnce(Return()); + EXPECT_CALL(*srProxy, RestoreOnProcessInfo(_, _)).WillOnce(Return(0)); auto ret = service->ReportAppProcessInfo(processInfo, BackupRestoreScenario::FULL_RESTORE); EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode()); @@ -1841,7 +1841,7 @@ HWTEST_F(ServiceTest, SUB_Service_ReportAppProcessInfo_0000, TestSize.Level1) EXPECT_CALL(*token, GetHapTokenInfo(_, _)).WillOnce(Return(0)); EXPECT_CALL(*jsonUtil, BuildBundleNameIndexInfo(_, _)).WillOnce(Return("")); EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); - EXPECT_CALL(*srProxy, IncrementalRestoreOnProcessInfo(_, _)).WillOnce(Return()); + EXPECT_CALL(*srProxy, IncrementalRestoreOnProcessInfo(_, _)).WillOnce(Return(0)); ret = service->ReportAppProcessInfo(processInfo, BackupRestoreScenario::INCREMENTAL_RESTORE); EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode()); @@ -1850,7 +1850,7 @@ HWTEST_F(ServiceTest, SUB_Service_ReportAppProcessInfo_0000, TestSize.Level1) EXPECT_CALL(*token, GetHapTokenInfo(_, _)).WillOnce(Return(0)); EXPECT_CALL(*jsonUtil, BuildBundleNameIndexInfo(_, _)).WillOnce(Return("")); EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); - EXPECT_CALL(*srProxy, BackupOnProcessInfo(_, _)).WillOnce(Return()); + EXPECT_CALL(*srProxy, BackupOnProcessInfo(_, _)).WillOnce(Return(0)); ret = service->ReportAppProcessInfo(processInfo, BackupRestoreScenario::FULL_BACKUP); EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode()); @@ -1859,7 +1859,7 @@ HWTEST_F(ServiceTest, SUB_Service_ReportAppProcessInfo_0000, TestSize.Level1) EXPECT_CALL(*token, GetHapTokenInfo(_, _)).WillOnce(Return(0)); EXPECT_CALL(*jsonUtil, BuildBundleNameIndexInfo(_, _)).WillOnce(Return("")); EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); - EXPECT_CALL(*srProxy, IncrementalBackupOnProcessInfo(_, _)).WillOnce(Return()); + EXPECT_CALL(*srProxy, IncrementalBackupOnProcessInfo(_, _)).WillOnce(Return(0)); ret = service->ReportAppProcessInfo(processInfo, BackupRestoreScenario::INCREMENTAL_BACKUP); EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode()); } catch (...) { @@ -1923,9 +1923,9 @@ HWTEST_F(ServiceTest, SUB_Service_DoTimeout_0000, TestSize.Level1) service->session_ = session_; EXPECT_TRUE(true); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)) - .WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)) - .WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)) + .WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)) + .WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)); EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(false)).WillOnce(Return(true)); EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect)); EXPECT_CALL(*connect, DisconnectBackupExtAbility()).WillOnce(Return(BError(BError::Codes::OK).GetCode())); @@ -1937,7 +1937,7 @@ HWTEST_F(ServiceTest, SUB_Service_DoTimeout_0000, TestSize.Level1) EXPECT_TRUE(true); shared_ptr sa = nullptr; - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::BACKUP)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::BACKUP)); EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(true)); EXPECT_CALL(*session, GetSAExtConnection(_)).WillOnce(Return(sa)); service->DoTimeout(service, bundleName); @@ -1964,23 +1964,23 @@ HWTEST_F(ServiceTest, SUB_Service_DoTimeout_0100, TestSize.Level1) try { string bundleName; shared_ptr sa = nullptr; - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::RESTORE)); EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(true)); EXPECT_CALL(*session, GetSAExtConnection(_)).WillOnce(Return(sa)); service->DoTimeout(service, bundleName); EXPECT_TRUE(true); sa = nullptr; - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)); EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(true)); EXPECT_CALL(*session, GetSAExtConnection(_)).WillOnce(Return(sa)); service->DoTimeout(service, bundleName); EXPECT_TRUE(true); sa = make_shared(nullptr, nullptr, nullptr, nullptr); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)) - .WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)) - .WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)) + .WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)) + .WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)); EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(true)).WillOnce(Return(true)); EXPECT_CALL(*session, GetSAExtConnection(_)).WillOnce(Return(sa)); EXPECT_CALL(*saConnect, DisconnectBackupSAExt()).WillOnce(Return(BError(BError::Codes::OK).GetCode())); @@ -2071,19 +2071,19 @@ HWTEST_F(ServiceTest, SUB_Service_ReleaseOnException_0000, TestSize.Level1) EXPECT_TRUE(true); EXPECT_CALL(*session, IsOnAllBundlesFinished()).WillOnce(Return(true)); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::BACKUP)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::BACKUP)); service->isInRelease_ = false; service->ReleaseOnException(); EXPECT_TRUE(true); EXPECT_CALL(*session, IsOnAllBundlesFinished()).WillOnce(Return(true)); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::BACKUP)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::BACKUP)); service->isInRelease_ = true; service->ReleaseOnException(); EXPECT_TRUE(true); EXPECT_CALL(*session, IsOnAllBundlesFinished()).WillOnce(Return(true)); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::RESTORE)); service->isInRelease_ = true; auto session_ = service->session_; service->session_ = nullptr; @@ -2117,9 +2117,9 @@ HWTEST_F(ServiceTest, SUB_Service_ClearResidualBundleData_0000, TestSize.Level1) EXPECT_CALL(*connect, IsExtAbilityConnected()).WillOnce(Return(true)); EXPECT_CALL(*connect, DisconnectBackupExtAbility()).WillOnce(Return(BError(BError::Codes::OK).GetCode())); EXPECT_CALL(*session, GetScenario()) - .WillOnce(Return(IServiceReverse::Scenario::CLEAN)) - .WillOnce(Return(IServiceReverse::Scenario::CLEAN)) - .WillOnce(Return(IServiceReverse::Scenario::CLEAN)); + .WillOnce(Return(IServiceReverseType::Scenario::CLEAN)) + .WillOnce(Return(IServiceReverseType::Scenario::CLEAN)) + .WillOnce(Return(IServiceReverseType::Scenario::CLEAN)); EXPECT_CALL(*cdConfig, DeleteClearBundleRecord(_)).WillOnce(Return(true)); EXPECT_CALL(*session, IsOnAllBundlesFinished()).WillOnce(Return(true)); EXPECT_CALL(*param, GetBackupOverrideBackupSARelease()).WillOnce(Return(true)); @@ -2131,9 +2131,9 @@ HWTEST_F(ServiceTest, SUB_Service_ClearResidualBundleData_0000, TestSize.Level1) EXPECT_CALL(*svcProxy, HandleClear()).WillOnce(Return(BError(BError::Codes::OK).GetCode())); EXPECT_CALL(*connect, IsExtAbilityConnected()).WillOnce(Return(false)); EXPECT_CALL(*session, GetScenario()) - .WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)) - .WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)) - .WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); + .WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)) + .WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)) + .WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)); EXPECT_CALL(*cdConfig, DeleteClearBundleRecord(_)).WillOnce(Return(true)); EXPECT_CALL(*param, GetBackupOverrideBackupSARelease()).WillOnce(Return(true)); res = service->ClearResidualBundleData(bundleName); @@ -2201,10 +2201,10 @@ HWTEST_F(ServiceTest, SUB_Service_HandleCurBundleFileReady_0000, TestSize.Level1 EXPECT_CALL(*session, StopFwkTimer(_)).WillOnce(Return(true)); EXPECT_CALL(*session, StopExtTimer(_)).WillOnce(Return(true)); EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); - EXPECT_CALL(*srProxy, BackupOnBundleFinished(_, _)).WillOnce(Return()); + EXPECT_CALL(*srProxy, BackupOnBundleFinished(_, _)).WillOnce(Return(0)); EXPECT_CALL(*connect, DisconnectBackupExtAbility()).WillOnce(Return(BError(BError::Codes::OK).GetCode())); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)) - .WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)) + .WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)); EXPECT_CALL(*cdConfig, DeleteClearBundleRecord(_)).WillOnce(Return(true)); res = service->HandleCurBundleFileReady(bundleName, fileName, isIncBackup); EXPECT_EQ(res, BError(BError::Codes::OK).GetCode()); @@ -2216,9 +2216,9 @@ HWTEST_F(ServiceTest, SUB_Service_HandleCurBundleFileReady_0000, TestSize.Level1 EXPECT_CALL(*session, StopFwkTimer(_)).WillOnce(Return(true)); EXPECT_CALL(*session, StopExtTimer(_)).WillOnce(Return(true)); EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); - EXPECT_CALL(*srProxy, IncrementalBackupOnBundleFinished(_, _)).WillOnce(Return()); + EXPECT_CALL(*srProxy, IncrementalBackupOnBundleFinished(_, _)).WillOnce(Return(0)); EXPECT_CALL(*connect, DisconnectBackupExtAbility()).WillOnce(Return(BError(BError::Codes::OK).GetCode())); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)); EXPECT_CALL(*cdConfig, DeleteClearBundleRecord(_)).WillOnce(Return(true)); res = service->HandleCurBundleFileReady(bundleName, fileName, isIncBackup); EXPECT_EQ(res, BError(BError::Codes::OK).GetCode()); @@ -2252,22 +2252,22 @@ HWTEST_F(ServiceTest, SUB_Service_CallOnBundleEndByScenario_0100, testing::ext:: service->session_ = session_; EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); - EXPECT_CALL(*srProxy, RestoreOnBundleFinished(_, _)).WillOnce(Return()); + EXPECT_CALL(*srProxy, RestoreOnBundleFinished(_, _)).WillOnce(Return(0)); service->CallOnBundleEndByScenario(bundleName, BackupRestoreScenario::FULL_RESTORE, errCode); EXPECT_TRUE(true); EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); - EXPECT_CALL(*srProxy, IncrementalRestoreOnBundleFinished(_, _)).WillOnce(Return()); + EXPECT_CALL(*srProxy, IncrementalRestoreOnBundleFinished(_, _)).WillOnce(Return(0)); service->CallOnBundleEndByScenario(bundleName, BackupRestoreScenario::INCREMENTAL_RESTORE, errCode); EXPECT_TRUE(true); EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); - EXPECT_CALL(*srProxy, BackupOnBundleFinished(_, _)).WillOnce(Return()); + EXPECT_CALL(*srProxy, BackupOnBundleFinished(_, _)).WillOnce(Return(0)); service->CallOnBundleEndByScenario(bundleName, BackupRestoreScenario::FULL_BACKUP, errCode); EXPECT_TRUE(true); EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); - EXPECT_CALL(*srProxy, IncrementalBackupOnBundleFinished(_, _)).WillOnce(Return()); + EXPECT_CALL(*srProxy, IncrementalBackupOnBundleFinished(_, _)).WillOnce(Return(0)); service->CallOnBundleEndByScenario(bundleName, BackupRestoreScenario::INCREMENTAL_BACKUP, errCode); EXPECT_TRUE(true); } catch (...) { @@ -2298,18 +2298,18 @@ HWTEST_F(ServiceTest, SUB_Service_GetSupportBackupBundleNames_0100, testing::ext const std::vector srcBundleNames; EXPECT_CALL(*jsonUtil, BuildBundleNameIndexInfo(_, _)).WillOnce(Return("")).WillOnce(Return("")); EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); - EXPECT_CALL(*srProxy, IncrementalBackupOnBundleStarted(_, _)).WillOnce(Return()); + EXPECT_CALL(*srProxy, IncrementalBackupOnBundleStarted(_, _)).WillOnce(Return(0)); EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); - EXPECT_CALL(*srProxy, BackupOnBundleStarted(_, _)).WillOnce(Return()); + EXPECT_CALL(*srProxy, BackupOnBundleStarted(_, _)).WillOnce(Return(0)); auto res = service->GetSupportBackupBundleNames(backupInfos, isIncBackup, srcBundleNames); EXPECT_EQ(res.size(), 1); isIncBackup = true; EXPECT_CALL(*jsonUtil, BuildBundleNameIndexInfo(_, _)).WillOnce(Return("")).WillOnce(Return("")); EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); - EXPECT_CALL(*srProxy, IncrementalBackupOnBundleStarted(_, _)).WillOnce(Return()); + EXPECT_CALL(*srProxy, IncrementalBackupOnBundleStarted(_, _)).WillOnce(Return(0)); EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); - EXPECT_CALL(*srProxy, BackupOnBundleStarted(_, _)).WillOnce(Return()); + EXPECT_CALL(*srProxy, BackupOnBundleStarted(_, _)).WillOnce(Return(0)); res = service->GetSupportBackupBundleNames(backupInfos, isIncBackup, srcBundleNames); EXPECT_EQ(res.size(), 1); } catch (...) { diff --git a/tests/unittests/backup_sa/module_ipc/service_reverse_proxy_test.cpp b/tests/unittests/backup_sa/module_ipc/service_reverse_proxy_test.cpp deleted file mode 100644 index f554d5263c5c469bcbe77f5b52d04904817a0574..0000000000000000000000000000000000000000 --- a/tests/unittests/backup_sa/module_ipc/service_reverse_proxy_test.cpp +++ /dev/null @@ -1,2686 +0,0 @@ -/* - * Copyright (c) 2022-2024 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 "b_error/b_error.h" -#include "b_file_info.h" -#include "iservice_registry.h" -#include "message_parcel_mock.h" -#include "module_ipc/service_reverse_proxy.h" -#include "service_reverse_mock.h" -#include "test_manager.h" -#include "unique_fd.h" - -namespace OHOS::FileManagement::Backup { -using namespace std; -using namespace testing; - -namespace { -const string FILE_NAME = "1.tar"; -const string BUNDLE_NAME = "com.example.app2backup"; -const string FILE_NAME_MANIFEST = "manifest.rp"; -const string RESULT_REPORT = "result_report"; -} // namespace - -class ServiceReverseProxyTest : public testing::Test { -public: - static void SetUpTestCase(void); - static void TearDownTestCase(); - void SetUp() override {}; - void TearDown() override {}; - -public: - static inline shared_ptr proxy_ = nullptr; - static inline sptr mock_ = nullptr; - static inline shared_ptr messageParcelMock_ = nullptr; -}; - -void ServiceReverseProxyTest::SetUpTestCase(void) -{ - mock_ = sptr(new ServiceReverseMock()); - proxy_ = make_shared(mock_); - messageParcelMock_ = make_shared(); - MessageParcelMock::messageParcel = messageParcelMock_; -} -void ServiceReverseProxyTest::TearDownTestCase() -{ - mock_ = nullptr; - proxy_ = nullptr; - MessageParcelMock::messageParcel = nullptr; - messageParcelMock_ = nullptr; -} - -/** - * @tc.number: SUB_ServiceReverse_proxy_BackupOnFileReady_0100 - * @tc.name: SUB_ServiceReverse_proxy_BackupOnFileReady_0100 - * @tc.desc: Test function of BackupOnFileReady interface for SUCCESS. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I6F3GV - */ -HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_BackupOnFileReady_0100, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_BackupOnFileReady_0100"; - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteBool(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteFileDescriptor(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true)); - EXPECT_CALL(*mock_, SendRequest(_, _, _, _)) - .Times(1) - .WillOnce(Invoke(mock_.GetRefPtr(), &ServiceReverseMock::InvokeSendRequest)); - - TestManager tm("ServiceReverseProxyTest_GetFd_0100"); - std::string filePath = tm.GetRootDirCurTest().append(FILE_NAME); - UniqueFd fd(open(filePath.data(), O_RDONLY | O_CREAT, S_IRUSR | S_IWUSR)); - EXPECT_TRUE(proxy_ != nullptr); - proxy_->BackupOnFileReady(BUNDLE_NAME, FILE_NAME, fd, 0); - EXPECT_TRUE(true); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by BackupOnFileReady."; - } - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_BackupOnFileReady_0100"; -} - -/** - * @tc.number: SUB_ServiceReverse_proxy_BackupOnFileReady_0101 - * @tc.name: SUB_ServiceReverse_proxy_BackupOnFileReady_0101 - * @tc.desc: Test function of BackupOnFileReady interface for FAILURE. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I9OVHB - */ -HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_BackupOnFileReady_0101, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_BackupOnFileReady_0101"; - try { - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false)); - EXPECT_TRUE(proxy_ != nullptr); - proxy_->BackupOnFileReady(BUNDLE_NAME, FILE_NAME, 0, 0); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(false)); - EXPECT_TRUE(proxy_ != nullptr); - proxy_->BackupOnFileReady(BUNDLE_NAME, FILE_NAME, 0, 0); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(false)); - EXPECT_TRUE(proxy_ != nullptr); - proxy_->BackupOnFileReady(BUNDLE_NAME, FILE_NAME, 0, 0); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteBool(_)).WillOnce(Return(false)); - EXPECT_TRUE(proxy_ != nullptr); - proxy_->BackupOnFileReady(BUNDLE_NAME, FILE_NAME, 0, 0); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by BackupOnFileReady."; - } - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_BackupOnFileReady_0101"; -} - -/** - * @tc.number: SUB_ServiceReverse_proxy_BackupOnFileReady_0102 - * @tc.name: SUB_ServiceReverse_proxy_BackupOnFileReady_0102 - * @tc.desc: Test function of BackupOnFileReady interface for FAILURE. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I9OVHB - */ -HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_BackupOnFileReady_0102, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_BackupOnFileReady_0102"; - try { - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteBool(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(false)); - EXPECT_TRUE(proxy_ != nullptr); - proxy_->BackupOnFileReady(BUNDLE_NAME, FILE_NAME, -1, 0); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteBool(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteFileDescriptor(_)).WillOnce(Return(false)); - EXPECT_TRUE(proxy_ != nullptr); - proxy_->BackupOnFileReady(BUNDLE_NAME, FILE_NAME, 0, 0); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteBool(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteFileDescriptor(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(false)); - EXPECT_TRUE(proxy_ != nullptr); - proxy_->BackupOnFileReady(BUNDLE_NAME, FILE_NAME, 0, 0); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by BackupOnFileReady."; - } - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_BackupOnFileReady_0102"; -} - -/** - * @tc.number: SUB_ServiceReverse_proxy_BackupOnFileReady_0103 - * @tc.name: SUB_ServiceReverse_proxy_BackupOnFileReady_0103 - * @tc.desc: Test function of BackupOnFileReady interface for FAILURE. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I9OVHB - */ -HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_BackupOnFileReady_0103, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_BackupOnFileReady_0103"; - try { - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteBool(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteFileDescriptor(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true)); - EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(-1)); - EXPECT_TRUE(proxy_ != nullptr); - proxy_->BackupOnFileReady(BUNDLE_NAME, FILE_NAME, 0, 0); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by BackupOnFileReady."; - } - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_BackupOnFileReady_0103"; -} - -/** - * @tc.number: SUB_ServiceReverse_proxy_BackupOnBundleStarted_0100 - * @tc.name: SUB_ServiceReverse_proxy_BackupOnBundleStarted_0100 - * @tc.desc: Test function of BackupOnBundleStarted interface for SUCCESS. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I6F3GV - */ -HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_BackupOnBundleStarted_0100, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_BackupOnBundleStarted_0100"; - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)); - EXPECT_CALL(*mock_, SendRequest(_, _, _, _)) - .Times(1) - .WillOnce(Invoke(mock_.GetRefPtr(), &ServiceReverseMock::InvokeSendRequest)); - EXPECT_TRUE(proxy_ != nullptr); - proxy_->BackupOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME); - EXPECT_TRUE(true); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by BackupOnBundleStarted."; - } - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_BackupOnBundleStarted_0100"; -} - -/** - * @tc.number: SUB_ServiceReverse_proxy_BackupOnBundleStarted_0101 - * @tc.name: SUB_ServiceReverse_proxy_BackupOnBundleStarted_0101 - * @tc.desc: Test function of BackupOnBundleStarted interface for FAILURE. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I6F3GV - */ -HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_BackupOnBundleStarted_0101, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_BackupOnBundleStarted_0101"; - try { - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false)); - EXPECT_TRUE(proxy_ != nullptr); - proxy_->BackupOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(false)); - EXPECT_TRUE(proxy_ != nullptr); - proxy_->BackupOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(false)); - EXPECT_TRUE(proxy_ != nullptr); - proxy_->BackupOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)); - EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(-1)); - EXPECT_TRUE(proxy_ != nullptr); - proxy_->BackupOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by BackupOnBundleStarted."; - } - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_BackupOnBundleStarted_0101"; -} - -/** - * @tc.number: SUB_ServiceReverse_proxy_BackupOnBundleFinished_0100 - * @tc.name: SUB_ServiceReverse_proxy_BackupOnBundleFinished_0100 - * @tc.desc: Test function of BackupOnBundleFinished interface for SUCCESS. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I6F3GV - */ -HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_BackupOnBundleFinished_0100, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_BackupOnBundleFinished_0100"; - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)); - EXPECT_CALL(*mock_, SendRequest(_, _, _, _)) - .Times(1) - .WillOnce(Invoke(mock_.GetRefPtr(), &ServiceReverseMock::InvokeSendRequest)); - EXPECT_TRUE(proxy_ != nullptr); - proxy_->BackupOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME); - EXPECT_TRUE(true); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by BackupOnBundleFinished."; - } - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_BackupOnBundleFinished_0100"; -} - -/** - * @tc.number: SUB_ServiceReverse_proxy_BackupOnBundleFinished_0101 - * @tc.name: SUB_ServiceReverse_proxy_BackupOnBundleFinished_0101 - * @tc.desc: Test function of BackupOnBundleFinished interface for FAILURE. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I6F3GV - */ -HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_BackupOnBundleFinished_0101, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_BackupOnBundleFinished_0101"; - try { - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false)); - EXPECT_TRUE(proxy_ != nullptr); - proxy_->BackupOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(false)); - proxy_->BackupOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(false)); - proxy_->BackupOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)); - EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(-1)); - proxy_->BackupOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by BackupOnBundleFinished."; - } - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_BackupOnBundleFinished_0101"; -} - -/** - * @tc.number: SUB_ServiceReverse_proxy_BackupOnAllBundlesFinished_0100 - * @tc.name: SUB_ServiceReverse_proxy_BackupOnAllBundlesFinished_0100 - * @tc.desc: Test function of BackupOnAllBundlesFinished interface for SUCCESS. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I6F3GV - */ -HWTEST_F(ServiceReverseProxyTest, - SUB_ServiceReverse_proxy_BackupOnAllBundlesFinished_0100, - testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_BackupOnAllBundlesFinished_0100"; - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true)); - EXPECT_CALL(*mock_, SendRequest(_, _, _, _)) - .Times(1) - .WillOnce(Invoke(mock_.GetRefPtr(), &ServiceReverseMock::InvokeSendRequest)); - EXPECT_TRUE(proxy_ != nullptr); - proxy_->BackupOnAllBundlesFinished(BError(BError::Codes::OK)); - EXPECT_TRUE(true); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by BackupOnAllBundlesFinished."; - } - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_BackupOnAllBundlesFinished_0100"; -} - -/** - * @tc.number: SUB_ServiceReverse_proxy_BackupOnAllBundlesFinished_0101 - * @tc.name: SUB_ServiceReverse_proxy_BackupOnAllBundlesFinished_0101 - * @tc.desc: Test function of BackupOnAllBundlesFinished interface for FAILURE. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I9OVHB - */ -HWTEST_F(ServiceReverseProxyTest, - SUB_ServiceReverse_proxy_BackupOnAllBundlesFinished_0101, - testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_BackupOnAllBundlesFinished_0101"; - try { - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false)); - EXPECT_TRUE(proxy_ != nullptr); - proxy_->BackupOnAllBundlesFinished(BError(BError::Codes::OK)); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(false)); - proxy_->BackupOnAllBundlesFinished(BError(BError::Codes::OK)); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true)); - EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(-1)); - proxy_->BackupOnAllBundlesFinished(BError(BError::Codes::OK)); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by BackupOnAllBundlesFinished."; - } - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_BackupOnAllBundlesFinished_0101"; -} - -/** - * @tc.number: SUB_ServiceReverse_proxy_BackupOnResultReport_0100 - * @tc.name: SUB_ServiceReverse_proxy_BackupOnResultReport_0100 - * @tc.desc: Test function of BackupOnResultReport interface for SUCCESS. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I6F3GV - */ -HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_BackupOnResultReport_0100, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_BackupOnResultReport_0100"; - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true)); - EXPECT_CALL(*mock_, SendRequest(_, _, _, _)) - .Times(1) - .WillOnce(Invoke(mock_.GetRefPtr(), &ServiceReverseMock::InvokeSendRequest)); - std::string bundleName = "app01"; - EXPECT_TRUE(proxy_ != nullptr); - proxy_->BackupOnResultReport(RESULT_REPORT, bundleName); - EXPECT_TRUE(true); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by BackupOnResultReport."; - } - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_BackupOnResultReport_0100"; -} - -/** - * @tc.number: SUB_ServiceReverse_proxy_BackupOnResultReport_0101 - * @tc.name: SUB_ServiceReverse_proxy_BackupOnResultReport_0101 - * @tc.desc: Test function of BackupOnResultReport interface for FAILURE. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I9OVHB - */ -HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_BackupOnResultReport_0101, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_BackupOnResultReport_0101"; - try { - std::string bundleName = "app01"; - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false)); - EXPECT_TRUE(proxy_ != nullptr); - proxy_->BackupOnResultReport(RESULT_REPORT, bundleName); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(false)); - proxy_->BackupOnResultReport(RESULT_REPORT, bundleName); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(false)); - proxy_->BackupOnResultReport(RESULT_REPORT, bundleName); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true)); - EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(-1)); - proxy_->BackupOnResultReport(RESULT_REPORT, bundleName); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by BackupOnResultReport."; - } - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_BackupOnResultReport_0101"; -} - -/** - * @tc.number: SUB_ServiceReverse_proxy_RestoreOnBundleStarted_0100 - * @tc.name: SUB_ServiceReverse_proxy_RestoreOnBundleStarted_0100 - * @tc.desc: Test function of RestoreOnBundleStarted interface for SUCCESS. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I6F3GV - */ -HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_RestoreOnBundleStarted_0100, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_RestoreOnBundleStarted_0100"; - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)); - EXPECT_CALL(*mock_, SendRequest(_, _, _, _)) - .Times(1) - .WillOnce(Invoke(mock_.GetRefPtr(), &ServiceReverseMock::InvokeSendRequest)); - EXPECT_TRUE(proxy_ != nullptr); - proxy_->RestoreOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME); - EXPECT_TRUE(true); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by RestoreOnBundleStarted."; - } - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_RestoreOnBundleStarted_0100"; -} - -/** - * @tc.number: SUB_ServiceReverse_proxy_RestoreOnBundleStarted_0101 - * @tc.name: SUB_ServiceReverse_proxy_RestoreOnBundleStarted_0101 - * @tc.desc: Test function of RestoreOnBundleStarted interface for FAILURE. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I9OVHB - */ -HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_RestoreOnBundleStarted_0101, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_RestoreOnBundleStarted_0101"; - try { - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false)); - EXPECT_TRUE(proxy_ != nullptr); - proxy_->RestoreOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(false)); - proxy_->RestoreOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(false)); - proxy_->RestoreOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)); - EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(-1)); - proxy_->RestoreOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by RestoreOnBundleStarted."; - } - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_RestoreOnBundleStarted_0101"; -} - -/** - * @tc.number: SUB_ServiceReverse_proxy_RestoreOnBundleFinished_0100 - * @tc.name: SUB_ServiceReverse_proxy_RestoreOnBundleFinished_0100 - * @tc.desc: Test function of RestoreOnBundleFinished interface for SUCCESS. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I6F3GV - */ -HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_RestoreOnBundleFinished_0100, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_RestoreOnBundleFinished_0100"; - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)); - EXPECT_CALL(*mock_, SendRequest(_, _, _, _)) - .Times(1) - .WillOnce(Invoke(mock_.GetRefPtr(), &ServiceReverseMock::InvokeSendRequest)); - EXPECT_TRUE(proxy_ != nullptr); - proxy_->RestoreOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME); - EXPECT_TRUE(true); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by RestoreOnBundleFinished."; - } - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_RestoreOnBundleFinished_0100"; -} - -/** - * @tc.number: SUB_ServiceReverse_proxy_RestoreOnBundleFinished_0101 - * @tc.name: SUB_ServiceReverse_proxy_RestoreOnBundleFinished_0101 - * @tc.desc: Test function of RestoreOnBundleFinished interface for FAILURE. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I9OVHB - */ -HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_RestoreOnBundleFinished_0101, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_RestoreOnBundleFinished_0101"; - try { - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false)); - EXPECT_TRUE(proxy_ != nullptr); - proxy_->RestoreOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(false)); - proxy_->RestoreOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(false)); - proxy_->RestoreOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)); - EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(-1)); - proxy_->RestoreOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by RestoreOnBundleFinished."; - } - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_RestoreOnBundleFinished_0101"; -} - -/** - * @tc.number: SUB_ServiceReverse_proxy_RestoreOnAllBundlesFinished_0100 - * @tc.name: SUB_ServiceReverse_proxy_RestoreOnAllBundlesFinished_0100 - * @tc.desc: Test function of RestoreOnAllBundlesFinished interface for SUCCESS. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I6F3GV - */ -HWTEST_F(ServiceReverseProxyTest, - SUB_ServiceReverse_proxy_RestoreOnAllBundlesFinished_0100, - testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_RestoreOnAllBundlesFinished_0100"; - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true)); - EXPECT_CALL(*mock_, SendRequest(_, _, _, _)) - .Times(1) - .WillOnce(Invoke(mock_.GetRefPtr(), &ServiceReverseMock::InvokeSendRequest)); - EXPECT_TRUE(proxy_ != nullptr); - proxy_->RestoreOnAllBundlesFinished(BError(BError::Codes::OK)); - EXPECT_TRUE(true); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by RestoreOnAllBundlesFinished."; - } - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_RestoreOnAllBundlesFinished_0100"; -} - -/** - * @tc.number: SUB_ServiceReverse_proxy_RestoreOnAllBundlesFinished_0101 - * @tc.name: SUB_ServiceReverse_proxy_RestoreOnAllBundlesFinished_0101 - * @tc.desc: Test function of RestoreOnAllBundlesFinished interface for FAILURE. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I9OVHB - */ -HWTEST_F(ServiceReverseProxyTest, - SUB_ServiceReverse_proxy_RestoreOnAllBundlesFinished_0101, - testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_RestoreOnAllBundlesFinished_0101"; - try { - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false)); - EXPECT_TRUE(proxy_ != nullptr); - proxy_->RestoreOnAllBundlesFinished(BError(BError::Codes::OK)); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(false)); - proxy_->RestoreOnAllBundlesFinished(BError(BError::Codes::OK)); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true)); - EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(-1)); - proxy_->RestoreOnAllBundlesFinished(BError(BError::Codes::OK)); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by RestoreOnAllBundlesFinished."; - } - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_RestoreOnAllBundlesFinished_0101"; -} - -/** - * @tc.number: SUB_ServiceReverse_proxy_RestoreOnFileReady_0100 - * @tc.name: SUB_ServiceReverse_proxy_RestoreOnFileReady_0100 - * @tc.desc: Test function of RestoreOnFileReady interface for SUCCESS. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I6F3GV - */ -HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_RestoreOnFileReady_0100, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_RestoreOnFileReady_0100"; - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteBool(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteFileDescriptor(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true)); - EXPECT_CALL(*mock_, SendRequest(_, _, _, _)) - .Times(1) - .WillOnce(Invoke(mock_.GetRefPtr(), &ServiceReverseMock::InvokeSendRequest)); - - TestManager tm("ServiceReverseProxyTest_GetFd_0200"); - int32_t errCode = 0; - std::string filePath = tm.GetRootDirCurTest().append(FILE_NAME); - UniqueFd fd(open(filePath.data(), O_RDONLY | O_CREAT, S_IRUSR | S_IWUSR)); - if (fd < 0) { - errCode = BError::GetCodeByErrno(errno); - } - EXPECT_TRUE(proxy_ != nullptr); - proxy_->RestoreOnFileReady(BUNDLE_NAME, FILE_NAME, fd, errCode); - EXPECT_TRUE(true); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by RestoreOnFileReady."; - } - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_RestoreOnFileReady_0100"; -} - -/** - * @tc.number: SUB_ServiceReverse_proxy_RestoreOnFileReady_0101 - * @tc.name: SUB_ServiceReverse_proxy_RestoreOnFileReady_0101 - * @tc.desc: Test function of RestoreOnFileReady interface for FAILURE. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I9OVHB - */ -HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_RestoreOnFileReady_0101, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_RestoreOnFileReady_0101"; - try { - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false)); - EXPECT_TRUE(proxy_ != nullptr); - proxy_->RestoreOnFileReady(BUNDLE_NAME, FILE_NAME, 0, 0); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(false)); - proxy_->RestoreOnFileReady(BUNDLE_NAME, FILE_NAME, 0, 0); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(false)); - proxy_->RestoreOnFileReady(BUNDLE_NAME, FILE_NAME, 0, 0); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by RestoreOnFileReady."; - } - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_RestoreOnFileReady_0101"; -} - -/** - * @tc.number: SUB_ServiceReverse_proxy_RestoreOnFileReady_0102 - * @tc.name: SUB_ServiceReverse_proxy_RestoreOnFileReady_0102 - * @tc.desc: Test function of RestoreOnFileReady interface for FAILURE. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I9OVHB - */ -HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_RestoreOnFileReady_0102, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_RestoreOnFileReady_0102"; - try { - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteBool(_)).WillOnce(Return(false)); - EXPECT_TRUE(proxy_ != nullptr); - proxy_->RestoreOnFileReady(BUNDLE_NAME, FILE_NAME, 0, 0); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteBool(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteFileDescriptor(_)).WillOnce(Return(false)); - proxy_->RestoreOnFileReady(BUNDLE_NAME, FILE_NAME, 0, 0); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by RestoreOnFileReady."; - } - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_RestoreOnFileReady_0102"; -} - -/** - * @tc.number: SUB_ServiceReverse_proxy_IncrementalBackupOnFileReady_0100 - * @tc.name: SUB_ServiceReverse_proxy_IncrementalBackupOnFileReady_0100 - * @tc.desc: Test function of IncrementalBackupOnFileReady interface for SUCCESS. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I911LB - */ -HWTEST_F(ServiceReverseProxyTest, - SUB_ServiceReverse_proxy_IncrementalBackupOnFileReady_0100, - testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_IncrementalBackupOnFileReady_0100"; - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteBool(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteFileDescriptor(_)).WillOnce(Return(true)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true)); - EXPECT_CALL(*mock_, SendRequest(_, _, _, _)) - .Times(1) - .WillOnce(Invoke(mock_.GetRefPtr(), &ServiceReverseMock::InvokeSendRequest)); - - TestManager tm("ServiceReverseProxyTest_GetFd_0300"); - std::string filePath = tm.GetRootDirCurTest().append(FILE_NAME); - UniqueFd fd(open(filePath.data(), O_RDONLY | O_CREAT, S_IRUSR | S_IWUSR)); - TestManager tm1("ServiceReverseProxyTest_GetFd_0301"); - std::string manifestFilePath = tm1.GetRootDirCurTest().append(FILE_NAME_MANIFEST); - UniqueFd manifestFd(open(manifestFilePath.data(), O_RDONLY | O_CREAT, S_IRUSR | S_IWUSR)); - EXPECT_TRUE(proxy_ != nullptr); - proxy_->IncrementalBackupOnFileReady(BUNDLE_NAME, FILE_NAME, fd, manifestFd, 0); - EXPECT_TRUE(true); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by IncrementalBackupOnFileReady."; - } - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_IncrementalBackupOnFileReady_0100"; -} - -/** - * @tc.number: SUB_ServiceReverse_proxy_IncrementalBackupOnFileReady_0101 - * @tc.name: SUB_ServiceReverse_proxy_IncrementalBackupOnFileReady_0101 - * @tc.desc: Test function of IncrementalBackupOnFileReady interface for FAILURE. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I9OVHB - */ -HWTEST_F(ServiceReverseProxyTest, - SUB_ServiceReverse_proxy_IncrementalBackupOnFileReady_0101, - testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_IncrementalBackupOnFileReady_0101"; - try { - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false)); - EXPECT_TRUE(proxy_ != nullptr); - proxy_->IncrementalBackupOnFileReady(BUNDLE_NAME, FILE_NAME, 0, 0, 0); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(false)); - proxy_->IncrementalBackupOnFileReady(BUNDLE_NAME, FILE_NAME, 0, 0, 0); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(false)); - proxy_->IncrementalBackupOnFileReady(BUNDLE_NAME, FILE_NAME, 0, 0, 0); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by IncrementalBackupOnFileReady."; - } - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_IncrementalBackupOnFileReady_0101"; -} - -/** - * @tc.number: SUB_ServiceReverse_proxy_IncrementalBackupOnFileReady_0102 - * @tc.name: SUB_ServiceReverse_proxy_IncrementalBackupOnFileReady_0102 - * @tc.desc: Test function of IncrementalBackupOnFileReady interface for FAILURE. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I9OVHB - */ -HWTEST_F(ServiceReverseProxyTest, - SUB_ServiceReverse_proxy_IncrementalBackupOnFileReady_0102, - testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_IncrementalBackupOnFileReady_0102"; - try { - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteBool(_)).WillOnce(Return(false)); - EXPECT_TRUE(proxy_ != nullptr); - proxy_->IncrementalBackupOnFileReady(BUNDLE_NAME, FILE_NAME, 0, 0, 0); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteBool(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(false)); - proxy_->IncrementalBackupOnFileReady(BUNDLE_NAME, FILE_NAME, -1, 0, 0); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteBool(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteFileDescriptor(_)).WillOnce(Return(false)); - proxy_->IncrementalBackupOnFileReady(BUNDLE_NAME, FILE_NAME, 0, 0, 0); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by IncrementalBackupOnFileReady."; - } - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_IncrementalBackupOnFileReady_0102"; -} - -/** - * @tc.number: SUB_ServiceReverse_proxy_IncrementalBackupOnFileReady_0103 - * @tc.name: SUB_ServiceReverse_proxy_IncrementalBackupOnFileReady_0103 - * @tc.desc: Test function of IncrementalBackupOnFileReady interface for FAILURE. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I9OVHB - */ -HWTEST_F(ServiceReverseProxyTest, - SUB_ServiceReverse_proxy_IncrementalBackupOnFileReady_0103, - testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_IncrementalBackupOnFileReady_0103"; - try { - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteBool(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteFileDescriptor(_)).WillOnce(Return(true)).WillOnce(Return(false)); - EXPECT_TRUE(proxy_ != nullptr); - proxy_->IncrementalBackupOnFileReady(BUNDLE_NAME, FILE_NAME, 0, 0, 0); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteBool(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteFileDescriptor(_)).WillOnce(Return(true)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(false)); - proxy_->IncrementalBackupOnFileReady(BUNDLE_NAME, FILE_NAME, 0, 0, 0); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteBool(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteFileDescriptor(_)).WillOnce(Return(true)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true)); - EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(-1)); - proxy_->IncrementalBackupOnFileReady(BUNDLE_NAME, FILE_NAME, 0, 0, 0); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by IncrementalBackupOnFileReady."; - } - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_IncrementalBackupOnFileReady_0103"; -} - -/** - * @tc.number: SUB_ServiceReverse_proxy_IncrementalBackupOnBundleStarted_0100 - * @tc.name: SUB_ServiceReverse_proxy_IncrementalBackupOnBundleStarted_0100 - * @tc.desc: Test function of IncrementalBackupOnBundleStarted interface for SUCCESS. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I911LB - */ -HWTEST_F(ServiceReverseProxyTest, - SUB_ServiceReverse_proxy_IncrementalBackupOnBundleStarted_0100, - testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_IncrementalBackupOnBundleStarted_0100"; - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)); - EXPECT_CALL(*mock_, SendRequest(_, _, _, _)) - .Times(1) - .WillOnce(Invoke(mock_.GetRefPtr(), &ServiceReverseMock::InvokeSendRequest)); - EXPECT_TRUE(proxy_ != nullptr); - proxy_->IncrementalBackupOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME); - EXPECT_TRUE(true); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by IncrementalBackupOnBundleStarted."; - } - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_IncrementalBackupOnBundleStarted_0100"; -} - -/** - * @tc.number: SUB_ServiceReverse_proxy_IncrementalBackupOnBundleStarted_0101 - * @tc.name: SUB_ServiceReverse_proxy_IncrementalBackupOnBundleStarted_0101 - * @tc.desc: Test function of IncrementalBackupOnBundleStarted interface for FAILURE. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I9OVHB - */ -HWTEST_F(ServiceReverseProxyTest, - SUB_ServiceReverse_proxy_IncrementalBackupOnBundleStarted_0101, - testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_IncrementalBackupOnBundleStarted_0101"; - try { - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false)); - EXPECT_TRUE(proxy_ != nullptr); - proxy_->IncrementalBackupOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(false)); - proxy_->IncrementalBackupOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(false)); - proxy_->IncrementalBackupOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)); - EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(-1)); - proxy_->IncrementalBackupOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by IncrementalBackupOnBundleStarted."; - } - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_IncrementalBackupOnBundleStarted_0101"; -} - -/** - * @tc.number: SUB_ServiceReverse_proxy_IncrementalBackupOnBundleFinished_0100 - * @tc.name: SUB_ServiceReverse_proxy_IncrementalBackupOnBundleFinished_0100 - * @tc.desc: Test function of IncrementalBackupOnBundleFinished interface for SUCCESS. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I911LB - */ -HWTEST_F(ServiceReverseProxyTest, - SUB_ServiceReverse_proxy_IncrementalBackupOnBundleFinished_0100, - testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_IncrementalBackupOnBundleFinished_0100"; - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)); - EXPECT_CALL(*mock_, SendRequest(_, _, _, _)) - .Times(1) - .WillOnce(Invoke(mock_.GetRefPtr(), &ServiceReverseMock::InvokeSendRequest)); - EXPECT_TRUE(proxy_ != nullptr); - proxy_->IncrementalBackupOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME); - EXPECT_TRUE(true); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by IncrementalBackupOnBundleFinished."; - } - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_IncrementalBackupOnBundleFinished_0100"; -} - -/** - * @tc.number: SUB_ServiceReverse_proxy_IncrementalBackupOnBundleFinished_0101 - * @tc.name: SUB_ServiceReverse_proxy_IncrementalBackupOnBundleFinished_0101 - * @tc.desc: Test function of IncrementalBackupOnBundleFinished interface for FAILURE. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I9OVHB - */ -HWTEST_F(ServiceReverseProxyTest, - SUB_ServiceReverse_proxy_IncrementalBackupOnBundleFinished_0101, - testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_IncrementalBackupOnBundleFinished_0101"; - try { - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false)); - EXPECT_TRUE(proxy_ != nullptr); - proxy_->IncrementalBackupOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(false)); - proxy_->IncrementalBackupOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(false)); - proxy_->IncrementalBackupOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)); - EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(-1)); - proxy_->IncrementalBackupOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by IncrementalBackupOnBundleFinished."; - } - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_IncrementalBackupOnBundleFinished_0101"; -} - -/** - * @tc.number: SUB_ServiceReverse_proxy_IncrementalBackupOnAllBundlesFinished_0100 - * @tc.name: SUB_ServiceReverse_proxy_IncrementalBackupOnAllBundlesFinished_0100 - * @tc.desc: Test function of IncrementalBackupOnAllBundlesFinished interface for SUCCESS. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I911LB - */ -HWTEST_F(ServiceReverseProxyTest, - SUB_ServiceReverse_proxy_IncrementalBackupOnAllBundlesFinished_0100, - testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) - << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_IncrementalBackupOnAllBundlesFinished_0100"; - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true)); - EXPECT_CALL(*mock_, SendRequest(_, _, _, _)) - .Times(1) - .WillOnce(Invoke(mock_.GetRefPtr(), &ServiceReverseMock::InvokeSendRequest)); - EXPECT_TRUE(proxy_ != nullptr); - proxy_->IncrementalBackupOnAllBundlesFinished(BError(BError::Codes::OK)); - EXPECT_TRUE(true); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by IncrementalBackupOnAllBundlesFinished."; - } - GTEST_LOG_(INFO) - << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_IncrementalBackupOnAllBundlesFinished_0100"; -} - -/** - * @tc.number: SUB_ServiceReverse_proxy_IncrementalBackupOnAllBundlesFinished_0101 - * @tc.name: SUB_ServiceReverse_proxy_IncrementalBackupOnAllBundlesFinished_0101 - * @tc.desc: Test function of IncrementalBackupOnAllBundlesFinished interface for FAILURE. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I9OVHB - */ -HWTEST_F(ServiceReverseProxyTest, - SUB_ServiceReverse_proxy_IncrementalBackupOnAllBundlesFinished_0101, - testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) - << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_IncrementalBackupOnAllBundlesFinished_0101"; - try { - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false)); - EXPECT_TRUE(proxy_ != nullptr); - proxy_->IncrementalBackupOnAllBundlesFinished(BError(BError::Codes::OK)); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(false)); - proxy_->IncrementalBackupOnAllBundlesFinished(BError(BError::Codes::OK)); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true)); - EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(-1)); - proxy_->IncrementalBackupOnAllBundlesFinished(BError(BError::Codes::OK)); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by IncrementalBackupOnAllBundlesFinished."; - } - GTEST_LOG_(INFO) - << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_IncrementalBackupOnAllBundlesFinished_0101"; -} - -/** - * @tc.number: SUB_ServiceReverse_proxy_IncrementalRestoreOnBundleStarted_0100 - * @tc.name: SUB_ServiceReverse_proxy_IncrementalRestoreOnBundleStarted_0100 - * @tc.desc: Test function of IncrementalRestoreOnBundleStarted interface for SUCCESS. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I911LB - */ -HWTEST_F(ServiceReverseProxyTest, - SUB_ServiceReverse_proxy_IncrementalRestoreOnBundleStarted_0100, - testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_IncrementalRestoreOnBundleStarted_0100"; - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)); - EXPECT_CALL(*mock_, SendRequest(_, _, _, _)) - .Times(1) - .WillOnce(Invoke(mock_.GetRefPtr(), &ServiceReverseMock::InvokeSendRequest)); - EXPECT_TRUE(proxy_ != nullptr); - proxy_->IncrementalRestoreOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME); - EXPECT_TRUE(true); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by IncrementalRestoreOnBundleStarted."; - } - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_IncrementalRestoreOnBundleStarted_0100"; -} - -/** - * @tc.number: SUB_ServiceReverse_proxy_IncrementalRestoreOnBundleStarted_0101 - * @tc.name: SUB_ServiceReverse_proxy_IncrementalRestoreOnBundleStarted_0101 - * @tc.desc: Test function of IncrementalRestoreOnBundleStarted interface for FAILURE. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I9OVHB - */ -HWTEST_F(ServiceReverseProxyTest, - SUB_ServiceReverse_proxy_IncrementalRestoreOnBundleStarted_0101, - testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_IncrementalRestoreOnBundleStarted_0101"; - try { - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false)); - EXPECT_TRUE(proxy_ != nullptr); - proxy_->IncrementalRestoreOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(false)); - proxy_->IncrementalRestoreOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(false)); - proxy_->IncrementalRestoreOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)); - EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(-1)); - proxy_->IncrementalRestoreOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by IncrementalRestoreOnBundleStarted."; - } - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_IncrementalRestoreOnBundleStarted_0101"; -} - -/** - * @tc.number: SUB_ServiceReverse_proxy_IncrementalRestoreOnBundleFinished_0100 - * @tc.name: SUB_ServiceReverse_proxy_IncrementalRestoreOnBundleFinished_0100 - * @tc.desc: Test function of IncrementalRestoreOnBundleFinished interface for SUCCESS. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I911LB - */ -HWTEST_F(ServiceReverseProxyTest, - SUB_ServiceReverse_proxy_IncrementalRestoreOnBundleFinished_0100, - testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) - << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_IncrementalRestoreOnBundleFinished_0100"; - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)); - EXPECT_CALL(*mock_, SendRequest(_, _, _, _)) - .Times(1) - .WillOnce(Invoke(mock_.GetRefPtr(), &ServiceReverseMock::InvokeSendRequest)); - EXPECT_TRUE(proxy_ != nullptr); - proxy_->IncrementalRestoreOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME); - EXPECT_TRUE(true); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by IncrementalRestoreOnBundleFinished."; - } - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_IncrementalRestoreOnBundleFinished_0100"; -} - -/** - * @tc.number: SUB_ServiceReverse_proxy_IncrementalRestoreOnBundleFinished_0101 - * @tc.name: SUB_ServiceReverse_proxy_IncrementalRestoreOnBundleFinished_0101 - * @tc.desc: Test function of IncrementalRestoreOnBundleFinished interface for FAILURE. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I9OVHB - */ -HWTEST_F(ServiceReverseProxyTest, - SUB_ServiceReverse_proxy_IncrementalRestoreOnBundleFinished_0101, - testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) - << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_IncrementalRestoreOnBundleFinished_0101"; - try { - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false)); - EXPECT_TRUE(proxy_ != nullptr); - proxy_->IncrementalRestoreOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(false)); - proxy_->IncrementalRestoreOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(false)); - proxy_->IncrementalRestoreOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)); - EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(-1)); - proxy_->IncrementalRestoreOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by IncrementalRestoreOnBundleFinished."; - } - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_IncrementalRestoreOnBundleFinished_0101"; -} - -/** - * @tc.number: SUB_ServiceReverse_proxy_IncrementalRestoreOnAllBundlesFinished_0100 - * @tc.name: SUB_ServiceReverse_proxy_IncrementalRestoreOnAllBundlesFinished_0100 - * @tc.desc: Test function of IncrementalRestoreOnAllBundlesFinished interface for SUCCESS. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I911LB - */ -HWTEST_F(ServiceReverseProxyTest, - SUB_ServiceReverse_proxy_IncrementalRestoreOnAllBundlesFinished_0100, - testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) - << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_IncrementalRestoreOnAllBundlesFinished_0100"; - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true)); - EXPECT_CALL(*mock_, SendRequest(_, _, _, _)) - .Times(1) - .WillOnce(Invoke(mock_.GetRefPtr(), &ServiceReverseMock::InvokeSendRequest)); - EXPECT_TRUE(proxy_ != nullptr); - proxy_->IncrementalRestoreOnAllBundlesFinished(BError(BError::Codes::OK)); - EXPECT_TRUE(true); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by IncrementalRestoreOnAllBundlesFinished."; - } - GTEST_LOG_(INFO) - << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_IncrementalRestoreOnAllBundlesFinished_0100"; -} - -/** - * @tc.number: SUB_ServiceReverse_proxy_IncrementalRestoreOnAllBundlesFinished_0101 - * @tc.name: SUB_ServiceReverse_proxy_IncrementalRestoreOnAllBundlesFinished_0101 - * @tc.desc: Test function of IncrementalRestoreOnAllBundlesFinished interface for FAILURE. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I9OVHB - */ -HWTEST_F(ServiceReverseProxyTest, - SUB_ServiceReverse_proxy_IncrementalRestoreOnAllBundlesFinished_0101, - testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) - << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_IncrementalRestoreOnAllBundlesFinished_0101"; - try { - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false)); - EXPECT_TRUE(proxy_ != nullptr); - proxy_->IncrementalRestoreOnAllBundlesFinished(BError(BError::Codes::OK)); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(false)); - proxy_->IncrementalRestoreOnAllBundlesFinished(BError(BError::Codes::OK)); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true)); - EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(-1)); - proxy_->IncrementalRestoreOnAllBundlesFinished(BError(BError::Codes::OK)); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by IncrementalRestoreOnAllBundlesFinished."; - } - GTEST_LOG_(INFO) - << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_IncrementalRestoreOnAllBundlesFinished_0101"; -} - -/** - * @tc.number: SUB_ServiceReverse_proxy_IncrementalRestoreOnFileReady_0100 - * @tc.name: SUB_ServiceReverse_proxy_IncrementalRestoreOnFileReady_0100 - * @tc.desc: Test function of IncrementalRestoreOnFileReady interface for SUCCESS. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I911LB - */ -HWTEST_F(ServiceReverseProxyTest, - SUB_ServiceReverse_proxy_IncrementalRestoreOnFileReady_0100, - testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_IncrementalRestoreOnFileReady_0100"; - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteBool(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteFileDescriptor(_)).WillOnce(Return(true)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true)); - EXPECT_CALL(*mock_, SendRequest(_, _, _, _)) - .Times(1) - .WillOnce(Invoke(mock_.GetRefPtr(), &ServiceReverseMock::InvokeSendRequest)); - - TestManager tm("ServiceReverseProxyTest_GetFd_0400"); - std::string filePath = tm.GetRootDirCurTest().append(FILE_NAME); - UniqueFd fd(open(filePath.data(), O_RDONLY | O_CREAT, S_IRUSR | S_IWUSR)); - TestManager tm1("ServiceReverseProxyTest_GetFd_0401"); - std::string manifestFilePath = tm1.GetRootDirCurTest().append(FILE_NAME_MANIFEST); - UniqueFd manifestFd(open(manifestFilePath.data(), O_RDONLY | O_CREAT, S_IRUSR | S_IWUSR)); - EXPECT_TRUE(proxy_ != nullptr); - proxy_->IncrementalRestoreOnFileReady(BUNDLE_NAME, FILE_NAME, fd, manifestFd, 0); - EXPECT_TRUE(true); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by IncrementalRestoreOnFileReady."; - } - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_IncrementalRestoreOnFileReady_0100"; -} - -/** - * @tc.number: SUB_ServiceReverse_proxy_IncrementalRestoreOnFileReady_0101 - * @tc.name: SUB_ServiceReverse_proxy_IncrementalRestoreOnFileReady_0101 - * @tc.desc: Test function of IncrementalRestoreOnFileReady interface for FAILURE. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I9OVHB - */ -HWTEST_F(ServiceReverseProxyTest, - SUB_ServiceReverse_proxy_IncrementalRestoreOnFileReady_0101, - testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_IncrementalRestoreOnFileReady_0101"; - try { - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false)); - EXPECT_TRUE(proxy_ != nullptr); - proxy_->IncrementalRestoreOnFileReady(BUNDLE_NAME, FILE_NAME, 0, 0, 0); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(false)); - proxy_->IncrementalRestoreOnFileReady(BUNDLE_NAME, FILE_NAME, 0, 0, 0); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(false)); - proxy_->IncrementalRestoreOnFileReady(BUNDLE_NAME, FILE_NAME, 0, 0, 0); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteBool(_)).WillOnce(Return(false)); - proxy_->IncrementalRestoreOnFileReady(BUNDLE_NAME, FILE_NAME, 0, 0, 0); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by IncrementalRestoreOnFileReady."; - } - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_IncrementalRestoreOnFileReady_0101"; -} - -/** - * @tc.number: SUB_ServiceReverse_proxy_IncrementalRestoreOnFileReady_0102 - * @tc.name: SUB_ServiceReverse_proxy_IncrementalRestoreOnFileReady_0102 - * @tc.desc: Test function of IncrementalRestoreOnFileReady interface for FAILURE. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I9OVHB - */ -HWTEST_F(ServiceReverseProxyTest, - SUB_ServiceReverse_proxy_IncrementalRestoreOnFileReady_0102, - testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_IncrementalRestoreOnFileReady_0102"; - try { - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteBool(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(false)); - EXPECT_TRUE(proxy_ != nullptr); - proxy_->IncrementalRestoreOnFileReady(BUNDLE_NAME, FILE_NAME, -1, 0, 0); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteBool(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteFileDescriptor(_)).WillOnce(Return(false)); - proxy_->IncrementalRestoreOnFileReady(BUNDLE_NAME, FILE_NAME, 0, 0, 0); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteBool(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteFileDescriptor(_)).WillOnce(Return(true)).WillOnce(Return(false)); - proxy_->IncrementalRestoreOnFileReady(BUNDLE_NAME, FILE_NAME, 0, 0, 0); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by IncrementalRestoreOnFileReady."; - } - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_IncrementalRestoreOnFileReady_0102"; -} - -/** - * @tc.number: SUB_ServiceReverse_proxy_IncrementalRestoreOnFileReady_0103 - * @tc.name: SUB_ServiceReverse_proxy_IncrementalRestoreOnFileReady_0103 - * @tc.desc: Test function of IncrementalRestoreOnFileReady interface for FAILURE. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I9OVHB - */ -HWTEST_F(ServiceReverseProxyTest, - SUB_ServiceReverse_proxy_IncrementalRestoreOnFileReady_0103, - testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_IncrementalRestoreOnFileReady_0103"; - try { - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteBool(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteFileDescriptor(_)).WillOnce(Return(true)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(false)); - EXPECT_TRUE(proxy_ != nullptr); - proxy_->IncrementalRestoreOnFileReady(BUNDLE_NAME, FILE_NAME, 0, 0, 0); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteBool(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteFileDescriptor(_)).WillOnce(Return(true)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true)); - EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(-1)); - proxy_->IncrementalRestoreOnFileReady(BUNDLE_NAME, FILE_NAME, 0, 0, 0); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by IncrementalRestoreOnFileReady."; - } - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_IncrementalRestoreOnFileReady_0103"; -} - -/** - * @tc.number: SUB_ServiceReverse_proxy_RestoreOnResultReport_0100 - * @tc.name: SUB_ServiceReverse_proxy_RestoreOnResultReport_0100 - * @tc.desc: Test function of RestoreOnResultReport interface for SUCCESS. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I6F3GV - */ -HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_RestoreOnResultReport_0100, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_RestoreOnResultReport_0100"; - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true)); - EXPECT_CALL(*mock_, SendRequest(_, _, _, _)) - .Times(1) - .WillOnce(Invoke(mock_.GetRefPtr(), &ServiceReverseMock::InvokeSendRequest)); - std::string bundleName = "app01"; - EXPECT_TRUE(proxy_ != nullptr); - proxy_->RestoreOnResultReport(RESULT_REPORT, bundleName); - EXPECT_TRUE(true); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by RestoreOnResultReport."; - } - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_RestoreOnResultReport_0100"; -} - -/** - * @tc.number: SUB_ServiceReverse_proxy_RestoreOnResultReport_0101 - * @tc.name: SUB_ServiceReverse_proxy_RestoreOnResultReport_0101 - * @tc.desc: Test function of RestoreOnResultReport interface for FAILURE. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I9OVHB - */ -HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_RestoreOnResultReport_0101, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_RestoreOnResultReport_0101"; - try { - std::string bundleName = "app01"; - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false)); - EXPECT_TRUE(proxy_ != nullptr); - proxy_->RestoreOnResultReport(RESULT_REPORT, bundleName); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(false)); - proxy_->RestoreOnResultReport(RESULT_REPORT, bundleName); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(false)); - proxy_->RestoreOnResultReport(RESULT_REPORT, bundleName); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true)); - EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(-1)); - proxy_->RestoreOnResultReport(RESULT_REPORT, bundleName); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by RestoreOnResultReport."; - } - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_RestoreOnResultReport_0101"; -} - -/** - * @tc.number: SUB_ServiceReverse_proxy_IncrementalRestoreOnResultReport_0100 - * @tc.name: SUB_ServiceReverse_proxy_IncrementalRestoreOnResultReport_0100 - * @tc.desc: Test function of IncrementalRestoreOnResultReport interface for SUCCESS. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I6F3GV - */ -HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_IncrementalRestoreOnResultReport_0100, - testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_IncrementalRestoreOnResultReport_0100"; - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true)); - EXPECT_CALL(*mock_, SendRequest(_, _, _, _)) - .Times(1) - .WillOnce(Invoke(mock_.GetRefPtr(), &ServiceReverseMock::InvokeSendRequest)); - std::string bundleName = "app01"; - EXPECT_TRUE(proxy_ != nullptr); - proxy_->IncrementalRestoreOnResultReport(RESULT_REPORT, bundleName); - EXPECT_TRUE(true); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by RestoreOnResultReport."; - } - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_IncrementalRestoreOnResultReport_0100"; -} - -/** - * @tc.number: SUB_ServiceReverse_proxy_IncrementalRestoreOnResultReport_0101 - * @tc.name: SUB_ServiceReverse_proxy_IncrementalRestoreOnResultReport_0101 - * @tc.desc: Test function of IncrementalRestoreOnResultReport interface for FAILURE. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I9OVHB - */ -HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_IncrementalRestoreOnResultReport_0101, - testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_IncrementalRestoreOnResultReport_0101"; - try { - std::string bundleName = "app01"; - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false)); - EXPECT_TRUE(proxy_ != nullptr); - proxy_->IncrementalRestoreOnResultReport(RESULT_REPORT, bundleName); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(false)); - proxy_->IncrementalRestoreOnResultReport(RESULT_REPORT, bundleName); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(false)); - proxy_->IncrementalRestoreOnResultReport(RESULT_REPORT, bundleName); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteInt32(_)).WillOnce(Return(true)); - EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(-1)); - proxy_->IncrementalRestoreOnResultReport(RESULT_REPORT, bundleName); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by RestoreOnResultReport."; - } - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_IncrementalRestoreOnResultReport_0101"; -} - -/** - * @tc.number: SUB_ServiceReverse_proxy_IncrementalBackupOnResultReport_0100 - * @tc.name: SUB_ServiceReverse_proxy_IncrementalBackupOnResultReport_0100 - * @tc.desc: Test function of IncrementalBackupOnResultReport interface for FAILURE. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I9OVHB - */ -HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_IncrementalBackupOnResultReport_0100, - testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_IncrementalBackupOnResultReport_0100"; - try { - std::string bundleName = "app01"; - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false)); - EXPECT_TRUE(proxy_ != nullptr); - proxy_->IncrementalBackupOnResultReport(RESULT_REPORT, bundleName); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(false)); - proxy_->IncrementalBackupOnResultReport(RESULT_REPORT, bundleName); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(false)); - proxy_->IncrementalBackupOnResultReport(RESULT_REPORT, bundleName); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true)); - EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(-1)); - proxy_->IncrementalBackupOnResultReport(RESULT_REPORT, bundleName); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by IncrementalBackupOnResultReport."; - } - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_IncrementalBackupOnResultReport_0100"; -} - -/** - * @tc.number: SUB_ServiceReverse_proxy_IncrementalBackupOnResultReport_0101 - * @tc.name: SUB_ServiceReverse_proxy_IncrementalBackupOnResultReport_0101 - * @tc.desc: Test function of IncrementalBackupOnResultReport interface for SUCCESS. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I6F3GV - */ -HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_IncrementalBackupOnResultReport_0101, - testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_IncrementalBackupOnResultReport_0101"; - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true)); - EXPECT_CALL(*mock_, SendRequest(_, _, _, _)) - .Times(1) - .WillOnce(Invoke(mock_.GetRefPtr(), &ServiceReverseMock::InvokeSendRequest)); - std::string bundleName = "app01"; - EXPECT_TRUE(proxy_ != nullptr); - proxy_->IncrementalBackupOnResultReport(RESULT_REPORT, bundleName); - EXPECT_TRUE(true); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by RestoreOnResultReport."; - } - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_IncrementalBackupOnResultReport_0101"; -} - -/** - * @tc.number: SUB_ServiceReverse_proxy_BackupOnProcessInfo_0100 - * @tc.name: SUB_ServiceReverse_proxy_BackupOnProcessInfo_0100 - * @tc.desc: Test function of BackupOnProcessInfo interface for SUCCESS. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I6F3GV - */ -HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_BackupOnProcessInfo_0100, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_BackupOnProcessInfo_0100"; - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true)); - EXPECT_CALL(*mock_, SendRequest(_, _, _, _)) - .Times(1) - .WillOnce(Invoke(mock_.GetRefPtr(), &ServiceReverseMock::InvokeSendRequest)); - EXPECT_TRUE(proxy_ != nullptr); - std::string processInfo = "{\"timeInfo\": \"\", \"resultInfo\": \"\"}"; - proxy_->BackupOnProcessInfo(BUNDLE_NAME, processInfo); - EXPECT_TRUE(true); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by BackupOnProcessInfo."; - } - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_BackupOnProcessInfo_0100"; -} - -/** - * @tc.number: SUB_ServiceReverse_proxy_BackupOnProcessInfo_0101 - * @tc.name: SUB_ServiceReverse_proxy_BackupOnProcessInfo_0101 - * @tc.desc: Test function of BackupOnProcessInfo interface for FAILURE. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I6F3GV - */ -HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_BackupOnProcessInfo_0101, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_BackupOnProcessInfo_0101"; - try { - std::string processInfo = "{\"timeInfo\": \"\", \"resultInfo\": \"\"}"; - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false)); - EXPECT_TRUE(proxy_ != nullptr); - proxy_->BackupOnProcessInfo(BUNDLE_NAME, processInfo); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(false)); - EXPECT_TRUE(proxy_ != nullptr); - proxy_->BackupOnProcessInfo(BUNDLE_NAME, processInfo); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(false)); - EXPECT_TRUE(proxy_ != nullptr); - proxy_->BackupOnProcessInfo(BUNDLE_NAME, processInfo); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true)); - EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(-1)); - proxy_->BackupOnProcessInfo(BUNDLE_NAME, processInfo); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by BackupOnProcessInfo."; - } - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_BackupOnProcessInfo_0101"; -} - -/** - * @tc.number: SUB_ServiceReverse_proxy_RestoreOnProcessInfo_0100 - * @tc.name: SUB_ServiceReverse_proxy_RestoreOnProcessInfo_0100 - * @tc.desc: Test function of RestoreOnProcessInfo interface for SUCCESS. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I6F3GV - */ -HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_RestoreOnProcessInfo_0100, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_RestoreOnProcessInfo_0100"; - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true)); - EXPECT_CALL(*mock_, SendRequest(_, _, _, _)) - .Times(1) - .WillOnce(Invoke(mock_.GetRefPtr(), &ServiceReverseMock::InvokeSendRequest)); - EXPECT_TRUE(proxy_ != nullptr); - std::string processInfo = "{\"timeInfo\": \"\", \"resultInfo\": \"\"}"; - proxy_->RestoreOnProcessInfo(BUNDLE_NAME, processInfo); - EXPECT_TRUE(true); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by RestoreOnProcessInfo."; - } - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_RestoreOnProcessInfo_0100"; -} - -/** - * @tc.number: SUB_ServiceReverse_proxy_RestoreOnProcessInfo_0101 - * @tc.name: SUB_ServiceReverse_proxy_RestoreOnProcessInfo_0101 - * @tc.desc: Test function of RestoreOnProcessInfo interface for FAILURE. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I6F3GV - */ -HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_RestoreOnProcessInfo_0101, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_RestoreOnProcessInfo_0101"; - try { - std::string processInfo = "{\"timeInfo\": \"\", \"resultInfo\": \"\"}"; - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false)); - EXPECT_TRUE(proxy_ != nullptr); - proxy_->RestoreOnProcessInfo(BUNDLE_NAME, processInfo); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(false)); - EXPECT_TRUE(proxy_ != nullptr); - proxy_->RestoreOnProcessInfo(BUNDLE_NAME, processInfo); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(false)); - EXPECT_TRUE(proxy_ != nullptr); - proxy_->RestoreOnProcessInfo(BUNDLE_NAME, processInfo); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true)); - EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(-1)); - proxy_->RestoreOnProcessInfo(BUNDLE_NAME, processInfo); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by RestoreOnProcessInfo."; - } - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_RestoreOnProcessInfo_0101"; -} - -/** - * @tc.number: SUB_ServiceReverse_proxy_IncrementalBackupOnProcessInfo_0100 - * @tc.name: SUB_ServiceReverse_proxy_IncrementalBackupOnProcessInfo_0100 - * @tc.desc: Test function of IncrementalBackupOnProcessInfo interface for SUCCESS. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I6F3GV - */ -HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_IncrementalBackupOnProcessInfo_0100, - testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_IncrementalBackupOnProcessInfo_0100"; - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true)); - EXPECT_CALL(*mock_, SendRequest(_, _, _, _)) - .Times(1) - .WillOnce(Invoke(mock_.GetRefPtr(), &ServiceReverseMock::InvokeSendRequest)); - EXPECT_TRUE(proxy_ != nullptr); - std::string processInfo = "{\"timeInfo\": \"\", \"resultInfo\": \"\"}"; - proxy_->IncrementalBackupOnProcessInfo(BUNDLE_NAME, processInfo); - EXPECT_TRUE(true); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by IncrementalBackupOnProcessInfo."; - } - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_IncrementalBackupOnProcessInfo_0100"; -} - -/** - * @tc.number: SUB_ServiceReverse_proxy_IncrementalBackupOnProcessInfo_0101 - * @tc.name: SUB_ServiceReverse_proxy_IncrementalBackupOnProcessInfo_0101 - * @tc.desc: Test function of IncrementalBackupOnProcessInfo interface for FAILURE. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I6F3GV - */ -HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_IncrementalBackupOnProcessInfo_0101, - testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_IncrementalBackupOnProcessInfo_0101"; - try { - std::string processInfo = "{\"timeInfo\": \"\", \"resultInfo\": \"\"}"; - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false)); - EXPECT_TRUE(proxy_ != nullptr); - proxy_->IncrementalBackupOnProcessInfo(BUNDLE_NAME, processInfo); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(false)); - EXPECT_TRUE(proxy_ != nullptr); - proxy_->IncrementalBackupOnProcessInfo(BUNDLE_NAME, processInfo); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(false)); - EXPECT_TRUE(proxy_ != nullptr); - proxy_->IncrementalBackupOnProcessInfo(BUNDLE_NAME, processInfo); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true)); - EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(-1)); - proxy_->IncrementalBackupOnProcessInfo(BUNDLE_NAME, processInfo); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by IncrementalBackupOnProcessInfo."; - } - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_IncrementalBackupOnProcessInfo_0101"; -} - -/** - * @tc.number: SUB_ServiceReverse_proxy_IncrementalRestoreOnProcessInfo_0100 - * @tc.name: SUB_ServiceReverse_proxy_IncrementalRestoreOnProcessInfo_0100 - * @tc.desc: Test function of IncrementalRestoreOnProcessInfo interface for SUCCESS. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I6F3GV - */ -HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_IncrementalRestoreOnProcessInfo_0100, - testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_IncrementalRestoreOnProcessInfo_0100"; - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true)); - EXPECT_CALL(*mock_, SendRequest(_, _, _, _)) - .Times(1) - .WillOnce(Invoke(mock_.GetRefPtr(), &ServiceReverseMock::InvokeSendRequest)); - EXPECT_TRUE(proxy_ != nullptr); - std::string processInfo = "{\"timeInfo\": \"\", \"resultInfo\": \"\"}"; - proxy_->IncrementalRestoreOnProcessInfo(BUNDLE_NAME, processInfo); - EXPECT_TRUE(true); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by IncrementalRestoreOnProcessInfo."; - } - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_IncrementalRestoreOnProcessInfo_0100"; -} - -/** - * @tc.number: SUB_ServiceReverse_proxy_IncrementalRestoreOnProcessInfo_0101 - * @tc.name: SUB_ServiceReverse_proxy_IncrementalRestoreOnProcessInfo_0101 - * @tc.desc: Test function of IncrementalRestoreOnProcessInfo interface for FAILURE. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I6F3GV - */ -HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_IncrementalRestoreOnProcessInfo_0101, - testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_IncrementalRestoreOnProcessInfo_0101"; - try { - std::string processInfo = "{\"timeInfo\": \"\", \"resultInfo\": \"\"}"; - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false)); - EXPECT_TRUE(proxy_ != nullptr); - proxy_->IncrementalRestoreOnProcessInfo(BUNDLE_NAME, processInfo); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(false)); - EXPECT_TRUE(proxy_ != nullptr); - proxy_->IncrementalRestoreOnProcessInfo(BUNDLE_NAME, processInfo); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(false)); - EXPECT_TRUE(proxy_ != nullptr); - proxy_->IncrementalRestoreOnProcessInfo(BUNDLE_NAME, processInfo); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)).WillOnce(Return(true)); - EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(-1)); - proxy_->IncrementalRestoreOnProcessInfo(BUNDLE_NAME, processInfo); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by IncrementalRestoreOnProcessInfo."; - } - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_IncrementalRestoreOnProcessInfo_0101"; -} - -/** - * @tc.number: SUB_ServiceReverse_proxy_BackupOnScanningInfo_0100 - * @tc.name: SUB_ServiceReverse_proxy_BackupOnScanningInfo_0100 - * @tc.desc: Test function of BackupOnScanningInfo interface for SUCCESS. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I6F3GV - */ -HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_BackupOnScanningInfo_0100, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_BackupOnScanningInfo_0100"; - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)); - EXPECT_CALL(*mock_, SendRequest(_, _, _, _)) - .Times(1) - .WillOnce(Invoke(mock_.GetRefPtr(), &ServiceReverseMock::InvokeSendRequest)); - EXPECT_TRUE(proxy_ != nullptr); - std::string scannedInfo; - proxy_->BackupOnScanningInfo(scannedInfo); - EXPECT_TRUE(true); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by BackupOnScanningInfo."; - } - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_BackupOnScanningInfo_0100"; -} - -/** - * @tc.number: SUB_ServiceReverse_proxy_BackupOnScanningInfo_0101 - * @tc.name: SUB_ServiceReverse_proxy_BackupOnScanningInfo_0101 - * @tc.desc: Test function of BackupOnScanningInfo interface for FAILURE. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I6F3GV - */ -HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_BackupOnScanningInfo_0101, - testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_BackupOnScanningInfo_0101"; - try { - std::string scannedInfo; - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false)); - EXPECT_TRUE(proxy_ != nullptr); - proxy_->BackupOnScanningInfo(scannedInfo); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(false)); - EXPECT_TRUE(proxy_ != nullptr); - proxy_->BackupOnScanningInfo(scannedInfo); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)); - EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(-1)); - proxy_->BackupOnScanningInfo(scannedInfo); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by BackupOnScanningInfo."; - } - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_BackupOnScanningInfo_0101"; -} - -/** - * @tc.number: SUB_ServiceReverse_proxy_IncrementalBackupOnScanningInfo_0100 - * @tc.name: SUB_ServiceReverse_proxy_IncrementalBackupOnScanningInfo_0100 - * @tc.desc: Test function of IncrementalBackupOnScanningInfo interface for SUCCESS. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I6F3GV - */ -HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_IncrementalBackupOnScanningInfo_0100, - testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_IncrementalBackupOnScanningInfo_0100"; - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)); - EXPECT_CALL(*mock_, SendRequest(_, _, _, _)) - .Times(1) - .WillOnce(Invoke(mock_.GetRefPtr(), &ServiceReverseMock::InvokeSendRequest)); - EXPECT_TRUE(proxy_ != nullptr); - std::string scannedInfo; - proxy_->IncrementalBackupOnScanningInfo(scannedInfo); - EXPECT_TRUE(true); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by IncrementalBackupOnScanningInfo."; - } - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_IncrementalBackupOnScanningInfo_0100"; -} - -/** - * @tc.number: SUB_ServiceReverse_proxy_IncrementalBackupOnScanningInfo_0101 - * @tc.name: SUB_ServiceReverse_proxy_IncrementalBackupOnScanningInfo_0101 - * @tc.desc: Test function of IncrementalBackupOnScanningInfo interface for FAILURE. - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I6F3GV - */ -HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_IncrementalBackupOnScanningInfo_0101, - testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-begin SUB_ServiceReverse_proxy_IncrementalBackupOnScanningInfo_0101"; - try { - std::string scannedInfo; - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(false)); - EXPECT_TRUE(proxy_ != nullptr); - proxy_->IncrementalBackupOnScanningInfo(scannedInfo); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(false)); - EXPECT_TRUE(proxy_ != nullptr); - proxy_->IncrementalBackupOnScanningInfo(scannedInfo); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - - try { - EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); - EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)); - EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(-1)); - proxy_->IncrementalBackupOnScanningInfo(scannedInfo); - EXPECT_TRUE(false); - } catch (BError &err) { - EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); - } - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-an exception occurred by IncrementalBackupOnScanningInfo."; - } - GTEST_LOG_(INFO) << "ServiceReverseProxyTest-end SUB_ServiceReverse_proxy_IncrementalBackupOnScanningInfo_0101"; -} -} // namespace OHOS::FileManagement::Backup \ No newline at end of file diff --git a/tests/unittests/backup_sa/module_ipc/service_test.cpp b/tests/unittests/backup_sa/module_ipc/service_test.cpp index 8e29a796fec12026d3b5f9df608879c3c18c9dbe..1617f219bedabf0b9ab9443802d2bf4838f8d0ee 100644 --- a/tests/unittests/backup_sa/module_ipc/service_test.cpp +++ b/tests/unittests/backup_sa/module_ipc/service_test.cpp @@ -44,7 +44,7 @@ public: void SetUp() {}; void TearDown() {}; - ErrCode Init(IServiceReverse::Scenario scenario); + ErrCode Init(IServiceReverseType::Scenario scenario); static inline sptr servicePtr_ = nullptr; static inline sptr remote_ = nullptr; @@ -64,7 +64,7 @@ void ServiceTest::TearDownTestCase() remote_ = nullptr; } -ErrCode ServiceTest::Init(IServiceReverse::Scenario scenario) +ErrCode ServiceTest::Init(IServiceReverseType::Scenario scenario) { vector bundleNames; vector detailInfos; @@ -83,7 +83,7 @@ ErrCode ServiceTest::Init(IServiceReverse::Scenario scenario) detailInfos.emplace_back(json); string errMsg; ErrCode ret = 0; - if (scenario == IServiceReverse::Scenario::RESTORE) { + if (scenario == IServiceReverseType::Scenario::RESTORE) { EXPECT_TRUE(servicePtr_ != nullptr); EXPECT_TRUE(remote_ != nullptr); UniqueFd fd = servicePtr_->GetLocalCapabilities(); @@ -97,8 +97,8 @@ ErrCode ServiceTest::Init(IServiceReverse::Scenario scenario) EXPECT_EQ(ret, BError(BError::Codes::OK)); ret = servicePtr_->Finish(); EXPECT_EQ(ret, BError(BError::Codes::OK)); - } else if (scenario == IServiceReverse::Scenario::BACKUP) { - sptr srptr_=static_cast>(remote_); + } else if (scenario == IServiceReverseType::Scenario::BACKUP) { + sptr srptr_ = static_cast>(remote_); ret = servicePtr_->InitBackupSession(srptr_); EXPECT_EQ(ret, BError(BError::Codes::OK)); ret = servicePtr_->InitBackupSessionWithErrMsg(srptr_, errMsg); @@ -215,7 +215,7 @@ HWTEST_F(ServiceTest, SUB_Service_PublishFile_0100, testing::ext::TestSize.Level { GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_PublishFile_0100"; try { - ErrCode ret = Init(IServiceReverse::Scenario::RESTORE); + ErrCode ret = Init(IServiceReverseType::Scenario::RESTORE); EXPECT_EQ(ret, BError(BError::Codes::OK)); BFileInfo fileInfo {BUNDLE_NAME, "", 0}; EXPECT_TRUE(servicePtr_ != nullptr); @@ -245,7 +245,7 @@ HWTEST_F(ServiceTest, SUB_Service_PublishFile_0101, testing::ext::TestSize.Level { GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_PublishFile_0101"; try { - ErrCode ret = Init(IServiceReverse::Scenario::RESTORE); + ErrCode ret = Init(IServiceReverseType::Scenario::RESTORE); EXPECT_EQ(ret, BError(BError::Codes::OK)); BFileInfo fileInfo {BUNDLE_NAME, "", 0}; EXPECT_TRUE(servicePtr_ != nullptr); @@ -275,7 +275,7 @@ HWTEST_F(ServiceTest, SUB_Service_PublishFile_0102, testing::ext::TestSize.Level { GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_PublishFile_0102"; try { - ErrCode ret = Init(IServiceReverse::Scenario::RESTORE); + ErrCode ret = Init(IServiceReverseType::Scenario::RESTORE); EXPECT_EQ(ret, BError(BError::Codes::OK)); BFileInfo fileInfo {BUNDLE_NAME, "", 0}; EXPECT_TRUE(servicePtr_ != nullptr); @@ -406,7 +406,7 @@ HWTEST_F(ServiceTest, SUB_Service_AppDone_0100, testing::ext::TestSize.Level1) auto ret = servicePtr_->AppDone(BError(BError::Codes::OK)); EXPECT_EQ(ret, BError(BError::Codes::OK)); GTEST_LOG_(INFO) << "SUB_Service_AppDone_0100 BACKUP"; - ret = Init(IServiceReverse::Scenario::BACKUP); + ret = Init(IServiceReverseType::Scenario::BACKUP); EXPECT_EQ(ret, BError(BError::Codes::OK)); GTEST_LOG_(INFO) << "ServiceTest-AppDone Branches"; ret = servicePtr_->AppDone(1); @@ -439,7 +439,7 @@ HWTEST_F(ServiceTest, SUB_Service_AppDone_0101, testing::ext::TestSize.Level1) auto ret = servicePtr_->AppDone(BError(BError::Codes::OK)); EXPECT_EQ(ret, BError(BError::Codes::OK)); GTEST_LOG_(INFO) << "SUB_Service_AppDone_0101 RESTORE"; - ret = Init(IServiceReverse::Scenario::RESTORE); + ret = Init(IServiceReverseType::Scenario::RESTORE); EXPECT_EQ(ret, BError(BError::Codes::OK)); ret = servicePtr_->AppDone(BError(BError::Codes::OK)); EXPECT_EQ(ret, BError(BError::Codes::OK)); @@ -526,13 +526,13 @@ HWTEST_F(ServiceTest, SUB_Service_LaunchBackupExtension_0100, testing::ext::Test GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_LaunchBackupExtension_0100"; try { GTEST_LOG_(INFO) << "SUB_Service_LaunchBackupExtension_0100 RESTORE"; - ErrCode ret = Init(IServiceReverse::Scenario::RESTORE); + ErrCode ret = Init(IServiceReverseType::Scenario::RESTORE); EXPECT_EQ(ret, BError(BError::Codes::OK)); EXPECT_TRUE(servicePtr_ != nullptr); ret = servicePtr_->LaunchBackupExtension(BUNDLE_NAME); EXPECT_EQ(ret, BError(BError::Codes::OK)); GTEST_LOG_(INFO) << "SUB_Service_LaunchBackupExtension_0100 BACKUP"; - ret = Init(IServiceReverse::Scenario::BACKUP); + ret = Init(IServiceReverseType::Scenario::BACKUP); EXPECT_EQ(ret, BError(BError::Codes::OK)); ret = servicePtr_->LaunchBackupExtension(BUNDLE_NAME); EXPECT_EQ(ret, BError(BError::Codes::OK)); @@ -557,7 +557,7 @@ HWTEST_F(ServiceTest, SUB_Service_LaunchBackupExtension_0101, testing::ext::Test GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_LaunchBackupExtension_0101"; try { GTEST_LOG_(INFO) << "SUB_Service_LaunchBackupExtension_0100 UNDEFINED"; - ErrCode ret = Init(IServiceReverse::Scenario::UNDEFINED); + ErrCode ret = Init(IServiceReverseType::Scenario::UNDEFINED); EXPECT_EQ(ret, BError(BError::Codes::OK)); EXPECT_TRUE(servicePtr_ != nullptr); ret = servicePtr_->LaunchBackupExtension(BUNDLE_NAME); @@ -582,7 +582,7 @@ HWTEST_F(ServiceTest, SUB_Service_GetFileHandle_0100, testing::ext::TestSize.Lev { GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_GetFileHandle_0100"; try { - ErrCode ret = Init(IServiceReverse::Scenario::RESTORE); + ErrCode ret = Init(IServiceReverseType::Scenario::RESTORE); EXPECT_EQ(ret, BError(BError::Codes::OK)); EXPECT_TRUE(servicePtr_ != nullptr); ret = servicePtr_->GetFileHandle(BUNDLE_NAME, FILE_NAME); @@ -607,7 +607,7 @@ HWTEST_F(ServiceTest, SUB_Service_GetFileHandle_0101, testing::ext::TestSize.Lev { GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_GetFileHandle_0101"; try { - ErrCode ret = Init(IServiceReverse::Scenario::RESTORE); + ErrCode ret = Init(IServiceReverseType::Scenario::RESTORE); EXPECT_EQ(ret, BError(BError::Codes::OK)); SvcSessionManager::Impl impl_; @@ -643,13 +643,13 @@ HWTEST_F(ServiceTest, SUB_Service_OnBackupExtensionDied_0100, testing::ext::Test GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_OnBackupExtensionDied_0100"; try { GTEST_LOG_(INFO) << "SUB_Service_OnBackupExtensionDied_0100 RESTORE"; - ErrCode ret = Init(IServiceReverse::Scenario::RESTORE); + ErrCode ret = Init(IServiceReverseType::Scenario::RESTORE); EXPECT_EQ(ret, BError(BError::Codes::OK)); string bundleName = BUNDLE_NAME; EXPECT_TRUE(servicePtr_ != nullptr); servicePtr_->OnBackupExtensionDied(move(bundleName)); GTEST_LOG_(INFO) << "SUB_Service_OnBackupExtensionDied_0100 BACKUP"; - ret = Init(IServiceReverse::Scenario::BACKUP); + ret = Init(IServiceReverseType::Scenario::BACKUP); EXPECT_EQ(ret, BError(BError::Codes::OK)); bundleName = BUNDLE_NAME; servicePtr_->OnBackupExtensionDied(move(bundleName)); @@ -674,7 +674,7 @@ HWTEST_F(ServiceTest, SUB_Service_OnBackupExtensionDied_0101, testing::ext::Test GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_OnBackupExtensionDied_0101"; try { GTEST_LOG_(INFO) << "SUB_Service_OnBackupExtensionDied_0101 RESTORE"; - ErrCode ret = Init(IServiceReverse::Scenario::RESTORE); + ErrCode ret = Init(IServiceReverseType::Scenario::RESTORE); EXPECT_EQ(ret, BError(BError::Codes::OK)); string bundleName = BUNDLE_NAME; SvcSessionManager::Impl impl_; @@ -684,12 +684,12 @@ HWTEST_F(ServiceTest, SUB_Service_OnBackupExtensionDied_0101, testing::ext::Test extInfo.versionName = "0.0.0.0-0.0.0.0"; impl_.restoreDataType = RESTORE_DATA_WAIT_SEND; impl_.backupExtNameMap[BUNDLE_NAME] = extInfo; - impl_.scenario = IServiceReverse::Scenario::RESTORE; + impl_.scenario = IServiceReverseType::Scenario::RESTORE; EXPECT_TRUE(servicePtr_ != nullptr); servicePtr_->OnBackupExtensionDied(move(bundleName)); GTEST_LOG_(INFO) << "SUB_Service_OnBackupExtensionDied_0101 BACKUP"; - ret = Init(IServiceReverse::Scenario::BACKUP); + ret = Init(IServiceReverseType::Scenario::BACKUP); EXPECT_EQ(ret, BError(BError::Codes::OK)); impl_.restoreDataType = RESTORE_DATA_READDY; bundleName = "123456789"; @@ -716,14 +716,14 @@ HWTEST_F(ServiceTest, SUB_Service_ExtStart_0100, testing::ext::TestSize.Level1) GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_ExtStart_0100"; try { GTEST_LOG_(INFO) << "SUB_Service_ExtStart_0100 BACKUP"; - ErrCode ret = Init(IServiceReverse::Scenario::BACKUP); + ErrCode ret = Init(IServiceReverseType::Scenario::BACKUP); EXPECT_EQ(ret, BError(BError::Codes::OK)); EXPECT_TRUE(servicePtr_ != nullptr); servicePtr_->ExtStart(BUNDLE_NAME); GTEST_LOG_(INFO) << "ServiceTest-ExtStart BACKUP Branches"; servicePtr_->ExtStart(BUNDLE_NAME); GTEST_LOG_(INFO) << "SUB_Service_ExtStart_0100 RESTORE"; - ret = Init(IServiceReverse::Scenario::RESTORE); + ret = Init(IServiceReverseType::Scenario::RESTORE); servicePtr_->ExtStart(BUNDLE_NAME); } catch (...) { EXPECT_TRUE(false); @@ -747,7 +747,7 @@ HWTEST_F(ServiceTest, SUB_Service_ExtStart_0101, testing::ext::TestSize.Level1) try { GTEST_LOG_(INFO) << "SUB_Service_ExtStart_0101 BACKUP"; std::string bundleName = "123456"; - ErrCode ret = Init(IServiceReverse::Scenario::BACKUP); + ErrCode ret = Init(IServiceReverseType::Scenario::BACKUP); EXPECT_EQ(ret, BError(BError::Codes::OK)); EXPECT_TRUE(servicePtr_ != nullptr); servicePtr_->ExtStart(bundleName); @@ -762,16 +762,16 @@ HWTEST_F(ServiceTest, SUB_Service_ExtStart_0101, testing::ext::TestSize.Level1) extInfo.backUpConnection = sptr(new SvcBackupConnection(callDied, callConnected, bundleNameIndexInfo)); extInfo.backUpConnection->backupProxy_ = nullptr; impl_.backupExtNameMap[BUNDLE_NAME] = extInfo; - impl_.scenario = IServiceReverse::Scenario::UNDEFINED; - ret = Init(IServiceReverse::Scenario::UNDEFINED); + impl_.scenario = IServiceReverseType::Scenario::UNDEFINED; + ret = Init(IServiceReverseType::Scenario::UNDEFINED); EXPECT_EQ(ret, BError(BError::Codes::OK)); servicePtr_->ExtStart(BUNDLE_NAME); - ret = Init(IServiceReverse::Scenario::RESTORE); + ret = Init(IServiceReverseType::Scenario::RESTORE); EXPECT_EQ(ret, BError(BError::Codes::OK)); servicePtr_->ExtStart(BUNDLE_NAME); - ret = Init(IServiceReverse::Scenario::UNDEFINED); + ret = Init(IServiceReverseType::Scenario::UNDEFINED); EXPECT_EQ(ret, BError(BError::Codes::OK)); servicePtr_->ExtStart(BUNDLE_NAME); } catch (...) { @@ -867,19 +867,19 @@ HWTEST_F(ServiceTest, SUB_Service_ExtConnectFailed_0100, testing::ext::TestSize. GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_ExtConnectFailed_0100"; try { GTEST_LOG_(INFO) << "SUB_Service_ExtConnectFailed_0100 RESTORE"; - ErrCode ret = Init(IServiceReverse::Scenario::RESTORE); + ErrCode ret = Init(IServiceReverseType::Scenario::RESTORE); EXPECT_EQ(ret, BError(BError::Codes::OK)); EXPECT_TRUE(servicePtr_ != nullptr); servicePtr_->ExtConnectFailed(BUNDLE_NAME, BError(BError::Codes::OK)); GTEST_LOG_(INFO) << "SUB_Service_ExtConnectFailed_0100 BACKUP"; - ret = Init(IServiceReverse::Scenario::BACKUP); + ret = Init(IServiceReverseType::Scenario::BACKUP); EXPECT_EQ(ret, BError(BError::Codes::OK)); servicePtr_->ExtConnectFailed(BUNDLE_NAME, BError(BError::Codes::OK)); SvcSessionManager::Impl impl_; impl_.clientToken = 1; impl_.restoreDataType = RESTORE_DATA_READDY; - ret = Init(IServiceReverse::Scenario::RESTORE); + ret = Init(IServiceReverseType::Scenario::RESTORE); EXPECT_EQ(ret, BError(BError::Codes::OK)); servicePtr_->ExtConnectFailed(BUNDLE_NAME, BError(BError::Codes::OK)); } catch (...) { @@ -1090,7 +1090,7 @@ HWTEST_F(ServiceTest, SUB_Service_SendStartAppGalleryNotify_0101, testing::ext:: { GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_SendStartAppGalleryNotify_0101"; try { - ErrCode ret = Init(IServiceReverse::Scenario::RESTORE); + ErrCode ret = Init(IServiceReverseType::Scenario::RESTORE); EXPECT_EQ(ret, BError(BError::Codes::OK)); EXPECT_TRUE(servicePtr_ != nullptr); servicePtr_->SendStartAppGalleryNotify(BUNDLE_NAME); @@ -1138,7 +1138,7 @@ HWTEST_F(ServiceTest, SUB_Service_GetBackupInfo_0100, testing::ext::TestSize.Lev try { std::string bundleName = "com.example.app2backup"; std::string backupInfo = "backup info"; - auto ret = Init(IServiceReverse::Scenario::BACKUP); + auto ret = Init(IServiceReverseType::Scenario::BACKUP); EXPECT_EQ(ret, BError(BError::Codes::OK)); EXPECT_TRUE(servicePtr_ != nullptr); servicePtr_->GetBackupInfo(bundleName, backupInfo); @@ -1164,7 +1164,7 @@ HWTEST_F(ServiceTest, SUB_Service_GetBackupInfo_0101, testing::ext::TestSize.Lev try { std::string bundleName = "com.example.app2backup"; std::string result = "ok"; - auto ret = Init(IServiceReverse::Scenario::BACKUP); + auto ret = Init(IServiceReverseType::Scenario::BACKUP); EXPECT_EQ(ret, BError(BError::Codes::OK)); EXPECT_TRUE(servicePtr_ != nullptr); servicePtr_->session_ = nullptr; @@ -1306,7 +1306,7 @@ HWTEST_F(ServiceTest, SUB_Service_OnBundleStarted_0100, testing::ext::TestSize.L servicePtr_->OnBundleStarted(BError(BError::Codes::SA_INVAL_ARG), session, BUNDLE_NAME); SvcSessionManager::Impl impl_; impl_.clientToken = 1; - impl_.scenario = IServiceReverse::Scenario::RESTORE; + impl_.scenario = IServiceReverseType::Scenario::RESTORE; servicePtr_->OnBundleStarted(BError(BError::Codes::SA_INVAL_ARG), session, BUNDLE_NAME); } catch (...) { EXPECT_TRUE(false); @@ -1550,7 +1550,7 @@ HWTEST_F(ServiceTest, SUB_Service_HandleCurBundleEndWork_0100, testing::ext::Tes BackupExtInfo extInfo {}; extInfo.backUpConnection = nullptr; impl_.backupExtNameMap[BUNDLE_NAME] = extInfo; - impl_.scenario = IServiceReverse::Scenario::RESTORE; + impl_.scenario = IServiceReverseType::Scenario::RESTORE; EXPECT_TRUE(servicePtr_ != nullptr); servicePtr_->HandleCurBundleEndWork(BUNDLE_NAME, BackupRestoreScenario::FULL_RESTORE); } catch (...) { @@ -1574,7 +1574,7 @@ HWTEST_F(ServiceTest, SUB_Service_LaunchBackupSAExtension_0100, testing::ext::Te GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_LaunchBackupSAExtension_0100"; try { std::string bundleName = "123456"; - ErrCode ret = Init(IServiceReverse::Scenario::RESTORE); + ErrCode ret = Init(IServiceReverseType::Scenario::RESTORE); EXPECT_EQ(ret, BError(BError::Codes::OK)); EXPECT_TRUE(servicePtr_ != nullptr); ret = servicePtr_->LaunchBackupSAExtension(BUNDLE_NAME); @@ -1597,7 +1597,7 @@ HWTEST_F(ServiceTest, SUB_Service_LaunchBackupSAExtension_0100, testing::ext::Te ret = servicePtr_->LaunchBackupSAExtension(bundleName); EXPECT_NE(ret, BError(BError::Codes::OK)); - ret = Init(IServiceReverse::Scenario::BACKUP); + ret = Init(IServiceReverseType::Scenario::BACKUP); EXPECT_EQ(ret, BError(BError::Codes::OK)); ret = servicePtr_->LaunchBackupSAExtension(bundleName); EXPECT_NE(ret, BError(BError::Codes::OK)); @@ -1622,7 +1622,7 @@ HWTEST_F(ServiceTest, SUB_Service_ExtConnectDied_0100, testing::ext::TestSize.Le GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_ExtConnectDied_0100"; try { std::string callName = "123456"; - ErrCode ret = Init(IServiceReverse::Scenario::RESTORE); + ErrCode ret = Init(IServiceReverseType::Scenario::RESTORE); EXPECT_EQ(ret, BError(BError::Codes::OK)); SvcSessionManager::Impl impl_; impl_.clientToken = 1; @@ -1632,7 +1632,7 @@ HWTEST_F(ServiceTest, SUB_Service_ExtConnectDied_0100, testing::ext::TestSize.Le string bundleNameIndexInfo = "123456789"; extInfo.backUpConnection = sptr(new SvcBackupConnection(callDied, callConnected, bundleNameIndexInfo)); impl_.backupExtNameMap[BUNDLE_NAME] = extInfo; - impl_.scenario = IServiceReverse::Scenario::RESTORE; + impl_.scenario = IServiceReverseType::Scenario::RESTORE; EXPECT_TRUE(servicePtr_ != nullptr); servicePtr_->ExtConnectDied(callName); extInfo.backUpConnection->isConnected_.store(true); @@ -1657,19 +1657,19 @@ HWTEST_F(ServiceTest, SUB_Service_NoticeClientFinish_0100, testing::ext::TestSiz { GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_NoticeClientFinish_0100"; try { - ErrCode ret = Init(IServiceReverse::Scenario::RESTORE); + ErrCode ret = Init(IServiceReverseType::Scenario::RESTORE); EXPECT_EQ(ret, BError(BError::Codes::OK)); EXPECT_TRUE(servicePtr_ != nullptr); servicePtr_->NoticeClientFinish(BUNDLE_NAME, BError(BError::Codes::OK)); GTEST_LOG_(INFO) << "SUB_Service_NoticeClientFinish_0100 BACKUP"; - ret = Init(IServiceReverse::Scenario::BACKUP); + ret = Init(IServiceReverseType::Scenario::BACKUP); EXPECT_EQ(ret, BError(BError::Codes::OK)); servicePtr_->NoticeClientFinish(BUNDLE_NAME, BError(BError::Codes::OK)); SvcSessionManager::Impl impl_; impl_.clientToken = 1; impl_.restoreDataType = RESTORE_DATA_READDY; - ret = Init(IServiceReverse::Scenario::RESTORE); + ret = Init(IServiceReverseType::Scenario::RESTORE); EXPECT_EQ(ret, BError(BError::Codes::OK)); servicePtr_->NoticeClientFinish(BUNDLE_NAME, BError(BError::Codes::OK)); } catch (...) { @@ -1692,13 +1692,13 @@ HWTEST_F(ServiceTest, SUB_Service_OnAllBundlesFinished_0100, testing::ext::TestS { GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_OnAllBundlesFinished_0100"; try { - ErrCode ret = Init(IServiceReverse::Scenario::BACKUP); + ErrCode ret = Init(IServiceReverseType::Scenario::BACKUP); EXPECT_EQ(ret, BError(BError::Codes::OK)); EXPECT_TRUE(servicePtr_ != nullptr); servicePtr_->session_ = sptr(new SvcSessionManager(servicePtr_)); servicePtr_->OnAllBundlesFinished(BError(BError::Codes::OK)); - ret = Init(IServiceReverse::Scenario::RESTORE); + ret = Init(IServiceReverseType::Scenario::RESTORE); EXPECT_EQ(ret, BError(BError::Codes::OK)); servicePtr_->OnAllBundlesFinished(BError(BError::Codes::OK)); } catch (...) { @@ -1721,12 +1721,12 @@ HWTEST_F(ServiceTest, SUB_Service_SendEndAppGalleryNotify_0100, testing::ext::Te { GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_SendEndAppGalleryNotify_0100"; try { - ErrCode ret = Init(IServiceReverse::Scenario::BACKUP); + ErrCode ret = Init(IServiceReverseType::Scenario::BACKUP); EXPECT_EQ(ret, BError(BError::Codes::OK)); EXPECT_TRUE(servicePtr_ != nullptr); servicePtr_->SendEndAppGalleryNotify(BUNDLE_NAME); - ret = Init(IServiceReverse::Scenario::RESTORE); + ret = Init(IServiceReverseType::Scenario::RESTORE); EXPECT_EQ(ret, BError(BError::Codes::OK)); servicePtr_->SendEndAppGalleryNotify(BUNDLE_NAME); } catch (...) { @@ -1749,12 +1749,12 @@ HWTEST_F(ServiceTest, SUB_Service_SendErrAppGalleryNotify_0100, testing::ext::Te { GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_SendErrAppGalleryNotify_0100"; try { - ErrCode ret = Init(IServiceReverse::Scenario::BACKUP); + ErrCode ret = Init(IServiceReverseType::Scenario::BACKUP); EXPECT_EQ(ret, BError(BError::Codes::OK)); EXPECT_TRUE(servicePtr_ != nullptr); servicePtr_->SendErrAppGalleryNotify(); - ret = Init(IServiceReverse::Scenario::RESTORE); + ret = Init(IServiceReverseType::Scenario::RESTORE); EXPECT_EQ(ret, BError(BError::Codes::OK)); servicePtr_->SendErrAppGalleryNotify(); } catch (...) { @@ -1777,12 +1777,12 @@ HWTEST_F(ServiceTest, SUB_Service_ClearDisposalOnSaStart_0100, testing::ext::Tes { GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_ClearDisposalOnSaStart_0100"; try { - ErrCode ret = Init(IServiceReverse::Scenario::BACKUP); + ErrCode ret = Init(IServiceReverseType::Scenario::BACKUP); EXPECT_EQ(ret, BError(BError::Codes::OK)); EXPECT_TRUE(servicePtr_ != nullptr); servicePtr_->ClearDisposalOnSaStart(); - ret = Init(IServiceReverse::Scenario::RESTORE); + ret = Init(IServiceReverseType::Scenario::RESTORE); EXPECT_EQ(ret, BError(BError::Codes::OK)); servicePtr_->ClearDisposalOnSaStart(); } catch (...) { @@ -1805,12 +1805,12 @@ HWTEST_F(ServiceTest, SUB_Service_DeleteDisConfigFile_0100, testing::ext::TestSi { GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_DeleteDisConfigFile_0100"; try { - ErrCode ret = Init(IServiceReverse::Scenario::BACKUP); + ErrCode ret = Init(IServiceReverseType::Scenario::BACKUP); EXPECT_EQ(ret, BError(BError::Codes::OK)); EXPECT_TRUE(servicePtr_ != nullptr); servicePtr_->DeleteDisConfigFile(); - ret = Init(IServiceReverse::Scenario::RESTORE); + ret = Init(IServiceReverseType::Scenario::RESTORE); EXPECT_EQ(ret, BError(BError::Codes::OK)); servicePtr_->DeleteDisConfigFile(); } catch (...) { @@ -1833,18 +1833,18 @@ HWTEST_F(ServiceTest, SUB_Service_ExtensionConnectFailRadarReport_0100, testing: { GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_ExtensionConnectFailRadarReport_0100"; try { - ErrCode ret = Init(IServiceReverse::Scenario::BACKUP); + ErrCode ret = Init(IServiceReverseType::Scenario::BACKUP); EXPECT_EQ(ret, BError(BError::Codes::OK)); EXPECT_TRUE(servicePtr_ != nullptr); servicePtr_->ClearBundleRadarReport(); servicePtr_->ExtensionConnectFailRadarReport(BUNDLE_NAME, BError(BError::Codes::OK), - IServiceReverse::Scenario::BACKUP); + IServiceReverseType::Scenario::BACKUP); EXPECT_TRUE(true); - ret = Init(IServiceReverse::Scenario::RESTORE); + ret = Init(IServiceReverseType::Scenario::RESTORE); EXPECT_EQ(ret, BError(BError::Codes::OK)); servicePtr_->ExtensionConnectFailRadarReport(BUNDLE_NAME, BError(BError::Codes::OK), - IServiceReverse::Scenario::RESTORE); + IServiceReverseType::Scenario::RESTORE); EXPECT_TRUE(true); } catch (...) { EXPECT_TRUE(false); @@ -1866,13 +1866,13 @@ HWTEST_F(ServiceTest, SUB_Service_StartRunningTimer_0100, testing::ext::TestSize { GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_StartRunningTimer_0100"; try { - ErrCode ret = Init(IServiceReverse::Scenario::BACKUP); + ErrCode ret = Init(IServiceReverseType::Scenario::BACKUP); EXPECT_EQ(ret, BError(BError::Codes::OK)); EXPECT_TRUE(servicePtr_ != nullptr); servicePtr_->StartRunningTimer(BUNDLE_NAME); EXPECT_TRUE(true); - ret = Init(IServiceReverse::Scenario::RESTORE); + ret = Init(IServiceReverseType::Scenario::RESTORE); EXPECT_EQ(ret, BError(BError::Codes::OK)); servicePtr_->StartRunningTimer(BUNDLE_NAME); EXPECT_TRUE(true); @@ -1896,17 +1896,17 @@ HWTEST_F(ServiceTest, SUB_Service_TimeoutRadarReport_0100, testing::ext::TestSiz { GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_TimeoutRadarReport_0100"; try { - ErrCode ret = Init(IServiceReverse::Scenario::BACKUP); + ErrCode ret = Init(IServiceReverseType::Scenario::BACKUP); EXPECT_EQ(ret, BError(BError::Codes::OK)); EXPECT_TRUE(servicePtr_ != nullptr); std::string bundleName = BUNDLE_NAME; servicePtr_->ClearBundleRadarReport(); - servicePtr_->TimeoutRadarReport(IServiceReverse::Scenario::BACKUP, bundleName); + servicePtr_->TimeoutRadarReport(IServiceReverseType::Scenario::BACKUP, bundleName); EXPECT_TRUE(true); - ret = Init(IServiceReverse::Scenario::RESTORE); + ret = Init(IServiceReverseType::Scenario::RESTORE); EXPECT_EQ(ret, BError(BError::Codes::OK)); - servicePtr_->TimeoutRadarReport(IServiceReverse::Scenario::RESTORE, bundleName); + servicePtr_->TimeoutRadarReport(IServiceReverseType::Scenario::RESTORE, bundleName); EXPECT_TRUE(true); } catch (...) { EXPECT_TRUE(false); @@ -1928,15 +1928,15 @@ HWTEST_F(ServiceTest, SUB_Service_ReportOnBundleStarted_0100, testing::ext::Test { GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_ReportOnBundleStarted_0100"; try { - ErrCode ret = Init(IServiceReverse::Scenario::BACKUP); + ErrCode ret = Init(IServiceReverseType::Scenario::BACKUP); EXPECT_EQ(ret, BError(BError::Codes::OK)); EXPECT_TRUE(servicePtr_ != nullptr); - servicePtr_->ReportOnBundleStarted(IServiceReverse::Scenario::BACKUP, BUNDLE_NAME); + servicePtr_->ReportOnBundleStarted(IServiceReverseType::Scenario::BACKUP, BUNDLE_NAME); EXPECT_TRUE(true); - ret = Init(IServiceReverse::Scenario::RESTORE); + ret = Init(IServiceReverseType::Scenario::RESTORE); EXPECT_EQ(ret, BError(BError::Codes::OK)); - servicePtr_->ReportOnBundleStarted(IServiceReverse::Scenario::RESTORE, BUNDLE_NAME); + servicePtr_->ReportOnBundleStarted(IServiceReverseType::Scenario::RESTORE, BUNDLE_NAME); EXPECT_TRUE(true); } catch (...) { EXPECT_TRUE(false); @@ -1958,7 +1958,7 @@ HWTEST_F(ServiceTest, SUB_Service_HandleNotSupportBundleNames_0100, testing::ext { GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_HandleNotSupportBundleNames_0100"; try { - ErrCode ret = Init(IServiceReverse::Scenario::BACKUP); + ErrCode ret = Init(IServiceReverseType::Scenario::BACKUP); EXPECT_EQ(ret, BError(BError::Codes::OK)); EXPECT_TRUE(servicePtr_ != nullptr); const std::vector srcBundleNames = {"test0", "test1", "test2", "test3"}; @@ -2048,7 +2048,7 @@ HWTEST_F(ServiceTest, SUB_Service_PublishFile_0103, testing::ext::TestSize.Level { GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_PublishFile_0103"; try { - ErrCode ret = Init(IServiceReverse::Scenario::RESTORE); + ErrCode ret = Init(IServiceReverseType::Scenario::RESTORE); EXPECT_EQ(ret, BError(BError::Codes::OK)); BFileInfo fileInfo {BUNDLE_NAME, "", 0}; EXPECT_TRUE(servicePtr_ != nullptr); diff --git a/tests/unittests/backup_sa/module_ipc/service_throw_test.cpp b/tests/unittests/backup_sa/module_ipc/service_throw_test.cpp index 316992b9572d41337b075153a81d9e12ec65c9aa..5d49c932073fd44352e637df419c57b031d7f738 100644 --- a/tests/unittests/backup_sa/module_ipc/service_throw_test.cpp +++ b/tests/unittests/backup_sa/module_ipc/service_throw_test.cpp @@ -586,7 +586,7 @@ HWTEST_F(ServiceThrowTest, SUB_Service_throw_LaunchBackupExtension_0100, testing try { EXPECT_NE(service, nullptr); BundleName bundleName; - EXPECT_CALL(*sessionMock, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); + EXPECT_CALL(*sessionMock, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)); auto ret = service->LaunchBackupExtension(bundleName); EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode()); } catch (...) { @@ -646,8 +646,8 @@ HWTEST_F(ServiceThrowTest, SUB_Service_throw_OnBackupExtensionDied_0100, testing EXPECT_NE(service, nullptr); string bundleName; EXPECT_CALL(*sessionMock, GetScenario()) - .WillOnce(Return(IServiceReverse::Scenario::CLEAN)) - .WillOnce(Return(IServiceReverse::Scenario::CLEAN)); + .WillOnce(Return(IServiceReverseType::Scenario::CLEAN)) + .WillOnce(Return(IServiceReverseType::Scenario::CLEAN)); EXPECT_CALL(*sessionMock, VerifyBundleName(_)).WillOnce(Return(BError(BError::Codes::SA_INVAL_ARG))); EXPECT_CALL(*sessionMock, StopFwkTimer(_)).WillOnce(Invoke([]() { throw BError(BError::Codes::EXT_THROW_EXCEPTION); @@ -683,21 +683,21 @@ HWTEST_F(ServiceThrowTest, SUB_Service_throw_ExtConnectFailed_0100, testing::ext BundleName bundleName; EXPECT_CALL(*sessionMock, GetScenario()).WillOnce(Invoke([]() { throw BError(BError::Codes::EXT_THROW_EXCEPTION); - return IServiceReverse::Scenario::UNDEFINED; + return IServiceReverseType::Scenario::UNDEFINED; })); service->ExtConnectFailed(bundleName, 0); EXPECT_TRUE(true); EXPECT_CALL(*sessionMock, GetScenario()).WillOnce(Invoke([]() { throw runtime_error("运行时错误"); - return IServiceReverse::Scenario::UNDEFINED; + return IServiceReverseType::Scenario::UNDEFINED; })); service->ExtConnectFailed(bundleName, 0); EXPECT_TRUE(true); EXPECT_CALL(*sessionMock, GetScenario()).WillOnce(Invoke([]() { throw "未知错误"; - return IServiceReverse::Scenario::UNDEFINED; + return IServiceReverseType::Scenario::UNDEFINED; })); service->ExtConnectFailed(bundleName, 0); EXPECT_TRUE(true); @@ -724,7 +724,7 @@ HWTEST_F(ServiceThrowTest, SUB_Service_throw_NoticeClientFinish_0100, testing::e EXPECT_NE(service, nullptr); string bundleName; ErrCode errCode = 0; - EXPECT_CALL(*sessionMock, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); + EXPECT_CALL(*sessionMock, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)); EXPECT_CALL(*sessionMock, IsOnAllBundlesFinished()).WillOnce(Return(false)); service->NoticeClientFinish(bundleName, errCode); EXPECT_TRUE(true); @@ -992,7 +992,7 @@ HWTEST_F(ServiceThrowTest, SUB_Service_throw_InitIncrementalBackupSession_0100, .WillOnce(Return(make_pair(true, DEBUG_ID + 1))) .WillOnce(Return(make_pair(true, DEBUG_ID + 1))); EXPECT_CALL(*sessionMock, Active(_)).WillOnce(Return(BError(BError::Codes::SA_REFUSED_ACT))); - EXPECT_CALL(*sessionMock, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); + EXPECT_CALL(*sessionMock, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)); ret = service->InitIncrementalBackupSession(reverse); EXPECT_EQ(ret, BError(BError::Codes::SA_REFUSED_ACT).GetCode()); diff --git a/tests/unittests/backup_sa/module_ipc/sub_service_test.cpp b/tests/unittests/backup_sa/module_ipc/sub_service_test.cpp index 5e4e17dd7b9ae133f8d33d1deb353e5b97fc2d02..bb02a82c8de995bdd6941e2c174738b6d23ed61f 100644 --- a/tests/unittests/backup_sa/module_ipc/sub_service_test.cpp +++ b/tests/unittests/backup_sa/module_ipc/sub_service_test.cpp @@ -71,7 +71,7 @@ HWTEST_F(ServiceTest, SUB_Service_ServiceResultReport_0000, TestSize.Level1) EXPECT_CALL(*token, GetHapTokenInfo(_, _)).WillOnce(Return(0)); EXPECT_CALL(*jsonUtil, BuildBundleNameIndexInfo(_, _)).WillOnce(Return("")); EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); - EXPECT_CALL(*srProxy, RestoreOnResultReport(_, _, _)).WillOnce(Return()); + EXPECT_CALL(*srProxy, RestoreOnResultReport(_, _, _)).WillOnce(Return(0)); EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(false)); EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(true)); EXPECT_CALL(*session, IsOnAllBundlesFinished()).WillOnce(Return(false)); @@ -83,7 +83,7 @@ HWTEST_F(ServiceTest, SUB_Service_ServiceResultReport_0000, TestSize.Level1) EXPECT_CALL(*token, GetHapTokenInfo(_, _)).WillOnce(Return(0)); EXPECT_CALL(*jsonUtil, BuildBundleNameIndexInfo(_, _)).WillOnce(Return("")); EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); - EXPECT_CALL(*srProxy, IncrementalRestoreOnResultReport(_, _, _)).WillOnce(Return()); + EXPECT_CALL(*srProxy, IncrementalRestoreOnResultReport(_, _, _)).WillOnce(Return(0)); EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(false)); EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(true)); EXPECT_CALL(*session, IsOnAllBundlesFinished()).WillOnce(Return(false)); @@ -96,7 +96,7 @@ HWTEST_F(ServiceTest, SUB_Service_ServiceResultReport_0000, TestSize.Level1) EXPECT_CALL(*jsonUtil, BuildBundleNameIndexInfo(_, _)).WillOnce(Return("")); EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(true)); EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); - EXPECT_CALL(*srProxy, BackupOnResultReport(_, _)).WillOnce(Return()); + EXPECT_CALL(*srProxy, BackupOnResultReport(_, _)).WillOnce(Return(0)); ret = service->ServiceResultReport("", BackupRestoreScenario::FULL_BACKUP, 0); EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode()); @@ -106,7 +106,7 @@ HWTEST_F(ServiceTest, SUB_Service_ServiceResultReport_0000, TestSize.Level1) EXPECT_CALL(*jsonUtil, BuildBundleNameIndexInfo(_, _)).WillOnce(Return("")); EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(true)); EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); - EXPECT_CALL(*srProxy, IncrementalBackupOnResultReport(_, _)).WillOnce(Return()); + EXPECT_CALL(*srProxy, IncrementalBackupOnResultReport(_, _)).WillOnce(Return(0)); ret = service->ServiceResultReport("", BackupRestoreScenario::INCREMENTAL_BACKUP, 0); EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode()); } catch (...) { @@ -130,30 +130,30 @@ HWTEST_F(ServiceTest, SUB_Service_SAResultReport_0000, TestSize.Level1) GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_SAResultReport_0000"; try { EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); - EXPECT_CALL(*srProxy, RestoreOnResultReport(_, _, _)).WillOnce(Return()); + EXPECT_CALL(*srProxy, RestoreOnResultReport(_, _, _)).WillOnce(Return(0)); EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(false)); EXPECT_CALL(*session, IsOnAllBundlesFinished()).WillOnce(Return(false)); auto ret = service->SAResultReport("", "", 0, BackupRestoreScenario::FULL_RESTORE); EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode()); EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); - EXPECT_CALL(*srProxy, IncrementalRestoreOnResultReport(_, _, _)).WillOnce(Return()); + EXPECT_CALL(*srProxy, IncrementalRestoreOnResultReport(_, _, _)).WillOnce(Return(0)); EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(false)); EXPECT_CALL(*session, IsOnAllBundlesFinished()).WillOnce(Return(false)); ret = service->SAResultReport("", "", 0, BackupRestoreScenario::INCREMENTAL_RESTORE); EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode()); EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)).WillOnce(Return(srProxy)); - EXPECT_CALL(*srProxy, BackupOnResultReport(_, _)).WillOnce(Return()); - EXPECT_CALL(*srProxy, BackupOnBundleFinished(_, _)).WillOnce(Return()); + EXPECT_CALL(*srProxy, BackupOnResultReport(_, _)).WillOnce(Return(0)); + EXPECT_CALL(*srProxy, BackupOnBundleFinished(_, _)).WillOnce(Return(0)); EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(false)); EXPECT_CALL(*session, IsOnAllBundlesFinished()).WillOnce(Return(false)); ret = service->SAResultReport("", "", 0, BackupRestoreScenario::FULL_BACKUP); EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode()); EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)).WillOnce(Return(srProxy)); - EXPECT_CALL(*srProxy, IncrementalBackupOnResultReport(_, _)).WillOnce(Return()); - EXPECT_CALL(*srProxy, IncrementalBackupOnBundleFinished(_, _)).WillOnce(Return()); + EXPECT_CALL(*srProxy, IncrementalBackupOnResultReport(_, _)).WillOnce(Return(0)); + EXPECT_CALL(*srProxy, IncrementalBackupOnBundleFinished(_, _)).WillOnce(Return(0)); EXPECT_CALL(*session, OnBundleFileReady(_, _)).WillOnce(Return(false)); EXPECT_CALL(*session, IsOnAllBundlesFinished()).WillOnce(Return(false)); ret = service->SAResultReport("", "", 0, BackupRestoreScenario::INCREMENTAL_BACKUP); @@ -180,14 +180,14 @@ HWTEST_F(ServiceTest, SUB_Service_LaunchBackupSAExtension_0000, TestSize.Level1) try { BundleName bundleName; EXPECT_CALL(*session, GetBackupExtInfo(_)).WillOnce(Return("")); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)); EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(false)); auto ret = service->LaunchBackupSAExtension(bundleName); EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode()); shared_ptr sa = nullptr; EXPECT_CALL(*session, GetBackupExtInfo(_)).WillOnce(Return("")); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)); EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(true)); EXPECT_CALL(*session, GetSAExtConnection(_)).WillOnce(Return(sa)); ret = service->LaunchBackupSAExtension(bundleName); @@ -195,14 +195,14 @@ HWTEST_F(ServiceTest, SUB_Service_LaunchBackupSAExtension_0000, TestSize.Level1) sa = make_shared(nullptr, nullptr, nullptr, nullptr); EXPECT_CALL(*session, GetBackupExtInfo(_)).WillOnce(Return("")); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)); EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(true)); EXPECT_CALL(*session, GetSAExtConnection(_)).WillOnce(Return(sa)); ret = service->LaunchBackupSAExtension(bundleName); EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode()); EXPECT_CALL(*session, GetBackupExtInfo(_)).WillOnce(Return("")); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::BACKUP)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::BACKUP)); EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(true)); EXPECT_CALL(*session, GetSAExtConnection(_)).WillOnce(Return(sa)); EXPECT_CALL(*saConnect, ConnectBackupSAExt(_, _, _)).WillOnce(Return(BError(BError::Codes::OK).GetCode())); @@ -210,7 +210,7 @@ HWTEST_F(ServiceTest, SUB_Service_LaunchBackupSAExtension_0000, TestSize.Level1) EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode()); EXPECT_CALL(*session, GetBackupExtInfo(_)).WillOnce(Return("")); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::RESTORE)); EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(true)); EXPECT_CALL(*session, GetSAExtConnection(_)).WillOnce(Return(sa)); EXPECT_CALL(*saConnect, ConnectBackupSAExt(_, _, _)).WillOnce(Return(BError(BError::Codes::OK).GetCode())); @@ -300,9 +300,9 @@ HWTEST_F(ServiceTest, SUB_Service_GetFileHandle_0100, TestSize.Level1) EXPECT_CALL(*session, GetServiceSchedAction(_)).WillOnce(Return(BConstants::ServiceSchedAction::RUNNING)); EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect)); EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy)); - EXPECT_CALL(*svcProxy, GetFileHandle(_, _)).WillOnce(Return(UniqueFd(-1))); + EXPECT_CALL(*svcProxy, GetIncrementalFileHandle(_, _)).WillOnce(Return(0)); EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); - EXPECT_CALL(*srProxy, RestoreOnFileReady(_, _, _, _)).WillOnce(Return()); + EXPECT_CALL(*srProxy, RestoreOnFileReady(_, _, _, _)).WillOnce(Return(0)); auto ret = service->GetFileHandle(bundleName, fileName); EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode()); @@ -313,12 +313,12 @@ HWTEST_F(ServiceTest, SUB_Service_GetFileHandle_0100, TestSize.Level1) EXPECT_CALL(*session, GetServiceSchedAction(_)).WillOnce(Return(BConstants::ServiceSchedAction::RUNNING)); EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect)); EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy)); - EXPECT_CALL(*svcProxy, GetFileHandle(_, _)).WillOnce(DoAll(SetArgReferee<1>(1), Return(UniqueFd(-1)))); + EXPECT_CALL(*svcProxy, GetIncrementalFileHandle(_, _)).WillOnce(Return(0)); EXPECT_CALL(*param, GetBackupDebugOverrideAccount()) .WillOnce(Return(make_pair(true, DEBUG_ID + 1))) .WillOnce(Return(make_pair(true, DEBUG_ID + 1))); EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); - EXPECT_CALL(*srProxy, RestoreOnFileReady(_, _, _, _)).WillOnce(Return()); + EXPECT_CALL(*srProxy, RestoreOnFileReady(_, _, _, _)).WillOnce(Return(0)); ret = service->GetFileHandle(bundleName, fileName); EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode()); } catch (...) { @@ -342,14 +342,14 @@ HWTEST_F(ServiceTest, SUB_Service_OnBackupExtensionDied_0000, TestSize.Level1) GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_OnBackupExtensionDied_0000"; try { service->isOccupyingSession_ = false; - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)); EXPECT_CALL(*cdConfig, DeleteClearBundleRecord(_)).WillOnce(Return(true)); EXPECT_CALL(*session, IsOnAllBundlesFinished()).WillOnce(Return(false)); service->OnBackupExtensionDied("", true); EXPECT_TRUE(true); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)) - .WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)) + .WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)); EXPECT_CALL(*session, StopFwkTimer(_)).WillOnce(Return(true)); EXPECT_CALL(*session, StopExtTimer(_)).WillOnce(Return(true)); EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(nullptr)); @@ -384,8 +384,8 @@ HWTEST_F(ServiceTest, SUB_Service_ExtConnectDied_0000, TestSize.Level1) EXPECT_CALL(*session, StopExtTimer(_)).WillOnce(Return(true)); EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(nullptr)); EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(true)); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)) - .WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)) + .WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)); EXPECT_CALL(*cdConfig, DeleteClearBundleRecord(_)).WillOnce(Return(true)); EXPECT_CALL(*session, IsOnAllBundlesFinished()).WillOnce(Return(false)); service->ExtConnectDied(callName); @@ -396,8 +396,8 @@ HWTEST_F(ServiceTest, SUB_Service_ExtConnectDied_0000, TestSize.Level1) EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect)); EXPECT_CALL(*connect, IsExtAbilityConnected()).WillOnce(Return(false)); EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(true)); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)) - .WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)) + .WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)); EXPECT_CALL(*cdConfig, DeleteClearBundleRecord(_)).WillOnce(Return(true)); EXPECT_CALL(*session, IsOnAllBundlesFinished()).WillOnce(Return(false)); service->ExtConnectDied(callName); @@ -409,8 +409,8 @@ HWTEST_F(ServiceTest, SUB_Service_ExtConnectDied_0000, TestSize.Level1) EXPECT_CALL(*connect, IsExtAbilityConnected()).WillOnce(Return(true)); EXPECT_CALL(*connect, DisconnectBackupExtAbility()).WillOnce(Return(BError(BError::Codes::OK).GetCode())); EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(true)); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)) - .WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)) + .WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)); EXPECT_CALL(*cdConfig, DeleteClearBundleRecord(_)).WillOnce(Return(true)); EXPECT_CALL(*session, IsOnAllBundlesFinished()).WillOnce(Return(false)); service->ExtConnectDied(callName); @@ -438,26 +438,26 @@ HWTEST_F(ServiceTest, SUB_Service_ExtStart_0000, TestSize.Level1) string callName; shared_ptr sa = make_shared(nullptr, nullptr, nullptr, nullptr); EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(true)); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)); EXPECT_CALL(*session, GetSAExtConnection(_)).WillOnce(Return(sa)); service->ExtStart(callName); EXPECT_TRUE(true); EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(false)); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)); EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(nullptr)); service->ExtStart(callName); EXPECT_TRUE(true); EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(false)); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)); EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect)); EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(nullptr)); service->ExtStart(callName); EXPECT_TRUE(true); EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(false)); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)); EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect)); EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy)); service->ExtStart(callName); @@ -484,26 +484,26 @@ HWTEST_F(ServiceTest, SUB_Service_ExtStart_0100, TestSize.Level1) try { string callName; EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(false)); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::BACKUP)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::BACKUP)); EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect)); EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy)); EXPECT_CALL(*session, GetClearDataFlag(_)).WillOnce(Return(false)); EXPECT_CALL(*svcProxy, HandleBackup(_)).WillOnce(Return(BError(BError::Codes::OK).GetCode())); EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); - EXPECT_CALL(*srProxy, BackupOnBundleStarted(_, _)).WillOnce(Return()); + EXPECT_CALL(*srProxy, BackupOnBundleStarted(_, _)).WillOnce(Return(0)); service->ExtStart(callName); EXPECT_TRUE(true); EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(false)).WillOnce(Return(true)); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::BACKUP)) - .WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)) - .WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::BACKUP)) + .WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)) + .WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)); EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect)); EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy)); EXPECT_CALL(*session, GetClearDataFlag(_)).WillOnce(Return(false)); EXPECT_CALL(*svcProxy, HandleBackup(_)).WillOnce(Return(BError(BError::Codes::SA_INVAL_ARG).GetCode())); EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); - EXPECT_CALL(*srProxy, BackupOnBundleStarted(_, _)).WillOnce(Return()); + EXPECT_CALL(*srProxy, BackupOnBundleStarted(_, _)).WillOnce(Return(0)); EXPECT_CALL(*cdConfig, DeleteClearBundleRecord(_)).WillOnce(Return(true)); EXPECT_CALL(*session, IsOnAllBundlesFinished()).WillOnce(Return(false)); service->ExtStart(callName); @@ -511,13 +511,13 @@ HWTEST_F(ServiceTest, SUB_Service_ExtStart_0100, TestSize.Level1) set fileNameVec; EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(false)); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::RESTORE)); EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(connect)); EXPECT_CALL(*connect, GetBackupExtProxy()).WillOnce(Return(svcProxy)); EXPECT_CALL(*session, GetClearDataFlag(_)).WillOnce(Return(false)); EXPECT_CALL(*svcProxy, HandleRestore(_)).WillOnce(Return(BError(BError::Codes::SA_INVAL_ARG).GetCode())); EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); - EXPECT_CALL(*srProxy, RestoreOnBundleStarted(_, _)).WillOnce(Return()); + EXPECT_CALL(*srProxy, RestoreOnBundleStarted(_, _)).WillOnce(Return(0)); EXPECT_CALL(*session, GetExtFileNameRequest(_)).WillOnce(Return(fileNameVec)); service->ExtStart(callName); EXPECT_TRUE(true); @@ -570,46 +570,46 @@ HWTEST_F(ServiceTest, SUB_Service_ReportOnExtConnectFailed_0000, TestSize.Level1 string bundleName; auto session_ = service->session_; service->session_ = nullptr; - service->ReportOnExtConnectFailed(IServiceReverse::Scenario::UNDEFINED, bundleName, 0); + service->ReportOnExtConnectFailed(IServiceReverseType::Scenario::UNDEFINED, bundleName, 0); service->session_ = session_; EXPECT_TRUE(true); - service->ReportOnExtConnectFailed(IServiceReverse::Scenario::UNDEFINED, bundleName, 0); + service->ReportOnExtConnectFailed(IServiceReverseType::Scenario::UNDEFINED, bundleName, 0); EXPECT_TRUE(true); EXPECT_CALL(*session, GetIsIncrementalBackup()).WillOnce(Return(true)); EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); - EXPECT_CALL(*srProxy, IncrementalBackupOnBundleStarted(_, _)).WillOnce(Return()); - service->ReportOnExtConnectFailed(IServiceReverse::Scenario::BACKUP, bundleName, 0); + EXPECT_CALL(*srProxy, IncrementalBackupOnBundleStarted(_, _)).WillOnce(Return(0)); + service->ReportOnExtConnectFailed(IServiceReverseType::Scenario::BACKUP, bundleName, 0); EXPECT_TRUE(true); EXPECT_CALL(*session, GetIsIncrementalBackup()).WillOnce(Return(false)); EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); - EXPECT_CALL(*srProxy, BackupOnBundleStarted(_, _)).WillOnce(Return()); - service->ReportOnExtConnectFailed(IServiceReverse::Scenario::BACKUP, bundleName, 0); + EXPECT_CALL(*srProxy, BackupOnBundleStarted(_, _)).WillOnce(Return(0)); + service->ReportOnExtConnectFailed(IServiceReverseType::Scenario::BACKUP, bundleName, 0); EXPECT_TRUE(true); EXPECT_CALL(*param, GetBackupOverrideIncrementalRestore()).WillOnce(Return(true)); EXPECT_CALL(*session, ValidRestoreDataType(_)).WillOnce(Return(true)); EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); - EXPECT_CALL(*srProxy, IncrementalRestoreOnBundleStarted(_, _)).WillOnce(Return()); + EXPECT_CALL(*srProxy, IncrementalRestoreOnBundleStarted(_, _)).WillOnce(Return(0)); EXPECT_CALL(*gallery, EndRestore(_, _)).WillOnce(Return(DisposeErr::OK)); - service->ReportOnExtConnectFailed(IServiceReverse::Scenario::RESTORE, bundleName, 0); + service->ReportOnExtConnectFailed(IServiceReverseType::Scenario::RESTORE, bundleName, 0); EXPECT_TRUE(true); EXPECT_CALL(*param, GetBackupOverrideIncrementalRestore()).WillOnce(Return(true)); EXPECT_CALL(*session, ValidRestoreDataType(_)).WillOnce(Return(false)); EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); - EXPECT_CALL(*srProxy, RestoreOnBundleStarted(_, _)).WillOnce(Return()); + EXPECT_CALL(*srProxy, RestoreOnBundleStarted(_, _)).WillOnce(Return(0)); EXPECT_CALL(*gallery, EndRestore(_, _)).WillOnce(Return(DisposeErr::OK)); - service->ReportOnExtConnectFailed(IServiceReverse::Scenario::RESTORE, bundleName, 0); + service->ReportOnExtConnectFailed(IServiceReverseType::Scenario::RESTORE, bundleName, 0); EXPECT_TRUE(true); EXPECT_CALL(*param, GetBackupOverrideIncrementalRestore()).WillOnce(Return(false)); EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); - EXPECT_CALL(*srProxy, RestoreOnBundleStarted(_, _)).WillOnce(Return()); + EXPECT_CALL(*srProxy, RestoreOnBundleStarted(_, _)).WillOnce(Return(0)); EXPECT_CALL(*gallery, EndRestore(_, _)).WillOnce(Return(DisposeErr::OK)); - service->ReportOnExtConnectFailed(IServiceReverse::Scenario::RESTORE, bundleName, 0); + service->ReportOnExtConnectFailed(IServiceReverseType::Scenario::RESTORE, bundleName, 0); EXPECT_TRUE(true); } catch (...) { EXPECT_TRUE(false); @@ -632,32 +632,32 @@ HWTEST_F(ServiceTest, SUB_Service_NoticeClientFinish_0000, TestSize.Level1) GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_NoticeClientFinish_0000"; try { string bundleName; - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)); EXPECT_CALL(*session, IsOnAllBundlesFinished()).WillOnce(Return(false)); service->NoticeClientFinish(bundleName, 0); EXPECT_TRUE(true); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::BACKUP)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::BACKUP)); EXPECT_CALL(*session, GetIsIncrementalBackup()).WillOnce(Return(true)); EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); - EXPECT_CALL(*srProxy, IncrementalBackupOnBundleFinished(_, _)).WillOnce(Return()); + EXPECT_CALL(*srProxy, IncrementalBackupOnBundleFinished(_, _)).WillOnce(Return(0)); EXPECT_CALL(*session, IsOnAllBundlesFinished()).WillOnce(Return(false)); service->NoticeClientFinish(bundleName, 0); EXPECT_TRUE(true); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::RESTORE)); EXPECT_CALL(*param, GetBackupOverrideIncrementalRestore()).WillOnce(Return(true)); EXPECT_CALL(*session, ValidRestoreDataType(_)).WillOnce(Return(true)); EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); - EXPECT_CALL(*srProxy, IncrementalRestoreOnBundleFinished(_, _)).WillOnce(Return()); + EXPECT_CALL(*srProxy, IncrementalRestoreOnBundleFinished(_, _)).WillOnce(Return(0)); EXPECT_CALL(*session, IsOnAllBundlesFinished()).WillOnce(Return(false)); service->NoticeClientFinish(bundleName, 0); EXPECT_TRUE(true); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::BACKUP)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::BACKUP)); EXPECT_CALL(*session, GetIsIncrementalBackup()).WillOnce(Return(false)); EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); - EXPECT_CALL(*srProxy, BackupOnBundleFinished(_, _)).WillOnce(Return()); + EXPECT_CALL(*srProxy, BackupOnBundleFinished(_, _)).WillOnce(Return(0)); EXPECT_CALL(*session, IsOnAllBundlesFinished()).WillOnce(Return(false)); service->NoticeClientFinish(bundleName, 0); EXPECT_TRUE(true); @@ -682,19 +682,19 @@ HWTEST_F(ServiceTest, SUB_Service_NoticeClientFinish_0100, TestSize.Level1) GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_NoticeClientFinish_0100"; try { string bundleName; - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::RESTORE)); EXPECT_CALL(*param, GetBackupOverrideIncrementalRestore()).WillOnce(Return(true)); EXPECT_CALL(*session, ValidRestoreDataType(_)).WillOnce(Return(false)); EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); - EXPECT_CALL(*srProxy, RestoreOnBundleFinished(_, _)).WillOnce(Return()); + EXPECT_CALL(*srProxy, RestoreOnBundleFinished(_, _)).WillOnce(Return(0)); EXPECT_CALL(*session, IsOnAllBundlesFinished()).WillOnce(Return(false)); service->NoticeClientFinish(bundleName, 0); EXPECT_TRUE(true); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::RESTORE)); EXPECT_CALL(*param, GetBackupOverrideIncrementalRestore()).WillOnce(Return(false)); EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); - EXPECT_CALL(*srProxy, RestoreOnBundleFinished(_, _)).WillOnce(Return()); + EXPECT_CALL(*srProxy, RestoreOnBundleFinished(_, _)).WillOnce(Return(0)); EXPECT_CALL(*session, IsOnAllBundlesFinished()).WillOnce(Return(false)); service->NoticeClientFinish(bundleName, 0); EXPECT_TRUE(true); @@ -758,13 +758,13 @@ HWTEST_F(ServiceTest, SUB_Service_ClearSessionAndSchedInfo_0000, TestSize.Level1 try { string bundleName; service->isOccupyingSession_ = false; - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)); EXPECT_CALL(*cdConfig, DeleteClearBundleRecord(_)).WillOnce(Return(true)); service->ClearSessionAndSchedInfo(bundleName); EXPECT_TRUE(true); service->isOccupyingSession_ = true; - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)); EXPECT_CALL(*cdConfig, DeleteClearBundleRecord(_)).WillOnce(Return(true)); EXPECT_CALL(*session, IsOnAllBundlesFinished()).WillOnce(Return(false)); service->ClearSessionAndSchedInfo(bundleName); @@ -772,7 +772,7 @@ HWTEST_F(ServiceTest, SUB_Service_ClearSessionAndSchedInfo_0000, TestSize.Level1 service->failedBundles_.clear(); service->successBundlesNum_ = 0; - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)); EXPECT_CALL(*cdConfig, DeleteClearBundleRecord(_)).WillOnce(Return(true)); EXPECT_CALL(*session, IsOnAllBundlesFinished()).WillOnce(Return(true)); service->ClearSessionAndSchedInfo(bundleName); @@ -798,19 +798,19 @@ HWTEST_F(ServiceTest, SUB_Service_HandleRestoreDepsBundle_0000, TestSize.Level1) GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_HandleRestoreDepsBundle_0000"; try { string bundleName; - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)); service->HandleRestoreDepsBundle(bundleName); EXPECT_TRUE(true); map bundleMap; - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::RESTORE)); EXPECT_CALL(*depManager, GetRestoreBundleMap()).WillOnce(Return(bundleMap)); service->HandleRestoreDepsBundle(bundleName); EXPECT_TRUE(true); bundleMap["bundleName"] = {.fileNames_ = {"name"}}; vector bundleInfos {{.name = "name"}}; - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::RESTORE)); EXPECT_CALL(*depManager, GetRestoreBundleMap()).WillOnce(Return(bundleMap)); EXPECT_CALL(*depManager, GetAllBundles()).WillOnce(Return(bundleInfos)); service->HandleRestoreDepsBundle(bundleName); @@ -818,7 +818,7 @@ HWTEST_F(ServiceTest, SUB_Service_HandleRestoreDepsBundle_0000, TestSize.Level1) bundleInfos.clear(); bundleInfos = {{.name = "bundleName"}}; - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::RESTORE)); EXPECT_CALL(*depManager, GetRestoreBundleMap()).WillOnce(Return(bundleMap)); EXPECT_CALL(*depManager, GetAllBundles()).WillOnce(Return(bundleInfos)); service->HandleRestoreDepsBundle(bundleName); @@ -850,36 +850,36 @@ HWTEST_F(ServiceTest, SUB_Service_OnAllBundlesFinished_0000, TestSize.Level1) service->isInRelease_.store(false); EXPECT_CALL(*session, IsOnAllBundlesFinished()).WillOnce(Return(true)); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)); EXPECT_CALL(*param, GetBackupOverrideBackupSARelease()).WillOnce(Return(true)); service->OnAllBundlesFinished(0); EXPECT_TRUE(true); service->isInRelease_.store(true); EXPECT_CALL(*session, IsOnAllBundlesFinished()).WillOnce(Return(true)); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)); EXPECT_CALL(*param, GetBackupOverrideBackupSARelease()).WillOnce(Return(true)); service->OnAllBundlesFinished(0); EXPECT_TRUE(true); service->isInRelease_.store(true); EXPECT_CALL(*session, IsOnAllBundlesFinished()).WillOnce(Return(true)); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)) - .WillOnce(Return(IServiceReverse::Scenario::RESTORE)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::RESTORE)) + .WillOnce(Return(IServiceReverseType::Scenario::RESTORE)); EXPECT_CALL(*session, CleanAndCheckIfNeedWait(_, _)).WillOnce(Return(true)); EXPECT_CALL(*param, GetBackupOverrideIncrementalRestore()).WillOnce(Return(false)); EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); - EXPECT_CALL(*srProxy, RestoreOnAllBundlesFinished(_)).WillOnce(Return()); + EXPECT_CALL(*srProxy, RestoreOnAllBundlesFinished(_)).WillOnce(Return(0)); EXPECT_CALL(*param, GetBackupOverrideBackupSARelease()).WillOnce(Return(true)); service->OnAllBundlesFinished(0); EXPECT_TRUE(true); service->isInRelease_.store(false); EXPECT_CALL(*session, IsOnAllBundlesFinished()).WillOnce(Return(true)); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::BACKUP)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::BACKUP)); EXPECT_CALL(*session, GetIsIncrementalBackup()).WillOnce(Return(true)); EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); - EXPECT_CALL(*srProxy, IncrementalBackupOnAllBundlesFinished(_)).WillOnce(Return()); + EXPECT_CALL(*srProxy, IncrementalBackupOnAllBundlesFinished(_)).WillOnce(Return(0)); EXPECT_CALL(*param, GetBackupOverrideBackupSARelease()).WillOnce(Return(true)); service->OnAllBundlesFinished(0); EXPECT_TRUE(true); @@ -905,32 +905,32 @@ HWTEST_F(ServiceTest, SUB_Service_OnAllBundlesFinished_0100, TestSize.Level1) try { service->isInRelease_.store(false); EXPECT_CALL(*session, IsOnAllBundlesFinished()).WillOnce(Return(true)); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::BACKUP)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::BACKUP)); EXPECT_CALL(*session, GetIsIncrementalBackup()).WillOnce(Return(false)); EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); - EXPECT_CALL(*srProxy, BackupOnAllBundlesFinished(_)).WillOnce(Return()); + EXPECT_CALL(*srProxy, BackupOnAllBundlesFinished(_)).WillOnce(Return(0)); EXPECT_CALL(*param, GetBackupOverrideBackupSARelease()).WillOnce(Return(true)); service->OnAllBundlesFinished(0); EXPECT_TRUE(true); service->isInRelease_.store(false); EXPECT_CALL(*session, IsOnAllBundlesFinished()).WillOnce(Return(true)); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::RESTORE)); EXPECT_CALL(*param, GetBackupOverrideIncrementalRestore()).WillOnce(Return(true)); EXPECT_CALL(*session, ValidRestoreDataType(_)).WillOnce(Return(true)); EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); - EXPECT_CALL(*srProxy, IncrementalRestoreOnAllBundlesFinished(_)).WillOnce(Return()); + EXPECT_CALL(*srProxy, IncrementalRestoreOnAllBundlesFinished(_)).WillOnce(Return(0)); EXPECT_CALL(*param, GetBackupOverrideBackupSARelease()).WillOnce(Return(true)); service->OnAllBundlesFinished(0); EXPECT_TRUE(true); service->isInRelease_.store(false); EXPECT_CALL(*session, IsOnAllBundlesFinished()).WillOnce(Return(true)); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::RESTORE)); EXPECT_CALL(*param, GetBackupOverrideIncrementalRestore()).WillOnce(Return(true)); EXPECT_CALL(*session, ValidRestoreDataType(_)).WillOnce(Return(false)); EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); - EXPECT_CALL(*srProxy, RestoreOnAllBundlesFinished(_)).WillOnce(Return()); + EXPECT_CALL(*srProxy, RestoreOnAllBundlesFinished(_)).WillOnce(Return(0)); EXPECT_CALL(*param, GetBackupOverrideBackupSARelease()).WillOnce(Return(true)); service->OnAllBundlesFinished(0); EXPECT_TRUE(true); @@ -956,17 +956,17 @@ HWTEST_F(ServiceTest, SUB_Service_OnAllBundlesFinished_0200, TestSize.Level1) try { service->isInRelease_.store(false); EXPECT_CALL(*session, IsOnAllBundlesFinished()).WillOnce(Return(true)); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::RESTORE)); EXPECT_CALL(*param, GetBackupOverrideIncrementalRestore()).WillOnce(Return(false)); EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); - EXPECT_CALL(*srProxy, RestoreOnAllBundlesFinished(_)).WillOnce(Return()); + EXPECT_CALL(*srProxy, RestoreOnAllBundlesFinished(_)).WillOnce(Return(0)); EXPECT_CALL(*param, GetBackupOverrideBackupSARelease()).WillOnce(Return(true)); service->OnAllBundlesFinished(0); EXPECT_TRUE(true); service->isInRelease_.store(false); EXPECT_CALL(*session, IsOnAllBundlesFinished()).WillOnce(Return(true)); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)); EXPECT_CALL(*param, GetBackupOverrideBackupSARelease()).WillOnce(Return(false)); service->OnAllBundlesFinished(0); EXPECT_TRUE(true); @@ -1023,18 +1023,18 @@ HWTEST_F(ServiceTest, SUB_Service_SendStartAppGalleryNotify_0000, TestSize.Level EXPECT_TRUE(true); EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(false)); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)); service->SendStartAppGalleryNotify(bundleName); EXPECT_TRUE(true); EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(false)); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::RESTORE)); EXPECT_CALL(*jdConfig, IfBundleNameInDisposalConfigFile(_)).WillOnce(Return(false)); service->SendStartAppGalleryNotify(bundleName); EXPECT_TRUE(true); EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(false)); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::RESTORE)); EXPECT_CALL(*jdConfig, IfBundleNameInDisposalConfigFile(_)).WillOnce(Return(true)); EXPECT_CALL(*gallery, StartRestore(_, _)).WillOnce(Return(DisposeErr::OK)); service->SendStartAppGalleryNotify(bundleName); @@ -1065,25 +1065,25 @@ HWTEST_F(ServiceTest, SUB_Service_SendEndAppGalleryNotify_0000, TestSize.Level1) EXPECT_TRUE(true); EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(false)); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)); service->SendEndAppGalleryNotify(bundleName); EXPECT_TRUE(true); EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(false)); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::RESTORE)); EXPECT_CALL(*gallery, EndRestore(_, _)).WillOnce(Return(DisposeErr::REQUEST_FAIL)); service->SendEndAppGalleryNotify(bundleName); EXPECT_TRUE(true); EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(false)); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::RESTORE)); EXPECT_CALL(*gallery, EndRestore(_, _)).WillOnce(Return(DisposeErr::OK)); EXPECT_CALL(*jdConfig, DeleteFromDisposalConfigFile(_)).WillOnce(Return(false)); service->SendEndAppGalleryNotify(bundleName); EXPECT_TRUE(true); EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(false)); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::RESTORE)); EXPECT_CALL(*gallery, EndRestore(_, _)).WillOnce(Return(DisposeErr::OK)); EXPECT_CALL(*jdConfig, DeleteFromDisposalConfigFile(_)).WillOnce(Return(true)); service->SendEndAppGalleryNotify(bundleName); @@ -1144,18 +1144,18 @@ HWTEST_F(ServiceTest, SUB_Service_SendErrAppGalleryNotify_0000, TestSize.Level1) { GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_SendErrAppGalleryNotify_0000"; try { - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)); service->SendErrAppGalleryNotify(); EXPECT_TRUE(true); vector bundleNameList; - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::RESTORE)); EXPECT_CALL(*jdConfig, GetBundleNameFromConfigFile()).WillOnce(Return(bundleNameList)); service->SendErrAppGalleryNotify(); EXPECT_TRUE(true); bundleNameList.emplace_back("100-bundleName"); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::RESTORE)); EXPECT_CALL(*jdConfig, GetBundleNameFromConfigFile()).WillOnce(Return(bundleNameList)); EXPECT_CALL(*gallery, EndRestore(_, _)).WillOnce(Return(DisposeErr::OK)); EXPECT_CALL(*jdConfig, DeleteFromDisposalConfigFile(_)).WillOnce(Return(true)); @@ -1212,24 +1212,24 @@ HWTEST_F(ServiceTest, SUB_Service_DeleteDisConfigFile_0000, TestSize.Level1) { GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_DeleteDisConfigFile_0000"; try { - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)); service->DeleteDisConfigFile(); EXPECT_TRUE(true); vector bundleNameList {"bundleName"}; - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::RESTORE)); EXPECT_CALL(*jdConfig, GetBundleNameFromConfigFile()).WillOnce(Return(bundleNameList)); service->DeleteDisConfigFile(); EXPECT_TRUE(true); bundleNameList.clear(); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::RESTORE)); EXPECT_CALL(*jdConfig, GetBundleNameFromConfigFile()).WillOnce(Return(bundleNameList)); EXPECT_CALL(*jdConfig, DeleteConfigFile()).WillOnce(Return(false)); service->DeleteDisConfigFile(); EXPECT_TRUE(true); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::RESTORE)); EXPECT_CALL(*jdConfig, GetBundleNameFromConfigFile()).WillOnce(Return(bundleNameList)); EXPECT_CALL(*jdConfig, DeleteConfigFile()).WillOnce(Return(true)); service->DeleteDisConfigFile(); @@ -1262,27 +1262,27 @@ HWTEST_F(ServiceTest, SUB_Service_SessionDeactive_0000, TestSize.Level1) auto sched = service->sched_; service->sched_ = nullptr; - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)) - .WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)) - .WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)) + .WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)) + .WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)); service->SessionDeactive(); EXPECT_TRUE(true); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)) - .WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)) - .WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::RESTORE)) + .WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)) + .WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)); EXPECT_CALL(*session, CleanAndCheckIfNeedWait(_, _)).WillOnce(Return(false)); service->SessionDeactive(); EXPECT_TRUE(true); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::RESTORE)); EXPECT_CALL(*session, CleanAndCheckIfNeedWait(_, _)) .WillOnce(DoAll(SetArgReferee<0>(BError(BError::Codes::SA_INVAL_ARG)), Return(true))); service->SessionDeactive(); EXPECT_TRUE(true); vector bundleNameList {"bundleName"}; - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::RESTORE)); EXPECT_CALL(*session, CleanAndCheckIfNeedWait(_, _)) .WillOnce(DoAll(SetArgReferee<1>(bundleNameList), Return(true))); EXPECT_CALL(*cdConfig, DeleteClearBundleRecord(_)).WillOnce(Return(true)); @@ -1311,18 +1311,18 @@ HWTEST_F(ServiceTest, SUB_Service_SessionDeactive_0100, TestSize.Level1) try { service->failedBundles_.clear(); service->successBundlesNum_ = 0; - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)) - .WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)) - .WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)) + .WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)) + .WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)); EXPECT_CALL(*session, ClearSessionData()).WillOnce(Return(BError(BError::Codes::SA_INVAL_ARG))); EXPECT_CALL(*session, GetSessionCnt()).WillOnce(Return(0)); service->SessionDeactive(); EXPECT_TRUE(true); service->isRmConfigFile_ = true; - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)) - .WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)) - .WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)) + .WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)) + .WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)); EXPECT_CALL(*session, ClearSessionData()).WillOnce(Return(BError(BError::Codes::OK))); EXPECT_CALL(*cdConfig, DeleteConfigFile()).WillOnce(Return(false)); EXPECT_CALL(*session, GetSessionCnt()).WillOnce(Return(0)); @@ -1330,9 +1330,9 @@ HWTEST_F(ServiceTest, SUB_Service_SessionDeactive_0100, TestSize.Level1) EXPECT_TRUE(true); service->isRmConfigFile_ = false; - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)) - .WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)) - .WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)) + .WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)) + .WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)); EXPECT_CALL(*session, ClearSessionData()).WillOnce(Return(BError(BError::Codes::OK))); EXPECT_CALL(*session, GetSessionCnt()).WillOnce(Return(0)); service->SessionDeactive(); @@ -1362,17 +1362,17 @@ HWTEST_F(ServiceTest, SUB_Service_SessionDeactive_0200, TestSize.Level1) service->isRmConfigFile_ = false; auto clearRecorder = service->clearRecorder_; service->clearRecorder_ = nullptr; - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)) - .WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)) - .WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)) + .WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)) + .WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)); EXPECT_CALL(*session, ClearSessionData()).WillOnce(Return(BError(BError::Codes::SA_INVAL_ARG))); EXPECT_CALL(*session, GetSessionCnt()).WillOnce(Return(0)); service->SessionDeactive(); EXPECT_TRUE(true); - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)) - .WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)) - .WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)) + .WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)) + .WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)); EXPECT_CALL(*session, ClearSessionData()).WillOnce(Return(BError(BError::Codes::SA_INVAL_ARG))); EXPECT_CALL(*session, GetSessionCnt()).WillOnce(Return(-1)); service->SessionDeactive(); @@ -1469,13 +1469,13 @@ HWTEST_F(ServiceTest, SUB_Service_TimeoutRadarReport_0000, TestSize.Level1) GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_TimeoutRadarReport_0000"; try { string bundleName; - service->TimeoutRadarReport(IServiceReverse::Scenario::BACKUP, bundleName); + service->TimeoutRadarReport(IServiceReverseType::Scenario::BACKUP, bundleName); EXPECT_TRUE(true); - service->TimeoutRadarReport(IServiceReverse::Scenario::RESTORE, bundleName); + service->TimeoutRadarReport(IServiceReverseType::Scenario::RESTORE, bundleName); EXPECT_TRUE(true); - service->TimeoutRadarReport(IServiceReverse::Scenario::UNDEFINED, bundleName); + service->TimeoutRadarReport(IServiceReverseType::Scenario::UNDEFINED, bundleName); EXPECT_TRUE(true); } catch (...) { EXPECT_TRUE(false); @@ -1933,9 +1933,9 @@ HWTEST_F(ServiceTest, SUB_Service_SendScannedInfo_0000, TestSize.Level1) EXPECT_TRUE(true); auto session_ = service->session_; - EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverseType::Scenario::UNDEFINED)); EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); - EXPECT_CALL(*srProxy, BackupOnScanningInfo(_)).WillOnce(Return()); + EXPECT_CALL(*srProxy, BackupOnScanningInfo(_)).WillOnce(Return(0)); EXPECT_CALL(*task, AddTask(_)).WillOnce(WithArgs<0>(Invoke([](const ThreadPool::Task &f) { f(); }))); diff --git a/tests/unittests/backup_sa/module_ipc/svc_extension_proxy_test.cpp b/tests/unittests/backup_sa/module_ipc/svc_extension_proxy_test.cpp index 572c43f8554ef78abb6bc6f45ca4dbbc90e9e495..75782d0a69be52ff56382efca2dd6ea4df665621 100644 --- a/tests/unittests/backup_sa/module_ipc/svc_extension_proxy_test.cpp +++ b/tests/unittests/backup_sa/module_ipc/svc_extension_proxy_test.cpp @@ -21,7 +21,7 @@ #include "b_error/b_error.h" #include "ext_extension_mock.h" #include "message_parcel_mock.h" -#include "module_ipc/svc_extension_proxy.h" +#include "extension_proxy.h" #include "unique_fd.h" namespace OHOS::FileManagement::Backup { @@ -35,7 +35,7 @@ public: void SetUp() override {}; void TearDown() override {}; public: - static inline sptr proxy_ = nullptr; + static inline sptr proxy_ = nullptr; static inline sptr mock_ = nullptr; static inline shared_ptr messageParcelMock_ = nullptr; }; @@ -43,7 +43,7 @@ public: void SvcExtensionProxyTest::SetUpTestCase() { mock_ = sptr(new BackupExtExtensionMock()); - proxy_ = sptr(new SvcExtensionProxy(mock_)); + proxy_ = sptr(new ExtensionProxy(mock_)); messageParcelMock_ = make_shared(); MessageParcelMock::messageParcel = messageParcelMock_; } diff --git a/tests/unittests/backup_sa/module_ipc/svc_session_manager_test.cpp b/tests/unittests/backup_sa/module_ipc/svc_session_manager_test.cpp index 54519072fce8a18172047c73678f99c7fbc71a86..bd61dd570f072815d00ce70f10069cca88ec6cdb 100644 --- a/tests/unittests/backup_sa/module_ipc/svc_session_manager_test.cpp +++ b/tests/unittests/backup_sa/module_ipc/svc_session_manager_test.cpp @@ -44,7 +44,7 @@ public: static void TearDownTestCase(void); void SetUp() override {}; void TearDown() override {}; - void Init(IServiceReverse::Scenario scenario); + void Init(IServiceReverseType::Scenario scenario); static inline sptr sessionManagerPtr_ = nullptr; static inline sptr remote_ = nullptr; @@ -67,7 +67,7 @@ void SvcSessionManagerTest::TearDownTestCase(void) remote_ = nullptr; } -void SvcSessionManagerTest::Init(IServiceReverse::Scenario scenario) +void SvcSessionManagerTest::Init(IServiceReverseType::Scenario scenario) { vector bundleNames; vector failedBundles; @@ -96,19 +96,19 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_VerifyCallerAndScenario_01 GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_VerifyCallerAndScenario_0100"; try { EXPECT_TRUE(sessionManagerPtr_ != nullptr); - sessionManagerPtr_->impl_.scenario = IServiceReverse::Scenario::BACKUP; + sessionManagerPtr_->impl_.scenario = IServiceReverseType::Scenario::BACKUP; ErrCode ret = sessionManagerPtr_->VerifyCallerAndScenario(CLIENT_TOKEN_ID, - IServiceReverse::Scenario::RESTORE); + IServiceReverseType::Scenario::RESTORE); EXPECT_TRUE(ret == BError(BError::Codes::SDK_MIXED_SCENARIO).GetCode()); - sessionManagerPtr_->impl_.scenario = IServiceReverse::Scenario::BACKUP; + sessionManagerPtr_->impl_.scenario = IServiceReverseType::Scenario::BACKUP; sessionManagerPtr_->impl_.clientToken = 0; - ret = sessionManagerPtr_->VerifyCallerAndScenario(CLIENT_TOKEN_ID, IServiceReverse::Scenario::BACKUP); + ret = sessionManagerPtr_->VerifyCallerAndScenario(CLIENT_TOKEN_ID, IServiceReverseType::Scenario::BACKUP); EXPECT_TRUE(ret == BError(BError::Codes::SA_REFUSED_ACT).GetCode()); - sessionManagerPtr_->impl_.scenario = IServiceReverse::Scenario::BACKUP; + sessionManagerPtr_->impl_.scenario = IServiceReverseType::Scenario::BACKUP; sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; - ret = sessionManagerPtr_->VerifyCallerAndScenario(CLIENT_TOKEN_ID, IServiceReverse::Scenario::BACKUP); + ret = sessionManagerPtr_->VerifyCallerAndScenario(CLIENT_TOKEN_ID, IServiceReverseType::Scenario::BACKUP); EXPECT_TRUE(ret == ERR_OK); } catch (...) { EXPECT_TRUE(false); @@ -141,13 +141,13 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_Active_0100, testing::ext: EXPECT_EQ(res, BError(BError::Codes::SA_INVAL_ARG).GetCode()); newImpl.clientToken = CLIENT_TOKEN_ID; - newImpl.scenario = IServiceReverse::Scenario::UNDEFINED; + newImpl.scenario = IServiceReverseType::Scenario::UNDEFINED; sessionManagerPtr_->impl_.clientToken = 0; res = sessionManagerPtr_->Active(newImpl); EXPECT_EQ(res, BError(BError::Codes::SA_INVAL_ARG).GetCode()); newImpl.clientToken = CLIENT_TOKEN_ID; - newImpl.scenario = IServiceReverse::Scenario::BACKUP; + newImpl.scenario = IServiceReverseType::Scenario::BACKUP; newImpl.clientProxy = nullptr; sessionManagerPtr_->impl_.clientToken = 0; res = sessionManagerPtr_->Active(newImpl); @@ -282,12 +282,12 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_getscenario_0100, testing: try { EXPECT_TRUE(sessionManagerPtr_ != nullptr); sessionManagerPtr_->impl_.clientToken = 0; - IServiceReverse::Scenario scenario = sessionManagerPtr_->GetScenario(); - EXPECT_TRUE(scenario == IServiceReverse::Scenario::UNDEFINED); + IServiceReverseType::Scenario scenario = sessionManagerPtr_->GetScenario(); + EXPECT_TRUE(scenario == IServiceReverseType::Scenario::UNDEFINED); sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; scenario = sessionManagerPtr_->GetScenario(); - EXPECT_TRUE(scenario == IServiceReverse::Scenario::UNDEFINED); + EXPECT_TRUE(scenario == IServiceReverseType::Scenario::UNDEFINED); } catch (...) { EXPECT_TRUE(false); GTEST_LOG_(INFO) << "SvcSessionManagerTest-an exception occurred by getscenario."; @@ -320,21 +320,21 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_onBundlefileready_0100, te sessionManagerPtr_->impl_.backupExtNameMap.clear(); sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {}; - sessionManagerPtr_->impl_.scenario = IServiceReverse::Scenario::RESTORE; + sessionManagerPtr_->impl_.scenario = IServiceReverseType::Scenario::RESTORE; fileReady = sessionManagerPtr_->OnBundleFileReady(BUNDLE_NAME); EXPECT_TRUE(fileReady); sessionManagerPtr_->impl_.backupExtNameMap.clear(); sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; sessionManagerPtr_->impl_.backupExtNameMap["123"] = {}; - sessionManagerPtr_->impl_.scenario = IServiceReverse::Scenario::BACKUP; + sessionManagerPtr_->impl_.scenario = IServiceReverseType::Scenario::BACKUP; fileReady = sessionManagerPtr_->OnBundleFileReady("123"); EXPECT_TRUE(fileReady); sessionManagerPtr_->impl_.backupExtNameMap.clear(); sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {}; - sessionManagerPtr_->impl_.scenario = IServiceReverse::Scenario::UNDEFINED; + sessionManagerPtr_->impl_.scenario = IServiceReverseType::Scenario::UNDEFINED; fileReady = sessionManagerPtr_->OnBundleFileReady(BUNDLE_NAME); EXPECT_FALSE(fileReady); GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_onBundlefileready_0100"; @@ -356,21 +356,21 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_onBundlefileready_0101, te sessionManagerPtr_->impl_.backupExtNameMap.clear(); sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {}; - sessionManagerPtr_->impl_.scenario = IServiceReverse::Scenario::BACKUP; + sessionManagerPtr_->impl_.scenario = IServiceReverseType::Scenario::BACKUP; bool fileReady = sessionManagerPtr_->OnBundleFileReady(BUNDLE_NAME, ""); EXPECT_FALSE(fileReady); sessionManagerPtr_->impl_.backupExtNameMap.clear(); sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {}; - sessionManagerPtr_->impl_.scenario = IServiceReverse::Scenario::BACKUP; + sessionManagerPtr_->impl_.scenario = IServiceReverseType::Scenario::BACKUP; fileReady = sessionManagerPtr_->OnBundleFileReady(BUNDLE_NAME, "test"); EXPECT_FALSE(fileReady); sessionManagerPtr_->impl_.backupExtNameMap.clear(); sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {}; - sessionManagerPtr_->impl_.scenario = IServiceReverse::Scenario::BACKUP; + sessionManagerPtr_->impl_.scenario = IServiceReverseType::Scenario::BACKUP; fileReady = sessionManagerPtr_->OnBundleFileReady(BUNDLE_NAME, string(BConstants::EXT_BACKUP_MANAGE)); EXPECT_FALSE(fileReady); @@ -402,7 +402,7 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_OnBundleExtManageInfo_0100 EXPECT_TRUE(move(ret) == -1); sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; - sessionManagerPtr_->impl_.scenario = IServiceReverse::Scenario::RESTORE; + sessionManagerPtr_->impl_.scenario = IServiceReverseType::Scenario::RESTORE; ret = sessionManagerPtr_->OnBundleExtManageInfo(BUNDLE_NAME, UniqueFd(-1)); EXPECT_TRUE(move(ret) == -1); @@ -583,7 +583,7 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetExtFileNameRequest_0102 GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_GetExtFileNameRequest_0102"; EXPECT_TRUE(sessionManagerPtr_ != nullptr); sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; - sessionManagerPtr_->impl_.scenario = IServiceReverse::Scenario::UNDEFINED; + sessionManagerPtr_->impl_.scenario = IServiceReverseType::Scenario::UNDEFINED; auto fileNameSet = sessionManagerPtr_->GetExtFileNameRequest(BUNDLE_NAME); EXPECT_TRUE(fileNameSet.empty()); GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_GetExtFileNameRequest_0102"; @@ -603,7 +603,7 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_GetExtFileNameRequest_0103 GTEST_LOG_(INFO) << "SvcSessionManagerTest-begin SUB_backup_sa_session_GetExtFileNameRequest_0103"; EXPECT_TRUE(sessionManagerPtr_ != nullptr); sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; - sessionManagerPtr_->impl_.scenario = IServiceReverse::Scenario::RESTORE; + sessionManagerPtr_->impl_.scenario = IServiceReverseType::Scenario::RESTORE; auto fileNameSet = sessionManagerPtr_->GetExtFileNameRequest(BUNDLE_NAME); EXPECT_FALSE(fileNameSet.empty()); GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_GetExtFileNameRequest_0103"; @@ -1009,14 +1009,14 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_NeedToUnloadService_0100, sessionManagerPtr_->impl_.backupExtNameMap.clear(); sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {}; sessionManagerPtr_->impl_.restoreDataType = RestoreTypeEnum::RESTORE_DATA_WAIT_SEND; - sessionManagerPtr_->impl_.scenario = IServiceReverse::Scenario::RESTORE; + sessionManagerPtr_->impl_.scenario = IServiceReverseType::Scenario::RESTORE; ret = sessionManagerPtr_->NeedToUnloadService(); EXPECT_FALSE(ret); sessionManagerPtr_->impl_.backupExtNameMap.clear(); sessionManagerPtr_->impl_.backupExtNameMap[BUNDLE_NAME] = {}; sessionManagerPtr_->impl_.restoreDataType = RestoreTypeEnum::RESTORE_DATA_WAIT_SEND; - sessionManagerPtr_->impl_.scenario = IServiceReverse::Scenario::BACKUP; + sessionManagerPtr_->impl_.scenario = IServiceReverseType::Scenario::BACKUP; ret = sessionManagerPtr_->NeedToUnloadService(); EXPECT_FALSE(ret); } catch (...) { @@ -1079,7 +1079,7 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_OnBundleFileReady_0200, te try { EXPECT_TRUE(sessionManagerPtr_ != nullptr); sessionManagerPtr_->Deactive(nullptr, true); - Init(IServiceReverse::Scenario::BACKUP); + Init(IServiceReverseType::Scenario::BACKUP); bool fileReady = sessionManagerPtr_->OnBundleFileReady(BUNDLE_NAME, MANAGE_JSON); EXPECT_FALSE(fileReady); fileReady = sessionManagerPtr_->OnBundleFileReady(BUNDLE_NAME, FILE_NAME); @@ -1470,12 +1470,12 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_IsOnAllBundlesFinished_010 EXPECT_FALSE(ret); sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; - sessionManagerPtr_->impl_.scenario = IServiceReverse::Scenario::RESTORE; + sessionManagerPtr_->impl_.scenario = IServiceReverseType::Scenario::RESTORE; ret = sessionManagerPtr_->IsOnAllBundlesFinished(); EXPECT_FALSE(ret); sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; - sessionManagerPtr_->impl_.scenario = IServiceReverse::Scenario::UNDEFINED; + sessionManagerPtr_->impl_.scenario = IServiceReverseType::Scenario::UNDEFINED; ret = sessionManagerPtr_->IsOnAllBundlesFinished(); EXPECT_FALSE(ret); GTEST_LOG_(INFO) << "SvcSessionManagerTest-end SUB_backup_sa_session_IsOnAllBundlesFinished_0100"; @@ -2017,7 +2017,7 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_Exception_0100, testing::e sessionManagerPtr_->SetExtFileNameRequest(BUNDLE_NAME, ""); EXPECT_TRUE(true); - sessionManagerPtr_->impl_.scenario = IServiceReverse::Scenario::RESTORE; + sessionManagerPtr_->impl_.scenario = IServiceReverseType::Scenario::RESTORE; std::set fileSet = sessionManagerPtr_->GetExtFileNameRequest(BUNDLE_NAME); EXPECT_TRUE(fileSet.empty()); diff --git a/tests/unittests/backup_sa/session/BUILD.gn b/tests/unittests/backup_sa/session/BUILD.gn index 9bcf5940e828dc6e6a08f525efbc63323e3ed9dc..98fcc477aa19185c994dffa370f43c6a2c3323bc 100644 --- a/tests/unittests/backup_sa/session/BUILD.gn +++ b/tests/unittests/backup_sa/session/BUILD.gn @@ -17,6 +17,17 @@ import("//foundation/filemanagement/app_file_service/backup.gni") ohos_unittest("b_incremental_session_test") { module_out_path = path_module_out_tests + sanitize = { + integer_overflow = true + ubsan = true + boundary_sanitize = true + cfi = true + cfi_cross_dso = true + cfi_vcall_icall_only = true + debug = false + blocklist = "${path_backup}/cfi_blocklist.txt" + } + include_dirs = [ "${path_backup}/frameworks/native/backup_kit_inner/include", "${path_backup}/interfaces/inner_api/native/backup_kit_inner/impl", @@ -37,25 +48,19 @@ ohos_unittest("b_incremental_session_test") { "${path_backup}/frameworks/native/backup_kit_inner/src/b_incremental_session_restore_async.cpp", "${path_backup}/frameworks/native/backup_kit_inner/src/service_incremental_reverse.cpp", "${path_backup}/frameworks/native/backup_kit_inner/src/service_reverse.cpp", - "${path_backup}/frameworks/native/backup_kit_inner/src/service_reverse_stub.cpp", "${path_backup}/tests/mock/utils_mock/src/utils_mock_global_variable.cpp", "b_incremental_session_test.cpp", "service_client_mock.cpp", "service_proxy_mock.cpp", ] + public_configs = [ "${path_backup}/services/backup_sa:public_idl_config" ] + deps = [ "${path_backup}/services/backup_sa:backup_sa_ipc_stub", "${path_backup}/utils:backup_utils", ] - sanitize = { - cfi = true - cfi_cross_dso = true - debug = false - blocklist = "${path_backup}/cfi_blocklist.txt" - } - defines = [ "LOG_TAG=\"app_file_service\"", "LOG_DOMAIN=0xD200000", diff --git a/tests/unittests/backup_sa/session/service_proxy_mock.h b/tests/unittests/backup_sa/session/service_proxy_mock.h index 85a4e056e67fa0d92629c95ccd59cb5527924423..dfbf9185ecee1e7ac6dc90d930a30c62dfe9f64b 100644 --- a/tests/unittests/backup_sa/session/service_proxy_mock.h +++ b/tests/unittests/backup_sa/session/service_proxy_mock.h @@ -25,6 +25,7 @@ class ServiceProxyMock : public ServiceProxy { public: explicit ServiceProxyMock(const sptr &impl) : ServiceProxy(impl) {} ~ServiceProxyMock() override {} + public: MOCK_METHOD1(InitRestoreSession, ErrCode(const sptr &remote)); MOCK_METHOD2(InitRestoreSessionWithErrMsg, ErrCode(const sptr &remote, std::string &errMsg)); diff --git a/tests/unittests/backup_tools/BUILD.gn b/tests/unittests/backup_tools/BUILD.gn index 18f59eb1f8679e56d88bf7999f3f1b8e7ada8102..31560d4c54529ea59a84c4210fe584079fecca22 100644 --- a/tests/unittests/backup_tools/BUILD.gn +++ b/tests/unittests/backup_tools/BUILD.gn @@ -25,7 +25,6 @@ ohos_unittest("backup_tool_test") { "${path_backup}/frameworks/native/backup_kit_inner/src/b_incremental_data.cpp", "${path_backup}/frameworks/native/backup_kit_inner/src/service_incremental_reverse.cpp", "${path_backup}/frameworks/native/backup_kit_inner/src/service_reverse.cpp", - "${path_backup}/frameworks/native/backup_kit_inner/src/service_reverse_stub.cpp", "${path_backup}/tests/mock/backup_kit_inner/b_session_backup_mock.cpp", "${path_backup}/tests/mock/backup_kit_inner/service_client_mock.cpp", "${path_backup}/tools/backup_tool/src/tools_op.cpp", @@ -94,7 +93,6 @@ ohos_unittest("backup_tool_restore_test") { "${path_backup}/frameworks/native/backup_kit_inner/src/b_incremental_restore_session.cpp", "${path_backup}/frameworks/native/backup_kit_inner/src/service_incremental_reverse.cpp", "${path_backup}/frameworks/native/backup_kit_inner/src/service_reverse.cpp", - "${path_backup}/frameworks/native/backup_kit_inner/src/service_reverse_stub.cpp", "${path_backup}/tests/mock/backup_kit_inner/b_session_restore_async_mock.cpp", "${path_backup}/tests/mock/backup_kit_inner/b_session_restore_mock.cpp", "${path_backup}/tools/backup_tool/src/tools_op.cpp", diff --git a/utils/include/b_radar/b_radar.h b/utils/include/b_radar/b_radar.h index 6b17d9851bab5ae138945fd69c91c30587efe056..0e367736cfedf15caf19711e439e486b70a33e85 100644 --- a/utils/include/b_radar/b_radar.h +++ b/utils/include/b_radar/b_radar.h @@ -119,7 +119,7 @@ public: enum BizStageBackup bizStage, int32_t resultCode); void RecordRestoreFuncRes(Info &info, const std::string &func, int32_t userId, enum BizStageRestore bizStage, int32_t resultCode); - void RecordStatisticRes(StatInfo &statInfo, int32_t userId, enum IServiceReverse::Scenario scenario, + void RecordStatisticRes(StatInfo &statInfo, int32_t userId, enum IServiceReverseType::Scenario scenario, int32_t succ_cnt, int32_t fail_cnt, int32_t resultCode); private: AppRadar() = default; diff --git a/utils/src/b_radar/b_radar.cpp b/utils/src/b_radar/b_radar.cpp index d25a28d296cd05f30fb33d45664d3259aaa54f14..09f853776abea82d1f39d00bf7aaea3c96eab75a 100644 --- a/utils/src/b_radar/b_radar.cpp +++ b/utils/src/b_radar/b_radar.cpp @@ -49,7 +49,7 @@ void AppRadar::RecordDefaultFuncRes(Info &info, const std::string &func, int32_t "PID", getpid(), "FUNC", func, "TIME", TimeUtils::GetCurrentTime(), - "BIZ_SCENE", static_cast(IServiceReverse::Scenario::UNDEFINED), + "BIZ_SCENE", static_cast(IServiceReverseType::Scenario::UNDEFINED), "BIZ_STAGE", static_cast(bizStage), "EXEC_STATUS", info.status, "RESULT_CODE", resultCode, @@ -70,7 +70,7 @@ void AppRadar::RecordBackupFuncRes(Info &info, const std::string &func, int32_t "PID", getpid(), "FUNC", func, "TIME", TimeUtils::GetCurrentTime(), - "BIZ_SCENE", static_cast(IServiceReverse::Scenario::BACKUP), + "BIZ_SCENE", static_cast(IServiceReverseType::Scenario::BACKUP), "BIZ_STAGE", static_cast(bizStage), "EXEC_STATUS", info.status, "RESULT_CODE", resultCode, @@ -91,14 +91,14 @@ void AppRadar::RecordRestoreFuncRes(Info &info, const std::string &func, int32_t "PID", getpid(), "FUNC", func, "TIME", TimeUtils::GetCurrentTime(), - "BIZ_SCENE", static_cast(IServiceReverse::Scenario::RESTORE), + "BIZ_SCENE", static_cast(IServiceReverseType::Scenario::RESTORE), "BIZ_STAGE", static_cast(bizStage), "EXEC_STATUS", info.status, "RESULT_CODE", resultCode, "RESULT_INFO", ss.str()); } -void AppRadar::RecordStatisticRes(StatInfo &statInfo, int32_t userId, enum IServiceReverse::Scenario scenario, +void AppRadar::RecordStatisticRes(StatInfo &statInfo, int32_t userId, enum IServiceReverseType::Scenario scenario, int32_t succ_cnt, int32_t fail_cnt, int32_t resultCode) { std::stringstream ss;