From e746ca7fd833b5164a49000891aa65f49ce74907 Mon Sep 17 00:00:00 2001 From: wangpggg Date: Tue, 10 Sep 2024 11:38:48 +0800 Subject: [PATCH] modify failed ut Signed-off-by: wangpeng --- .../backup_ext/include/ext_backup_js_mock.h | 91 ++++++++ .../backup_ext/include/ext_extension_mock.h | 125 ++++++++++ .../backup_ext/src/ext_extension_mock.cpp | 220 ++++++++++++++++++ .../src/ext_extension_stub_mock.cpp | 28 +++ tests/mock/cJson/include/cJsonMock.h | 6 +- tests/mock/cJson/src/cJsonMock.cpp | 5 + .../include/service_reverse_proxy_mock.h | 2 +- .../backup_ext/ext_backup_js_test.cpp | 12 +- .../backup_ext/ext_extension_stub_test.cpp | 35 +-- .../module_ipc/service_throw_test.cpp | 23 +- .../module_ipc/svc_session_manager_test.cpp | 10 +- .../session/b_incremental_session_test.cpp | 2 +- .../backup_sa/session/service_proxy_mock.h | 1 + ...son_service_disposal_config_other_test.cpp | 2 +- utils/src/b_jsonutil/b_jsonutil.cpp | 6 +- 15 files changed, 518 insertions(+), 50 deletions(-) create mode 100644 tests/mock/backup_ext/include/ext_backup_js_mock.h create mode 100644 tests/mock/backup_ext/include/ext_extension_mock.h create mode 100644 tests/mock/backup_ext/src/ext_extension_mock.cpp create mode 100644 tests/mock/backup_ext/src/ext_extension_stub_mock.cpp diff --git a/tests/mock/backup_ext/include/ext_backup_js_mock.h b/tests/mock/backup_ext/include/ext_backup_js_mock.h new file mode 100644 index 000000000..001051de5 --- /dev/null +++ b/tests/mock/backup_ext/include/ext_backup_js_mock.h @@ -0,0 +1,91 @@ +/* + * 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_BACKUP_JS_MOCK_H +#define OHOS_FILEMGMT_BACKUP_EXT_BACKUP_JS_MOCK_H + +#include + +#include "ability_info.h" +#include "ext_backup_js.h" + +namespace OHOS::FileManagement::Backup { +class BExtBackupJs { +public: + BExtBackupJs() = default; + virtual ~BExtBackupJs() = default; +public: + virtual void Init(const std::shared_ptr &, + const std::shared_ptr &, + std::shared_ptr &, + const sptr &) = 0; + virtual ExtBackupJs *Create(const std::unique_ptr &) = 0; + virtual ErrCode OnBackup(std::function, + std::function) = 0; + virtual ErrCode OnRestore(std::function, + std::function) = 0; + virtual ErrCode GetBackupInfo(std::function); + virtual ErrCode InvokeAppExtMethod(ErrCode, const std::string) = 0; + virtual int CallJsMethod(const std::string &, AbilityRuntime::JsRuntime &, NativeReference *, InputArgsParser, + ResultValueParser) = 0; + virtual std::tuple CallObjectMethod(std::string_view, const std::vector &) = 0; + virtual std::function &argv)> ParseRestoreExInfo() = 0; + virtual std::function &argv)> ParseRestoreInfo() = 0; + virtual std::function &argv)> ParseBackupExInfo() = 0; + virtual std::function &argv)> ParseBackupInfo() = 0; + virtual ErrCode CallJSRestoreEx() = 0; + virtual ErrCode CallJSRestore() = 0; + virtual ErrCode CallJsOnBackupEx() = 0; + virtual ErrCode CallJsOnBackup() = 0; + virtual void ExportJsContext() = 0; +public: + virtual bool GetProfileFromAbility(const OHOS::AppExecFwk::AbilityInfo &, const std::string &, + std::vector &) const = 0; +public: + static inline std::shared_ptr extBackupJs = nullptr; +}; + +class ExtBackupJsMock : public BExtBackupJs { +public: + MOCK_METHOD(void, Init, (const std::shared_ptr &, + const std::shared_ptr &, + std::shared_ptr &, + const sptr &)); + MOCK_METHOD(ExtBackupJs *, Create, (const std::unique_ptr &)); + MOCK_METHOD(ErrCode, OnBackup, (std::function, + std::function)); + MOCK_METHOD(ErrCode, OnRestore, (std::function, + std::function)); + MOCK_METHOD(ErrCode, GetBackupInfo, (std::function)); + MOCK_METHOD(ErrCode, InvokeAppExtMethod, (ErrCode, const std::string)); + MOCK_METHOD(int, CallJsMethod, (const std::string&, AbilityRuntime::JsRuntime&, NativeReference*, InputArgsParser, + ResultValueParser)); + MOCK_METHOD((std::tuple), CallObjectMethod, + (std::string_view, const std::vector &)); + MOCK_METHOD((std::function &argv)>), ParseRestoreExInfo, ()); + MOCK_METHOD((std::function &argv)>), ParseRestoreInfo, ()); + MOCK_METHOD((std::function &argv)>), ParseBackupExInfo, ()); + MOCK_METHOD((std::function &argv)>), ParseBackupInfo, ()); + MOCK_METHOD(ErrCode, CallJSRestoreEx, ()); + MOCK_METHOD(ErrCode, CallJSRestore, ()); + MOCK_METHOD(ErrCode, CallJsOnBackupEx, ()); + MOCK_METHOD(ErrCode, CallJsOnBackup, ()); + MOCK_METHOD(void, ExportJsContext, ()); +public: + MOCK_METHOD(bool, GetProfileFromAbility, (const OHOS::AppExecFwk::AbilityInfo&, const std::string&, + std::vector&), (const)); +}; +} // namespace OHOS::FileManagement::Backup +#endif // OHOS_FILEMGMT_BACKUP_EXT_BACKUP_JS_MOCK_H diff --git a/tests/mock/backup_ext/include/ext_extension_mock.h b/tests/mock/backup_ext/include/ext_extension_mock.h new file mode 100644 index 000000000..1e97a71f6 --- /dev/null +++ b/tests/mock/backup_ext/include/ext_extension_mock.h @@ -0,0 +1,125 @@ +/* + * 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_MOCK_H +#define OHOS_FILEMGMT_BACKUP_EXT_EXTENSION_MOCK_H + +#include + +#include "ext_extension.h" + +namespace OHOS::FileManagement::Backup { +class BExtExtension { +public: + virtual ErrCode GetIncrementalFileHandle(const string &) = 0; + virtual UniqueFd GetFileHandle(const string &, int32_t &) = 0; + virtual ErrCode HandleClear() = 0; + virtual ErrCode BigFileReady(sptr) = 0; + virtual ErrCode PublishFile(const std::string &) = 0; + virtual ErrCode PublishIncrementalFile(const string &) = 0; + virtual ErrCode HandleBackup() = 0; + virtual int DoBackup(const BJsonEntityExtensionConfig &) = 0; + virtual int DoRestore(const string &) = 0; + virtual int DoIncrementalRestore() = 0; + virtual void AsyncTaskBackup(const string) = 0; + virtual void AsyncTaskRestore(std::set, const std::vector) = 0; + virtual void AsyncTaskIncrementalRestore() = 0; + virtual void AsyncTaskIncreRestoreSpecialVersion() = 0; + virtual void AsyncTaskRestoreForUpgrade() = 0; + virtual void ExtClear() = 0; + virtual void AsyncTaskIncrementalRestoreForUpgrade() = 0; + virtual void DoClear() = 0; + virtual void AppDone(ErrCode) = 0; + virtual void AppResultReport(const std::string, BackupRestoreScenario, ErrCode) = 0; + virtual void AsyncTaskOnBackup() = 0; + virtual ErrCode HandleRestore() = 0; + virtual void CompareFiles(UniqueFd, UniqueFd, std::vector&, + std::vector&, std::vector&) = 0; + virtual ErrCode HandleIncrementalBackup(UniqueFd, UniqueFd) = 0; + virtual ErrCode IncrementalOnBackup() = 0; + virtual tuple GetIncrementalBackupFileHandle() = 0; + virtual ErrCode IncrementalBigFileReady(const TarMap&, const std::vector&, + sptr) = 0; + virtual void AsyncTaskDoIncrementalBackup(UniqueFd, UniqueFd) = 0; + virtual void AsyncTaskOnIncrementalBackup() = 0; + virtual void IncrementalPacket(const std::vector&, TarMap&, sptr) = 0; + virtual int DoIncrementalBackup(const std::vector&, + const std::vector&, const std::vector&) = 0; + virtual void AppIncrementalDone(ErrCode) = 0; + virtual ErrCode GetBackupInfo(std::string&) = 0; + virtual ErrCode UpdateFdSendRate(std::string&, int32_t) = 0; + virtual std::function RestoreResultCallbackEx(wptr) = 0; + virtual std::function AppDoneCallbackEx(wptr) = 0; + virtual std::function IncRestoreResultCallbackEx(wptr) = 0; + virtual std::function HandleBackupEx(wptr) = 0; + virtual std::function HandleTaskBackupEx(wptr) = 0; + virtual void WaitToSendFd(std::chrono::system_clock::time_point&, int&) = 0; + virtual void RefreshTimeInfo(std::chrono::system_clock::time_point&, int&) = 0; +public: + BExtExtension() = default; + virtual ~BExtExtension() = default; +public: + static inline std::shared_ptr extExtension = nullptr; +}; + +class ExtExtensionMock : public BExtExtension { +public: + MOCK_METHOD(UniqueFd, GetFileHandle, (const string &, int32_t &)); + MOCK_METHOD(ErrCode, GetIncrementalFileHandle, (const string &)); + MOCK_METHOD(ErrCode, HandleClear, ()); + MOCK_METHOD(ErrCode, BigFileReady, (sptr)); + MOCK_METHOD(ErrCode, PublishFile, (const std::string &)); + MOCK_METHOD(ErrCode, PublishIncrementalFile, (const string &)); + MOCK_METHOD(ErrCode, HandleBackup, ()); + MOCK_METHOD(int, DoBackup, (const BJsonEntityExtensionConfig &)); + MOCK_METHOD(int, DoRestore, (const string &)); + MOCK_METHOD(int, DoIncrementalRestore, ()); + MOCK_METHOD(void, AsyncTaskBackup, (const string)); + MOCK_METHOD(void, AsyncTaskRestore, (std::set, const std::vector)); + MOCK_METHOD(void, AsyncTaskIncrementalRestore, ()); + MOCK_METHOD(void, AsyncTaskIncreRestoreSpecialVersion, ()); + MOCK_METHOD(void, AsyncTaskRestoreForUpgrade, ()); + MOCK_METHOD(void, ExtClear, ()); + MOCK_METHOD(void, AsyncTaskIncrementalRestoreForUpgrade, ()); + MOCK_METHOD(void, DoClear, ()); + MOCK_METHOD(void, AppDone, (ErrCode)); + MOCK_METHOD(void, AppResultReport, (const std::string, BackupRestoreScenario, ErrCode)); + MOCK_METHOD(void, AsyncTaskOnBackup, ()); + MOCK_METHOD(ErrCode, HandleRestore, ()); + MOCK_METHOD(void, CompareFiles, (UniqueFd, UniqueFd, (std::vector&), + (std::vector&), (std::vector&))); + MOCK_METHOD(ErrCode, HandleIncrementalBackup, (UniqueFd, UniqueFd)); + MOCK_METHOD(ErrCode, IncrementalOnBackup, ()); + MOCK_METHOD((std::tuple), GetIncrementalBackupFileHandle, ()); + MOCK_METHOD(ErrCode, IncrementalBigFileReady, (const TarMap&, (const std::vector&), + sptr)); + MOCK_METHOD(void, AsyncTaskDoIncrementalBackup, (UniqueFd, UniqueFd)); + MOCK_METHOD(void, AsyncTaskOnIncrementalBackup, ()); + MOCK_METHOD(void, IncrementalPacket, ((const std::vector&), TarMap&, sptr)); + MOCK_METHOD(int, DoIncrementalBackup, ((const std::vector&), + (const std::vector&), (const std::vector&))); + MOCK_METHOD(void, AppIncrementalDone, (ErrCode)); + MOCK_METHOD(ErrCode, GetBackupInfo, (std::string&)); + MOCK_METHOD(ErrCode, UpdateFdSendRate, (std::string&, int32_t)); + MOCK_METHOD((std::function), RestoreResultCallbackEx, (wptr)); + MOCK_METHOD((std::function), AppDoneCallbackEx, (wptr)); + MOCK_METHOD((std::function), IncRestoreResultCallbackEx, (wptr)); + MOCK_METHOD((std::function), HandleBackupEx, (wptr)); + MOCK_METHOD((std::function), HandleTaskBackupEx, (wptr)); + MOCK_METHOD(void, WaitToSendFd, ((std::chrono::system_clock::time_point&), int&)); + MOCK_METHOD(void, RefreshTimeInfo, ((std::chrono::system_clock::time_point&), int&)); +}; +} // namespace OHOS::FileManagement::Backup +#endif // OHOS_FILEMGMT_BACKUP_EXT_EXTENSION_MOCK_H \ No newline at end of file diff --git a/tests/mock/backup_ext/src/ext_extension_mock.cpp b/tests/mock/backup_ext/src/ext_extension_mock.cpp new file mode 100644 index 000000000..80b8d6dc6 --- /dev/null +++ b/tests/mock/backup_ext/src/ext_extension_mock.cpp @@ -0,0 +1,220 @@ +/* + * 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.h" +#include "ext_extension_mock.h" + +namespace OHOS::FileManagement::Backup { +using namespace std; +void BackupExtExtension::VerifyCaller() +{ +} + +UniqueFd BackupExtExtension::GetFileHandle(const string &fileName, int32_t &errCode) +{ + return BExtExtension::extExtension->GetFileHandle(fileName, errCode); +} + +ErrCode BackupExtExtension::GetIncrementalFileHandle(const string &fileName) +{ + return BExtExtension::extExtension->GetIncrementalFileHandle(fileName); +} + +ErrCode BackupExtExtension::HandleClear() +{ + return BExtExtension::extExtension->HandleClear(); +} + +ErrCode BackupExtExtension::BigFileReady(sptr proxy) +{ + return BExtExtension::extExtension->BigFileReady(proxy); +} + +ErrCode BackupExtExtension::PublishFile(const std::string &fileName) +{ + return BExtExtension::extExtension->PublishFile(fileName); +} + +ErrCode BackupExtExtension::PublishIncrementalFile(const string &fileName) +{ + return BExtExtension::extExtension->PublishIncrementalFile(fileName); +} + +ErrCode BackupExtExtension::HandleBackup() +{ + return BExtExtension::extExtension->HandleBackup(); +} + +int BackupExtExtension::DoBackup(const BJsonEntityExtensionConfig &usrConfig) +{ + return BExtExtension::extExtension->DoBackup(usrConfig); +} + +int BackupExtExtension::DoRestore(const string &fileName) +{ + return BExtExtension::extExtension->DoRestore(fileName); +} + +int BackupExtExtension::DoIncrementalRestore() +{ + return BExtExtension::extExtension->DoIncrementalRestore(); +} + +void BackupExtExtension::AsyncTaskBackup(const string config) +{ +} + +void BackupExtExtension::AsyncTaskRestore(std::set fileSet, + const std::vector extManageInfo) +{ +} + +void BackupExtExtension::AsyncTaskIncrementalRestore() +{ +} + +void BackupExtExtension::AsyncTaskIncreRestoreSpecialVersion() +{ +} + +void BackupExtExtension::AsyncTaskRestoreForUpgrade() +{ +} + +void BackupExtExtension::ExtClear() +{ +} + +void BackupExtExtension::AsyncTaskIncrementalRestoreForUpgrade() +{ +} + +void BackupExtExtension::DoClear() +{ +} + +void BackupExtExtension::AppDone(ErrCode errCode) +{ +} + +void BackupExtExtension::AppResultReport(const std::string restoreRetInfo, + BackupRestoreScenario scenario, ErrCode errCode) +{ +} + +void BackupExtExtension::AsyncTaskOnBackup() +{ +} + +ErrCode BackupExtExtension::HandleRestore() +{ + return BExtExtension::extExtension->HandleRestore(); +} + +void BackupExtExtension::CompareFiles(UniqueFd incrementalFd, + UniqueFd manifestFd, + vector &allFiles, + vector &smallFiles, + vector &bigFiles) +{ +} + +ErrCode BackupExtExtension::HandleIncrementalBackup(UniqueFd incrementalFd, UniqueFd manifestFd) +{ + return BExtExtension::extExtension->HandleIncrementalBackup(std::move(incrementalFd), std::move(manifestFd)); +} + +ErrCode BackupExtExtension::IncrementalOnBackup() +{ + return BExtExtension::extExtension->IncrementalOnBackup(); +} + +tuple BackupExtExtension::GetIncrementalBackupFileHandle() +{ + return BExtExtension::extExtension->GetIncrementalBackupFileHandle(); +} + +ErrCode BackupExtExtension::IncrementalBigFileReady(const TarMap &pkgInfo, + const vector &bigInfos, sptr proxy) +{ + return BExtExtension::extExtension->IncrementalBigFileReady(pkgInfo, bigInfos, proxy); +} + +void BackupExtExtension::AsyncTaskDoIncrementalBackup(UniqueFd incrementalFd, UniqueFd manifestFd) +{ +} + +void BackupExtExtension::AsyncTaskOnIncrementalBackup() +{ +} + +void BackupExtExtension::IncrementalPacket(const vector &, TarMap &, sptr) +{ +} + +int BackupExtExtension::DoIncrementalBackup(const vector &allFiles, + const vector &smallFiles, + const vector &bigFiles) +{ + return BExtExtension::extExtension->DoIncrementalBackup(allFiles, smallFiles, bigFiles); +} + +void BackupExtExtension::AppIncrementalDone(ErrCode errCode) +{ +} + +ErrCode BackupExtExtension::GetBackupInfo(std::string &result) +{ + return BExtExtension::extExtension->GetBackupInfo(result); +} + +ErrCode BackupExtExtension::UpdateFdSendRate(std::string &bundleName, int32_t sendRate) +{ + return BExtExtension::extExtension->UpdateFdSendRate(bundleName, sendRate); +} + +std::function BackupExtExtension::RestoreResultCallbackEx(wptr obj) +{ + return BExtExtension::extExtension->RestoreResultCallbackEx(obj); +} + +std::function BackupExtExtension::AppDoneCallbackEx(wptr obj) +{ + return BExtExtension::extExtension->AppDoneCallbackEx(obj); +} + +std::function BackupExtExtension::IncRestoreResultCallbackEx(wptr obj) +{ + return BExtExtension::extExtension->IncRestoreResultCallbackEx(obj); +} + +std::function BackupExtExtension::HandleBackupEx(wptr obj) +{ + return BExtExtension::extExtension->HandleBackupEx(obj); +} + +std::function BackupExtExtension::HandleTaskBackupEx(wptr obj) +{ + return BExtExtension::extExtension->HandleTaskBackupEx(obj); +} + +void BackupExtExtension::WaitToSendFd(std::chrono::system_clock::time_point &startTime, int &fdSendNum) +{ +} + +void BackupExtExtension::RefreshTimeInfo(std::chrono::system_clock::time_point &startTime, int &fdSendNum) +{ +} +} // namespace OHOS::FileManagement::Backup diff --git a/tests/mock/backup_ext/src/ext_extension_stub_mock.cpp b/tests/mock/backup_ext/src/ext_extension_stub_mock.cpp new file mode 100644 index 000000000..6f9309402 --- /dev/null +++ b/tests/mock/backup_ext/src/ext_extension_stub_mock.cpp @@ -0,0 +1,28 @@ +/* + * 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 diff --git a/tests/mock/cJson/include/cJsonMock.h b/tests/mock/cJson/include/cJsonMock.h index 6d47050cd..f488cc5e3 100644 --- a/tests/mock/cJson/include/cJsonMock.h +++ b/tests/mock/cJson/include/cJsonMock.h @@ -33,8 +33,9 @@ public: virtual void cJSON_Delete(cJSON *item) = 0; virtual cJSON_bool cJSON_AddItemToObject(cJSON *object, const char *string, cJSON *item) = 0; virtual int cJSON_GetArraySize(const cJSON *array) = 0; - virtual cJSON_bool cJSON_AddItemToArray(cJSON *array, cJSON *item); - virtual cJSON *cJSON_AddStringToObject(cJSON *const object, const char *const name, const char *const string); + virtual cJSON_bool cJSON_AddItemToArray(cJSON *array, cJSON *item) = 0; + virtual cJSON *cJSON_AddStringToObject(cJSON *const object, const char *const name, const char *const string) = 0; + virtual cJSON_bool cJSON_IsArray(const cJSON * const item) = 0; public: static inline std::shared_ptr cJsonPtr = nullptr; @@ -53,6 +54,7 @@ public: MOCK_METHOD2(cJSON_AddItemToArray, cJSON_bool(cJSON *array, cJSON *item)); MOCK_METHOD3(cJSON_AddStringToObject, cJSON *(cJSON *const object, const char *const name, const char *const string)); + MOCK_METHOD1(cJSON_IsArray, cJSON_bool(const cJSON * const item)); }; } // namespace OHOS::FileManagement::Backup #endif \ No newline at end of file diff --git a/tests/mock/cJson/src/cJsonMock.cpp b/tests/mock/cJson/src/cJsonMock.cpp index 8aa2427dd..f3a8c4cfe 100644 --- a/tests/mock/cJson/src/cJsonMock.cpp +++ b/tests/mock/cJson/src/cJsonMock.cpp @@ -66,4 +66,9 @@ CJSON_PUBLIC(cJSON_bool) cJSON_AddItemToArray(cJSON *array, cJSON *item) CJSON_PUBLIC(cJSON*) cJSON_AddStringToObject(cJSON * const object, const char * const name, const char * const string) { return CJson::cJsonPtr->cJSON_AddStringToObject(object, name, string); +} + +CJSON_PUBLIC(cJSON_bool) cJSON_IsArray(const cJSON * const item) +{ + return CJson::cJsonPtr->cJSON_IsArray(item); } \ No newline at end of file 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 12fdb9f54..8a74af4bd 100644 --- a/tests/mock/module_ipc/include/service_reverse_proxy_mock.h +++ b/tests/mock/module_ipc/include/service_reverse_proxy_mock.h @@ -1,5 +1,5 @@ /* - * Copyright , (c) 2022-2024 Huawei Device Co., Ltd. + * 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 diff --git a/tests/unittests/backup_ext/ext_backup_js_test.cpp b/tests/unittests/backup_ext/ext_backup_js_test.cpp index b8013123d..51cec6cc1 100644 --- a/tests/unittests/backup_ext/ext_backup_js_test.cpp +++ b/tests/unittests/backup_ext/ext_backup_js_test.cpp @@ -123,13 +123,13 @@ HWTEST_F(ExtBackupJsTest, SUB_backup_ext_js_GetSrcPath_0100, testing::ext::TestS { GTEST_LOG_(INFO) << "ExtBackupJsTest-begin SUB_backup_ext_js_GetSrcPath_0100"; try { - AppExecFwk::AbilityInfo info; - info.srcEntrance = ""; - auto ret = GetSrcPath(info); + sptr info = sptr(new AppExecFwk::AbilityInfo()); + info->srcEntrance = ""; + auto ret = GetSrcPath(*info); EXPECT_TRUE(ret.empty()); - info.srcEntrance = "test"; - ret = GetSrcPath(info); + info->srcEntrance = "test"; + ret = GetSrcPath(*info); EXPECT_FALSE(ret.empty()); } catch (...) { EXPECT_TRUE(false); @@ -1411,7 +1411,6 @@ HWTEST_F(ExtBackupJsTest, SUB_backup_ext_js_GetBackupInfo_0100, testing::ext::Te GTEST_LOG_(INFO) << "ExtBackupJsTest-begin SUB_backup_ext_js_GetBackupInfo_0100"; try { extBackupJs->jsObj_ = make_unique(); - EXPECT_CALL(*napiMock, napi_is_exception_pending(_, _)).WillOnce(Return(napi_ok)); EXPECT_CALL(*extBackupMock, GetNapiEnv()).WillOnce(Return(nullptr)); EXPECT_CALL(*napiMock, napi_get_uv_event_loop(_, _)).WillOnce(Return(napi_invalid_arg)); auto ret = extBackupJs->GetBackupInfo([](ErrCode, std::string){}); @@ -1462,7 +1461,6 @@ HWTEST_F(ExtBackupJsTest, SUB_backup_ext_js_GetBackupInfo_0200, testing::ext::Te auto ret = extBackupJs->GetBackupInfo([](ErrCode, std::string){}); EXPECT_EQ(ret, EINVAL); - EXPECT_CALL(*napiMock, napi_is_exception_pending(_, _)).WillOnce(Return(napi_ok)); EXPECT_CALL(*extBackupMock, GetNapiEnv()).WillOnce(Return(nullptr)).WillOnce(Return(nullptr)); EXPECT_CALL(*napiMock, napi_get_uv_event_loop(_, _)).WillOnce(Return(napi_ok)); EXPECT_CALL(*napiMock, napi_is_promise(_, _, _)) diff --git a/tests/unittests/backup_ext/ext_extension_stub_test.cpp b/tests/unittests/backup_ext/ext_extension_stub_test.cpp index ba73c7db6..4f9be41a0 100644 --- a/tests/unittests/backup_ext/ext_extension_stub_test.cpp +++ b/tests/unittests/backup_ext/ext_extension_stub_test.cpp @@ -82,12 +82,12 @@ HWTEST_F(ExtExtensionStubTest, SUB_backup_ext_ExtExtensionStub_OnRemoteRequest_0 { 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())); - EXPECT_TRUE(stub != nullptr); auto err = stub->OnRemoteRequest(code, data, reply, option); EXPECT_EQ(err, BError(BError::Codes::EXT_INVAL_ARG)); @@ -121,22 +121,24 @@ HWTEST_F(ExtExtensionStubTest, SUB_backup_ext_ExtExtensionStub_CmdGetFileHandle_ { 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)); - EXPECT_TRUE(stub != nullptr); 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)); @@ -144,6 +146,7 @@ HWTEST_F(ExtExtensionStubTest, SUB_backup_ext_ExtExtensionStub_CmdGetFileHandle_ 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)); @@ -167,11 +170,11 @@ HWTEST_F(ExtExtensionStubTest, SUB_backup_ext_ExtExtensionStub_CmdHandleClear_01 { 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)); - EXPECT_TRUE(stub != nullptr); auto err = stub->CmdHandleClear(data, reply); EXPECT_EQ(err, BError(BError::Codes::EXT_BROKEN_IPC)); @@ -199,14 +202,16 @@ HWTEST_F(ExtExtensionStubTest, SUB_backup_ext_ExtExtensionStub_CmdHandleBackup_0 { 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)); - EXPECT_TRUE(stub != nullptr); 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); @@ -231,10 +236,10 @@ HWTEST_F(ExtExtensionStubTest, SUB_backup_ext_ExtExtensionStub_CmdPublishFile_01 { 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)); - EXPECT_TRUE(stub != nullptr); auto err = stub->CmdPublishFile(data, reply); EXPECT_EQ(err, BError(BError::Codes::EXT_INVAL_ARG)); @@ -269,14 +274,16 @@ HWTEST_F(ExtExtensionStubTest, SUB_backup_ext_ExtExtensionStub_CmdHandleRestore_ { 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)); - EXPECT_TRUE(stub != nullptr); 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); @@ -302,10 +309,10 @@ HWTEST_F(ExtExtensionStubTest, SUB_backup_ext_ExtExtensionStub_CmdGetIncremental { 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)); - EXPECT_TRUE(stub != nullptr); auto err = stub->CmdGetIncrementalFileHandle(data, reply); EXPECT_EQ(err, BError(BError::Codes::EXT_INVAL_ARG)); @@ -341,10 +348,10 @@ HWTEST_F(ExtExtensionStubTest, SUB_backup_ext_ExtExtensionStub_CmdPublishIncreme { 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)); - EXPECT_TRUE(stub != nullptr); auto err = stub->CmdPublishIncrementalFile(data, reply); EXPECT_EQ(err, BError(BError::Codes::EXT_INVAL_ARG)); @@ -380,12 +387,12 @@ HWTEST_F(ExtExtensionStubTest, SUB_backup_ext_ExtExtensionStub_CmdHandleIncremen { 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)); - EXPECT_TRUE(stub != nullptr); auto err = stub->CmdHandleIncrementalBackup(data, reply); EXPECT_EQ(err, BError(BError::Codes::EXT_BROKEN_IPC)); @@ -415,14 +422,16 @@ HWTEST_F(ExtExtensionStubTest, SUB_backup_ext_ExtExtensionStub_CmdIncrementalOnB { 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)); - EXPECT_TRUE(stub != nullptr); 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); @@ -449,12 +458,12 @@ HWTEST_F(ExtExtensionStubTest, SUB_backup_ext_ExtExtensionStub_CmdGetIncremental 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)); - EXPECT_TRUE(stub != nullptr); auto err = stub->CmdGetIncrementalBackupFileHandle(data, reply); EXPECT_EQ(err, BError(BError::Codes::EXT_BROKEN_IPC)); @@ -490,11 +499,11 @@ HWTEST_F(ExtExtensionStubTest, SUB_backup_ext_ExtExtensionStub_CmdGetBackupInfo_ { 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)); - EXPECT_TRUE(stub != nullptr); auto err = stub->CmdGetBackupInfo(data, reply); EXPECT_EQ(err, BError(BError::Codes::EXT_BROKEN_IPC)); @@ -529,10 +538,10 @@ HWTEST_F(ExtExtensionStubTest, SUB_backup_ext_ExtExtensionStub_CmdUpdateSendRate { 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)); - EXPECT_TRUE(stub != nullptr); auto err = stub->CmdUpdateFdSendRate(data, reply); EXPECT_EQ(err, BError(BError::Codes::EXT_INVAL_ARG)); 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 3ae9f6711..031be7b9a 100644 --- a/tests/unittests/backup_sa/module_ipc/service_throw_test.cpp +++ b/tests/unittests/backup_sa/module_ipc/service_throw_test.cpp @@ -408,12 +408,14 @@ HWTEST_F(ServiceThrowTest, SUB_Service_throw_AppDone_0100, testing::ext::TestSiz EXPECT_CALL(*sessionMock, VerifyBundleName(_)).WillOnce(Invoke([]() { throw BError(BError::Codes::EXT_THROW_EXCEPTION); })); + EXPECT_CALL(*sessionMock, IsOnAllBundlesFinished()).WillOnce(Return(false)); auto ret = service->AppDone(0); EXPECT_EQ(ret, BError(BError::Codes::EXT_THROW_EXCEPTION).GetCode()); EXPECT_CALL(*sessionMock, VerifyBundleName(_)).WillOnce(Invoke([]() { throw runtime_error("运行时错误"); })); + EXPECT_CALL(*sessionMock, IsOnAllBundlesFinished()).WillOnce(Return(false)); ret = service->AppDone(0); EXPECT_EQ(ret, EPERM); @@ -542,6 +544,7 @@ HWTEST_F(ServiceThrowTest, SUB_Service_throw_OnBackupExtensionDied_0100, testing EXPECT_CALL(*sessionMock, RemoveExtInfo(_)).WillOnce(Invoke([]() { throw BError(BError::Codes::EXT_THROW_EXCEPTION); })); + EXPECT_CALL(*sessionMock, IsOnAllBundlesFinished()).WillOnce(Return(false)); service->OnBackupExtensionDied("bundleName"); EXPECT_TRUE(true); } catch (...) { @@ -575,11 +578,8 @@ HWTEST_F(ServiceThrowTest, SUB_Service_throw_ExtStart_0100, testing::ext::TestSi })); EXPECT_CALL(*sessionMock, RemoveExtInfo(_)).WillOnce(Invoke([]() { throw BError(BError::Codes::EXT_THROW_EXCEPTION); - })).WillOnce(Invoke([]() { - throw BError(BError::Codes::EXT_THROW_EXCEPTION); - })).WillOnce(Invoke([]() { - throw BError(BError::Codes::EXT_THROW_EXCEPTION); })); + EXPECT_CALL(*sessionMock, IsOnAllBundlesFinished()).WillOnce(Return(false)); service->ExtStart(bundleName); EXPECT_TRUE(true); } catch (...) { @@ -607,9 +607,6 @@ HWTEST_F(ServiceThrowTest, SUB_Service_throw_ExtConnectFailed_0100, testing::ext EXPECT_CALL(*sessionMock, GetScenario()).WillOnce(Invoke([]() { throw BError(BError::Codes::EXT_THROW_EXCEPTION); return IServiceReverse::Scenario::UNDEFINED; - })).WillOnce(Invoke([]() { - throw BError(BError::Codes::EXT_THROW_EXCEPTION); - return IServiceReverse::Scenario::UNDEFINED; })); service->ExtConnectFailed(bundleName, 0); EXPECT_TRUE(true); @@ -617,9 +614,6 @@ HWTEST_F(ServiceThrowTest, SUB_Service_throw_ExtConnectFailed_0100, testing::ext EXPECT_CALL(*sessionMock, GetScenario()).WillOnce(Invoke([]() { throw runtime_error("运行时错误"); return IServiceReverse::Scenario::UNDEFINED; - })).WillOnce(Invoke([]() { - throw runtime_error("运行时错误"); - return IServiceReverse::Scenario::UNDEFINED; })); service->ExtConnectFailed(bundleName, 0); EXPECT_TRUE(true); @@ -627,9 +621,6 @@ HWTEST_F(ServiceThrowTest, SUB_Service_throw_ExtConnectFailed_0100, testing::ext EXPECT_CALL(*sessionMock, GetScenario()).WillOnce(Invoke([]() { throw "未知错误"; return IServiceReverse::Scenario::UNDEFINED; - })).WillOnce(Invoke([]() { - throw "未知错误"; - return IServiceReverse::Scenario::UNDEFINED; })); service->ExtConnectFailed(bundleName, 0); EXPECT_TRUE(true); @@ -660,6 +651,7 @@ HWTEST_F(ServiceThrowTest, SUB_Service_throw_NoticeClientFinish_0100, testing::e throw BError(BError::Codes::EXT_THROW_EXCEPTION); return IServiceReverse::Scenario::UNDEFINED; })); + EXPECT_CALL(*sessionMock, IsOnAllBundlesFinished()).WillOnce(Return(false)); service->NoticeClientFinish(bundleName, errCode); EXPECT_TRUE(true); } catch (...) { @@ -787,6 +779,7 @@ HWTEST_F(ServiceThrowTest, SUB_Service_throw_SADone_0100, testing::ext::TestSize throw BError(BError::Codes::EXT_THROW_EXCEPTION); return false; })); + EXPECT_CALL(*sessionMock, IsOnAllBundlesFinished()).WillOnce(Return(false)); auto ret = service->SADone(errCode, bundleName); EXPECT_EQ(ret, BError(BError::Codes::EXT_THROW_EXCEPTION).GetCode()); @@ -794,6 +787,7 @@ HWTEST_F(ServiceThrowTest, SUB_Service_throw_SADone_0100, testing::ext::TestSize throw runtime_error("运行时错误"); return false; })); + EXPECT_CALL(*sessionMock, IsOnAllBundlesFinished()).WillOnce(Return(false)); ret = service->SADone(errCode, bundleName); EXPECT_EQ(ret, EPERM); @@ -801,6 +795,7 @@ HWTEST_F(ServiceThrowTest, SUB_Service_throw_SADone_0100, testing::ext::TestSize throw "未知错误"; return false; })); + EXPECT_CALL(*sessionMock, IsOnAllBundlesFinished()).WillOnce(Return(false)); ret = service->SADone(errCode, bundleName); EXPECT_EQ(ret, EPERM); } catch (...) { @@ -1087,12 +1082,14 @@ HWTEST_F(ServiceThrowTest, SUB_Service_throw_AppIncrementalDone_0100, testing::e EXPECT_CALL(*sessionMock, VerifyBundleName(_)).WillOnce(Invoke([]() { throw BError(BError::Codes::EXT_THROW_EXCEPTION); })); + EXPECT_CALL(*sessionMock, IsOnAllBundlesFinished()).WillOnce(Return(false)); auto ret = service->AppIncrementalDone(0); EXPECT_EQ(ret, BError(BError::Codes::EXT_THROW_EXCEPTION).GetCode()); EXPECT_CALL(*sessionMock, VerifyBundleName(_)).WillOnce(Invoke([]() { throw "未知错误"; })); + EXPECT_CALL(*sessionMock, IsOnAllBundlesFinished()).WillOnce(Return(false)); ret = service->AppIncrementalDone(0); EXPECT_EQ(ret, EPERM); } catch (...) { 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 925d15182..2ef31f1da 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 @@ -1767,14 +1767,8 @@ HWTEST_F(SvcSessionManagerTest, SUB_backup_sa_session_UpdateTimer_0100, testing: EXPECT_FALSE(ret); sessionManagerPtr_->impl_.clientToken = CLIENT_TOKEN_ID; - sessionManagerPtr_->reversePtr_ = nullptr; - ret = sessionManagerPtr_->UpdateTimer(BUNDLE_NAME, BConstants::TIMEOUT_INVALID, callback); - EXPECT_FALSE(ret); - - servicePtr_->session_ = nullptr; - sessionManagerPtr_->reversePtr_ = servicePtr_; - ret = sessionManagerPtr_->UpdateTimer(BUNDLE_NAME, BConstants::TIMEOUT_INVALID, callback); - EXPECT_TRUE(ret); + sessionManagerPtr_->impl_.backupExtNameMap.clear(); + EXPECT_THROW(sessionManagerPtr_->UpdateTimer(BUNDLE_NAME, BConstants::TIMEOUT_INVALID, callback), BError); BackupExtInfo info; info.extTimerStatus = false; diff --git a/tests/unittests/backup_sa/session/b_incremental_session_test.cpp b/tests/unittests/backup_sa/session/b_incremental_session_test.cpp index 54d192c5f..8c0cfb086 100644 --- a/tests/unittests/backup_sa/session/b_incremental_session_test.cpp +++ b/tests/unittests/backup_sa/session/b_incremental_session_test.cpp @@ -663,7 +663,7 @@ HWTEST_F(IncrementalSessionTest, SUB_b_incremental_session_test_2000, testing::e auto err = restoreSession->PublishSAFile(fileInfo, move(fd)); EXPECT_EQ(err, BError(BError::Codes::SDK_BROKEN_IPC).GetCode()); - EXPECT_CALL(*proxy, PublishIncrementalFile(_)).WillOnce(Return(0)); + EXPECT_CALL(*proxy, PublishSAIncrementalFile(_, _)).WillOnce(Return(0)); ServiceProxy::serviceProxy_ = proxy; err = restoreSession->PublishSAFile(fileInfo, move(fd)); EXPECT_EQ(err, BError(BError::Codes::OK).GetCode()); diff --git a/tests/unittests/backup_sa/session/service_proxy_mock.h b/tests/unittests/backup_sa/session/service_proxy_mock.h index 946043b33..521d3904a 100644 --- a/tests/unittests/backup_sa/session/service_proxy_mock.h +++ b/tests/unittests/backup_sa/session/service_proxy_mock.h @@ -51,6 +51,7 @@ public: MOCK_METHOD2(AppendBundlesIncrementalBackupSession, ErrCode(const std::vector &bundlesToBackup, const std::vector &infos)); MOCK_METHOD1(PublishIncrementalFile, ErrCode(const BFileInfo &fileInfo)); + MOCK_METHOD2(PublishSAIncrementalFile, ErrCode(const BFileInfo &fileInfo, UniqueFd fd)); MOCK_METHOD3(AppIncrementalFileReady, ErrCode(const std::string &fileName, UniqueFd fd, UniqueFd manifestFd)); MOCK_METHOD4(AppIncrementalFileReady, ErrCode(const std::string &fileName, UniqueFd fd, UniqueFd manifestFd, int32_t errCode)); diff --git a/tests/unittests/backup_utils/b_json/b_json_service_disposal_config_other_test.cpp b/tests/unittests/backup_utils/b_json/b_json_service_disposal_config_other_test.cpp index 10b967f40..3b566013f 100644 --- a/tests/unittests/backup_utils/b_json/b_json_service_disposal_config_other_test.cpp +++ b/tests/unittests/backup_utils/b_json/b_json_service_disposal_config_other_test.cpp @@ -177,6 +177,7 @@ HWTEST_F(BJsonServiceDisposalConfigTest, Disposal_Config_Test_0202, testing::ext const string bundleName = "test1"; EXPECT_CALL(*cJsonMock, cJSON_Parse(_)).WillOnce(Return(reinterpret_cast(&cjson))); EXPECT_CALL(*cJsonMock, cJSON_GetObjectItem(_, _)).WillOnce(Return(reinterpret_cast(&cjson))); + EXPECT_CALL(*cJsonMock, cJSON_IsArray(_)).WillOnce(Return(true)); EXPECT_CALL(*cJsonMock, cJSON_CreateObject()).WillOnce(Return(reinterpret_cast(&cjson))); EXPECT_CALL(*cJsonMock, cJSON_AddStringToObject(_, _, _)).WillOnce(Return(nullptr)); EXPECT_CALL(*cJsonMock, cJSON_AddItemToArray(_, _)).WillOnce(Return(true)); @@ -216,7 +217,6 @@ HWTEST_F(BJsonServiceDisposalConfigTest, Disposal_Config_Test_0203, testing::ext EXPECT_EQ(access(filePath.c_str(), F_OK), 0); const string bundleName = "test1"; EXPECT_CALL(*cJsonMock, cJSON_Parse(_)).WillOnce(Return(nullptr)); - EXPECT_CALL(*cJsonMock, cJSON_Delete(_)).WillOnce(Return()); bool retAdd = config.AppendIntoDisposalConfigFile(bundleName); EXPECT_FALSE(retAdd); } catch (...) { diff --git a/utils/src/b_jsonutil/b_jsonutil.cpp b/utils/src/b_jsonutil/b_jsonutil.cpp index 21347ab9f..489a75272 100644 --- a/utils/src/b_jsonutil/b_jsonutil.cpp +++ b/utils/src/b_jsonutil/b_jsonutil.cpp @@ -43,9 +43,8 @@ BJsonUtil::BundleDetailInfo BJsonUtil::ParseBundleNameIndexStr(const std::string return bundleDetailInfo; } std::string bundleName = bundleNameStr.substr(0, hasPos); - std::string indexStr = ""; if (to_string(bundleNameStr.back()) != BUNDLE_INDEX_SPLICE) { - indexStr = bundleNameStr.substr(hasPos + 1); + std::string indexStr = bundleNameStr.substr(hasPos + 1); int index = std::stoi(indexStr); bundleDetailInfo.bundleIndex = index; } else { @@ -83,9 +82,8 @@ std::map> BJsonUtil::Build bundleNamesOnly.emplace_back(bundleName); } else { std::string bundleNameSplit = bundleName.substr(0, pos); - std::string indexSplit = ""; if (to_string(bundleName.back()) != BUNDLE_INDEX_SPLICE) { - indexSplit = bundleName.substr(pos + 1); + std::string indexSplit = bundleName.substr(pos + 1); int index = std::stoi(indexSplit); bundleIndex = index; } else { -- Gitee