From 8190652fae06db1f04d7cb3bb4f0d03b084f2c10 Mon Sep 17 00:00:00 2001 From: wangpggg Date: Sat, 11 May 2024 18:27:54 +0800 Subject: [PATCH] add ut to improve coverage Signed-off-by: wangpeng --- tests/mock/module_ipc/message_parcel_mock.cpp | 123 ++ tests/mock/module_ipc/message_parcel_mock.h | 89 ++ tests/unittests/backup_sa/module_ipc/BUILD.gn | 24 +- .../module_ipc/service_reverse_proxy_test.cpp | 1309 ++++++++++++++++- .../module_ipc/service_stub_test.cpp | 1287 +++++++++++++--- .../module_ipc/svc_backup_connection_test.cpp | 134 +- .../module_ipc/svc_extension_proxy_test.cpp | 224 ++- 7 files changed, 2815 insertions(+), 375 deletions(-) create mode 100644 tests/mock/module_ipc/message_parcel_mock.cpp create mode 100644 tests/mock/module_ipc/message_parcel_mock.h diff --git a/tests/mock/module_ipc/message_parcel_mock.cpp b/tests/mock/module_ipc/message_parcel_mock.cpp new file mode 100644 index 000000000..bba15b0dc --- /dev/null +++ b/tests/mock/module_ipc/message_parcel_mock.cpp @@ -0,0 +1,123 @@ +/* + * 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 "iremote_broker.h" +#include "message_parcel_mock.h" + +namespace OHOS { +using namespace OHOS::FileManagement::Backup; +sptr BrokerRegistration::NewInstance(const std::u16string &descriptor, const sptr &object) +{ + return BackupIfaceCast::cast->iface_cast(object); +} + +Parcelable::Parcelable() : Parcelable(false) +{} + +Parcelable::Parcelable(bool asRemote) +{ + asRemote_ = asRemote; + behavior_ = 0; +} + +bool MessageParcel::WriteInterfaceToken(std::u16string name) +{ + return BackupMessageParcel::messageParcel->WriteInterfaceToken(name); +} + +std::u16string MessageParcel::ReadInterfaceToken() +{ + return BackupMessageParcel::messageParcel->ReadInterfaceToken(); +} + +bool Parcel::WriteParcelable(const Parcelable *object) +{ + return BackupMessageParcel::messageParcel->WriteParcelable(object); +} + +bool Parcel::WriteInt32(int32_t value) +{ + return BackupMessageParcel::messageParcel->WriteInt32(value); +} + +int32_t Parcel::ReadInt32() +{ + return BackupMessageParcel::messageParcel->ReadInt32(); +} + +bool Parcel::ReadInt32(int32_t &value) +{ + return BackupMessageParcel::messageParcel->ReadInt32(value); +} + +bool Parcel::WriteRemoteObject(const Parcelable *object) +{ + return BackupMessageParcel::messageParcel->WriteRemoteObject(object); +} + +bool MessageParcel::WriteRemoteObject(const sptr &object) +{ + return BackupMessageParcel::messageParcel->WriteRemoteObject(object); +} + +sptr MessageParcel::ReadRemoteObject() +{ + return BackupMessageParcel::messageParcel->ReadRemoteObject(); +} + +bool Parcel::ReadBool() +{ + return BackupMessageParcel::messageParcel->ReadBool(); +} + +bool Parcel::ReadBool(bool &value) +{ + return BackupMessageParcel::messageParcel->ReadBool(value); +} + +bool Parcel::WriteBool(bool value) +{ + return BackupMessageParcel::messageParcel->WriteBool(value); +} + +bool Parcel::WriteString(const std::string &value) +{ + return BackupMessageParcel::messageParcel->WriteString(value); +} + +bool Parcel::ReadString(std::string &value) +{ + return BackupMessageParcel::messageParcel->ReadString(value); +} + +bool Parcel::ReadStringVector(std::vector *value) +{ + return BackupMessageParcel::messageParcel->ReadStringVector(value); +} + +bool MessageParcel::WriteFileDescriptor(int fd) +{ + return BackupMessageParcel::messageParcel->WriteFileDescriptor(fd); +} + +int MessageParcel::ReadFileDescriptor() +{ + return BackupMessageParcel::messageParcel->ReadFileDescriptor(); +} + +bool Parcel::ReadUint32(uint32_t &value) +{ + return BackupMessageParcel::messageParcel->ReadUint32(value); +} +} // namespace OHOS \ No newline at end of file diff --git a/tests/mock/module_ipc/message_parcel_mock.h b/tests/mock/module_ipc/message_parcel_mock.h new file mode 100644 index 000000000..97984c231 --- /dev/null +++ b/tests/mock/module_ipc/message_parcel_mock.h @@ -0,0 +1,89 @@ +/* + * 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_MESSAGE_PARCEL_MOCK_H +#define OHOS_FILEMGMT_BACKUP_MESSAGE_PARCEL_MOCK_H + +#include +#include +#include + +#include "message_parcel.h" +#include "iremote_broker.h" +#include "b_file_info.h" +#include "b_incremental_data.h" + +namespace OHOS::FileManagement::Backup { +class BackupIfaceCast { +public: + virtual ~BackupIfaceCast() = default; + virtual sptr iface_cast(const sptr &) = 0; +public: + static inline std::shared_ptr cast = nullptr; +}; + +class IfaceCastMock : public BackupIfaceCast { +public: + MOCK_METHOD1(iface_cast, sptr(const sptr &)); +}; + +class BackupMessageParcel { +public: + virtual ~BackupMessageParcel() = default; +public: + virtual bool WriteInterfaceToken(std::u16string name) = 0; + virtual std::u16string ReadInterfaceToken() = 0; + virtual bool WriteParcelable(const Parcelable *object) = 0; + virtual bool WriteInt32(int32_t value) = 0; + virtual int32_t ReadInt32() = 0; + virtual bool ReadInt32(int32_t &value) = 0; + virtual bool WriteRemoteObject(const Parcelable *object) = 0; + virtual bool WriteRemoteObject(const sptr &object) = 0; + virtual sptr ReadRemoteObject() = 0; + virtual bool ReadBool(); + virtual bool ReadBool(bool &value) = 0; + virtual bool WriteBool(bool value) = 0; + virtual bool WriteString(const std::string &value) = 0; + virtual bool WriteFileDescriptor(int fd) = 0; + virtual bool ReadString(std::string &value) = 0; + virtual int ReadFileDescriptor() = 0; + virtual bool ReadStringVector(std::vector *value) = 0; + virtual bool ReadUint32(uint32_t &value) = 0; +public: + static inline std::shared_ptr messageParcel = nullptr; +}; + +class MessageParcelMock : public BackupMessageParcel { +public: + MOCK_METHOD1(WriteInterfaceToken, bool(std::u16string name)); + MOCK_METHOD0(ReadInterfaceToken, std::u16string()); + MOCK_METHOD1(WriteParcelable, bool(const Parcelable *object)); + MOCK_METHOD1(WriteInt32, bool(int32_t value)); + MOCK_METHOD0(ReadInt32, int32_t()); + MOCK_METHOD1(ReadInt32, bool(int32_t &value)); + MOCK_METHOD1(WriteRemoteObject, bool(const Parcelable *object)); + MOCK_METHOD1(WriteRemoteObject, bool(const sptr &object)); + MOCK_METHOD0(ReadRemoteObject, sptr()); + MOCK_METHOD0(ReadBool, bool()); + MOCK_METHOD1(ReadBool, bool(bool &value)); + MOCK_METHOD1(WriteBool, bool(bool value)); + MOCK_METHOD1(WriteString, bool(const std::string &value)); + MOCK_METHOD1(WriteFileDescriptor, bool(int fd)); + MOCK_METHOD1(ReadString, bool(std::string &value)); + MOCK_METHOD0(ReadFileDescriptor, int()); + MOCK_METHOD1(ReadStringVector, bool(std::vector *value)); + MOCK_METHOD1(ReadUint32, bool(uint32_t &value)); +}; +} // namespace OHOS::FileManagement::Backup +#endif // OHOS_FILEMGMT_BACKUP_MESSAGE_PARCEL_MOCK_H \ No newline at end of file diff --git a/tests/unittests/backup_sa/module_ipc/BUILD.gn b/tests/unittests/backup_sa/module_ipc/BUILD.gn index 4d4dbe523..45f8caab7 100644 --- a/tests/unittests/backup_sa/module_ipc/BUILD.gn +++ b/tests/unittests/backup_sa/module_ipc/BUILD.gn @@ -21,7 +21,15 @@ ohos_unittest("module_ipc_test") { sources = [ "${path_backup_mock}/module_ipc/app_gallery_dispose_proxy_mock.cpp", + "${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/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/service_stub.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", "service_reverse_proxy_test.cpp", "service_stub_test.cpp", "svc_backup_connection_test.cpp", @@ -29,15 +37,17 @@ ohos_unittest("module_ipc_test") { ] include_dirs = [ + "${path_backup_mock}/module_ipc", + "${path_backup}/frameworks/native/backup_kit_inner/include", "${path_backup}/services/backup_sa/include", - "${path_base}/include", "${path_backup}/tests/unittests/backup_api/backup_impl/include", "${path_backup}/interfaces/inner_api/native/backup_kit_inner/impl", + "${path_base}/include", + "${path_ipc}/interfaces/innerkits/ipc_core/include", ] deps = [ "${path_backup}/interfaces/inner_api/native/backup_kit_inner:backup_kit_inner", - "${path_backup}/services/backup_sa:backup_sa", "${path_backup}/tests/utils:backup_test_utils", "${path_backup}/utils:backup_utils", "//third_party/googletest:gmock_main", @@ -50,6 +60,7 @@ ohos_unittest("module_ipc_test") { "c_utils:utils", "hilog:libhilog", "hisysevent:libhisysevent", + "hitrace:hitrace_meter", "ipc:ipc_core", "safwk:system_ability_fwk", "samgr:samgr_proxy", @@ -57,13 +68,18 @@ ohos_unittest("module_ipc_test") { ] sanitize = { - integer_overflow = true cfi = true cfi_cross_dso = true debug = false blocklist = "${path_backup}/cfi_blocklist.txt" } + defines = [ + "LOG_TAG=\"app_file_service\"", + "LOG_DOMAIN=0xD004303", + "private = public", + ] + use_exceptions = true } @@ -121,7 +137,6 @@ ohos_unittest("backup_service_test") { ] sanitize = { - integer_overflow = true cfi = true cfi_cross_dso = true debug = false @@ -231,7 +246,6 @@ ohos_unittest("backup_service_scheduler_test") { ] sanitize = { - integer_overflow = true cfi = true cfi_cross_dso = true debug = false 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 index 95aa35746..43852a4ae 100644 --- a/tests/unittests/backup_sa/module_ipc/service_reverse_proxy_test.cpp +++ b/tests/unittests/backup_sa/module_ipc/service_reverse_proxy_test.cpp @@ -22,6 +22,7 @@ #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" @@ -40,23 +41,29 @@ const string RESULT_REPORT = "result_report"; class ServiceReverseProxyTest : public testing::Test { public: - static void SetUpTestCase(void) {}; - static void TearDownTestCase() {}; - void SetUp() override; - void TearDown() override; - shared_ptr proxy_ = nullptr; - sptr mock_ = nullptr; + 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::SetUp() +void ServiceReverseProxyTest::SetUpTestCase(void) { mock_ = sptr(new ServiceReverseMock()); proxy_ = make_shared(mock_); + messageParcelMock_ = make_shared(); + MessageParcelMock::messageParcel = messageParcelMock_; } -void ServiceReverseProxyTest::TearDown() +void ServiceReverseProxyTest::TearDownTestCase() { mock_ = nullptr; proxy_ = nullptr; + MessageParcelMock::messageParcel = nullptr; + messageParcelMock_ = nullptr; } /** @@ -72,6 +79,11 @@ HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_BackupOnFileReady_010 { 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)); @@ -87,6 +99,119 @@ HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_BackupOnFileReady_010 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)); + proxy_->BackupOnFileReady(BUNDLE_NAME, FILE_NAME, 0, 0); + } 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_->BackupOnFileReady(BUNDLE_NAME, FILE_NAME, 0, 0); + } 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_->BackupOnFileReady(BUNDLE_NAME, FILE_NAME, 0, 0); + } 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_->BackupOnFileReady(BUNDLE_NAME, FILE_NAME, 0, 0); + } 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_->BackupOnFileReady(BUNDLE_NAME, FILE_NAME, -1, 0); + } 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_, WriteFileDescriptor(_)).WillOnce(Return(false)); + proxy_->BackupOnFileReady(BUNDLE_NAME, FILE_NAME, 0, 0); + } 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)); + proxy_->BackupOnFileReady(BUNDLE_NAME, FILE_NAME, 0, 0); + } 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(true)); + EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(-1)); + proxy_->BackupOnFileReady(BUNDLE_NAME, FILE_NAME, 0, 0); + } 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_BackupOnBundleStarted_0100 * @tc.name: SUB_ServiceReverse_proxy_BackupOnBundleStarted_0100 @@ -100,6 +225,9 @@ HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_BackupOnBundleStarted { 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)); @@ -111,6 +239,59 @@ HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_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)); + proxy_->BackupOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME); + } 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_->BackupOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME); + } 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_->BackupOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME); + } 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_->BackupOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME); + } 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 @@ -124,6 +305,9 @@ HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_BackupOnBundleFinishe { 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)); @@ -135,6 +319,59 @@ HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_BackupOnBundleFinishe 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)); + proxy_->BackupOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME); + } 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); + } 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); + } 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); + } 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 @@ -150,6 +387,8 @@ HWTEST_F(ServiceReverseProxyTest, { 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)); @@ -161,6 +400,130 @@ HWTEST_F(ServiceReverseProxyTest, 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)); + proxy_->BackupOnAllBundlesFinished(BError(BError::Codes::OK)); + } 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)); + } 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)); + } 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"; + proxy_->BackupOnResultReport(RESULT_REPORT, bundleName); + } 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)); + proxy_->BackupOnResultReport(RESULT_REPORT, bundleName); + } 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); + } 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); + } 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); + } 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 @@ -174,6 +537,9 @@ HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_RestoreOnBundleStarte { 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)); @@ -185,6 +551,59 @@ HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_RestoreOnBundleStarte 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)); + proxy_->RestoreOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME); + } 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); + } 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); + } 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); + } 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 @@ -198,6 +617,9 @@ HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_RestoreOnBundleFinish { 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)); @@ -209,6 +631,59 @@ HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_RestoreOnBundleFinish 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)); + proxy_->RestoreOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME); + } 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); + } 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); + } 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); + } 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 @@ -224,6 +699,8 @@ HWTEST_F(ServiceReverseProxyTest, { 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)); @@ -235,6 +712,51 @@ HWTEST_F(ServiceReverseProxyTest, 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)); + proxy_->RestoreOnAllBundlesFinished(BError(BError::Codes::OK)); + } 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)); + } 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)); + } 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 @@ -248,6 +770,10 @@ HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_RestoreOnFileReady_01 { 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(*mock_, SendRequest(_, _, _, _)) .Times(1) .WillOnce(Invoke(mock_.GetRefPtr(), &ServiceReverseMock::InvokeSendRequest)); @@ -263,6 +789,67 @@ HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_RestoreOnFileReady_01 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)); + proxy_->RestoreOnFileReady(BUNDLE_NAME, FILE_NAME, 0); + } 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); + } 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); + } 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_->RestoreOnFileReady(BUNDLE_NAME, FILE_NAME, 0); + } 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); + } 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_IncrementalBackupOnFileReady_0100 * @tc.name: SUB_ServiceReverse_proxy_IncrementalBackupOnFileReady_0100 @@ -278,6 +865,11 @@ HWTEST_F(ServiceReverseProxyTest, { 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)); @@ -296,6 +888,133 @@ HWTEST_F(ServiceReverseProxyTest, 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)); + proxy_->IncrementalBackupOnFileReady(BUNDLE_NAME, FILE_NAME, 0, 0, 0); + } 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); + } 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); + } 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_->IncrementalBackupOnFileReady(BUNDLE_NAME, FILE_NAME, 0, 0, 0); + } 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); + } 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(true)); + EXPECT_CALL(*messageParcelMock_, WriteFileDescriptor(_)).WillOnce(Return(false)); + proxy_->IncrementalBackupOnFileReady(BUNDLE_NAME, FILE_NAME, 0, 0, 0); + } 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_->IncrementalBackupOnFileReady(BUNDLE_NAME, FILE_NAME, 0, 0, 0); + } 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); + } 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); + } 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_IncrementalBackupOnBundleStarted_0100 * @tc.name: SUB_ServiceReverse_proxy_IncrementalBackupOnBundleStarted_0100 @@ -311,6 +1030,9 @@ HWTEST_F(ServiceReverseProxyTest, { 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)); @@ -322,6 +1044,61 @@ HWTEST_F(ServiceReverseProxyTest, 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)); + proxy_->IncrementalBackupOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME); + } 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); + } 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); + } 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); + } 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 @@ -337,6 +1114,9 @@ HWTEST_F(ServiceReverseProxyTest, { 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)); @@ -348,6 +1128,62 @@ HWTEST_F(ServiceReverseProxyTest, 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)); + proxy_->IncrementalBackupOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME); + } 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); + } 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); + } 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); + } 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 @@ -364,6 +1200,8 @@ HWTEST_F(ServiceReverseProxyTest, 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)); @@ -376,6 +1214,53 @@ HWTEST_F(ServiceReverseProxyTest, << "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)); + proxy_->IncrementalBackupOnAllBundlesFinished(BError(BError::Codes::OK)); + } 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)); + } 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)); + } 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 @@ -391,6 +1276,9 @@ HWTEST_F(ServiceReverseProxyTest, { 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)); @@ -402,6 +1290,62 @@ HWTEST_F(ServiceReverseProxyTest, 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)); + proxy_->IncrementalRestoreOnBundleStarted(BError(BError::Codes::OK), BUNDLE_NAME); + } 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); + } 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); + } 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); + } 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 @@ -418,6 +1362,9 @@ HWTEST_F(ServiceReverseProxyTest, 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)); @@ -429,6 +1376,62 @@ HWTEST_F(ServiceReverseProxyTest, 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)); + proxy_->IncrementalRestoreOnBundleFinished(BError(BError::Codes::OK), BUNDLE_NAME); + } 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); + } 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); + } 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); + } 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 @@ -445,6 +1448,8 @@ HWTEST_F(ServiceReverseProxyTest, 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)); @@ -457,6 +1462,53 @@ HWTEST_F(ServiceReverseProxyTest, << "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)); + proxy_->IncrementalRestoreOnAllBundlesFinished(BError(BError::Codes::OK)); + } 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)); + } 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)); + } 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 @@ -472,6 +1524,11 @@ HWTEST_F(ServiceReverseProxyTest, { 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)); @@ -490,6 +1547,133 @@ HWTEST_F(ServiceReverseProxyTest, 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)); + proxy_->IncrementalRestoreOnFileReady(BUNDLE_NAME, FILE_NAME, 0, 0, 0); + } 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); + } 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); + } 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); + } 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_->IncrementalRestoreOnFileReady(BUNDLE_NAME, FILE_NAME, -1, 0, 0); + } 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_, WriteFileDescriptor(_)).WillOnce(Return(false)); + proxy_->IncrementalRestoreOnFileReady(BUNDLE_NAME, FILE_NAME, 0, 0, 0); + } 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); + } 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_->IncrementalRestoreOnFileReady(BUNDLE_NAME, FILE_NAME, 0, 0, 0); + } 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); + } 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_RestoreOnResultReport_0100 * @tc.name: SUB_ServiceReverse_proxy_RestoreOnResultReport_0100 @@ -503,6 +1687,8 @@ HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_RestoreOnResultReport { 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(*mock_, SendRequest(_, _, _, _)) .Times(1) .WillOnce(Invoke(mock_.GetRefPtr(), &ServiceReverseMock::InvokeSendRequest)); @@ -515,6 +1701,58 @@ HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_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)); + proxy_->RestoreOnResultReport(RESULT_REPORT, bundleName); + } 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); + } 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); + } 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_->RestoreOnResultReport(RESULT_REPORT, bundleName); + } 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 @@ -529,6 +1767,8 @@ HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_IncrementalRestoreOnR { 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(*mock_, SendRequest(_, _, _, _)) .Times(1) .WillOnce(Invoke(mock_.GetRefPtr(), &ServiceReverseMock::InvokeSendRequest)); @@ -540,4 +1780,57 @@ HWTEST_F(ServiceReverseProxyTest, SUB_ServiceReverse_proxy_IncrementalRestoreOnR } 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)); + proxy_->IncrementalRestoreOnResultReport(RESULT_REPORT, bundleName); + } 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); + } 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); + } 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_->IncrementalRestoreOnResultReport(RESULT_REPORT, bundleName); + } 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"; +} } // namespace OHOS::FileManagement::Backup \ No newline at end of file diff --git a/tests/unittests/backup_sa/module_ipc/service_stub_test.cpp b/tests/unittests/backup_sa/module_ipc/service_stub_test.cpp index b6f67d334..40d494e86 100644 --- a/tests/unittests/backup_sa/module_ipc/service_stub_test.cpp +++ b/tests/unittests/backup_sa/module_ipc/service_stub_test.cpp @@ -18,13 +18,15 @@ #include #include #include -#include +#include #include #include #include "b_error/b_error.h" #include "b_resources/b_constants.h" +#include "ipc_types.h" #include "i_service.h" +#include "message_parcel_mock.h" #include "module_ipc/service_stub.h" #include "service_reverse_mock.h" #include "test_manager.h" @@ -39,7 +41,7 @@ const string BUNDLE_NAME = "com.example.app2backup"; const string FILE_NAME = "1.tar"; } // namespace -class MockService final : public ServiceStub { +class ServiceMock final : public ServiceStub { public: MOCK_METHOD1(InitRestoreSession, ErrCode(sptr remote)); MOCK_METHOD1(InitBackupSession, ErrCode(sptr remote)); @@ -63,6 +65,7 @@ public: MOCK_METHOD0(Finish, ErrCode()); MOCK_METHOD0(Release, ErrCode()); MOCK_METHOD1(GetLocalCapabilitiesIncremental, UniqueFd(const std::vector &bundleNames)); + MOCK_METHOD0(GetAppLocalListAndDoIncrementalBackup, ErrCode()); MOCK_METHOD1(InitIncrementalBackupSession, ErrCode(sptr remote)); MOCK_METHOD1(AppendBundlesIncrementalBackupSession, ErrCode(const std::vector &bundlesToBackup)); @@ -74,59 +77,130 @@ public: MOCK_METHOD2(GetIncrementalFileHandle, ErrCode(const std::string &bundleName, const std::string &fileName)); MOCK_METHOD2(GetBackupInfo, ErrCode(string &bundleName, string &result)); MOCK_METHOD3(UpdateTimer, ErrCode(BundleName &bundleName, uint32_t timeOut, bool &result)); - MOCK_METHOD0(GetAppLocalListAndDoIncrementalBackup, ErrCode()); - UniqueFd InvokeGetLocalCapabilities() - { - if (bCapabilities_) { - return UniqueFd(-1); - } - TestManager tm("MockService_GetFd_0100"); - std::string filePath = tm.GetRootDirCurTest().append(FILE_NAME); - UniqueFd fd(open(filePath.data(), O_RDONLY | O_CREAT, S_IRUSR | S_IWUSR)); - bCapabilities_ = true; - return fd; - } - -private: - bool bCapabilities_ = {false}; }; class ServiceStubTest : public testing::Test { public: - static void SetUpTestCase(void) {}; - static void TearDownTestCase() {}; + static void SetUpTestCase(void); + static void TearDownTestCase(); void SetUp() override {}; void TearDown() override {}; +public: + static inline shared_ptr messageParcelMock = nullptr; + static inline shared_ptr service = nullptr; + static inline shared_ptr castMock = nullptr; + static inline sptr remote = nullptr; }; +void ServiceStubTest::SetUpTestCase(void) +{ + remote = sptr(new ServiceReverseMock()); + service = make_shared(); + messageParcelMock = make_shared(); + MessageParcelMock::messageParcel = messageParcelMock; + castMock = std::make_shared(); + IfaceCastMock::cast = castMock; +} +void ServiceStubTest::TearDownTestCase() +{ + remote = nullptr; + service = nullptr; + MessageParcelMock::messageParcel = nullptr; + messageParcelMock = nullptr; + IfaceCastMock::cast = nullptr; + castMock = nullptr; +} + +/** + * @tc.number: SUB_backup_sa_ServiceStub_OnRemoteRequest_0100 + * @tc.name: SUB_backup_sa_ServiceStub_OnRemoteRequest_0100 + * @tc.desc: Test function of OnRemoteRequest interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: I9OVHB + */ +HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_OnRemoteRequest_0100, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "ServiceStubTest-begin SUB_backup_sa_ServiceStub_OnRemoteRequest_0100"; + try { + MessageParcel data; + MessageParcel reply; + MessageOption option; + try { + EXPECT_CALL(*messageParcelMock, ReadInterfaceToken()).WillOnce(Return(u16string())); + service->OnRemoteRequest(0, data, reply, option); + } catch (BError &err) { + EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); + } + + try { + const std::u16string descriptor = ServiceStub::GetDescriptor(); + EXPECT_CALL(*messageParcelMock, ReadInterfaceToken()).WillOnce(Return(descriptor)); + EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(false)); + service->OnRemoteRequest(static_cast(IServiceInterfaceCode::SERVICE_CMD_GET_FILE_NAME), + data, reply, option); + } catch (BError &err) { + EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); + } + + const std::u16string descriptor = ServiceStub::GetDescriptor(); + EXPECT_CALL(*messageParcelMock, ReadInterfaceToken()).WillOnce(Return(descriptor)); + auto ret = service->OnRemoteRequest(-1, data, reply, option); + EXPECT_EQ(ret, IPC_STUB_UNKNOW_TRANS_ERR); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "ServiceStubTest-an exception occurred by InitRestoreSession."; + } + GTEST_LOG_(INFO) << "ServiceStubTest-end SUB_backup_sa_ServiceStub_OnRemoteRequest_0100"; +} + /** * @tc.number: SUB_backup_sa_ServiceStub_InitRestoreSession_0100 * @tc.name: SUB_backup_sa_ServiceStub_InitRestoreSession_0100 * @tc.desc: Test function of InitRestoreSession interface for SUCCESS. * @tc.size: MEDIUM * @tc.type: FUNC - * @tc.level Level 0 + * @tc.level Level 1 * @tc.require: I6F3GV */ -HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_InitRestoreSession_0100, testing::ext::TestSize.Level0) +HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_InitRestoreSession_0100, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "ServiceStubTest-begin SUB_backup_sa_ServiceStub_InitRestoreSession_0100"; try { - MockService service; - EXPECT_CALL(service, InitRestoreSession(_)).WillOnce(Return(BError(BError::Codes::OK))); MessageParcel data; MessageParcel reply; - MessageOption option; + try { + EXPECT_CALL(*messageParcelMock, ReadRemoteObject()).WillOnce(Return(nullptr)); + service->CmdInitRestoreSession(data, reply); + } catch (BError &err) { + EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); + } - EXPECT_TRUE(data.WriteInterfaceToken(IService::GetDescriptor())); - sptr remote = sptr(new ServiceReverseMock()); - EXPECT_TRUE(data.WriteRemoteObject(remote->AsObject().GetRefPtr())); + try { + EXPECT_CALL(*messageParcelMock, ReadRemoteObject()).WillOnce(Return(remote)); + EXPECT_CALL(*castMock, iface_cast(_)).WillOnce(Return(nullptr)); + service->CmdInitRestoreSession(data, reply); + } catch (BError &err) { + EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); + } + + try { + EXPECT_CALL(*messageParcelMock, ReadRemoteObject()).WillOnce(Return(remote)); + EXPECT_CALL(*castMock, iface_cast(_)).WillOnce(Return(remote)); + EXPECT_CALL(*service, InitRestoreSession(_)).WillOnce(Return(BError(BError::Codes::OK))); + EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(false)); + service->CmdInitRestoreSession(data, reply); + } catch (BError &err) { + EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); + } - EXPECT_EQ( - BError(BError::Codes::OK), - service.OnRemoteRequest(static_cast(IServiceInterfaceCode::SERVICE_CMD_INIT_RESTORE_SESSION), - data, reply, option)); - remote = nullptr; + EXPECT_CALL(*messageParcelMock, ReadRemoteObject()).WillOnce(Return(remote)); + EXPECT_CALL(*castMock, iface_cast(_)).WillOnce(Return(remote)); + EXPECT_CALL(*service, InitRestoreSession(_)).WillOnce(Return(BError(BError::Codes::OK))); + EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(true)); + auto ret = service->CmdInitRestoreSession(data, reply); + EXPECT_EQ(ret, BError(BError::Codes::OK)); } catch (...) { EXPECT_TRUE(false); GTEST_LOG_(INFO) << "ServiceStubTest-an exception occurred by InitRestoreSession."; @@ -140,27 +214,46 @@ HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_InitRestoreSession_0100, tes * @tc.desc: Test function of InitBackupSession interface for SUCCESS. * @tc.size: MEDIUM * @tc.type: FUNC - * @tc.level Level 0 + * @tc.level Level 1 * @tc.require: I6F3GV */ -HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_InitBackupSession_0100, testing::ext::TestSize.Level0) +HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_InitBackupSession_0100, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "ServiceStubTest-begin SUB_backup_sa_ServiceStub_InitBackupSession_0100"; try { - MockService service; - EXPECT_CALL(service, InitBackupSession(_)).WillOnce(Return(BError(BError::Codes::OK))); MessageParcel data; MessageParcel reply; - MessageOption option; - sptr remote = sptr(new ServiceReverseMock()); + try { + EXPECT_CALL(*messageParcelMock, ReadRemoteObject()).WillOnce(Return(nullptr)); + service->CmdInitBackupSession(data, reply); + } catch (BError &err) { + EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); + } - EXPECT_TRUE(data.WriteInterfaceToken(IService::GetDescriptor())); - EXPECT_TRUE(data.WriteRemoteObject(remote->AsObject().GetRefPtr())); + try { + EXPECT_CALL(*messageParcelMock, ReadRemoteObject()).WillOnce(Return(remote)); + EXPECT_CALL(*castMock, iface_cast(_)).WillOnce(Return(nullptr)); + service->CmdInitBackupSession(data, reply); + } catch (BError &err) { + EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); + } + + try { + EXPECT_CALL(*messageParcelMock, ReadRemoteObject()).WillOnce(Return(remote)); + EXPECT_CALL(*castMock, iface_cast(_)).WillOnce(Return(remote)); + EXPECT_CALL(*service, InitBackupSession(_)).WillOnce(Return(BError(BError::Codes::OK))); + EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(false)); + service->CmdInitBackupSession(data, reply); + } catch (BError &err) { + EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); + } - EXPECT_EQ(BError(BError::Codes::OK), - service.OnRemoteRequest(static_cast(IServiceInterfaceCode::SERVICE_CMD_INIT_BACKUP_SESSION), - data, reply, option)); - remote = nullptr; + EXPECT_CALL(*messageParcelMock, ReadRemoteObject()).WillOnce(Return(remote)); + EXPECT_CALL(*castMock, iface_cast(_)).WillOnce(Return(remote)); + EXPECT_CALL(*service, InitBackupSession(_)).WillOnce(Return(BError(BError::Codes::OK))); + EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(true)); + auto ret = service->CmdInitBackupSession(data, reply); + EXPECT_EQ(ret, BError(BError::Codes::OK)); } catch (...) { EXPECT_TRUE(false); GTEST_LOG_(INFO) << "ServiceStubTest-an exception occurred by InitBackupSession."; @@ -174,23 +267,27 @@ HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_InitBackupSession_0100, test * @tc.desc: Test function of Start interface for SUCCESS. * @tc.size: MEDIUM * @tc.type: FUNC - * @tc.level Level 0 + * @tc.level Level 1 * @tc.require: I6F3GV */ -HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_Start_0100, testing::ext::TestSize.Level0) +HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_Start_0100, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "ServiceStubTest-begin SUB_backup_sa_ServiceStub_Start_0100"; try { - MockService service; - EXPECT_CALL(service, Start()).WillOnce(Return(BError(BError::Codes::OK))); MessageParcel data; MessageParcel reply; - MessageOption option; + try { + EXPECT_CALL(*service, Start()).WillOnce(Return(BError(BError::Codes::OK))); + EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(false)); + service->CmdStart(data, reply); + } catch (BError &err) { + EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); + } - EXPECT_TRUE(data.WriteInterfaceToken(IService::GetDescriptor())); - EXPECT_EQ(BError(BError::Codes::OK), - service.OnRemoteRequest(static_cast(IServiceInterfaceCode::SERVICE_CMD_START), data, reply, - option)); + EXPECT_CALL(*service, Start()).WillOnce(Return(BError(BError::Codes::OK))); + EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(true)); + auto ret = service->CmdStart(data, reply); + EXPECT_EQ(ret, BError(BError::Codes::OK)); } catch (...) { EXPECT_TRUE(false); GTEST_LOG_(INFO) << "ServiceStubTest-an exception occurred by Start."; @@ -204,38 +301,27 @@ HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_Start_0100, testing::ext::Te * @tc.desc: Test function of GetLocalCapabilities interface for SUCCESS. * @tc.size: MEDIUM * @tc.type: FUNC - * @tc.level Level 0 + * @tc.level Level 1 * @tc.require: I6F3GV */ -HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_GetLocalCapabilities_0100, testing::ext::TestSize.Level0) +HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_GetLocalCapabilities_0100, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "ServiceStubTest-begin SUB_backup_sa_ServiceStub_GetLocalCapabilities_0100"; try { - sptr serviceSptr = sptr(new MockService()); - EXPECT_CALL(*serviceSptr, GetLocalCapabilities()) - .Times(2) - .WillOnce(Invoke(serviceSptr.GetRefPtr(), &MockService::InvokeGetLocalCapabilities)) - .WillOnce(Invoke(serviceSptr.GetRefPtr(), &MockService::InvokeGetLocalCapabilities)); MessageParcel data; MessageParcel reply; - MessageOption option; + try { + EXPECT_CALL(*service, GetLocalCapabilities()).WillOnce(Return(UniqueFd(0))); + EXPECT_CALL(*messageParcelMock, WriteFileDescriptor(_)).WillOnce(Return(false)); + service->CmdGetLocalCapabilities(data, reply); + } catch (BError &err) { + EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); + } - EXPECT_TRUE(data.WriteInterfaceToken(IService::GetDescriptor())); - - EXPECT_EQ( - BError(BError::Codes::OK), - serviceSptr->OnRemoteRequest( - static_cast(IServiceInterfaceCode::SERVICE_CMD_GET_LOCAL_CAPABILITIES), data, reply, option)); - UniqueFd fd(reply.ReadFileDescriptor()); - EXPECT_GT(fd, BError(BError::Codes::OK)); - GTEST_LOG_(INFO) << "ServiceStubTest-CmdGetLocalCapabilities Brances"; - MessageParcel brances; - EXPECT_TRUE(brances.WriteInterfaceToken(IService::GetDescriptor())); - EXPECT_NE(BError(BError::Codes::OK), - serviceSptr->OnRemoteRequest( - static_cast(IServiceInterfaceCode::SERVICE_CMD_GET_LOCAL_CAPABILITIES), brances, reply, - option)); - serviceSptr = nullptr; + EXPECT_CALL(*service, GetLocalCapabilities()).WillOnce(Return(UniqueFd(0))); + EXPECT_CALL(*messageParcelMock, WriteFileDescriptor(_)).WillOnce(Return(true)); + auto ret = service->CmdGetLocalCapabilities(data, reply); + EXPECT_EQ(ret, BError(BError::Codes::OK)); } catch (...) { EXPECT_TRUE(false); GTEST_LOG_(INFO) << "ServiceStubTest-an exception occurred by GetLocalCapabilities."; @@ -249,25 +335,40 @@ HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_GetLocalCapabilities_0100, t * @tc.desc: Test function of PublishFile interface for SUCCESS. * @tc.size: MEDIUM * @tc.type: FUNC - * @tc.level Level 0 + * @tc.level Level 1 * @tc.require: I6F3GV */ -HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_PublishFile_0100, testing::ext::TestSize.Level0) +HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_PublishFile_0100, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "ServiceStubTest-begin SUB_backup_sa_ServiceStub_PublishFile_0100"; try { - MockService service; - EXPECT_CALL(service, PublishFile(_)).WillOnce(Return(BError(BError::Codes::OK))); MessageParcel data; MessageParcel reply; - MessageOption option; + try { + EXPECT_CALL(*messageParcelMock, ReadInt32()).WillOnce(Return(0)); + service->CmdPublishFile(data, reply); + } catch (BError &err) { + EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); + } + + try { + EXPECT_CALL(*messageParcelMock, ReadInt32()).WillOnce(Return(1)); + EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true)).WillOnce(Return(true)); + EXPECT_CALL(*messageParcelMock, ReadUint32(_)).WillOnce(Return(true)); + EXPECT_CALL(*service, PublishFile(_)).WillOnce(Return(0)); + EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(false)); + service->CmdPublishFile(data, reply); + } catch (BError &err) { + EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); + } - BFileInfo fileInfo {BUNDLE_NAME, FILE_NAME, -1}; - EXPECT_TRUE(data.WriteInterfaceToken(IService::GetDescriptor())); - EXPECT_TRUE(data.WriteParcelable(&fileInfo)); - EXPECT_EQ(BError(BError::Codes::OK), - service.OnRemoteRequest(static_cast(IServiceInterfaceCode::SERVICE_CMD_PUBLISH_FILE), data, - reply, option)); + EXPECT_CALL(*messageParcelMock, ReadInt32()).WillOnce(Return(1)); + EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true)).WillOnce(Return(true)); + EXPECT_CALL(*messageParcelMock, ReadUint32(_)).WillOnce(Return(true)); + EXPECT_CALL(*service, PublishFile(_)).WillOnce(Return(0)); + EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(true)); + auto ret = service->CmdPublishFile(data, reply); + EXPECT_EQ(ret, BError(BError::Codes::OK)); } catch (...) { EXPECT_TRUE(false); GTEST_LOG_(INFO) << "ServiceStubTest-an exception occurred by PublishFile."; @@ -278,41 +379,56 @@ HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_PublishFile_0100, testing::e /** * @tc.number: SUB_backup_sa_ServiceStub_AppFileReady_0100 * @tc.name: SUB_backup_sa_ServiceStub_AppFileReady_0100 - * @tc.desc: Test function of AppFileReady interface for SUCCESS. + * @tc.desc: Test function of AppFileReady interface for FAILURE. * @tc.size: MEDIUM * @tc.type: FUNC - * @tc.level Level 0 + * @tc.level Level 1 * @tc.require: I6F3GV */ -HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_AppFileReady_0100, testing::ext::TestSize.Level0) +HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_AppFileReady_0100, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "ServiceStubTest-begin SUB_backup_sa_ServiceStub_AppFileReady_0100"; try { - MockService service; - EXPECT_CALL(service, AppFileReady(_, _, _)) - .WillOnce(Return(BError(BError::Codes::OK))) - .WillOnce(Return(BError(BError::Codes::OK))); MessageParcel data; MessageParcel reply; - MessageOption option; + try { + EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(false)); + service->CmdAppFileReady(data, reply); + } catch (BError &err) { + EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); + } + + try { + EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true)); + EXPECT_CALL(*messageParcelMock, ReadBool()).WillOnce(Return(true)); + EXPECT_CALL(*messageParcelMock, ReadFileDescriptor()).WillOnce(Return(-1)); + service->CmdAppFileReady(data, reply); + } catch (BError &err) { + EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); + } - TestManager tm("ServiceStub_GetFd_0200"); - std::string filePath = tm.GetRootDirCurTest().append(FILE_NAME); - UniqueFd fd(open(filePath.data(), O_RDONLY | O_CREAT, S_IRUSR | S_IWUSR)); - - EXPECT_TRUE(data.WriteInterfaceToken(IService::GetDescriptor())); - EXPECT_TRUE(data.WriteString(FILE_NAME)); - EXPECT_TRUE(data.WriteBool(true)); - EXPECT_TRUE(data.WriteFileDescriptor(fd)); - EXPECT_EQ(BError(BError::Codes::OK), - service.OnRemoteRequest(static_cast(IServiceInterfaceCode::SERVICE_CMD_APP_FILE_READY), - data, reply, option)); - MessageParcel brances; - EXPECT_TRUE(brances.WriteInterfaceToken(IService::GetDescriptor())); - EXPECT_TRUE(brances.WriteString(FILE_NAME)); - EXPECT_EQ(BError(BError::Codes::OK), - service.OnRemoteRequest(static_cast(IServiceInterfaceCode::SERVICE_CMD_APP_FILE_READY), - brances, reply, option)); + try { + EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true)); + EXPECT_CALL(*messageParcelMock, ReadBool()).WillOnce(Return(true)); + EXPECT_CALL(*messageParcelMock, ReadFileDescriptor()).WillOnce(Return(0)); + EXPECT_CALL(*messageParcelMock, ReadInt32()).WillOnce(Return(0)); + EXPECT_CALL(*service, AppFileReady(_, _, _)).WillOnce(Return(0)); + EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(false)); + service->CmdAppFileReady(data, reply); + } catch (BError &err) { + EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); + } + + try { + EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true)); + EXPECT_CALL(*messageParcelMock, ReadBool()).WillOnce(Return(false)); + EXPECT_CALL(*messageParcelMock, ReadInt32()).WillOnce(Return(0)); + EXPECT_CALL(*service, AppFileReady(_, _, _)).WillOnce(Return(0)); + EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(false)); + service->CmdAppFileReady(data, reply); + } catch (BError &err) { + EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); + } } catch (...) { EXPECT_TRUE(false); GTEST_LOG_(INFO) << "ServiceStubTest-an exception occurred by AppFileReady."; @@ -320,30 +436,71 @@ HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_AppFileReady_0100, testing:: GTEST_LOG_(INFO) << "ServiceStubTest-end SUB_backup_sa_ServiceStub_AppFileReady_0100"; } +/** + * @tc.number: SUB_backup_sa_ServiceStub_AppFileReady_0101 + * @tc.name: SUB_backup_sa_ServiceStub_AppFileReady_0101 + * @tc.desc: Test function of AppFileReady interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: I6F3GV + */ +HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_AppFileReady_0101, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "ServiceStubTest-begin SUB_backup_sa_ServiceStub_AppFileReady_0101"; + try { + MessageParcel data; + MessageParcel reply; + EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true)); + EXPECT_CALL(*messageParcelMock, ReadBool()).WillOnce(Return(false)); + EXPECT_CALL(*messageParcelMock, ReadInt32()).WillOnce(Return(0)); + EXPECT_CALL(*service, AppFileReady(_, _, _)).WillOnce(Return(0)); + EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(true)); + auto ret = service->CmdAppFileReady(data, reply); + EXPECT_EQ(ret, BError(BError::Codes::OK)); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "ServiceStubTest-an exception occurred by AppFileReady."; + } + GTEST_LOG_(INFO) << "ServiceStubTest-end SUB_backup_sa_ServiceStub_AppFileReady_0101"; +} + /** * @tc.number: SUB_backup_sa_ServiceStub_AppDone_0100 * @tc.name: SUB_backup_sa_ServiceStub_AppDone_0100 * @tc.desc: Test function of AppDone interface for SUCCESS. * @tc.size: MEDIUM * @tc.type: FUNC - * @tc.level Level 0 + * @tc.level Level 1 * @tc.require: I6F3GV */ -HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_AppDone_0100, testing::ext::TestSize.Level0) +HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_AppDone_0100, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "ServiceStubTest-begin SUB_backup_sa_ServiceStub_AppDone_0100"; try { - MockService service; - EXPECT_CALL(service, AppDone(_)).WillOnce(Return(BError(BError::Codes::OK))); MessageParcel data; MessageParcel reply; - MessageOption option; + try { + EXPECT_CALL(*messageParcelMock, ReadBool(_)).WillOnce(Return(false)); + service->CmdAppDone(data, reply); + } catch (BError &err) { + EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); + } - EXPECT_TRUE(data.WriteInterfaceToken(IService::GetDescriptor())); - EXPECT_TRUE(data.WriteInt32(BError(BError::Codes::OK))); - EXPECT_EQ(BError(BError::Codes::OK), - service.OnRemoteRequest(static_cast(IServiceInterfaceCode::SERVICE_CMD_APP_DONE), data, - reply, option)); + try { + EXPECT_CALL(*messageParcelMock, ReadBool(_)).WillOnce(Return(true)); + EXPECT_CALL(*service, AppDone(_)).WillOnce(Return(0)); + EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(false)); + service->CmdAppDone(data, reply); + } catch (BError &err) { + EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); + } + + EXPECT_CALL(*messageParcelMock, ReadBool(_)).WillOnce(Return(true)); + EXPECT_CALL(*service, AppDone(_)).WillOnce(Return(0)); + EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(true)); + auto ret = service->CmdAppDone(data, reply); + EXPECT_EQ(ret, BError(BError::Codes::OK)); } catch (...) { EXPECT_TRUE(false); GTEST_LOG_(INFO) << "ServiceStubTest-an exception occurred by AppDone."; @@ -357,27 +514,33 @@ HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_AppDone_0100, testing::ext:: * @tc.desc: Test function of GetFileHandle interface for SUCCESS. * @tc.size: MEDIUM * @tc.type: FUNC - * @tc.level Level 0 + * @tc.level Level 1 * @tc.require: I6F3GV */ -HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_GetFileHandle_0100, testing::ext::TestSize.Level0) +HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_GetFileHandle_0100, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "ServiceStubTest-begin SUB_backup_sa_ServiceStub_GetFileHandle_0100"; try { - MockService service; - EXPECT_CALL(service, GetFileHandle(_, _)).WillOnce(Return(BError(BError::Codes::OK))); MessageParcel data; MessageParcel reply; - MessageOption option; - option.SetFlags(MessageOption::TF_ASYNC); - - EXPECT_TRUE(data.WriteInterfaceToken(IService::GetDescriptor())); - EXPECT_TRUE(data.WriteString(BUNDLE_NAME)); - EXPECT_TRUE(data.WriteString(FILE_NAME)); - EXPECT_EQ(BError(BError::Codes::OK), - service.OnRemoteRequest(static_cast(IServiceInterfaceCode::SERVICE_CMD_GET_FILE_NAME), data, - reply, option)); - EXPECT_NE(BError(BError::Codes::OK), service.OnRemoteRequest(3333, data, reply, option)); + try { + EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(false)); + service->CmdGetFileHandle(data, reply); + } catch (BError &err) { + EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); + } + + try { + EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true)).WillOnce(Return(false)); + service->CmdGetFileHandle(data, reply); + } catch (BError &err) { + EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); + } + + EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true)).WillOnce(Return(true)); + EXPECT_CALL(*service, GetFileHandle(_, _)).WillOnce(Return(BError(BError::Codes::OK))); + auto ret = service->CmdGetFileHandle(data, reply); + EXPECT_EQ(ret, BError(BError::Codes::OK)); } catch (...) { EXPECT_TRUE(false); GTEST_LOG_(INFO) << "ServiceStubTest-an exception occurred by GetFileHandle."; @@ -388,36 +551,61 @@ HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_GetFileHandle_0100, testing: /** * @tc.number: SUB_backup_sa_ServiceStub_AppendBundlesRestoreSession_0100 * @tc.name: SUB_backup_sa_ServiceStub_AppendBundlesRestoreSession_0100 - * @tc.desc: Test function of AppendBundlesRestoreSession interface for SUCCESS. + * @tc.desc: Test function of AppendBundlesRestoreSession interface for FAILURE. * @tc.size: MEDIUM * @tc.type: FUNC - * @tc.level Level 0 + * @tc.level Level 1 * @tc.require: I6URNZ */ -HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_AppendBundlesRestoreSession_0100, testing::ext::TestSize.Level0) +HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_AppendBundlesRestoreSession_0100, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "ServiceStubTest-begin SUB_backup_sa_ServiceStub_AppendBundlesRestoreSession_0100"; try { - MockService service; MessageParcel data; MessageParcel reply; - MessageOption option; + try { + EXPECT_CALL(*messageParcelMock, ReadFileDescriptor()).WillOnce(Return(-1)); + service->CmdAppendBundlesRestoreSession(data, reply); + } catch (BError &err) { + EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); + } - vector bundleNames; - bundleNames.push_back(BUNDLE_NAME); - TestManager tm("ServiceStub_GetFd_0300"); - std::string filePath = tm.GetRootDirCurTest().append(FILE_NAME); - UniqueFd fd(open(filePath.data(), O_RDONLY | O_CREAT, S_IRUSR | S_IWUSR)); - - EXPECT_TRUE(data.WriteInterfaceToken(IService::GetDescriptor())); - EXPECT_TRUE(data.WriteFileDescriptor(fd)); - EXPECT_TRUE(data.WriteStringVector(bundleNames)); - EXPECT_TRUE(data.WriteInt32(0)); - EXPECT_TRUE(data.WriteInt32(-1)); - EXPECT_EQ(BError(BError::Codes::OK), - service.OnRemoteRequest( - static_cast(IServiceInterfaceCode::SERVICE_CMD_APPEND_BUNDLES_RESTORE_SESSION), data, - reply, option)); + try { + EXPECT_CALL(*messageParcelMock, ReadFileDescriptor()).WillOnce(Return(0)); + EXPECT_CALL(*messageParcelMock, ReadStringVector(_)).WillOnce(Return(false)); + service->CmdAppendBundlesRestoreSession(data, reply); + } catch (BError &err) { + EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); + } + + try { + EXPECT_CALL(*messageParcelMock, ReadFileDescriptor()).WillOnce(Return(0)); + EXPECT_CALL(*messageParcelMock, ReadStringVector(_)).WillOnce(Return(true)); + EXPECT_CALL(*messageParcelMock, ReadInt32(_)).WillOnce(Return(false)); + service->CmdAppendBundlesRestoreSession(data, reply); + } catch (BError &err) { + EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); + } + + try { + EXPECT_CALL(*messageParcelMock, ReadFileDescriptor()).WillOnce(Return(0)); + EXPECT_CALL(*messageParcelMock, ReadStringVector(_)).WillOnce(Return(true)); + EXPECT_CALL(*messageParcelMock, ReadInt32(_)).WillOnce(Return(true)).WillOnce(Return(false)); + service->CmdAppendBundlesRestoreSession(data, reply); + } catch (BError &err) { + EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); + } + + try { + EXPECT_CALL(*messageParcelMock, ReadFileDescriptor()).WillOnce(Return(0)); + EXPECT_CALL(*messageParcelMock, ReadStringVector(_)).WillOnce(Return(true)); + EXPECT_CALL(*messageParcelMock, ReadInt32(_)).WillOnce(Return(true)).WillOnce(Return(true)); + EXPECT_CALL(*service, AppendBundlesRestoreSession(_, _, _, _)).WillOnce(Return(BError(BError::Codes::OK))); + EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(false)); + service->CmdAppendBundlesRestoreSession(data, reply); + } catch (BError &err) { + EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); + } } catch (...) { EXPECT_TRUE(false); GTEST_LOG_(INFO) << "ServiceStubTest-an exception occurred by AppendBundlesRestoreSession."; @@ -425,45 +613,33 @@ HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_AppendBundlesRestoreSession_ GTEST_LOG_(INFO) << "ServiceStubTest-end SUB_backup_sa_ServiceStub_AppendBundlesRestoreSession_0100"; } - /** * @tc.number: SUB_backup_sa_ServiceStub_AppendBundlesRestoreSession_0101 * @tc.name: SUB_backup_sa_ServiceStub_AppendBundlesRestoreSession_0101 * @tc.desc: Test function of AppendBundlesRestoreSession interface for SUCCESS. * @tc.size: MEDIUM * @tc.type: FUNC - * @tc.level Level 0 + * @tc.level Level 1 * @tc.require: I6URNZ */ -HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_AppendBundlesRestoreSession_0101, testing::ext::TestSize.Level0) +HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_AppendBundlesRestoreSession_0101, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "ServiceStubTest-begin SUB_backup_sa_ServiceStub_AppendBundlesRestoreSession_0100"; try { - MockService service; MessageParcel data; MessageParcel reply; - MessageOption option; - - vector bundleNames; - bundleNames.push_back(BUNDLE_NAME); - TestManager tm("ServiceStub_GetFd_0300"); - std::string filePath = tm.GetRootDirCurTest().append(FILE_NAME); - UniqueFd fd(open(filePath.data(), O_RDONLY | O_CREAT, S_IRUSR | S_IWUSR)); - - EXPECT_TRUE(data.WriteInterfaceToken(IService::GetDescriptor())); - EXPECT_TRUE(data.WriteFileDescriptor(fd)); - EXPECT_TRUE(data.WriteStringVector(bundleNames)); - EXPECT_TRUE(data.WriteInt32(0)); - EXPECT_TRUE(data.WriteInt32(-1)); - EXPECT_EQ(BError(BError::Codes::OK), - service.OnRemoteRequest( - static_cast(IServiceInterfaceCode::SERVICE_CMD_APPEND_BUNDLES_RESTORE_SESSION), data, - reply, option)); + EXPECT_CALL(*messageParcelMock, ReadFileDescriptor()).WillOnce(Return(0)); + EXPECT_CALL(*messageParcelMock, ReadStringVector(_)).WillOnce(Return(true)); + EXPECT_CALL(*messageParcelMock, ReadInt32(_)).WillOnce(Return(true)).WillOnce(Return(true)); + EXPECT_CALL(*service, AppendBundlesRestoreSession(_, _, _, _)).WillOnce(Return(BError(BError::Codes::OK))); + EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(true)); + auto ret = service->CmdAppendBundlesRestoreSession(data, reply); + EXPECT_EQ(ret, BError(BError::Codes::OK)); } catch (...) { EXPECT_TRUE(false); GTEST_LOG_(INFO) << "ServiceStubTest-an exception occurred by AppendBundlesRestoreSession."; } - GTEST_LOG_(INFO) << "ServiceStubTest-end SUB_backup_sa_ServiceStub_AppendBundlesRestoreSession_0100"; + GTEST_LOG_(INFO) << "ServiceStubTest-end SUB_backup_sa_ServiceStub_AppendBundlesRestoreSession_0101"; } /** @@ -472,28 +648,36 @@ HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_AppendBundlesRestoreSession_ * @tc.desc: Test function of AppendBundlesBackupSession interface for SUCCESS. * @tc.size: MEDIUM * @tc.type: FUNC - * @tc.level Level 0 + * @tc.level Level 1 * @tc.require: I6URNZ */ -HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_AppendBundlesBackupSession_0100, testing::ext::TestSize.Level0) +HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_AppendBundlesBackupSession_0100, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "ServiceStubTest-begin SUB_backup_sa_ServiceStub_AppendBundlesBackupSession_0100"; try { - MockService service; - EXPECT_CALL(service, AppendBundlesBackupSession(_)).WillOnce(Return(BError(BError::Codes::OK))); MessageParcel data; MessageParcel reply; - MessageOption option; + try { + EXPECT_CALL(*messageParcelMock, ReadStringVector(_)).WillOnce(Return(false)); + service->CmdAppendBundlesBackupSession(data, reply); + } catch (BError &err) { + EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); + } - vector bundleNames; - bundleNames.push_back(BUNDLE_NAME); + try { + EXPECT_CALL(*messageParcelMock, ReadStringVector(_)).WillOnce(Return(true)); + EXPECT_CALL(*service, AppendBundlesBackupSession(_)).WillOnce(Return(BError(BError::Codes::OK))); + EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(false)); + service->CmdAppendBundlesBackupSession(data, reply); + } catch (BError &err) { + EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); + } - EXPECT_TRUE(data.WriteInterfaceToken(IService::GetDescriptor())); - EXPECT_TRUE(data.WriteStringVector(bundleNames)); - EXPECT_EQ(BError(BError::Codes::OK), - service.OnRemoteRequest( - static_cast(IServiceInterfaceCode::SERVICE_CMD_APPEND_BUNDLES_BACKUP_SESSION), data, - reply, option)); + EXPECT_CALL(*messageParcelMock, ReadStringVector(_)).WillOnce(Return(true)); + EXPECT_CALL(*service, AppendBundlesBackupSession(_)).WillOnce(Return(BError(BError::Codes::OK))); + EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(true)); + auto ret = service->CmdAppendBundlesBackupSession(data, reply); + EXPECT_EQ(ret, BError(BError::Codes::OK)); } catch (...) { EXPECT_TRUE(false); GTEST_LOG_(INFO) << "ServiceStubTest-an exception occurred by AppendBundlesBackupSession."; @@ -504,26 +688,30 @@ HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_AppendBundlesBackupSession_0 /** * @tc.number: SUB_backup_sa_ServiceStub_Finish_0100 * @tc.name: SUB_backup_sa_ServiceStub_Finish_0100 - * @tc.desc: Test function of AppendBundlesBackupSession interface for SUCCESS. + * @tc.desc: Test function of Finish interface for SUCCESS. * @tc.size: MEDIUM * @tc.type: FUNC - * @tc.level Level 0 + * @tc.level Level 1 * @tc.require: I6URNZ */ -HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_Finish_0100, testing::ext::TestSize.Level0) +HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_Finish_0100, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "ServiceStubTest-begin SUB_backup_sa_ServiceStub_Finish_0100"; try { - MockService service; - EXPECT_CALL(service, Finish()).WillOnce(Return(BError(BError::Codes::OK))); MessageParcel data; MessageParcel reply; - MessageOption option; + try { + EXPECT_CALL(*service, Finish()).WillOnce(Return(0)); + EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(false)); + service->CmdFinish(data, reply); + } catch (BError &err) { + EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); + } - EXPECT_TRUE(data.WriteInterfaceToken(IService::GetDescriptor())); - EXPECT_EQ(BError(BError::Codes::OK), - service.OnRemoteRequest(static_cast(IServiceInterfaceCode::SERVICE_CMD_FINISH), data, reply, - option)); + EXPECT_CALL(*service, Finish()).WillOnce(Return(0)); + EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(true)); + auto ret = service->CmdFinish(data, reply); + EXPECT_EQ(ret, BError(BError::Codes::OK)); } catch (...) { EXPECT_TRUE(false); GTEST_LOG_(INFO) << "ServiceStubTest-an exception occurred by Finish."; @@ -540,20 +728,24 @@ HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_Finish_0100, testing::ext::T * @tc.level Level 1 * @tc.require: I6URNZ */ -HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_Release_0100, testing::ext::TestSize.Level0) +HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_Release_0100, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "ServiceStubTest-begin SUB_backup_sa_ServiceStub_Release_0100"; try { - MockService service; - EXPECT_CALL(service, Release()).WillOnce(Return(BError(BError::Codes::OK))); MessageParcel data; MessageParcel reply; - MessageOption option; + try { + EXPECT_CALL(*service, Release()).WillOnce(Return(0)); + EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(false)); + service->CmdRelease(data, reply); + } catch (BError &err) { + EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); + } - EXPECT_TRUE(data.WriteInterfaceToken(IService::GetDescriptor())); - EXPECT_EQ(BError(BError::Codes::OK), - service.OnRemoteRequest(static_cast(IServiceInterfaceCode::SERVICE_CMD_RELSEASE_SESSION), - data, reply, option)); + EXPECT_CALL(*service, Release()).WillOnce(Return(0)); + EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(true)); + auto ret = service->CmdRelease(data, reply); + EXPECT_EQ(ret, BError(BError::Codes::OK)); } catch (...) { EXPECT_TRUE(false); GTEST_LOG_(INFO) << "ServiceStubTest-an exception occurred by Release."; @@ -567,25 +759,44 @@ HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_Release_0100, testing::ext:: * @tc.desc: Test function of GetBackupInfo interface for SUCCESS. * @tc.size: MEDIUM * @tc.type: FUNC - * @tc.level Level 0 + * @tc.level Level 1 * @tc.require: I6URNZ */ -HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_GetBackupInfo_0100, testing::ext::TestSize.Level0) +HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_GetBackupInfo_0100, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "ServiceStubTest-begin SUB_backup_sa_ServiceStub_GetBackupInfo_0100"; try { - MockService service; - EXPECT_CALL(service, GetBackupInfo(_, _)).WillOnce(Return(BError(BError::Codes::OK))); MessageParcel data; MessageParcel reply; - MessageOption option; - std::string bundleName = "com.example.app2backup"; - EXPECT_TRUE(data.WriteInterfaceToken(IService::GetDescriptor())); - EXPECT_TRUE(data.WriteString(bundleName)); - EXPECT_EQ(BError(BError::Codes::OK), - service.OnRemoteRequest( - static_cast(IServiceInterfaceCode::SERVICE_CMD_GET_BACKUP_INFO), data, - reply, option)); + try { + EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(false)); + service->CmdGetBackupInfo(data, reply); + } catch (BError &err) { + EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); + } + + try { + EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true)); + EXPECT_CALL(*service, GetBackupInfo(_, _)).WillOnce(Return(-1)); + service->CmdGetBackupInfo(data, reply); + } catch (BError &err) { + EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); + } + + try { + EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true)); + EXPECT_CALL(*service, GetBackupInfo(_, _)).WillOnce(Return(0)); + EXPECT_CALL(*messageParcelMock, WriteString(_)).WillOnce(Return(false)); + service->CmdGetBackupInfo(data, reply); + } catch (BError &err) { + EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); + } + + EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true)); + EXPECT_CALL(*service, GetBackupInfo(_, _)).WillOnce(Return(0)); + EXPECT_CALL(*messageParcelMock, WriteString(_)).WillOnce(Return(true)); + auto ret = service->CmdGetBackupInfo(data, reply); + EXPECT_EQ(ret, BError(BError::Codes::OK)); } catch (...) { EXPECT_TRUE(false); GTEST_LOG_(INFO) << "ServiceStubTest-an exception occurred by GetBackupInfo."; @@ -599,29 +810,637 @@ HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_GetBackupInfo_0100, testing: * @tc.desc: Test function of UpdateTimer interface for SUCCESS. * @tc.size: MEDIUM * @tc.type: FUNC - * @tc.level Level 0 + * @tc.level Level 1 * @tc.require: I6URNZ */ -HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_UpdateTimer_0100, testing::ext::TestSize.Level0) +HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_UpdateTimer_0100, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "ServiceStubTest-begin SUB_backup_sa_ServiceStub_UpdateTimer_0100"; try { - MockService service; - EXPECT_CALL(service, UpdateTimer(_, _, _)).WillOnce(Return(BError(BError::Codes::OK))); MessageParcel data; MessageParcel reply; - MessageOption option; - std::string bundleName = "com.example.app2backup"; - uint32_t timeOut = 30000; - EXPECT_TRUE(data.WriteInterfaceToken(IService::GetDescriptor())); - EXPECT_TRUE(data.WriteString(bundleName)); - EXPECT_TRUE(data.WriteUint32(timeOut)); - EXPECT_EQ(BError(BError::Codes::OK), service.OnRemoteRequest( - static_cast(IServiceInterfaceCode::SERVICE_CMD_UPDATE_TIMER), data, reply, option)); + try { + EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(false)); + service->CmdUpdateTimer(data, reply); + } catch (BError &err) { + EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); + } + + try { + EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true)); + EXPECT_CALL(*messageParcelMock, ReadUint32(_)).WillOnce(Return(false)); + service->CmdUpdateTimer(data, reply); + } catch (BError &err) { + EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); + } + + try { + EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true)); + EXPECT_CALL(*messageParcelMock, ReadUint32(_)).WillOnce(Return(true)); + EXPECT_CALL(*service, UpdateTimer(_, _, _)).WillOnce(Return(-1)); + service->CmdUpdateTimer(data, reply); + } catch (BError &err) { + EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); + } + + try { + EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true)); + EXPECT_CALL(*messageParcelMock, ReadUint32(_)).WillOnce(Return(true)); + EXPECT_CALL(*service, UpdateTimer(_, _, _)).WillOnce(Return(0)); + EXPECT_CALL(*messageParcelMock, WriteBool(_)).WillOnce(Return(false)); + service->CmdUpdateTimer(data, reply); + } catch (BError &err) { + EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); + } + + EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true)); + EXPECT_CALL(*messageParcelMock, ReadUint32(_)).WillOnce(Return(true)); + EXPECT_CALL(*service, UpdateTimer(_, _, _)).WillOnce(Return(0)); + EXPECT_CALL(*messageParcelMock, WriteBool(_)).WillOnce(Return(true)); + auto ret = service->CmdUpdateTimer(data, reply); + EXPECT_EQ(ret, BError(BError::Codes::OK)); } catch (...) { EXPECT_TRUE(false); GTEST_LOG_(INFO) << "ServiceStubTest-an exception occurred by UpdateTimer."; } GTEST_LOG_(INFO) << "ServiceStubTest-end SUB_backup_sa_ServiceStub_UpdateTimer_0100"; } + +/** + * @tc.number: SUB_backup_sa_ServiceStub_AppendBundlesDetailsRestoreSession_0100 + * @tc.name: SUB_backup_sa_ServiceStub_AppendBundlesDetailsRestoreSession_0100 + * @tc.desc: Test function of AppendBundlesDetailsRestoreSession interface for FAILURE. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: I6URNZ + */ +HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_AppendBundlesDetailsRestoreSession_0100, + testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "ServiceStubTest-begin SUB_backup_sa_ServiceStub_AppendBundlesDetailsRestoreSession_0100"; + try { + MessageParcel data; + MessageParcel reply; + try { + EXPECT_CALL(*messageParcelMock, ReadFileDescriptor()).WillOnce(Return(-1)); + service->CmdAppendBundlesDetailsRestoreSession(data, reply); + } catch (BError &err) { + EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); + } + + try { + EXPECT_CALL(*messageParcelMock, ReadFileDescriptor()).WillOnce(Return(0)); + EXPECT_CALL(*messageParcelMock, ReadStringVector(_)).WillOnce(Return(false)); + service->CmdAppendBundlesDetailsRestoreSession(data, reply); + } catch (BError &err) { + EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); + } + + try { + EXPECT_CALL(*messageParcelMock, ReadFileDescriptor()).WillOnce(Return(0)); + EXPECT_CALL(*messageParcelMock, ReadStringVector(_)).WillOnce(Return(true)).WillOnce(Return(false)); + service->CmdAppendBundlesDetailsRestoreSession(data, reply); + } catch (BError &err) { + EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); + } + + try { + EXPECT_CALL(*messageParcelMock, ReadFileDescriptor()).WillOnce(Return(0)); + EXPECT_CALL(*messageParcelMock, ReadStringVector(_)).WillOnce(Return(true)).WillOnce(Return(true)); + EXPECT_CALL(*messageParcelMock, ReadInt32(_)).WillOnce(Return(false)); + service->CmdAppendBundlesDetailsRestoreSession(data, reply); + } catch (BError &err) { + EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); + } + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "ServiceStubTest-an exception occurred by AppendBundlesDetailsRestoreSession."; + } + GTEST_LOG_(INFO) << "ServiceStubTest-end SUB_backup_sa_ServiceStub_AppendBundlesDetailsRestoreSession_0100"; +} + +/** + * @tc.number: SUB_backup_sa_ServiceStub_AppendBundlesDetailsRestoreSession_0101 + * @tc.name: SUB_backup_sa_ServiceStub_AppendBundlesDetailsRestoreSession_0101 + * @tc.desc: Test function of AppendBundlesDetailsRestoreSession interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: I6URNZ + */ +HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_AppendBundlesDetailsRestoreSession_0101, + testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "ServiceStubTest-begin SUB_backup_sa_ServiceStub_AppendBundlesDetailsRestoreSession_0101"; + try { + MessageParcel data; + MessageParcel reply; + try { + EXPECT_CALL(*messageParcelMock, ReadFileDescriptor()).WillOnce(Return(0)); + EXPECT_CALL(*messageParcelMock, ReadStringVector(_)).WillOnce(Return(true)).WillOnce(Return(true)); + EXPECT_CALL(*messageParcelMock, ReadInt32(_)).WillOnce(Return(true)).WillOnce(Return(false)); + service->CmdAppendBundlesDetailsRestoreSession(data, reply); + } catch (BError &err) { + EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); + } + + try { + EXPECT_CALL(*messageParcelMock, ReadFileDescriptor()).WillOnce(Return(0)); + EXPECT_CALL(*messageParcelMock, ReadStringVector(_)).WillOnce(Return(true)).WillOnce(Return(true)); + EXPECT_CALL(*messageParcelMock, ReadInt32(_)).WillOnce(Return(true)).WillOnce(Return(true)); + EXPECT_CALL(*service, AppendBundlesRestoreSession(_, _, _, _, _)).WillOnce(Return(0)); + EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(false)); + service->CmdAppendBundlesDetailsRestoreSession(data, reply); + } catch (BError &err) { + EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); + } + + EXPECT_CALL(*messageParcelMock, ReadFileDescriptor()).WillOnce(Return(0)); + EXPECT_CALL(*messageParcelMock, ReadStringVector(_)).WillOnce(Return(true)).WillOnce(Return(true)); + EXPECT_CALL(*messageParcelMock, ReadInt32(_)).WillOnce(Return(true)).WillOnce(Return(true)); + EXPECT_CALL(*service, AppendBundlesRestoreSession(_, _, _, _, _)).WillOnce(Return(0)); + EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(true)); + auto ret = service->CmdAppendBundlesDetailsRestoreSession(data, reply); + EXPECT_EQ(ret, BError(BError::Codes::OK)); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "ServiceStubTest-an exception occurred by AppendBundlesDetailsRestoreSession."; + } + GTEST_LOG_(INFO) << "ServiceStubTest-end SUB_backup_sa_ServiceStub_AppendBundlesDetailsRestoreSession_0101"; +} + +/** + * @tc.number: SUB_backup_sa_ServiceStub_AppendBundlesDetailsBackupSession_0100 + * @tc.name: SUB_backup_sa_ServiceStub_AppendBundlesDetailsBackupSession_0100 + * @tc.desc: Test function of AppendBundlesDetailsBackupSession interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: I6URNZ + */ +HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_AppendBundlesDetailsBackupSession_0100, + testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "ServiceStubTest-begin SUB_backup_sa_ServiceStub_AppendBundlesDetailsBackupSession_0100"; + try { + MessageParcel data; + MessageParcel reply; + try { + EXPECT_CALL(*messageParcelMock, ReadStringVector(_)).WillOnce(Return(false)); + service->CmdAppendBundlesDetailsBackupSession(data, reply); + } catch (BError &err) { + EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); + } + + try { + EXPECT_CALL(*messageParcelMock, ReadStringVector(_)).WillOnce(Return(true)).WillOnce(Return(false)); + service->CmdAppendBundlesDetailsBackupSession(data, reply); + } catch (BError &err) { + EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); + } + + try { + EXPECT_CALL(*messageParcelMock, ReadStringVector(_)).WillOnce(Return(true)).WillOnce(Return(true)); + EXPECT_CALL(*service, AppendBundlesDetailsBackupSession(_, _)).WillOnce(Return(0)); + EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(false)); + service->CmdAppendBundlesDetailsBackupSession(data, reply); + } catch (BError &err) { + EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); + } + + EXPECT_CALL(*messageParcelMock, ReadStringVector(_)).WillOnce(Return(true)).WillOnce(Return(true)); + EXPECT_CALL(*service, AppendBundlesDetailsBackupSession(_, _)).WillOnce(Return(0)); + EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(true)); + auto ret = service->CmdAppendBundlesDetailsBackupSession(data, reply); + EXPECT_EQ(ret, BError(BError::Codes::OK)); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "ServiceStubTest-an exception occurred by AppendBundlesDetailsBackupSession."; + } + GTEST_LOG_(INFO) << "ServiceStubTest-end SUB_backup_sa_ServiceStub_AppendBundlesDetailsBackupSession_0100"; +} + +/** + * @tc.number: SUB_backup_sa_ServiceStub_GetLocalCapabilitiesIncremental_0100 + * @tc.name: SUB_backup_sa_ServiceStub_GetLocalCapabilitiesIncremental_0100 + * @tc.desc: Test function of GetLocalCapabilitiesIncremental interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: I6F3GV + */ +HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_GetLocalCapabilitiesIncremental_0100, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "ServiceStubTest-begin SUB_backup_sa_ServiceStub_GetLocalCapabilitiesIncremental_0100"; + try { + MessageParcel data; + MessageParcel reply; + try { + EXPECT_CALL(*messageParcelMock, ReadInt32(_)).WillOnce(Return(false)); + service->CmdGetLocalCapabilitiesIncremental(data, reply); + } catch (BError &err) { + EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); + } + + try { + EXPECT_CALL(*messageParcelMock, ReadInt32(_)).WillOnce(DoAll(SetArgReferee<0>(1), Return(true))); + EXPECT_CALL(*messageParcelMock, ReadInt32()).WillOnce(Return(0)); + service->CmdGetLocalCapabilitiesIncremental(data, reply); + } catch (BError &err) { + EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); + } + + try { + EXPECT_CALL(*messageParcelMock, ReadInt32(_)).WillOnce(Return(true)); + EXPECT_CALL(*service, GetLocalCapabilitiesIncremental(_)).WillOnce(Return(UniqueFd(0))); + EXPECT_CALL(*messageParcelMock, WriteFileDescriptor(_)).WillOnce(Return(false)); + service->CmdGetLocalCapabilitiesIncremental(data, reply); + } catch (BError &err) { + EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); + } + + EXPECT_CALL(*messageParcelMock, ReadInt32(_)).WillOnce(Return(true)); + EXPECT_CALL(*service, GetLocalCapabilitiesIncremental(_)).WillOnce(Return(UniqueFd(0))); + EXPECT_CALL(*messageParcelMock, WriteFileDescriptor(_)).WillOnce(Return(true)); + auto ret = service->CmdGetLocalCapabilitiesIncremental(data, reply); + EXPECT_EQ(ret, BError(BError::Codes::OK)); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "ServiceStubTest-an exception occurred by GetLocalCapabilitiesIncremental."; + } + GTEST_LOG_(INFO) << "ServiceStubTest-end SUB_backup_sa_ServiceStub_GetLocalCapabilitiesIncremental_0100"; +} + +/** + * @tc.number: SUB_backup_sa_ServiceStub_InitIncrementalBackupSession_0100 + * @tc.name: SUB_backup_sa_ServiceStub_InitIncrementalBackupSession_0100 + * @tc.desc: Test function of InitIncrementalBackupSession interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: I6URNZ + */ +HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_InitIncrementalBackupSession_0100, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "ServiceStubTest-begin SUB_backup_sa_ServiceStub_InitIncrementalBackupSession_0100"; + try { + MessageParcel data; + MessageParcel reply; + try { + EXPECT_CALL(*messageParcelMock, ReadRemoteObject()).WillOnce(Return(nullptr)); + service->CmdInitIncrementalBackupSession(data, reply); + } catch (BError &err) { + EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); + } + + try { + EXPECT_CALL(*messageParcelMock, ReadRemoteObject()).WillOnce(Return(remote)); + EXPECT_CALL(*castMock, iface_cast(_)).WillOnce(Return(nullptr)); + service->CmdInitIncrementalBackupSession(data, reply); + } catch (BError &err) { + EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); + } + + try { + EXPECT_CALL(*messageParcelMock, ReadRemoteObject()).WillOnce(Return(remote)); + EXPECT_CALL(*castMock, iface_cast(_)).WillOnce(Return(remote)); + EXPECT_CALL(*service, InitIncrementalBackupSession(_)).WillOnce(Return(0)); + EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(false)); + service->CmdInitIncrementalBackupSession(data, reply); + } catch (BError &err) { + EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); + } + + EXPECT_CALL(*messageParcelMock, ReadRemoteObject()).WillOnce(Return(remote)); + EXPECT_CALL(*castMock, iface_cast(_)).WillOnce(Return(remote)); + EXPECT_CALL(*service, InitIncrementalBackupSession(_)).WillOnce(Return(0)); + EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(true)); + auto ret = service->CmdInitIncrementalBackupSession(data, reply); + EXPECT_EQ(ret, BError(BError::Codes::OK)); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "ServiceStubTest-an exception occurred by InitIncrementalBackupSession."; + } + GTEST_LOG_(INFO) << "ServiceStubTest-end SUB_backup_sa_ServiceStub_InitIncrementalBackupSession_0100"; +} + +/** + * @tc.number: SUB_backup_sa_ServiceStub_AppendBundlesIncrementalBackupSession_0100 + * @tc.name: SUB_backup_sa_ServiceStub_AppendBundlesIncrementalBackupSession_0100 + * @tc.desc: Test function of AppendBundlesIncrementalBackupSession interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: I6URNZ + */ +HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_AppendBundlesIncrementalBackupSession_0100, + testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "ServiceStubTest-begin SUB_backup_sa_ServiceStub_AppendBundlesIncrementalBackupSession_0100"; + try { + MessageParcel data; + MessageParcel reply; + try { + EXPECT_CALL(*messageParcelMock, ReadInt32(_)).WillOnce(Return(false)); + service->CmdAppendBundlesIncrementalBackupSession(data, reply); + } catch (BError &err) { + EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); + } + + try { + EXPECT_CALL(*messageParcelMock, ReadInt32(_)).WillOnce(DoAll(SetArgReferee<0>(1), Return(true))); + EXPECT_CALL(*messageParcelMock, ReadInt32()).WillOnce(Return(0)); + service->CmdAppendBundlesIncrementalBackupSession(data, reply); + } catch (BError &err) { + EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); + } + + try { + EXPECT_CALL(*messageParcelMock, ReadInt32(_)).WillOnce(Return(true)); + EXPECT_CALL(*service, AppendBundlesIncrementalBackupSession(_)).WillOnce(Return(0)); + EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(false)); + service->CmdAppendBundlesIncrementalBackupSession(data, reply); + } catch (BError &err) { + EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); + } + + EXPECT_CALL(*messageParcelMock, ReadInt32(_)).WillOnce(Return(true)); + EXPECT_CALL(*service, AppendBundlesIncrementalBackupSession(_)).WillOnce(Return(0)); + EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(true)); + auto ret = service->CmdAppendBundlesIncrementalBackupSession(data, reply); + EXPECT_EQ(ret, BError(BError::Codes::OK)); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "ServiceStubTest-an exception occurred by AppendBundlesIncrementalBackupSession."; + } + GTEST_LOG_(INFO) << "ServiceStubTest-end SUB_backup_sa_ServiceStub_InitIncrementalBackupSession_0100"; +} + +/** + * @tc.number: SUB_backup_sa_ServiceStub_PublishIncrementalFile_0100 + * @tc.name: SUB_backup_sa_ServiceStub_PublishIncrementalFile_0100 + * @tc.desc: Test function of PublishIncrementalFile interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: I6F3GV + */ +HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_PublishIncrementalFile_0100, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "ServiceStubTest-begin SUB_backup_sa_ServiceStub_PublishIncrementalFile_0100"; + try { + MessageParcel data; + MessageParcel reply; + try { + EXPECT_CALL(*messageParcelMock, ReadInt32()).WillOnce(Return(0)); + service->CmdPublishIncrementalFile(data, reply); + } catch (BError &err) { + EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); + } + + try { + EXPECT_CALL(*messageParcelMock, ReadInt32()).WillOnce(Return(1)); + EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true)).WillOnce(Return(true)); + EXPECT_CALL(*messageParcelMock, ReadUint32(_)).WillOnce(Return(true)); + EXPECT_CALL(*service, PublishIncrementalFile(_)).WillOnce(Return(0)); + EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(false)); + service->CmdPublishIncrementalFile(data, reply); + } catch (BError &err) { + EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); + } + + EXPECT_CALL(*messageParcelMock, ReadInt32()).WillOnce(Return(1)); + EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true)).WillOnce(Return(true)); + EXPECT_CALL(*messageParcelMock, ReadUint32(_)).WillOnce(Return(true)); + EXPECT_CALL(*service, PublishIncrementalFile(_)).WillOnce(Return(0)); + EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(true)); + auto ret = service->CmdPublishIncrementalFile(data, reply); + EXPECT_EQ(ret, BError(BError::Codes::OK)); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "ServiceStubTest-an exception occurred by PublishIncrementalFile."; + } + GTEST_LOG_(INFO) << "ServiceStubTest-end SUB_backup_sa_ServiceStub_PublishIncrementalFile_0100"; +} + +/** + * @tc.number: SUB_backup_sa_ServiceStub_PublishSAIncrementalFile_0100 + * @tc.name: SUB_backup_sa_ServiceStub_PublishSAIncrementalFile_0100 + * @tc.desc: Test function of PublishSAIncrementalFile interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: I6F3GV + */ +HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_PublishSAIncrementalFile_0100, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "ServiceStubTest-begin SUB_backup_sa_ServiceStub_PublishSAIncrementalFile_0100"; + try { + MessageParcel data; + MessageParcel reply; + try { + EXPECT_CALL(*messageParcelMock, ReadInt32()).WillOnce(Return(0)); + service->CmdPublishSAIncrementalFile(data, reply); + } catch (BError &err) { + EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); + } + + try { + EXPECT_CALL(*messageParcelMock, ReadInt32()).WillOnce(Return(1)); + EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true)).WillOnce(Return(true)); + EXPECT_CALL(*messageParcelMock, ReadUint32(_)).WillOnce(Return(true)); + EXPECT_CALL(*messageParcelMock, ReadFileDescriptor()).WillOnce(Return(0)); + EXPECT_CALL(*service, PublishSAIncrementalFile(_, _)).WillOnce(Return(0)); + EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(false)); + service->CmdPublishSAIncrementalFile(data, reply); + } catch (BError &err) { + EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); + } + + EXPECT_CALL(*messageParcelMock, ReadInt32()).WillOnce(Return(1)); + EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true)).WillOnce(Return(true)); + EXPECT_CALL(*messageParcelMock, ReadUint32(_)).WillOnce(Return(true)); + EXPECT_CALL(*messageParcelMock, ReadFileDescriptor()).WillOnce(Return(0)); + EXPECT_CALL(*service, PublishSAIncrementalFile(_, _)).WillOnce(Return(0)); + EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(true)); + auto ret = service->CmdPublishSAIncrementalFile(data, reply); + EXPECT_EQ(ret, BError(BError::Codes::OK)); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "ServiceStubTest-an exception occurred by PublishSAIncrementalFile."; + } + GTEST_LOG_(INFO) << "ServiceStubTest-end SUB_backup_sa_ServiceStub_PublishSAIncrementalFile_0100"; +} + +/** + * @tc.number: SUB_backup_sa_ServiceStub_AppIncrementalFileReady_0100 + * @tc.name: SUB_backup_sa_ServiceStub_AppIncrementalFileReady_0100 + * @tc.desc: Test function of AppIncrementalFileReady interface for FAILURE. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: I6F3GV + */ +HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_AppIncrementalFileReady_0100, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "ServiceStubTest-begin SUB_backup_sa_ServiceStub_AppIncrementalFileReady_0100"; + try { + MessageParcel data; + MessageParcel reply; + try { + EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(false)); + service->CmdAppIncrementalFileReady(data, reply); + } catch (BError &err) { + EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); + } + + try { + EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true)); + EXPECT_CALL(*messageParcelMock, ReadBool()).WillOnce(Return(true)); + EXPECT_CALL(*messageParcelMock, ReadFileDescriptor()).WillOnce(Return(-1)); + service->CmdAppIncrementalFileReady(data, reply); + } catch (BError &err) { + EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); + } + + try { + EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true)); + EXPECT_CALL(*messageParcelMock, ReadBool()).WillOnce(Return(true)); + EXPECT_CALL(*messageParcelMock, ReadFileDescriptor()).WillOnce(Return(0)).WillOnce(Return(-1)); + service->CmdAppIncrementalFileReady(data, reply); + } catch (BError &err) { + EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); + } + + try { + EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true)); + EXPECT_CALL(*messageParcelMock, ReadBool()).WillOnce(Return(true)); + EXPECT_CALL(*messageParcelMock, ReadFileDescriptor()).WillOnce(Return(0)).WillOnce(Return(1)); + EXPECT_CALL(*messageParcelMock, ReadInt32()).WillOnce(Return(0)); + EXPECT_CALL(*service, AppIncrementalFileReady(_, _, _, _)).WillOnce(Return(0)); + EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(false)); + service->CmdAppIncrementalFileReady(data, reply); + } catch (BError &err) { + EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); + } + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "ServiceStubTest-an exception occurred by AppIncrementalFileReady."; + } + GTEST_LOG_(INFO) << "ServiceStubTest-end SUB_backup_sa_ServiceStub_AppIncrementalFileReady_0100"; +} + +/** + * @tc.number: SUB_backup_sa_ServiceStub_AppIncrementalFileReady_0101 + * @tc.name: SUB_backup_sa_ServiceStub_AppIncrementalFileReady_0101 + * @tc.desc: Test function of AppIncrementalFileReady interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: I6F3GV + */ +HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_AppIncrementalFileReady_0101, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "ServiceStubTest-begin SUB_backup_sa_ServiceStub_AppIncrementalFileReady_0101"; + try { + MessageParcel data; + MessageParcel reply; + + EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true)); + EXPECT_CALL(*messageParcelMock, ReadBool()).WillOnce(Return(false)); + EXPECT_CALL(*messageParcelMock, ReadInt32()).WillOnce(Return(0)); + EXPECT_CALL(*service, AppIncrementalFileReady(_, _, _, _)).WillOnce(Return(0)); + EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(true)); + auto ret = service->CmdAppIncrementalFileReady(data, reply); + EXPECT_EQ(ret, BError(BError::Codes::OK)); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "ServiceStubTest-an exception occurred by AppIncrementalFileReady."; + } + GTEST_LOG_(INFO) << "ServiceStubTest-end SUB_backup_sa_ServiceStub_AppIncrementalFileReady_0101"; +} + +/** + * @tc.number: SUB_backup_sa_ServiceStub_AppIncrementalDone_0100 + * @tc.name: SUB_backup_sa_ServiceStub_AppIncrementalDone_0100 + * @tc.desc: Test function of AppIncrementalDone interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: I6F3GV + */ +HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_AppIncrementalDone_0100, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "ServiceStubTest-begin SUB_backup_sa_ServiceStub_AppIncrementalDone_0100"; + try { + MessageParcel data; + MessageParcel reply; + try { + EXPECT_CALL(*messageParcelMock, ReadInt32(_)).WillOnce(Return(false)); + service->CmdAppIncrementalDone(data, reply); + } catch (BError &err) { + EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); + } + + try { + EXPECT_CALL(*messageParcelMock, ReadInt32(_)).WillOnce(Return(true)); + EXPECT_CALL(*service, AppIncrementalDone(_)).WillOnce(Return(0)); + EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(false)); + service->CmdAppIncrementalDone(data, reply); + } catch (BError &err) { + EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); + } + + EXPECT_CALL(*messageParcelMock, ReadInt32(_)).WillOnce(Return(true)); + EXPECT_CALL(*service, AppIncrementalDone(_)).WillOnce(Return(0)); + EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(true)); + auto ret = service->CmdAppIncrementalDone(data, reply); + EXPECT_EQ(ret, BError(BError::Codes::OK)); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "ServiceStubTest-an exception occurred by AppIncrementalDone."; + } + GTEST_LOG_(INFO) << "ServiceStubTest-end SUB_backup_sa_ServiceStub_AppIncrementalDone_0100"; +} + +/** + * @tc.number: SUB_backup_sa_ServiceStub_GetIncrementalFileHandle_0100 + * @tc.name: SUB_backup_sa_ServiceStub_GetIncrementalFileHandle_0100 + * @tc.desc: Test function of GetIncrementalFileHandle interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: I6F3GV + */ +HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_GetIncrementalFileHandle_0100, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "ServiceStubTest-begin SUB_backup_sa_ServiceStub_GetIncrementalFileHandle_0100"; + try { + MessageParcel data; + MessageParcel reply; + try { + EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(false)); + service->CmdGetIncrementalFileHandle(data, reply); + } catch (BError &err) { + EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_INVAL_ARG); + } + + try { + EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true)).WillOnce(Return(false)); + service->CmdGetIncrementalFileHandle(data, reply); + } catch (BError &err) { + EXPECT_EQ(err.GetRawCode(), BError::Codes::SA_BROKEN_IPC); + } + + EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true)).WillOnce(Return(true)); + EXPECT_CALL(*service, GetIncrementalFileHandle(_, _)).WillOnce(Return(BError(BError::Codes::OK))); + auto ret = service->CmdGetIncrementalFileHandle(data, reply); + EXPECT_EQ(ret, BError(BError::Codes::OK)); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "ServiceStubTest-an exception occurred by GetIncrementalFileHandle."; + } + GTEST_LOG_(INFO) << "ServiceStubTest-end SUB_backup_sa_ServiceStub_GetIncrementalFileHandle_0100"; +} } // namespace OHOS::FileManagement::Backup \ No newline at end of file diff --git a/tests/unittests/backup_sa/module_ipc/svc_backup_connection_test.cpp b/tests/unittests/backup_sa/module_ipc/svc_backup_connection_test.cpp index 22d5f467a..2b2478b57 100644 --- a/tests/unittests/backup_sa/module_ipc/svc_backup_connection_test.cpp +++ b/tests/unittests/backup_sa/module_ipc/svc_backup_connection_test.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2022-2023 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 @@ -23,24 +23,22 @@ #include "b_error/b_error.h" #include "element_name.h" #include "ext_extension_mock.h" +#include "message_parcel_mock.h" #include "module_ipc/svc_backup_connection.h" namespace OHOS::FileManagement::Backup { using namespace std; using namespace testing; -namespace { -constexpr int32_t WAIT_TIME = 1; -constexpr int DEFAULT_USER_ID = 100; -} // namespace - class SvcBackupConnectionTest : public testing::Test { public: - static void SetUpTestCase(void) {}; - static void TearDownTestCase() {}; - void SetUp() override; - void TearDown() override; - sptr backupCon_ = nullptr; + static void SetUpTestCase(void); + static void TearDownTestCase(); + void SetUp() override {}; + void TearDown() override {}; +public: + static inline sptr backupCon_ = nullptr; + static inline shared_ptr castMock = nullptr; }; static void CallDied(const std::string &&name) @@ -53,13 +51,46 @@ static void CallDone(const std::string &&name) GTEST_LOG_(INFO) << "ServiceReverseProxyTest-CallDone SUCCESS"; } -void SvcBackupConnectionTest::SetUp() +void SvcBackupConnectionTest::SetUpTestCase() { backupCon_ = sptr(new SvcBackupConnection(CallDied, CallDone)); + castMock = std::make_shared(); + IfaceCastMock::cast = castMock; } -void SvcBackupConnectionTest::TearDown() +void SvcBackupConnectionTest::TearDownTestCase() { backupCon_ = nullptr; + IfaceCastMock::cast = nullptr; + castMock = nullptr; +} + +/** + * @tc.number: SUB_BackupConnection_OnAbilityConnectDone_0100 + * @tc.name: SUB_BackupConnection_OnAbilityConnectDone_0100 + * @tc.desc: 测试 OnAbilityConnectDone 链接回调接口调用成功 + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: I6F3GV + */ +HWTEST_F(SvcBackupConnectionTest, SUB_BackupConnection_OnAbilityConnectDone_0100, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "SvcBackupConnectionTest-begin SUB_BackupConnection_OnAbilityConnectDone_0100"; + try { + int resultCode = 0; + AppExecFwk::ElementName element; + backupCon_->OnAbilityConnectDone(element, nullptr, resultCode); + EXPECT_TRUE(true); + + sptr remoteObject = sptr(new BackupExtExtensionMock); + EXPECT_CALL(*castMock, iface_cast(_)).WillOnce(Return(nullptr)); + backupCon_->OnAbilityConnectDone(element, remoteObject, resultCode); + EXPECT_TRUE(true); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "SvcBackupConnectionTest-an exception occurred by OnAbilityConnectDone."; + } + GTEST_LOG_(INFO) << "SvcBackupConnectionTest-end SUB_BackupConnection_OnAbilityConnectDone_0100"; } /** @@ -74,13 +105,25 @@ void SvcBackupConnectionTest::TearDown() HWTEST_F(SvcBackupConnectionTest, SUB_BackupConnection_OnAbilityDisconnectDone_0100, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "SvcBackupConnectionTest-begin SUB_BackupConnection_OnAbilityDisconnectDone_0100"; - AppExecFwk::ElementName element; - string bundleName = ""; - element.SetBundleName(bundleName); - int resultCode = 1; - backupCon_->OnAbilityDisconnectDone(element, resultCode); - bool ret = backupCon_->IsExtAbilityConnected(); - EXPECT_FALSE(ret); + try { + AppExecFwk::ElementName element; + string bundleName = ""; + element.SetBundleName(bundleName); + int resultCode = 1; + + backupCon_->isConnectedDone_ = false; + backupCon_->OnAbilityDisconnectDone(element, resultCode); + bool ret = backupCon_->IsExtAbilityConnected(); + EXPECT_FALSE(ret); + + backupCon_->isConnectedDone_ = true; + backupCon_->OnAbilityDisconnectDone(element, resultCode); + ret = backupCon_->IsExtAbilityConnected(); + EXPECT_FALSE(ret); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "SvcBackupConnectionTest-an exception occurred by OnAbilityDisconnectDone."; + } GTEST_LOG_(INFO) << "SvcBackupConnectionTest-end SUB_BackupConnection_OnAbilityDisconnectDone_0100"; } @@ -100,55 +143,4 @@ HWTEST_F(SvcBackupConnectionTest, SUB_BackupConnection_GetBackupExtProxy_0100, t EXPECT_EQ(proxy, nullptr); GTEST_LOG_(INFO) << "SvcBackupConnectionTest-end SUB_BackupConnection_GetBackupExtProxy_0100"; } - -/** - * @tc.number: SUB_BackupConnection_ConnectBackupExtAbility_0100 - * @tc.name: SUB_BackupConnection_ConnectBackupExtAbility_0100 - * @tc.desc: 测试 ConnectBackupExtAbility 拉起extension接口调用成功 - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I6F3GV - */ -HWTEST_F(SvcBackupConnectionTest, SUB_BackupConnection_ConnectBackupExtAbility_0100, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "SvcBackupConnectionTest-begin SUB_BackupConnection_ConnectBackupExtAbility_0100"; - AAFwk::Want want; - ErrCode ret = backupCon_->ConnectBackupExtAbility(want, DEFAULT_USER_ID); - EXPECT_NE(ret, BError(BError::Codes::OK)); - GTEST_LOG_(INFO) << "SvcBackupConnectionTest-end SUB_BackupConnection_ConnectBackupExtAbility_0100"; -} - -static void CallBack(sptr backupCon) -{ - GTEST_LOG_(INFO) << "SvcBackupConnectionTest-CallBack Begin"; - sleep(WAIT_TIME); - backupCon->OnAbilityDisconnectDone({}, WAIT_TIME); - GTEST_LOG_(INFO) << "SvcBackupConnectionTest-CallBack End"; -} - -/** - * @tc.number: SUB_BackupConnection_DisconnectBackupExtAbility_0100 - * @tc.name: SUB_BackupConnection_DisconnectBackupExtAbility_0100 - * @tc.desc: 测试 DisconnectBackupExtAbility 拉起extension接口调用成功 - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 1 - * @tc.require: I6F3GV - */ -HWTEST_F(SvcBackupConnectionTest, SUB_BackupConnection_DisconnectBackupExtAbility_0100, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "SvcBackupConnectionTest-begin SUB_BackupConnection_DisconnectBackupExtAbility_0100"; - ErrCode ret = backupCon_->DisconnectBackupExtAbility(); - EXPECT_EQ(ret, BError(BError::Codes::OK)); - GTEST_LOG_(INFO) << "SvcBackupConnectionTest-DisconnectBackupExtAbility async Begin"; - auto future = std::async(std::launch::async, CallBack, backupCon_); - sleep(WAIT_TIME); - GTEST_LOG_(INFO) << "SvcBackupConnectionTest-DisconnectBackupExtAbility Branches Begin"; - ret = backupCon_->DisconnectBackupExtAbility(); - EXPECT_EQ(ret, BError(BError::Codes::OK)); - GTEST_LOG_(INFO) << "SvcBackupConnectionTest-DisconnectBackupExtAbility Branches End"; - future.get(); - GTEST_LOG_(INFO) << "SvcBackupConnectionTest-end SUB_BackupConnection_DisconnectBackupExtAbility_0100"; -} } // namespace OHOS::FileManagement::Backup \ No newline at end of file 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 ebf0fdd7c..2011f852f 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 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2022-2023 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 @@ -16,9 +16,11 @@ #include #include #include +#include #include "b_error/b_error.h" #include "ext_extension_mock.h" +#include "message_parcel_mock.h" #include "module_ipc/svc_extension_proxy.h" #include "unique_fd.h" @@ -28,23 +30,29 @@ using namespace testing; class SvcExtensionProxyTest : public testing::Test { public: - static void SetUpTestCase(void) {}; - static void TearDownTestCase() {}; - void SetUp() override; - void TearDown() override; - sptr proxy_ = nullptr; - sptr mock_ = nullptr; + static void SetUpTestCase(void); + static void TearDownTestCase(); + void SetUp() override {}; + void TearDown() override {}; +public: + static inline sptr proxy_ = nullptr; + static inline sptr mock_ = nullptr; + static inline shared_ptr messageParcelMock_ = nullptr; }; -void SvcExtensionProxyTest::SetUp() +void SvcExtensionProxyTest::SetUpTestCase() { mock_ = sptr(new BackupExtExtensionMock()); proxy_ = sptr(new SvcExtensionProxy(mock_)); + messageParcelMock_ = make_shared(); + MessageParcelMock::messageParcel = messageParcelMock_; } -void SvcExtensionProxyTest::TearDown() +void SvcExtensionProxyTest::TearDownTestCase() { mock_ = nullptr; proxy_ = nullptr; + MessageParcelMock::messageParcel = nullptr; + messageParcelMock_ = nullptr; } /** @@ -59,16 +67,37 @@ void SvcExtensionProxyTest::TearDown() HWTEST_F(SvcExtensionProxyTest, SUB_Ext_Extension_proxy_GetFileHandle_0100, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "SvcExtensionProxyTest-begin SUB_Ext_Extension_proxy_GetFileHandle_0100"; - EXPECT_CALL(*mock_, SendRequest(_, _, _, _)) - .Times(2) - .WillOnce(Invoke(mock_.GetRefPtr(), &BackupExtExtensionMock::InvokeGetFileHandleRequest)) - .WillOnce(Return(EPERM)); - string fileName = "1.tar"; - UniqueFd fd = proxy_->GetFileHandle(fileName); - EXPECT_GT(fd, BError(BError::Codes::OK)); - - UniqueFd fdErr = proxy_->GetFileHandle(fileName); - EXPECT_LT(fdErr, BError(BError::Codes::OK)); + try { + string fileName = "1.tar"; + EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); + EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(false)); + UniqueFd fd = proxy_->GetFileHandle(fileName); + EXPECT_LT(fd, BError(BError::Codes::OK)); + + EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); + EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)); + EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(EPERM)); + fd = proxy_->GetFileHandle(fileName); + EXPECT_LT(fd, BError(BError::Codes::OK)); + + EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); + EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)); + EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(NO_ERROR)); + EXPECT_CALL(*messageParcelMock_, ReadBool()).WillOnce(Return(true)); + EXPECT_CALL(*messageParcelMock_, ReadFileDescriptor()).WillOnce(Return(-1)); + fd = proxy_->GetFileHandle(fileName); + EXPECT_LT(fd, BError(BError::Codes::OK)); + + EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); + EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)); + EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(NO_ERROR)); + EXPECT_CALL(*messageParcelMock_, ReadBool()).WillOnce(Return(false)); + fd = proxy_->GetFileHandle(fileName); + EXPECT_LT(fd, BError(BError::Codes::OK)); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "SvcExtensionProxyTest-an exception occurred by GetFileHandle."; + } GTEST_LOG_(INFO) << "SvcExtensionProxyTest-end SUB_Ext_Extension_proxy_GetFileHandle_0100"; } @@ -84,15 +113,21 @@ HWTEST_F(SvcExtensionProxyTest, SUB_Ext_Extension_proxy_GetFileHandle_0100, test HWTEST_F(SvcExtensionProxyTest, SUB_Ext_Extension_proxy_HandleClear_0100, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "SvcExtensionProxyTest-begin SUB_Ext_Extension_proxy_HandleClear_0100"; - EXPECT_CALL(*mock_, SendRequest(_, _, _, _)) - .Times(2) - .WillOnce(Invoke(mock_.GetRefPtr(), &BackupExtExtensionMock::InvokeSendRequest)) - .WillOnce(Return(EPERM)); - ErrCode ret = proxy_->HandleClear(); - EXPECT_EQ(BError(BError::Codes::OK), ret); - - ret = proxy_->HandleClear(); - EXPECT_NE(BError(BError::Codes::OK), ret); + try { + EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); + EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(EPERM)); + ErrCode ret = proxy_->HandleClear(); + EXPECT_EQ(EPERM, ret); + + EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); + EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(0)); + EXPECT_CALL(*messageParcelMock_, ReadInt32()).WillOnce(Return(0)); + ret = proxy_->HandleClear(); + EXPECT_EQ(BError(BError::Codes::OK), ret); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "SvcExtensionProxyTest-an exception occurred by HandleClear."; + } GTEST_LOG_(INFO) << "SvcExtensionProxyTest-end SUB_Ext_Extension_proxy_HandleClear_0100"; } @@ -108,15 +143,21 @@ HWTEST_F(SvcExtensionProxyTest, SUB_Ext_Extension_proxy_HandleClear_0100, testin HWTEST_F(SvcExtensionProxyTest, SUB_Ext_Extension_proxy_HandleBackup_0100, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "SvcExtensionProxyTest-begin SUB_Ext_Extension_proxy_HandleBackup_0100"; - EXPECT_CALL(*mock_, SendRequest(_, _, _, _)) - .Times(2) - .WillOnce(Invoke(mock_.GetRefPtr(), &BackupExtExtensionMock::InvokeSendRequest)) - .WillOnce(Return(EPERM)); - ErrCode ret = proxy_->HandleBackup(); - EXPECT_EQ(BError(BError::Codes::OK), ret); - - ret = proxy_->HandleBackup(); - EXPECT_NE(BError(BError::Codes::OK), ret); + try { + EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); + EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(EPERM)); + ErrCode ret = proxy_->HandleBackup(); + EXPECT_EQ(EPERM, ret); + + EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); + EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(0)); + EXPECT_CALL(*messageParcelMock_, ReadInt32()).WillOnce(Return(0)); + ret = proxy_->HandleBackup(); + EXPECT_EQ(BError(BError::Codes::OK), ret); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "SvcExtensionProxyTest-an exception occurred by HandleBackup."; + } GTEST_LOG_(INFO) << "SvcExtensionProxyTest-end SUB_Ext_Extension_proxy_HandleBackup_0100"; } @@ -132,19 +173,62 @@ HWTEST_F(SvcExtensionProxyTest, SUB_Ext_Extension_proxy_HandleBackup_0100, testi HWTEST_F(SvcExtensionProxyTest, SUB_Ext_Extension_proxy_PublishFile_0100, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "SvcExtensionProxyTest-begin SUB_Ext_Extension_proxy_PublishFile_0100"; - EXPECT_CALL(*mock_, SendRequest(_, _, _, _)) - .Times(2) - .WillOnce(Invoke(mock_.GetRefPtr(), &BackupExtExtensionMock::InvokeSendRequest)) - .WillOnce(Return(EPERM)); - string fileName = "1.tar"; - ErrCode ret = proxy_->PublishFile(fileName); - EXPECT_EQ(BError(BError::Codes::OK), ret); - - ret = proxy_->PublishFile(fileName); - EXPECT_NE(BError(BError::Codes::OK), ret); + try { + string fileName = "1.tar"; + EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); + EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(false)); + ErrCode ret = proxy_->PublishFile(fileName); + EXPECT_EQ(EPERM, ret); + + EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); + EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)); + EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(EPERM)); + ret = proxy_->PublishFile(fileName); + EXPECT_EQ(EPERM, ret); + + EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); + EXPECT_CALL(*messageParcelMock_, WriteString(_)).WillOnce(Return(true)); + EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(0)); + EXPECT_CALL(*messageParcelMock_, ReadInt32()).WillOnce(Return(0)); + ret = proxy_->PublishFile(fileName); + EXPECT_EQ(BError(BError::Codes::OK), ret); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "SvcExtensionProxyTest-an exception occurred by PublishFile."; + } GTEST_LOG_(INFO) << "SvcExtensionProxyTest-end SUB_Ext_Extension_proxy_PublishFile_0100"; } +/** + * @tc.number: SUB_Ext_Extension_proxy_HandleRestore_0100 + * @tc.name: SUB_Ext_Extension_proxy_HandleRestore_0100 + * @tc.desc: 测试 HandleRestore 接口调用成功和失败 + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: I6F3GV + */ +HWTEST_F(SvcExtensionProxyTest, SUB_Ext_Extension_proxy_HandleRestore_0100, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "SvcExtensionProxyTest-begin SUB_Ext_Extension_proxy_HandleRestore_0100"; + try { + EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); + EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(EPERM)); + ErrCode ret = proxy_->HandleRestore(); + EXPECT_EQ(EPERM, ret); + + EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); + EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(0)); + EXPECT_CALL(*messageParcelMock_, ReadInt32()).WillOnce(Return(0)); + ret = proxy_->HandleRestore(); + EXPECT_EQ(BError(BError::Codes::OK), ret); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "SvcExtensionProxyTest-an exception occurred by HandleRestore."; + } + GTEST_LOG_(INFO) << "SvcExtensionProxyTest-end SUB_Ext_Extension_proxy_HandleRestore_0100"; +} + /** * @tc.number: SUB_Ext_Extension_proxy_GetBackupInfo_0100 * @tc.name: SUB_Ext_Extension_proxy_GetBackupInfo_0100 @@ -157,16 +241,42 @@ HWTEST_F(SvcExtensionProxyTest, SUB_Ext_Extension_proxy_PublishFile_0100, testin HWTEST_F(SvcExtensionProxyTest, SUB_Ext_Extension_proxy_GetBackupInfo_0100, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "SvcExtensionProxyTest-begin SUB_Ext_Extension_proxy_GetBackupInfo_0100"; - EXPECT_CALL(*mock_, SendRequest(_, _, _, _)) - .Times(2) - .WillOnce(Invoke(mock_.GetRefPtr(), &BackupExtExtensionMock::InvokeSendRequest)) - .WillOnce(Return(EPERM)); - string result = "result_report"; - ErrCode ret = proxy_->GetBackupInfo(result); - EXPECT_EQ(BError(BError::Codes::OK), ret); - - ret = proxy_->GetBackupInfo(result); - EXPECT_NE(BError(BError::Codes::OK), ret); + try { + string result = "result_report"; + EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); + EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(EPERM)); + ErrCode ret = proxy_->GetBackupInfo(result); + EXPECT_EQ(EPERM, ret); + + EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); + EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(NO_ERROR)); + EXPECT_CALL(*messageParcelMock_, ReadInt32(_)).WillOnce(Return(false)); + ret = proxy_->GetBackupInfo(result); + EXPECT_EQ(BError(BError::Codes::OK), ret); + + EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); + EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(NO_ERROR)); + EXPECT_CALL(*messageParcelMock_, ReadInt32(_)).WillOnce(DoAll(SetArgReferee<0>(EPERM), Return(true))); + ret = proxy_->GetBackupInfo(result); + EXPECT_EQ(EPERM, ret); + + EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); + EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(NO_ERROR)); + EXPECT_CALL(*messageParcelMock_, ReadInt32(_)).WillOnce(DoAll(SetArgReferee<0>(NO_ERROR), Return(true))); + EXPECT_CALL(*messageParcelMock_, ReadString(_)).WillOnce(Return(false)); + ret = proxy_->GetBackupInfo(result); + EXPECT_EQ(BError(BError::Codes::OK), ret); + + EXPECT_CALL(*messageParcelMock_, WriteInterfaceToken(_)).WillOnce(Return(true)); + EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(NO_ERROR)); + EXPECT_CALL(*messageParcelMock_, ReadInt32(_)).WillOnce(DoAll(SetArgReferee<0>(NO_ERROR), Return(true))); + EXPECT_CALL(*messageParcelMock_, ReadString(_)).WillOnce(Return(true)); + ret = proxy_->GetBackupInfo(result); + EXPECT_EQ(BError(BError::Codes::OK), ret); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "SvcExtensionProxyTest-an exception occurred by GetBackupInfo."; + } GTEST_LOG_(INFO) << "SvcExtensionProxyTest-end SUB_Ext_Extension_proxy_GetBackupInfo_0100"; } } // namespace OHOS::FileManagement::Backup \ No newline at end of file -- Gitee