From 3715b73acd841e8d56d812a8667643e496d0889f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=BC=A0=E6=99=9F=E9=92=B0?= Date: Thu, 23 Jan 2025 19:58:09 +0800 Subject: [PATCH] add UT MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 张晟钰 --- .../b_session_backup_test.cpp | 38 +++++- .../b_session_restore_test.cpp | 32 +++++ .../backup_impl/service_proxy_test.cpp | 85 +++++++++++++ .../backup_impl/service_reverse_stub_test.cpp | 72 +++++++++++ .../backup_impl/service_reverse_test.cpp | 114 ++++++++++++++++++ .../module_external/bms_adapter_test.cpp | 14 ++- .../backup_sa/module_ipc/sub_service_test.cpp | 74 +++++++++++- .../session/b_incremental_session_test.cpp | 36 ++++++ 8 files changed, 461 insertions(+), 4 deletions(-) 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 a4a5583f2..4ec32326e 100644 --- a/tests/moduletests/backup_kit_inner/b_session_backup_test.cpp +++ b/tests/moduletests/backup_kit_inner/b_session_backup_test.cpp @@ -423,7 +423,7 @@ HWTEST_F(BSessionBackupTest, SUB_backup_b_session_backup_1100, testing::ext::Tes GTEST_LOG_(INFO) << "BSessionBackupTest-begin SUB_backup_b_session_backup_1100"; try { if (backupPtr_ == nullptr) { - GTEST_LOG_(INFO) << "SUB_backup_b_session_backup_0900 backupPtr_ == nullptr"; + GTEST_LOG_(INFO) << "SUB_backup_b_session_backup_1100 backupPtr_ == nullptr"; return; } GTEST_LOG_(INFO) << "GetInstance is false"; @@ -436,8 +436,42 @@ HWTEST_F(BSessionBackupTest, SUB_backup_b_session_backup_1100, testing::ext::Tes EXPECT_LT(err, 0); } catch (...) { EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "BSessionBackupTest-an exception occurred by RemoveExtConn."; + GTEST_LOG_(INFO) << "BSessionBackupTest-an exception occurred by GetLocalCapabilities."; } GTEST_LOG_(INFO) << "BSessionBackupTest-end SUB_backup_b_session_backup_1100"; } + +/** + * @tc.number: SUB_backup_b_session_backup_1200 + * @tc.name: SUB_backup_b_session_backup_1200 + * @tc.desc: 测试 GetBackupDataSize 接口 + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: issuesI9KPRL + */ +HWTEST_F(BSessionBackupTest, SUB_backup_b_session_backup_1200, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "BSessionBackupTest-begin SUB_backup_b_session_backup_1200"; + try { + if (backupPtr_ == nullptr) { + GTEST_LOG_(INFO) << "SUB_backup_b_session_backup_1200 backupPtr_ == nullptr"; + return; + } + GTEST_LOG_(INFO) << "GetInstance is false"; + bool isPreciseScan = true; + vector bundleNameList; + SetMockGetInstance(false); + auto err = backupPtr_->GetBackupDataSize(isPreciseScan, bundleNameList); + EXPECT_LT(err, 0); + GTEST_LOG_(INFO) << "GetInstance is true"; + SetMockGetInstance(true); + err = backupPtr_->GetBackupDataSize(isPreciseScan, bundleNameList); + EXPECT_LT(err, 0); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "BSessionBackupTest-an exception occurred by GetBackupDataSize."; + } + GTEST_LOG_(INFO) << "BSessionBackupTest-end SUB_backup_b_session_backup_1200"; +} } // 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 0c2b9b32c..417df640a 100644 --- a/tests/moduletests/backup_kit_inner/b_session_restore_test.cpp +++ b/tests/moduletests/backup_kit_inner/b_session_restore_test.cpp @@ -513,4 +513,36 @@ HWTEST_F(BSessionRestoreTest, SUB_backup_b_session_restore_1100, testing::ext::T } GTEST_LOG_(INFO) << "BSessionRestoreTest-end SUB_backup_b_session_restore_1100"; } + +/** + * @tc.number: SUB_backup_b_session_restore_1200 + * @tc.name: SUB_backup_b_session_restore_1200 + * @tc.desc: 测试 GetLocalCapabilities 接口 + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: issuesI9KPRL + */ +HWTEST_F(BSessionBackupTest, SUB_backup_b_session_restore_1200, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "BSessionBackupTest-begin SUB_backup_b_session_restore_1200"; + try { + if (backupPtr_ == nullptr) { + GTEST_LOG_(INFO) << "SUB_backup_b_session_restore_1200 backupPtr_ == nullptr"; + return; + } + GTEST_LOG_(INFO) << "GetInstance is false"; + SetMockGetInstance(false); + auto err = backupPtr_->GetLocalCapabilities(); + EXPECT_LT(err, 0); + GTEST_LOG_(INFO) << "GetInstance is true"; + SetMockGetInstance(true); + err = backupPtr_->GetLocalCapabilities(); + EXPECT_LT(err, 0); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "BSessionBackupTest-an exception occurred by GetLocalCapabilities."; + } + GTEST_LOG_(INFO) << "BSessionBackupTest-end SUB_backup_b_session_restore_1200"; +} } // 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 ee2de7234..a417e80f2 100644 --- a/tests/unittests/backup_api/backup_impl/service_proxy_test.cpp +++ b/tests/unittests/backup_api/backup_impl/service_proxy_test.cpp @@ -1441,4 +1441,89 @@ HWTEST_F(ServiceProxyTest, SUB_Service_proxy_Cancel_0100, testing::ext::TestSize EXPECT_NE(ret, BError(BError::Codes::OK)); GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_Cancel_0100"; } + +/** + * @tc.number: SUB_Service_proxy_RefreshDataSize_0100 + * @tc.name: SUB_Service_proxy_RefreshDataSize_0100 + * @tc.desc: 测试 RefreshDataSize 调用成功和失败 + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: I90ZV5 + */ +HWTEST_F(ServiceProxyTest, SUB_Service_proxy_RefreshDataSize_0100, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_RefreshDataSize_0100"; + if (proxy_ == nullptr) { + GTEST_LOG_(INFO) << "SUB_Service_proxy_RefreshDataSize_0100 proxy_ == nullptr"; + return; + } + EXPECT_CALL(*mock_, SendRequest(_, _, _, _)) + .Times(2) + .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeSendRequest)) + .WillOnce(Return(EPERM)) + .WillOnce(Return(EPERM)); + int64_t totalSize = 0; + ErrCode ret = proxy_->RefreshDataSize(totalSize); + EXPECT_EQ(ret, BError(BError::Codes::OK)); + ret = proxy_->proxy_->RefreshDataSize(totalSize); + EXPECT_NE(ret, BError(BError::Codes::OK)); + GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_RefreshDataSize_0100"; +} + +/** + * @tc.number: SUB_Service_proxy_GetLocalCapabilitiesForBdInfos_0100 + * @tc.name: SUB_Service_proxy_GetLocalCapabilitiesForBdInfos_0100 + * @tc.desc: 测试 GetLocalCapabilitiesForBdInfos 调用成功和失败 + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: I90ZV5 + */ +HWTEST_F(ServiceProxyTest, SUB_Service_proxy_GetLocalCapabilitiesForBdInfos_0100, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_GetLocalCapabilitiesForBdInfos_0100"; + if (proxy_ == nullptr) { + GTEST_LOG_(INFO) << "SUB_Service_proxy_GetLocalCapabilitiesForBdInfos_0100 proxy_ == nullptr"; + return; + } + EXPECT_CALL(*mock_, SendRequest(_, _, _, _)) + .Times(2) + .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeSendRequest)) + .WillOnce(Return(EPERM)); + ErrCode ret = proxy_->GetLocalCapabilitiesForBdInfos(); + EXPECT_EQ(ret, BError(BError::Codes::OK)); + ret = proxy_->proxy_->GetLocalCapabilitiesForBdInfos(); + EXPECT_NE(ret, BError(BError::Codes::OK)); + GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_GetLocalCapabilitiesForBdInfos_0100"; +} + +/** + * @tc.number: SUB_Service_proxy_GetBackupDataSize_0100 + * @tc.name: SUB_Service_proxy_GetBackupDataSize_0100 + * @tc.desc: 测试 GetBackupDataSize 调用成功和失败 + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: I90ZV5 + */ +HWTEST_F(ServiceProxyTest, SUB_Service_proxy_GetBackupDataSize_0100, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "ServiceProxyTest-begin SUB_Service_proxy_GetBackupDataSize_0100"; + if (proxy_ == nullptr) { + GTEST_LOG_(INFO) << "SUB_Service_proxy_GetBackupDataSize_0100 proxy_ == nullptr"; + return; + } + EXPECT_CALL(*mock_, SendRequest(_, _, _, _)) + .Times(2) + .WillOnce(Invoke(mock_.GetRefPtr(), &IServiceMock::InvokeSendRequest)) + .WillOnce(Return(EPERM)); + bool isPreciseScan = true; + vector bundleNameList; + ErrCode ret = proxy_->GetBackupDataSize(isPreciseScan, bundleNameList); + EXPECT_EQ(ret, BError(BError::Codes::OK)); + ret = proxy_->proxy_->GetBackupDataSize(isPreciseScan, bundleNameList); + EXPECT_NE(ret, BError(BError::Codes::OK)); + GTEST_LOG_(INFO) << "ServiceProxyTest-end SUB_Service_proxy_GetBackupDataSize_0100"; +} } // namespace OHOS::FileManagement::Backup \ No newline at end of file diff --git a/tests/unittests/backup_api/backup_impl/service_reverse_stub_test.cpp b/tests/unittests/backup_api/backup_impl/service_reverse_stub_test.cpp index 7c2284f6b..a7673a437 100644 --- a/tests/unittests/backup_api/backup_impl/service_reverse_stub_test.cpp +++ b/tests/unittests/backup_api/backup_impl/service_reverse_stub_test.cpp @@ -886,4 +886,76 @@ HWTEST_F(ServiceReverseStubTest, GTEST_LOG_(INFO) << "ServiceReverseStubTest-end SUB_backup_ServiceReverseStub_IncrementalRestoreOnResultReport_0100"; } + +/** + * @tc.number: SUB_backup_ServiceReverseStub_BackupOnScanningInfo_0100 + * @tc.name: SUB_backup_ServiceReverseStub_BackupOnScanningInfo_0100 + * @tc.desc: Test function of BackupOnScanningInfo interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: I6F3GV + */ +HWTEST_F(ServiceReverseStubTest, + SUB_backup_ServiceReverseStub_BackupOnScanningInfo_0100, + testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "ServiceReverseStubTest-begin SUB_backup_ServiceReverseStub_BackupOnScanningInfo_0100"; + try { + MockServiceReverse service; + EXPECT_CALL(service, BackupOnScanningInfo(_)).WillOnce(Return()); + MessageParcel data; + MessageParcel reply; + MessageOption option; + + EXPECT_TRUE(data.WriteInterfaceToken(IServiceReverse::GetDescriptor())); + EXPECT_TRUE(data.WriteString(BUNDLE_NAME)); + + EXPECT_EQ(BError(BError::Codes::OK), + service.OnRemoteRequest( + static_cast(IServiceReverseInterfaceCode::SERVICER_BACKUP_ON_SCANNED_INFO), data, + reply, option)); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "ServiceReverseStubTest-an exception occurred by BackupOnScanningInfo."; + } + GTEST_LOG_(INFO) << "ServiceReverseStubTest-end SUB_backup_ServiceReverseStub_BackupOnScanningInfo_0100"; +} + +/** + * @tc.number: SUB_backup_ServiceReverseStub_IncrementalBackupOnScanningInfo_0100 + * @tc.name: SUB_backup_ServiceReverseStub_IncrementalBackupOnScanningInfo_0100 + * @tc.desc: Test function of IncrementalBackupOnScanningInfo interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: I6F3GV + */ +HWTEST_F(ServiceReverseStubTest, + SUB_backup_ServiceReverseStub_IncrementalBackupOnScanningInfo_0100, + testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << + "ServiceReverseStubTest-begin SUB_backup_ServiceReverseStub_IncrementalBackupOnScanningInfo_0100"; + try { + MockServiceReverse service; + EXPECT_CALL(service, BackupOnScanningInfo(_)).WillOnce(Return()); + MessageParcel data; + MessageParcel reply; + MessageOption option; + + EXPECT_TRUE(data.WriteInterfaceToken(IServiceReverse::GetDescriptor())); + EXPECT_TRUE(data.WriteString(BUNDLE_NAME)); + + EXPECT_EQ(BError(BError::Codes::OK), + service.OnRemoteRequest( + static_cast( + IServiceReverseInterfaceCode::SERVICER_INCREMENTAL_BACKUP_ON_SCANNED_INFO), + data, reply, option)); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "ServiceReverseStubTest-an exception occurred by BackupOnScanningInfo."; + } + GTEST_LOG_(INFO) << "ServiceReverseStubTest-end SUB_backup_ServiceReverseStub_IncrementalBackupOnScanningInfo_0100"; +} } // namespace OHOS::FileManagement::Backup \ No newline at end of file diff --git a/tests/unittests/backup_api/backup_impl/service_reverse_test.cpp b/tests/unittests/backup_api/backup_impl/service_reverse_test.cpp index 98bccfac2..1f5cb90e6 100644 --- a/tests/unittests/backup_api/backup_impl/service_reverse_test.cpp +++ b/tests/unittests/backup_api/backup_impl/service_reverse_test.cpp @@ -1751,4 +1751,118 @@ HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_IncrementalBackupOnResult } GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_IncrementalBackupOnResultReport_0101"; } + +/** + * @tc.number: SUB_backup_ServiceReverse_BackupOnScanningInfo_0100 + * @tc.name: SUB_backup_ServiceReverse_BackupOnScanningInfo_0100 + * @tc.desc: 测试 BackupOnScanningInfo 接口 + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: I6F3GV + */ +HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_BackupOnScanningInfo_0100, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_BackupOnScanningInfo_0100"; + try { + Init(IServiceReverse::Scenario::BACKUP); + if (service_ == nullptr) { + GTEST_LOG_(INFO) << + "SUB_backup_ServiceReverse_BackupOnScanningInfo_0100 service_ == nullptr"; + return; + } + std::string scannedInfo = ""; + service_->BackupOnScanningInfo(scannedInfo); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by BackupOnScanningInfo."; + } + GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_BackupOnScanningInfo_0100"; +} + +/** + * @tc.number: SUB_backup_ServiceReverse_BackupOnScanningInfo_0101 + * @tc.name: SUB_backup_ServiceReverse_BackupOnScanningInfo_0101 + * @tc.desc: 测试 BackupOnScanningInfo 接口 + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: I6F3GV + */ +HWTEST_F(ServiceReverseTest, SUB_backup_ServiceReverse_BackupOnScanningInfo_0101, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_BackupOnScanningInfo_0101"; + try { + Init(IServiceReverse::Scenario::RESTORE); + if (service_ == nullptr) { + GTEST_LOG_(INFO) << + "SUB_backup_ServiceReverse_BackupOnScanningInfo_0101 service_ == nullptr"; + return; + } + std::string scannedInfo = ""; + service_->BackupOnScanningInfo(scannedInfo); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by BackupOnScanningInfo."; + } + GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_BackupOnScanningInfo_0101"; +} + +/** + * @tc.number: SUB_backup_ServiceReverse_IncrementalBackupOnScanningInfo_0100 + * @tc.name: SUB_backup_ServiceReverse_IncrementalBackupOnScanningInfo_0100 + * @tc.desc: 测试 IncrementalBackupOnScanningInfo 接口 + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: I6F3GV + */ +HWTEST_F(ServiceReverseTest, + SUB_backup_ServiceReverse_IncrementalBackupOnScanningInfo_0100, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalBackupOnScanningInfo_0100"; + try { + Init(IServiceReverse::Scenario::RESTORE); + if (service_ == nullptr) { + GTEST_LOG_(INFO) << + "SUB_backup_ServiceReverse_IncrementalBackupOnScanningInfo_0100 service_ == nullptr"; + return; + } + std::string scannedInfo = ""; + service_->BackupOnScanningInfo(scannedInfo); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by BackupOnScanningInfo."; + } + GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_IncrementalBackupOnScanningInfo_0100"; +} + +/** + * @tc.number: SUB_backup_ServiceReverse_IncrementalBackupOnScanningInfo_0101 + * @tc.name: SUB_backup_ServiceReverse_IncrementalBackupOnScanningInfo_0101 + * @tc.desc: 测试 IncrementalBackupOnScanningInfo 接口 + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: I6F3GV + */ +HWTEST_F(ServiceReverseTest, + SUB_backup_ServiceReverse_IncrementalBackupOnScanningInfo_0101, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "ServiceReverseTest-begin SUB_backup_ServiceReverse_IncrementalBackupOnScanningInfo_0101"; + try { + Init(IServiceReverse::Scenario::BACKUP); + if (service_ == nullptr) { + GTEST_LOG_(INFO) << + "SUB_backup_ServiceReverse_IncrementalBackupOnScanningInfo_0101 service_ == nullptr"; + return; + } + std::string scannedInfo = ""; + service_->BackupOnScanningInfo(scannedInfo); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "ServiceReverseTest-an exception occurred by BackupOnScanningInfo."; + } + GTEST_LOG_(INFO) << "ServiceReverseTest-end SUB_backup_ServiceReverse_IncrementalBackupOnScanningInfo_0101"; +} } // namespace OHOS::FileManagement::Backup \ No newline at end of file diff --git a/tests/unittests/backup_sa/module_external/bms_adapter_test.cpp b/tests/unittests/backup_sa/module_external/bms_adapter_test.cpp index 4ad91d23e..76e0d1e2f 100644 --- a/tests/unittests/backup_sa/module_external/bms_adapter_test.cpp +++ b/tests/unittests/backup_sa/module_external/bms_adapter_test.cpp @@ -207,12 +207,24 @@ HWTEST_F(BmsAdapterTest, SUB_bms_adapter_CreatBackupEnv_test_0000, testing::ext: GTEST_LOG_(INFO) << "BmsAdapterTest-begin SUB_bms_adapter_CreatBackupEnv_test_0000"; try { std::vector bundleNameList; - EXPECT_CALL(*sam, GetSystemAbility(_)).WillOnce(Return(bms)).WillOnce(Return(bms)); + BIncrementalData data; + data.bundleName = BUNDLE_NAME; + data.lastIncrementalTime = 0; + bundleNameList.push_back(data); + EXPECT_CALL(*sam, GetSystemAbility(_)).WillOnce(Return(bms)); EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(true)); BundleMgrAdapter::CreatBackupEnv(bundleNameList, USER_ID); EXPECT_TRUE(true); + EXPECT_CALL(*sam, GetSystemAbility(_)).WillOnce(Return(bms)); + EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(false)); + BundleMgrAdapter::CreatBackupEnv(bundleNameList, USER_ID); + EXPECT_TRUE(true); + + BJsonUtil::BundleDetailInfo info; + EXPECT_CALL(*sam, GetSystemAbility(_)).WillOnce(Return(bms)); EXPECT_CALL(*saUtils, IsSABundleName(_)).WillOnce(Return(false)); + EXPECT_CALL(*jsonUtil, ParseBundleNameIndexStr(_)).WillOnce(Return(info)); BundleMgrAdapter::CreatBackupEnv(bundleNameList, USER_ID); EXPECT_TRUE(true); } catch (...) { diff --git a/tests/unittests/backup_sa/module_ipc/sub_service_test.cpp b/tests/unittests/backup_sa/module_ipc/sub_service_test.cpp index a982e92e2..ef6ad9b3f 100644 --- a/tests/unittests/backup_sa/module_ipc/sub_service_test.cpp +++ b/tests/unittests/backup_sa/module_ipc/sub_service_test.cpp @@ -1613,6 +1613,14 @@ HWTEST_F(ServiceTest, SUB_Service_GetScanningInfo_0000, TestSize.Level1) string scanning = BUNDLE_NAME; bool ret = service->GetScanningInfo(nullptr, size, scanning); EXPECT_FALSE(ret); + + EXPECT_CALL(*jsonUtil, WriteToStr(_, _, _, _)).WillOnce(Return(false)); + bool ret = service->GetScanningInfo(nullptr, size, scanning); + EXPECT_FALSE(ret); + + EXPECT_CALL(*jsonUtil, WriteToStr(_, _, _, _)).WillOnce(Return(true)); + bool ret = service->GetScanningInfo(nullptr, size, scanning); + EXPECT_TRUE(ret); } catch (...) { EXPECT_TRUE(false); GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by GetScanningInfo."; @@ -1647,7 +1655,7 @@ HWTEST_F(ServiceTest, SUB_Service_WriteToList_0000, TestSize.Level1) } GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_WriteToList_0000"; } - +S /** * @tc.number: SUB_Service_DeleteFromList_0000 * @tc.name: SUB_Service_DeleteFromList_0000 @@ -1909,4 +1917,68 @@ HWTEST_F(ServiceTest, SUB_Service_GetDataSizeStepByStep_0000, TestSize.Level1) GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by GetDataSizeStepByStep."; } GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_GetDataSizeStepByStep_0000"; +} + +/** + * @tc.number: SUB_Service_CyclicSendScannedInfo_0000 + * @tc.name: SUB_Service_CyclicSendScannedInfo_0000 + * @tc.desc: 测试 CyclicSendScannedInfo 接口 + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: issueIAKC3I + */ +HWTEST_F(ServiceTest, SUB_Service_CyclicSendScannedInfo_0000, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_CyclicSendScannedInfo_0000"; + try { + bool isPreciseScan = false; + vector bundleNameList; + EXPECT_CALL(*task, AddTask(_)).WillOnce(WithArgs<0>(Invoke([](const ThreadPool::Task &f) { + f(); + }))); + service->CyclicSendScannedInfo(isPreciseScan, bundleNameList); + EXPECT_TRUE(true); + + isPreciseScan = true; + EXPECT_CALL(*task, AddTask(_)).WillOnce(WithArgs<0>(Invoke([](const ThreadPool::Task &f) { + f(); + }))); + service->CyclicSendScannedInfo(isPreciseScan, bundleNameList); + EXPECT_TRUE(true); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by CyclicSendScannedInfo."; + } + GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_CyclicSendScannedInfo_0000"; +} + +/** + * @tc.number: SUB_Service_SendScannedInfo_0000 + * @tc.name: SUB_Service_SendScannedInfo_0000 + * @tc.desc: 测试 SendScannedInfo 接口 + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: issueIAKC3I + */ +HWTEST_F(ServiceTest, SUB_Service_SendScannedInfo_0000, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_SendScannedInfo_0000"; + try { + string scannendInfos = ""; + service->SendScannedInfo(scannendInfos, nullptr); + EXPECT_TRUE(true); + + auto session_ = service->session_; + EXPECT_CALL(*task, AddTask(_)).WillOnce(WithArgs<0>(Invoke([](const ThreadPool::Task &f) { + f(); + }))); + service->service->SendScannedInfo(scannendInfos, session_); + EXPECT_TRUE(true); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by CyclicSendScannedInfo."; + } + GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_SendScannedInfo_0000"; } \ No newline at end of file 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 e074a00e0..cc404f3d7 100644 --- a/tests/unittests/backup_sa/session/b_incremental_session_test.cpp +++ b/tests/unittests/backup_sa/session/b_incremental_session_test.cpp @@ -897,4 +897,40 @@ HWTEST_F(IncrementalSessionTest, SUB_b_incremental_session_test_2700, testing::e } GTEST_LOG_(INFO) << "IncrementalSessionTest-end SUB_b_incremental_session_test_2700"; } + +/** + * @tc.number: SUB_b_incremental_session_test_2800 + * @tc.name: SUB_b_incremental_session_test_2800 + * @tc.desc: 测试 GetBackupDataSize 接口 + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: issuesI9KPRL + */ +HWTEST_F(IncrementalSessionTest, SUB_b_incremental_session_test_2800, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "IncrementalSessionTest-begin SUB_b_incremental_session_test_2800"; + try { + bool isPreciseScan; + vector bundleNameList; + ServiceProxy::serviceProxy_ = nullptr; + EXPECT_TRUE(backupSession != nullptr); + auto err = backupSession->GetBackupDataSize(isPreciseScan, bundleNameList); + EXPECT_EQ(err, BError(BError::Codes::SDK_BROKEN_IPC).GetCode()); + + ServiceProxy::serviceProxy_ = proxy; + EXPECT_CALL(*proxy, GetBackupDataSize(_, _)).WillOnce(Return(UniqueFd(-1))); + err = backupSession->GetBackupDataSize(isPreciseScan, bundleNameList); + EXPECT_EQ(err, BError(BError::Codes::SDK_BROKEN_IPC).GetCode()); + + EXPECT_CALL(*proxy, GetBackupDataSize(_, _)).WillOnce(Return(UniqueFd(-1))); + err = backupSession->GetBackupDataSize(isPreciseScan, bundleNameList); + EXPECT_EQ(err.Get(), 0); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "IncrementalSessionTest-an exception occurred by GetBackupDataSize."; + } + GTEST_LOG_(INFO) << "IncrementalSessionTest-end SUB_b_incremental_session_test_2800"; +} + } // namespace OHOS::FileManagement::Backup \ No newline at end of file -- Gitee