diff --git a/tests/mock/backup_kit_inner/b_session_backup_mock.cpp b/tests/mock/backup_kit_inner/b_session_backup_mock.cpp index e06d1fb425a4b847df86a9855ca68fb7008216ef..0fe6a3e7c287c383547578b10873a09064f18877 100644 --- a/tests/mock/backup_kit_inner/b_session_backup_mock.cpp +++ b/tests/mock/backup_kit_inner/b_session_backup_mock.cpp @@ -97,4 +97,9 @@ ErrCode BSessionBackup::Release() { return BError(BError::Codes::OK); } + +ErrCode BSessionBackup::Cancel(std::string bundleName) +{ + return BError(BError::Codes::OK); +} } // namespace OHOS::FileManagement::Backup \ No newline at end of file diff --git a/tests/mock/backup_kit_inner/b_session_restore_async_mock.cpp b/tests/mock/backup_kit_inner/b_session_restore_async_mock.cpp index 9e680cd346eea84a7c7045bf1e2af753ae7ca7a8..b6c03de3a11f7493a18f8227d84ba8d82c766b90 100644 --- a/tests/mock/backup_kit_inner/b_session_restore_async_mock.cpp +++ b/tests/mock/backup_kit_inner/b_session_restore_async_mock.cpp @@ -136,4 +136,9 @@ ErrCode BSessionRestoreAsync::Release() } void BSessionRestoreAsync::RegisterBackupServiceDied(function functor) {} + +ErrCode BSessionRestoreAsync::Cancel(std::string bundleName) +{ + return BError(BError::Codes::OK); +} } // namespace OHOS::FileManagement::Backup \ No newline at end of file diff --git a/tests/mock/backup_kit_inner/b_session_restore_mock.cpp b/tests/mock/backup_kit_inner/b_session_restore_mock.cpp index b3138a19e9a010afa8a56aa863dffd28aec5ac29..164500fe32c9e319856b3e8667a39c54c4409cdd 100644 --- a/tests/mock/backup_kit_inner/b_session_restore_mock.cpp +++ b/tests/mock/backup_kit_inner/b_session_restore_mock.cpp @@ -109,4 +109,9 @@ ErrCode BSessionRestore::Release() } void BSessionRestore::RegisterBackupServiceDied(function functor) {} + +ErrCode BSessionRestore::Cancel(std::string bundleName) +{ + return BError(BError::Codes::OK); +} } // namespace OHOS::FileManagement::Backup \ No newline at end of file diff --git a/tests/mock/module_ipc/include/service_stub_mock.h b/tests/mock/module_ipc/include/service_stub_mock.h index 85a71336fb7d5ea1666be315af1215aa5f7d5fe0..bdcbc8730a8e622048313994ca45ad0609334241 100644 --- a/tests/mock/module_ipc/include/service_stub_mock.h +++ b/tests/mock/module_ipc/include/service_stub_mock.h @@ -37,6 +37,7 @@ public: virtual int32_t CmdAppendBundlesDetailsBackupSession(MessageParcel&, MessageParcel&) = 0; virtual int32_t CmdFinish(MessageParcel&, MessageParcel&) = 0; virtual int32_t CmdRelease(MessageParcel&, MessageParcel&) = 0; + virtual int32_t CmdCancel(MessageParcel&, MessageParcel&) = 0; virtual int32_t CmdGetLocalCapabilitiesIncremental(MessageParcel&, MessageParcel&) = 0; virtual int32_t CmdGetAppLocalListAndDoIncrementalBackup(MessageParcel&, MessageParcel&) = 0; virtual int32_t CmdInitIncrementalBackupSession(MessageParcel&, MessageParcel&) = 0; diff --git a/tests/mock/module_ipc/service_stub_mock.cpp b/tests/mock/module_ipc/service_stub_mock.cpp index 101f2fdfb4e9332029fdcee7026c9a91cb2fe665..fb059d7bd8adcc0469609a8b3ecfdcb00bcab5cc 100644 --- a/tests/mock/module_ipc/service_stub_mock.cpp +++ b/tests/mock/module_ipc/service_stub_mock.cpp @@ -81,6 +81,8 @@ void ServiceStub::ServiceStubSupplement() &ServiceStub::CmdUpdateSendRate; opToInterfaceMap_[static_cast(IServiceInterfaceCode::SERVICE_CMD_REPORT_APP_PROCESS_INFO)] = &ServiceStub::CmdReportAppProcessInfo; + opToInterfaceMap_[static_cast(IServiceInterfaceCode::SERVICE_CMD_CANCEL_BUNDLE)] = + &ServiceStub::CmdCancel; } int32_t ServiceStub::OnRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) @@ -272,6 +274,19 @@ int32_t ServiceStub::CmdRelease(MessageParcel &data, MessageParcel &reply) return BError(BError::Codes::OK); } +int32_t ServiceStub::CmdCancel(MessageParcel &data, MessageParcel &reply) +{ + int ret = ERR_OK; + string bundleName; + if (!data.ReadString(bundleName)) { + return BError(BError::Codes::SA_INVAL_ARG, "Failed to receive bundleName"); + } + int result = BError::BackupErrorCode::E_CANCEL_UNSTARTED_TASK; + ret = Cancel(bundleName, result); + reply.WriteInt32(result); + return ret; +} + int32_t ServiceStub::CmdGetLocalCapabilitiesIncremental(MessageParcel &data, MessageParcel &reply) { return BError(BError::Codes::OK); diff --git a/tests/mock/module_ipc/src/service_stub_mock.cpp b/tests/mock/module_ipc/src/service_stub_mock.cpp index df67aac7dd604be1d730df440fefd2337b6f8729..7272d63598906329e31aad1a9dc9bb6e7f5d7f03 100644 --- a/tests/mock/module_ipc/src/service_stub_mock.cpp +++ b/tests/mock/module_ipc/src/service_stub_mock.cpp @@ -117,6 +117,11 @@ int32_t ServiceStub::CmdRelease(MessageParcel &data, MessageParcel &reply) return BServiceStub::stub->CmdRelease(data, reply); } +int32_t ServiceStub::CmdCancel(MessageParcel &data, MessageParcel &reply) +{ + return BServiceStub::stub->CmdCancel(data, reply); +} + int32_t ServiceStub::CmdGetLocalCapabilitiesIncremental(MessageParcel &data, MessageParcel &reply) { return BServiceStub::stub->CmdGetLocalCapabilitiesIncremental(data, reply); diff --git a/tests/moduletests/backup_kit_inner/b_session_backup_test.cpp b/tests/moduletests/backup_kit_inner/b_session_backup_test.cpp index 10b69da7dc9cb7718e5a4f56dfd924e50c0cb955..b71d7be11ebfc8ff87269bf59a5badd000a303e8 100644 --- a/tests/moduletests/backup_kit_inner/b_session_backup_test.cpp +++ b/tests/moduletests/backup_kit_inner/b_session_backup_test.cpp @@ -375,4 +375,37 @@ HWTEST_F(BSessionBackupTest, SUB_backup_b_session_backup_0900, testing::ext::Tes } GTEST_LOG_(INFO) << "BSessionBackupTest-end SUB_backup_b_session_backup_0900"; } + +/** + * @tc.number: SUB_backup_b_session_backup_1000 + * @tc.name: SUB_backup_b_session_backup_1000 + * @tc.desc: 测试Cancel接口 + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: I6F3GV + */ +HWTEST_F(BSessionBackupTest, SUB_backup_b_session_backup_1000, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "BSessionBackupTest-Cancel SUB_backup_b_session_backup_1000"; + try { + if (backupPtr_ == nullptr) { + GTEST_LOG_(INFO) << "SUB_backup_b_session_backup_1000 backupPtr_ == nullptr"; + return; + } + BundleName bundleName; + GTEST_LOG_(INFO) << "GetInstance is true"; + SetMockGetInstance(true); + auto ret = backupPtr_->Cancel(bundleName); + EXPECT_EQ(ret, ErrCode(BError::Codes::OK)); + GTEST_LOG_(INFO) << "GetInstance is false"; + SetMockGetInstance(false); + ret = backupPtr_->Cancel(bundleName); + EXPECT_NE(ret, ErrCode(BError::Codes::OK)); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "BSessionBackupTest-an exception occurred by Cancel."; + } + GTEST_LOG_(INFO) << "BSessionBackupTest-end SUB_backup_b_session_backup_1000"; +} } // namespace OHOS::FileManagement::Backup \ No newline at end of file diff --git a/tests/moduletests/backup_kit_inner/b_session_restore_async_test.cpp b/tests/moduletests/backup_kit_inner/b_session_restore_async_test.cpp index 9d6d8e81a51a55e1d61c372e44072d41bc5dd907..aa3f5a3ed5885f0adfaebdfc49737bcf053a8172 100644 --- a/tests/moduletests/backup_kit_inner/b_session_restore_async_test.cpp +++ b/tests/moduletests/backup_kit_inner/b_session_restore_async_test.cpp @@ -338,4 +338,35 @@ HWTEST_F(BSessionRestoreAsyncTest, SUB_backup_b_session_restore_async_0700, test } GTEST_LOG_(INFO) << "BSessionRestoreAsyncTest-end SUB_backup_b_session_restore_async_0700"; } + +/** + * @tc.number: SUB_backup_b_session_restore_async_0800 + * @tc.name: SUB_backup_b_session_restore_async_0800 + * @tc.desc: 测试Cancel接口 + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: I7L7A6 + */ +HWTEST_F(BSessionRestoreAsyncTest, SUB_backup_b_session_restore_async_0800, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "BSessionRestoreAsyncTest-begin SUB_backup_b_session_restore_async_0800"; + try { + if (restorePtr_ == nullptr) { + GTEST_LOG_(INFO) << "SUB_backup_b_session_restore_async_0800 restorePtr_ == nullptr"; + return; + } + BundleName bundleName; + SetMockGetInstance(false); + ErrCode ret = restorePtr_->Cancel(bundleName); + EXPECT_NE(ret, ErrCode(BError::Codes::OK)); + SetMockGetInstance(true); + ret = restorePtr_->Cancel(bundleName); + EXPECT_EQ(ret, ErrCode(BError::Codes::OK)); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "BSessionRestoreAsyncTest-an exception occurred by Cancel."; + } + GTEST_LOG_(INFO) << "BSessionRestoreAsyncTest-end SUB_backup_b_session_restore_async_0800"; +} } // namespace OHOS::FileManagement::Backup \ No newline at end of file diff --git a/tests/moduletests/backup_kit_inner/b_session_restore_test.cpp b/tests/moduletests/backup_kit_inner/b_session_restore_test.cpp index 1ab1115b1996cfbcf16494f7c5a58fa02da0e2c7..0c2b9b32c5e31a6e80f5d88ad39fb9ce5dd7f35a 100644 --- a/tests/moduletests/backup_kit_inner/b_session_restore_test.cpp +++ b/tests/moduletests/backup_kit_inner/b_session_restore_test.cpp @@ -479,4 +479,38 @@ HWTEST_F(BSessionRestoreTest, SUB_backup_b_session_restore_1000, testing::ext::T } GTEST_LOG_(INFO) << "BSessionRestoreTest-end SUB_backup_b_session_restore_1000"; } + +/** + * @tc.number: SUB_backup_b_session_restore_1100 + * @tc.name: SUB_backup_b_session_restore_1100 + * @tc.desc: 测试Cancel接口 + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: I6F3GV + */ +HWTEST_F(BSessionRestoreTest, SUB_backup_b_session_restore_1100, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "BSessionRestoreTest-begin SUB_backup_b_session_restore_1100"; + try { + if (restorePtr_ == nullptr) { + GTEST_LOG_(INFO) << "SUB_backup_b_session_restore_1100 restorePtr_ == nullptr"; + return; + } + GTEST_LOG_(INFO) << "GetInstance is false"; + BundleName bundleName; + SetMockGetInstance(false); + auto ret = restorePtr_->Cancel(bundleName); + EXPECT_NE(ret, ErrCode(BError::Codes::OK)); + + GTEST_LOG_(INFO) << "GetInstance is true"; + SetMockGetInstance(true); + ret = restorePtr_->Cancel(bundleName); + EXPECT_EQ(ret, ErrCode(BError::Codes::OK)); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "BSessionRestoreTest-an exception occurred by Cancel."; + } + GTEST_LOG_(INFO) << "BSessionRestoreTest-end SUB_backup_b_session_restore_1100"; +} } // namespace OHOS::FileManagement::Backup \ No newline at end of file diff --git a/tests/unittests/backup_api/backup_impl/service_proxy_test.cpp b/tests/unittests/backup_api/backup_impl/service_proxy_test.cpp index 63ad75d97bd9dfa65fcea2edea0311867da60d22..d1fb27bb8ff9a318345b50acb66a416e301348fc 100644 --- a/tests/unittests/backup_api/backup_impl/service_proxy_test.cpp +++ b/tests/unittests/backup_api/backup_impl/service_proxy_test.cpp @@ -1326,4 +1326,33 @@ HWTEST_F(ServiceProxyTest, SUB_Service_proxy_StartFwkTimer_0100, testing::ext::T EXPECT_NE(ret, BError(BError::Codes::OK)); GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_StartFwkTimer_0100"; } + +/** + * @tc.number: SUB_Service_proxy_Cancel_0100 + * @tc.name: SUB_Service_proxy_Cancel_0100 + * @tc.desc: 测试 Cancel 调用成功和失败 + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: I90ZV5 + */ +HWTEST_F(ServiceProxyTest, SUB_Service_proxy_Cancel_0100, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_Cancel_0100"; + if (proxy_ == nullptr) { + GTEST_LOG_(INFO) << "SUB_Service_proxy_Cancel_0100 proxy_ == nullptr"; + return; + } + EXPECT_CALL(*mock_, SendRequest(_, _, _, _)) + .Times(2) + .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeSendRequest)) + .WillOnce(Return(EPERM)); + std::string bundleName; + int result; + ErrCode ret = proxy_->Cancel(bundleName, result); + EXPECT_EQ(ret, BError(BError::Codes::OK)); + ret = proxy_->Cancel(bundleName, result); + EXPECT_NE(ret, BError(BError::Codes::OK)); + GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_Cancel_0100"; +} } // namespace OHOS::FileManagement::Backup \ No newline at end of file diff --git a/tests/unittests/backup_sa/module_ipc/service_incremental_test.cpp b/tests/unittests/backup_sa/module_ipc/service_incremental_test.cpp index 1bfc002e1ea24112b4e59e91dc155c41e6f23247..fe947567fadfe1c78c5a97354d6668fd2ec9ec08 100644 --- a/tests/unittests/backup_sa/module_ipc/service_incremental_test.cpp +++ b/tests/unittests/backup_sa/module_ipc/service_incremental_test.cpp @@ -1079,4 +1079,54 @@ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_SetCurrentBackupSessProp } GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_SetCurrentBackupSessProperties_0200"; } + +/** + * @tc.number: SUB_ServiceIncremental_Cancel_0000 + * @tc.name: SUB_ServiceIncremental_Cancel_0000 + * @tc.desc: 测试 Cancel 的正常/异常分支 + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: issueIAKC3I + */ +HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_Cancel_0000, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_Cancel_0000"; + try { + string bundleName = "com.example.app2backup"; + BackupExtInfo info {}; + info.backupExtName = "com.example.app2backup"; + SvcSessionManager::Impl impl; + impl.backupExtNameMap.insert(make_pair(bundleName, info)); + int32_t result; + + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); + service->Cancel(bundleName, result); + EXPECT_EQ(result, BError(BError::BackupErrorCode::E_CANCEL_NO_TASK).GetCode()); + + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); + EXPECT_CALL(*session, GetImpl()).WillOnce(Return(impl)); + EXPECT_CALL(*session, GetServiceSchedAction(_)).WillOnce(Return(BConstants::ServiceSchedAction::CLEAN)); + service->Cancel(bundleName, result); + EXPECT_EQ(result, BError(BError::BackupErrorCode::E_CANCEL_NO_TASK).GetCode()); + + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); + EXPECT_CALL(*session, GetImpl()).WillOnce(Return(impl)); + EXPECT_CALL(*session, GetServiceSchedAction(_)).WillOnce(Return(BConstants::ServiceSchedAction::START)); + service->Cancel(bundleName, result); + EXPECT_EQ(result, BError(BError::BackupErrorCode::E_CANCEL_UNSTARTED_TASK).GetCode()); + + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)) + .WillOnce(Return(IServiceReverse::Scenario::RESTORE)); + EXPECT_CALL(*session, GetImpl()).WillOnce(Return(impl)); + EXPECT_CALL(*session, GetServiceSchedAction(_)).WillOnce(Return(BConstants::ServiceSchedAction::RUNNING)); + EXPECT_CALL(*session, GetExtConnection(_)).WillOnce(Return(nullptr)); + service->Cancel(bundleName, result); + EXPECT_EQ(result, BError(BError::Codes::OK).GetCode()); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by Cancel."; + } + GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_Cancel_0000"; +} } \ 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 6288e19a7e488800c515ffc556c53b79b685abb0..60aef6c36d6f5b9d3135deffec5f2d11f9672720 100644 --- a/tests/unittests/backup_sa/module_ipc/service_stub_test.cpp +++ b/tests/unittests/backup_sa/module_ipc/service_stub_test.cpp @@ -710,6 +710,50 @@ HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_Release_0100, testing::ext:: GTEST_LOG_(INFO) << "ServiceStubTest-end SUB_backup_sa_ServiceStub_Release_0100"; } +/** + * @tc.number: SUB_backup_sa_ServiceStub_Cancel_0100 + * @tc.name: SUB_backup_sa_ServiceStub_Cancel_0100 + * @tc.desc: Test function of Cancel interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: I6URNZ + */ +HWTEST_F(ServiceStubTest, SUB_backup_sa_ServiceStub_Cancel_0100, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "ServiceStubTest-begin SUB_backup_sa_ServiceStub_Cancel_0100"; + try { + MessageParcel data; + MessageParcel reply; + EXPECT_TRUE(service != nullptr); + EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(false)); + auto err = service->CmdCancel(data, reply); + EXPECT_EQ(err, BError(BError::Codes::SA_INVAL_ARG)); + + EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true)); + EXPECT_CALL(*service, Cancel(_, _)).WillOnce(Return(BError::BackupErrorCode::E_CANCEL_UNSTARTED_TASK)); + EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(true)); + err = service->CmdCancel(data, reply); + EXPECT_EQ(err, BError(BError::BackupErrorCode::E_CANCEL_UNSTARTED_TASK)); + + EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true)); + EXPECT_CALL(*service, Cancel(_, _)).WillOnce(Return(0)); + EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(false)); + err = service->CmdCancel(data, reply); + EXPECT_EQ(err, BError(BError::Codes::SA_BROKEN_IPC)); + + EXPECT_CALL(*messageParcelMock, ReadString(_)).WillOnce(Return(true)); + EXPECT_CALL(*service, Cancel(_, _)).WillOnce(Return(0)); + EXPECT_CALL(*messageParcelMock, WriteInt32(_)).WillOnce(Return(true)); + err = service->CmdCancel(data, reply); + EXPECT_EQ(err, BError(BError::Codes::OK)); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "ServiceStubTest-an exception occurred by Cancel."; + } + GTEST_LOG_(INFO) << "ServiceStubTest-end SUB_backup_sa_ServiceStub_Cancel_0100"; +} + /** * @tc.number: SUB_backup_sa_ServiceStub_GetBackupInfo_0100 * @tc.name: SUB_backup_sa_ServiceStub_GetBackupInfo_0100 diff --git a/tests/unittests/backup_sa/session/b_incremental_session_test.cpp b/tests/unittests/backup_sa/session/b_incremental_session_test.cpp index 8c0cfb08652747f31a3ecd6f12686623dfcc7e31..17779f0b877d2f37fcacc95c83369fb484fa6b21 100644 --- a/tests/unittests/backup_sa/session/b_incremental_session_test.cpp +++ b/tests/unittests/backup_sa/session/b_incremental_session_test.cpp @@ -673,4 +673,94 @@ HWTEST_F(IncrementalSessionTest, SUB_b_incremental_session_test_2000, testing::e } GTEST_LOG_(INFO) << "IncrementalSessionTest-end SUB_b_incremental_session_test_2000"; } + +/** + * @tc.number: SUB_b_incremental_session_test_2100 + * @tc.name: SUB_b_incremental_session_test_2100 + * @tc.desc: 测试 Cancel 接口 + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: issuesI9KPRL + */ +HWTEST_F(IncrementalSessionTest, SUB_b_incremental_session_test_2100, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "IncrementalSessionTest-begin SUB_b_incremental_session_test_2100"; + try { + ServiceProxy::serviceProxy_ = nullptr; + std::string bundleName; + EXPECT_TRUE(backupSession != nullptr); + auto err = backupSession->Cancel(bundleName); + EXPECT_EQ(err, BError(BError::BackupErrorCode::E_CANCEL_UNSTARTED_TASK).GetCode()); + + EXPECT_CALL(*proxy, Cancel(_, _)).WillOnce(DoAll(SetArgReferee<1>(0), Return(0))); + ServiceProxy::serviceProxy_ = proxy; + err = backupSession->Cancel(bundleName); + EXPECT_EQ(err, BError(BError::Codes::OK).GetCode()); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "IncrementalSessionTest-an exception occurred by Cancel."; + } + GTEST_LOG_(INFO) << "IncrementalSessionTest-end SUB_b_incremental_session_test_2100"; +} + +/** + * @tc.number: SUB_b_incremental_session_test_2200 + * @tc.name: SUB_b_incremental_session_test_2200 + * @tc.desc: 测试 Cancel 接口 + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: issuesI9KPRL + */ +HWTEST_F(IncrementalSessionTest, SUB_b_incremental_session_test_2200, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "IncrementalSessionTest-begin SUB_b_incremental_session_test_2200"; + try { + ServiceProxy::serviceProxy_ = nullptr; + std::string bundleName; + EXPECT_TRUE(restoreSession != nullptr); + auto err = restoreSession->Cancel(bundleName); + EXPECT_EQ(err, BError(BError::BackupErrorCode::E_CANCEL_UNSTARTED_TASK).GetCode()); + + EXPECT_CALL(*proxy, Cancel(_, _)).WillOnce(DoAll(SetArgReferee<1>(0), Return(0))); + ServiceProxy::serviceProxy_ = proxy; + err = restoreSession->Cancel(bundleName); + EXPECT_EQ(err, BError(BError::Codes::OK).GetCode()); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "IncrementalSessionTest-an exception occurred by Cancel."; + } + GTEST_LOG_(INFO) << "IncrementalSessionTest-end SUB_b_incremental_session_test_2200"; +} + +/** + * @tc.number: SUB_b_incremental_session_test_2300 + * @tc.name: SUB_b_incremental_session_test_2300 + * @tc.desc: 测试 Cancel 接口 + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: issuesI9KPRL + */ +HWTEST_F(IncrementalSessionTest, SUB_b_incremental_session_test_2300, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "IncrementalSessionTest-begin SUB_b_incremental_session_test_2300"; + try { + ServiceProxy::serviceProxy_ = nullptr; + std::string bundleName; + EXPECT_TRUE(restoreAsyncSession != nullptr); + auto err = restoreAsyncSession->Cancel(bundleName); + EXPECT_EQ(err, BError(BError::BackupErrorCode::E_CANCEL_UNSTARTED_TASK).GetCode()); + + EXPECT_CALL(*proxy, Cancel(_, _)).WillOnce(DoAll(SetArgReferee<1>(0), Return(0))); + ServiceProxy::serviceProxy_ = proxy; + err = restoreAsyncSession->Cancel(bundleName); + EXPECT_EQ(err, BError(BError::Codes::OK).GetCode()); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "IncrementalSessionTest-an exception occurred by Cancel."; + } + GTEST_LOG_(INFO) << "IncrementalSessionTest-end SUB_b_incremental_session_test_2300"; +} } // namespace OHOS::FileManagement::Backup \ No newline at end of file