From bbe6317b7acd1aa589dc5b60084475ea37cae078 Mon Sep 17 00:00:00 2001 From: wangpggg Date: Tue, 17 Dec 2024 10:45:59 +0800 Subject: [PATCH] add ut Signed-off-by: wangpeng --- .../kits/js/backup/general_callbacks.cpp | 1 + .../backup_ext/untar_file_sup_test.cpp | 310 ++++++++++++++++-- .../module_ipc/service_incremental_test.cpp | 121 ++++++- .../backup_sa/module_ipc/sub_service_test.cpp | 103 ++++++ 4 files changed, 509 insertions(+), 26 deletions(-) diff --git a/interfaces/kits/js/backup/general_callbacks.cpp b/interfaces/kits/js/backup/general_callbacks.cpp index 49996a822..6ca01da33 100644 --- a/interfaces/kits/js/backup/general_callbacks.cpp +++ b/interfaces/kits/js/backup/general_callbacks.cpp @@ -128,6 +128,7 @@ static void DoCallJsMethod(napi_env env, void *data, InputArgsParser argParser) napi_value callback = ctx->cb_.Deref(env).val_; if (!bool(ctx->cb_)) { HILOGE("Failed to get ref."); + napi_close_handle_scope(env, scope); return; } napi_value result = nullptr; diff --git a/tests/unittests/backup_ext/untar_file_sup_test.cpp b/tests/unittests/backup_ext/untar_file_sup_test.cpp index 780ad61fd..2d537fa14 100644 --- a/tests/unittests/backup_ext/untar_file_sup_test.cpp +++ b/tests/unittests/backup_ext/untar_file_sup_test.cpp @@ -241,6 +241,10 @@ HWTEST_F(UntarFileSupTest, SUB_Untar_File_CreateDir_0100, testing::ext::TestSize EXPECT_CALL(*funcMock, access(_, _)).WillOnce(Return(0)); UntarFile::GetInstance().CreateDir(rootPath, S_IRWXU); + rootPath = "rootPath/realName/"; + EXPECT_CALL(*funcMock, access(_, _)).WillOnce(Return(0)); + UntarFile::GetInstance().CreateDir(rootPath, S_IRWXU); + rootPath = "rootPath/realName"; EXPECT_CALL(*funcMock, access(_, _)).WillOnce(Return(1)).WillOnce(Return(0)) .WillOnce(Return(1)).WillOnce(Return(0)); @@ -270,20 +274,50 @@ HWTEST_F(UntarFileSupTest, SUB_Untar_File_CreateDir_0100, testing::ext::TestSize HWTEST_F(UntarFileSupTest, SUB_Untar_File_ParseFileByTypeFlag_0100, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "UntarFileSupTest-begin SUB_Untar_File_CreateDir_0100"; - FileStatInfo info; - info.fullPath = "realName"; UntarFile::GetInstance().rootPath_ = "rootPath"; try { - UntarFile::GetInstance().ParseFileByTypeFlag(SYMTYPE, info); + char c = '\0'; + FileStatInfo info; + info.fullPath = "/test.txt"; + EXPECT_CALL(*funcMock, realpath(_, _)).WillOnce(Return(&c)); + EXPECT_CALL(*funcMock, fopen(_, _)).WillOnce(Return(nullptr)); + EXPECT_CALL(*funcMock, fseeko(_, _, _)).WillOnce(Return(0)); + auto [ret, flag, m] = UntarFile::GetInstance().ParseFileByTypeFlag(REGTYPE, info); + EXPECT_EQ(ret, 0); + EXPECT_FALSE(flag); - EXPECT_CALL(*funcMock, access(_, _)).WillOnce(Return(1)).WillOnce(Return(0)) - .WillOnce(Return(1)).WillOnce(Return(0)); - EXPECT_CALL(*funcMock, mkdir(_, _)).WillOnce(Return(0)); - UntarFile::GetInstance().ParseFileByTypeFlag(DIRTYPE, info); - EXPECT_EQ(info.fullPath, "rootPath/realName"); + info.fullPath = "/test/../test.txt"; + tie(ret, flag, std::ignore) = UntarFile::GetInstance().ParseFileByTypeFlag(REGTYPE, info); + EXPECT_EQ(ret, DEFAULT_ERR); + EXPECT_TRUE(flag); + info.fullPath = "/test.txt"; + EXPECT_CALL(*funcMock, realpath(_, _)).WillOnce(Return(&c)); + EXPECT_CALL(*funcMock, fopen(_, _)).WillOnce(Return(nullptr)); EXPECT_CALL(*funcMock, fseeko(_, _, _)).WillOnce(Return(0)); - UntarFile::GetInstance().ParseFileByTypeFlag('6', info); + tie(ret, flag, std::ignore) = UntarFile::GetInstance().ParseFileByTypeFlag(AREGTYPE, info); + EXPECT_EQ(ret, 0); + EXPECT_FALSE(flag); + + info.fullPath = "/test/../test.txt"; + tie(ret, flag, std::ignore) = UntarFile::GetInstance().ParseFileByTypeFlag(AREGTYPE, info); + EXPECT_EQ(ret, DEFAULT_ERR); + EXPECT_TRUE(flag); + + tie(ret, flag, std::ignore) = UntarFile::GetInstance().ParseFileByTypeFlag(SYMTYPE, info); + EXPECT_EQ(ret, 0); + EXPECT_TRUE(flag); + + info.fullPath = "/test/"; + EXPECT_CALL(*funcMock, access(_, _)).WillOnce(Return(0)); + tie(ret, flag, std::ignore) = UntarFile::GetInstance().ParseFileByTypeFlag(DIRTYPE, info); + EXPECT_EQ(ret, 0); + EXPECT_FALSE(flag); + + info.fullPath = "/test/../test/"; + tie(ret, flag, std::ignore) = UntarFile::GetInstance().ParseFileByTypeFlag(DIRTYPE, info); + EXPECT_EQ(ret, DEFAULT_ERR); + EXPECT_TRUE(flag); } catch (...) { EXPECT_TRUE(false); GTEST_LOG_(INFO) << "UntarFileSupTest-an exception occurred by ParseFileByTypeFlag."; @@ -291,6 +325,211 @@ HWTEST_F(UntarFileSupTest, SUB_Untar_File_ParseFileByTypeFlag_0100, testing::ext GTEST_LOG_(INFO) << "UntarFileSupTest-end SUB_Untar_File_CreateDir_0100"; } +/** + * @tc.number: SUB_Untar_File_ParseFileByTypeFlag_0200 + * @tc.name: SUB_Untar_File_ParseFileByTypeFlag_0200 + * @tc.desc: 测试 ParseFileByTypeFlag 接口 + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: I6F3GV + */ +HWTEST_F(UntarFileSupTest, SUB_Untar_File_ParseFileByTypeFlag_0200, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "UntarFileSupTest-begin SUB_Untar_File_CreateDir_0100"; + UntarFile::GetInstance().rootPath_ = "rootPath"; + try { + FileStatInfo info; + UntarFile::GetInstance().tarFileSize_ = PATH_MAX_LEN + 1; + info.fullPath = "/test/../test/"; + auto [ret, flag, m] = UntarFile::GetInstance().ParseFileByTypeFlag(GNUTYPE_LONGNAME, info); + EXPECT_EQ(ret, DEFAULT_ERR); + EXPECT_TRUE(flag); + + info.fullPath = "/test"; + info.longName = "/test/../longName"; + tie(ret, flag, std::ignore) = UntarFile::GetInstance().ParseFileByTypeFlag(GNUTYPE_LONGNAME, info); + EXPECT_EQ(ret, DEFAULT_ERR); + EXPECT_TRUE(flag); + + info.fullPath = "/test"; + info.longName = "longName"; + tie(ret, flag, std::ignore) = UntarFile::GetInstance().ParseFileByTypeFlag(GNUTYPE_LONGNAME, info); + EXPECT_EQ(ret, DEFAULT_ERR); + EXPECT_TRUE(flag); + + EXPECT_CALL(*funcMock, fseeko(_, _, _)).WillOnce(Return(0)); + tie(ret, flag, std::ignore) = UntarFile::GetInstance().ParseFileByTypeFlag('6', info); + EXPECT_EQ(ret, 0); + EXPECT_TRUE(flag); + + EXPECT_CALL(*funcMock, fseeko(_, _, _)).WillOnce(Return(-1)); + tie(ret, flag, std::ignore) = UntarFile::GetInstance().ParseFileByTypeFlag('6', info); + EXPECT_EQ(ret, DEFAULT_ERR); + EXPECT_TRUE(flag); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "UntarFileSupTest-an exception occurred by ParseFileByTypeFlag."; + } + GTEST_LOG_(INFO) << "UntarFileSupTest-end SUB_Untar_File_CreateDir_0200"; +} + +/** + * @tc.number: SUB_Untar_File_DealFileTag_0100 + * @tc.name: SUB_Untar_File_DealFileTag_0100 + * @tc.desc: 测试 DealFileTag 接口 + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: I6F3GV + */ +HWTEST_F(UntarFileSupTest, SUB_Untar_File_DealFileTag_0100, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "UntarFileSupTest-begin SUB_Untar_File_DealFileTag_0100"; + try { + char c = '\0'; + ErrFileInfo errFileInfo; + FileStatInfo info; + bool isFilter = false; + std::string tmpFullPath; + info.fullPath = "/test.txt"; + UntarFile::GetInstance().includes_.clear(); + EXPECT_CALL(*funcMock, realpath(_, _)).WillOnce(Return(&c)); + EXPECT_CALL(*funcMock, fopen(_, _)).WillOnce(Return(nullptr)); + EXPECT_CALL(*funcMock, fseeko(_, _, _)).WillOnce(Return(0)); + EXPECT_EQ(UntarFile::GetInstance().DealFileTag(errFileInfo, info, isFilter, tmpFullPath), true); + + info.fullPath = "/../test.txt"; + UntarFile::GetInstance().rootPath_ = "/root/"; + EXPECT_EQ(UntarFile::GetInstance().DealFileTag(errFileInfo, info, isFilter, tmpFullPath), false); + + ReportFileInfo report; + UntarFile::GetInstance().includes_.emplace("/test/", report); + EXPECT_CALL(*funcMock, fseeko(_, _, _)).WillOnce(Return(0)); + EXPECT_EQ(UntarFile::GetInstance().DealFileTag(errFileInfo, info, isFilter, tmpFullPath), true); + + EXPECT_CALL(*funcMock, fseeko(_, _, _)).WillOnce(Return(-1)); + EXPECT_EQ(UntarFile::GetInstance().DealFileTag(errFileInfo, info, isFilter, tmpFullPath), false); + + tmpFullPath = "/test/"; + info.fullPath = "/test.txt"; + EXPECT_CALL(*funcMock, realpath(_, _)).WillOnce(Return(&c)); + EXPECT_CALL(*funcMock, fopen(_, _)).WillOnce(Return(nullptr)); + EXPECT_CALL(*funcMock, fseeko(_, _, _)).WillOnce(Return(0)); + EXPECT_EQ(UntarFile::GetInstance().DealFileTag(errFileInfo, info, isFilter, tmpFullPath), true); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "UntarFileSupTest-an exception occurred by DealFileTag."; + } + GTEST_LOG_(INFO) << "UntarFileSupTest-end SUB_Untar_File_DealFileTag_0100"; +} + +/** + * @tc.number: SUB_Untar_File_ParseIncrementalFileByTypeFlag_0100 + * @tc.name: SUB_Untar_File_ParseIncrementalFileByTypeFlag_0100 + * @tc.desc: 测试 ParseIncrementalFileByTypeFlag 接口 + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: I6F3GV + */ +HWTEST_F(UntarFileSupTest, SUB_Untar_File_ParseIncrementalFileByTypeFlag_0100, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "UntarFileSupTest-begin SUB_Untar_File_CreateDir_0100"; + UntarFile::GetInstance().rootPath_ = "rootPath"; + try { + char c = '\0'; + FileStatInfo info; + info.fullPath = "/test.txt"; + UntarFile::GetInstance().includes_.clear(); + EXPECT_CALL(*funcMock, realpath(_, _)).WillOnce(Return(&c)); + EXPECT_CALL(*funcMock, fopen(_, _)).WillOnce(Return(nullptr)); + EXPECT_CALL(*funcMock, fseeko(_, _, _)).WillOnce(Return(0)); + auto [ret, flag, m] = UntarFile::GetInstance().ParseIncrementalFileByTypeFlag(REGTYPE, info); + EXPECT_EQ(ret, 0); + EXPECT_FALSE(flag); + + info.fullPath = "/test/../test.txt"; + tie(ret, flag, std::ignore) = UntarFile::GetInstance().ParseIncrementalFileByTypeFlag(REGTYPE, info); + EXPECT_EQ(ret, DEFAULT_ERR); + EXPECT_TRUE(flag); + + info.fullPath = "/test.txt"; + EXPECT_CALL(*funcMock, realpath(_, _)).WillOnce(Return(&c)); + EXPECT_CALL(*funcMock, fopen(_, _)).WillOnce(Return(nullptr)); + EXPECT_CALL(*funcMock, fseeko(_, _, _)).WillOnce(Return(0)); + tie(ret, flag, std::ignore) = UntarFile::GetInstance().ParseIncrementalFileByTypeFlag(AREGTYPE, info); + EXPECT_EQ(ret, 0); + EXPECT_FALSE(flag); + + info.fullPath = "/test/../test.txt"; + tie(ret, flag, std::ignore) = UntarFile::GetInstance().ParseIncrementalFileByTypeFlag(AREGTYPE, info); + EXPECT_EQ(ret, DEFAULT_ERR); + EXPECT_TRUE(flag); + + tie(ret, flag, std::ignore) = UntarFile::GetInstance().ParseIncrementalFileByTypeFlag(SYMTYPE, info); + EXPECT_EQ(ret, 0); + EXPECT_TRUE(flag); + + info.fullPath = "/test/"; + EXPECT_CALL(*funcMock, access(_, _)).WillOnce(Return(0)); + tie(ret, flag, std::ignore) = UntarFile::GetInstance().ParseIncrementalFileByTypeFlag(DIRTYPE, info); + EXPECT_EQ(ret, 0); + EXPECT_FALSE(flag); + + info.fullPath = "/test/../test/"; + tie(ret, flag, std::ignore) = UntarFile::GetInstance().ParseIncrementalFileByTypeFlag(DIRTYPE, info); + EXPECT_EQ(ret, DEFAULT_ERR); + EXPECT_TRUE(flag); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "UntarFileSupTest-an exception occurred by ParseIncrementalFileByTypeFlag."; + } + GTEST_LOG_(INFO) << "UntarFileSupTest-end SUB_Untar_File_CreateDir_0100"; +} + +/** + * @tc.number: SUB_Untar_File_ParseIncrementalFileByTypeFlag_0200 + * @tc.name: SUB_Untar_File_ParseIncrementalFileByTypeFlag_0200 + * @tc.desc: 测试 ParseIncrementalFileByTypeFlag 接口 + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: I6F3GV + */ +HWTEST_F(UntarFileSupTest, SUB_Untar_File_ParseIncrementalFileByTypeFlag_0200, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "UntarFileSupTest-begin SUB_Untar_File_CreateDir_0100"; + UntarFile::GetInstance().rootPath_ = "rootPath"; + try { + FileStatInfo info; + UntarFile::GetInstance().tarFileSize_ = PATH_MAX_LEN + 1; + info.fullPath = "/test/../test/"; + auto [ret, flag, m] = UntarFile::GetInstance().ParseIncrementalFileByTypeFlag(GNUTYPE_LONGNAME, info); + EXPECT_EQ(ret, DEFAULT_ERR); + EXPECT_TRUE(flag); + + info.fullPath = "/test"; + tie(ret, flag, std::ignore) = UntarFile::GetInstance().ParseIncrementalFileByTypeFlag(GNUTYPE_LONGNAME, info); + EXPECT_EQ(ret, DEFAULT_ERR); + EXPECT_TRUE(flag); + + EXPECT_CALL(*funcMock, fseeko(_, _, _)).WillOnce(Return(0)); + tie(ret, flag, std::ignore) = UntarFile::GetInstance().ParseIncrementalFileByTypeFlag('6', info); + EXPECT_EQ(ret, 0); + EXPECT_TRUE(flag); + + EXPECT_CALL(*funcMock, fseeko(_, _, _)).WillOnce(Return(-1)); + tie(ret, flag, std::ignore) = UntarFile::GetInstance().ParseIncrementalFileByTypeFlag('6', info); + EXPECT_EQ(ret, DEFAULT_ERR); + EXPECT_TRUE(flag); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "UntarFileSupTest-an exception occurred by ParseIncrementalFileByTypeFlag."; + } + GTEST_LOG_(INFO) << "UntarFileSupTest-end SUB_Untar_File_CreateDir_0200"; +} + /** * @tc.number: SUB_Untar_File_IsValidTarBlock_0100 * @tc.name: SUB_Untar_File_IsValidTarBlock_0100 @@ -349,19 +588,50 @@ HWTEST_F(UntarFileSupTest, SUB_Untar_File_IsValidTarBlock_0200, testing::ext::Te HWTEST_F(UntarFileSupTest, SUB_Untar_File_CheckIfTarBlockValid_0100, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "UntarFileSupTest-begin SUB_Untar_File_CheckIfTarBlockValid_0100"; - char buff[BLOCK_SIZE] = {0}; - size_t buffLen = 0; - TarHeader *header {}; - int ret = 0; try { - EXPECT_EQ(UntarFile::GetInstance().CheckIfTarBlockValid(buff, buffLen, header, ret), false); - for (int i = 0; i < BLOCK_SIZE; i++) { - buff[i] = 'a' + i % 26; - } - EXPECT_EQ(UntarFile::GetInstance().CheckIfTarBlockValid(buff, buffLen, header, ret), false); + char buff[BLOCK_SIZE] = {0}; + size_t buffLen = 0; + TarHeader header; + int ret = 0; + + EXPECT_EQ(UntarFile::GetInstance().CheckIfTarBlockValid(nullptr, 0, nullptr, ret), false); + + EXPECT_EQ(UntarFile::GetInstance().CheckIfTarBlockValid(buff, 0, nullptr, ret), false); + buffLen = BLOCK_SIZE; - EXPECT_EQ(UntarFile::GetInstance().CheckIfTarBlockValid(buff, buffLen, header, ret), false); - EXPECT_TRUE(true); + EXPECT_EQ(UntarFile::GetInstance().CheckIfTarBlockValid(buff, buffLen, nullptr, ret), false); + + buff[0] = '0'; + EXPECT_CALL(*funcMock, ftello(_)).WillOnce(Return(0)); + EXPECT_EQ(UntarFile::GetInstance().CheckIfTarBlockValid(buff, buffLen, &header, ret), false); + + buff[0] = '\0'; + header.typeFlag = GNUTYPE_LONGNAME; + UntarFile::GetInstance().tarFileSize_ = 0; + EXPECT_CALL(*funcMock, ftello(_)).WillOnce(Return(READ_BUFF_SIZE + 1)); + EXPECT_EQ(UntarFile::GetInstance().CheckIfTarBlockValid(buff, buffLen, &header, ret), false); + + header.typeFlag = REGTYPE; + EXPECT_CALL(*funcMock, fread(_, _, _, _)).WillOnce(Return(0)); + EXPECT_CALL(*funcMock, ftello(_)).WillOnce(Return(0)); + EXPECT_EQ(UntarFile::GetInstance().CheckIfTarBlockValid(buff, buffLen, &header, ret), false); + + EXPECT_CALL(*funcMock, fread(_, _, _, _)).WillOnce(Return(BLOCK_SIZE)); + EXPECT_EQ(UntarFile::GetInstance().CheckIfTarBlockValid(buff, buffLen, &header, ret), false); + + EXPECT_CALL(*funcMock, fread(_, _, _, _)).WillOnce(WithArgs<0>(Invoke([](void* buff) { + (reinterpret_cast(buff))[0] = '0'; + return BLOCK_SIZE; + }))); + EXPECT_CALL(*funcMock, ftello(_)).WillOnce(Return(0)); + EXPECT_EQ(UntarFile::GetInstance().CheckIfTarBlockValid(buff, buffLen, &header, ret), false); + + string sum = "01647"; + header.typeFlag = 'x'; + memcpy_s(&header.magic, sizeof(header.magic), TMAGIC.c_str(), TMAGIC.length()); + memcpy_s(&header.chksum, sizeof(header.chksum), sum.c_str(), sum.length()); + buff[0] = '0'; + EXPECT_EQ(UntarFile::GetInstance().CheckIfTarBlockValid(buff, buffLen, &header, ret), true); } catch (...) { EXPECT_TRUE(false); GTEST_LOG_(INFO) << "UntarFileSupTest-an exception occurred by CheckIfTarBlockValid."; 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 95d726a20..e349a9e26 100644 --- a/tests/unittests/backup_sa/module_ipc/service_incremental_test.cpp +++ b/tests/unittests/backup_sa/module_ipc/service_incremental_test.cpp @@ -526,22 +526,58 @@ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_AppendBundlesIncremental EXPECT_EQ(service->AppendBundlesIncrementalBackupSession({}), BError(BError::Codes::SA_INVAL_ARG).GetCode()); service->session_ = session_; - vector bundleInfos {{ .allToBackup = true }}; + service->isOccupyingSession_ = true; + EXPECT_EQ(service->AppendBundlesIncrementalBackupSession({}), BError(BError::Codes::SA_INVAL_ARG).GetCode()); + + service->isOccupyingSession_ = false; + vector bundleInfos; EXPECT_CALL(*session, GetSessionUserId()).WillOnce(Return(0)).WillOnce(Return(0)); EXPECT_CALL(*bms, GetBundleInfosForAppend(_, _)).WillOnce(Return(bundleInfos)); EXPECT_EQ(service->AppendBundlesIncrementalBackupSession({}), BError(BError::Codes::OK).GetCode()); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by AppendBundlesIncrementalBackupSession."; + } + GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_AppendBundlesIncrementalBackupSession_0000"; +} - bundleInfos[0].allToBackup = false; +/** + * @tc.number: SUB_ServiceIncremental_AppendBundlesIncrementalBackupSession_0100 + * @tc.name: SUB_ServiceIncremental_AppendBundlesIncrementalBackupSession_0100 + * @tc.desc: 测试 AppendBundlesIncrementalBackupSession 的正常/异常分支 + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: issueIAKC3I + */ +HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_AppendBundlesIncrementalBackupSession_0100, TestSize.Level1) +{ + GTEST_LOG_(INFO) << + "ServiceIncrementalTest-begin SUB_ServiceIncremental_AppendBundlesIncrementalBackupSession_0100"; + try { + auto session_ = service->session_; + service->session_ = nullptr; + auto ret = service->AppendBundlesIncrementalBackupSession({}, {}); + EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode()); + service->session_ = session_; + + service->isOccupyingSession_ = true; + ret = service->AppendBundlesIncrementalBackupSession({}, {}); + EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode()); + + service->isOccupyingSession_ = false; + map> bundleNameDetailMap; + vector bundleInfos; EXPECT_CALL(*session, GetSessionUserId()).WillOnce(Return(0)).WillOnce(Return(0)); + EXPECT_CALL(*jsonUtil, BuildBundleInfos(_, _, _, _, _)).WillOnce(Return(bundleNameDetailMap)); EXPECT_CALL(*bms, GetBundleInfosForAppend(_, _)).WillOnce(Return(bundleInfos)); - EXPECT_CALL(*session, GetServiceReverseProxy()).WillOnce(Return(srProxy)); - EXPECT_CALL(*srProxy, IncrementalBackupOnBundleStarted(_, _)).WillOnce(Return()); - EXPECT_EQ(service->AppendBundlesIncrementalBackupSession({}), BError(BError::Codes::OK).GetCode()); + ret = service->AppendBundlesIncrementalBackupSession({}, {}); + EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode()); } catch (...) { EXPECT_TRUE(false); GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by AppendBundlesIncrementalBackupSession."; } - GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_AppendBundlesIncrementalBackupSession_0000"; + GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_AppendBundlesIncrementalBackupSession_0100"; } /** @@ -1094,4 +1130,77 @@ HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_SetCurrentBackupSessProp } GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_SetCurrentBackupSessProperties_0200"; } + +/** + * @tc.number: SUB_ServiceIncremental_Release_0000 + * @tc.name: SUB_ServiceIncremental_Release_0000 + * @tc.desc: 测试 Release 的正常/异常分支 + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: issueIAKC3I + */ +HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_Release_0000, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_Release_0000"; + try { + auto session_ = service->session_; + service->session_ = nullptr; + auto ret = service->Release(); + EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode()); + + service->session_ = session_; + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::RESTORE)); + EXPECT_CALL(*session, GetSessionUserId()).WillOnce(Return(0)); + ret = service->Release(); + EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode()); + + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::BACKUP)); + EXPECT_CALL(*session, GetSessionUserId()).WillOnce(Return(0)); + ret = service->Release(); + EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode()); + + EXPECT_CALL(*session, GetScenario()).WillOnce(Return(IServiceReverse::Scenario::UNDEFINED)); + ret = service->Release(); + EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode()); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by Release."; + } + GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_Release_0200"; +} + +/** + * @tc.number: SUB_ServiceIncremental_SetBundleIncDataInfo_0000 + * @tc.name: SUB_ServiceIncremental_SetBundleIncDataInfo_0000 + * @tc.desc: 测试 SetBundleIncDataInfo 的正常/异常分支 + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: issueIAKC3I + */ +HWTEST_F(ServiceIncrementalTest, SUB_ServiceIncremental_SetBundleIncDataInfo_0000, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "ServiceIncrementalTest-begin SUB_ServiceIncremental_SetBundleIncDataInfo_0000"; + try { + vector bundlesToBackup; + vector supportBundleNames; + service->SetBundleIncDataInfo(bundlesToBackup, supportBundleNames); + EXPECT_TRUE(true); + + BIncrementalData data; + data.bundleName = "bundleName"; + bundlesToBackup.push_back(data); + service->SetBundleIncDataInfo(bundlesToBackup, supportBundleNames); + EXPECT_TRUE(true); + + supportBundleNames.emplace_back("bundleName"); + service->SetBundleIncDataInfo(bundlesToBackup, supportBundleNames); + EXPECT_TRUE(true); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "ServiceIncrementalTest-an exception occurred by SetBundleIncDataInfo."; + } + GTEST_LOG_(INFO) << "ServiceIncrementalTest-end SUB_ServiceIncremental_SetBundleIncDataInfo_0200"; +} } \ No newline at end of file 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 dcd9e4407..ce2c88e40 100644 --- a/tests/unittests/backup_sa/module_ipc/sub_service_test.cpp +++ b/tests/unittests/backup_sa/module_ipc/sub_service_test.cpp @@ -1405,3 +1405,106 @@ HWTEST_F(ServiceTest, SUB_Service_SessionDeactive_0200, TestSize.Level1) } GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_SessionDeactive_0200"; } + +/** + * @tc.number: SUB_Service_StartExtTimer_0000 + * @tc.name: SUB_Service_StartExtTimer_0000 + * @tc.desc: 测试 StartExtTimer 的正常/异常分支 + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: issueIAKC3I + */ +HWTEST_F(ServiceTest, SUB_Service_StartExtTimer_0000, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_StartExtTimer_0000"; + try { + bool isExtStart = false; + auto session_ = service->session_; + service->session_ = nullptr; + auto ret = service->StartExtTimer(isExtStart); + EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode()); + + service->session_ = session_; + EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0)); + EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_HAP)); + EXPECT_CALL(*token, GetHapTokenInfo(_, _)).WillOnce(Return(0)); + EXPECT_CALL(*jsonUtil, BuildBundleNameIndexInfo(_, _)).WillOnce(Return("")); + EXPECT_CALL(*session, StopFwkTimer(_)).WillOnce(Return(true)); + EXPECT_CALL(*session, StartExtTimer(_, _)).WillOnce(Return(true)); + ret = service->StartExtTimer(isExtStart); + EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode()); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by StartExtTimer."; + } + GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_StartExtTimer_0000"; +} + +/** + * @tc.number: SUB_Service_StartFwkTimer_0000 + * @tc.name: SUB_Service_StartFwkTimer_0000 + * @tc.desc: 测试 StartFwkTimer 的正常/异常分支 + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: issueIAKC3I + */ +HWTEST_F(ServiceTest, SUB_Service_StartFwkTimer_0000, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_StartFwkTimer_0000"; + try { + bool isFwkStart = false; + auto session_ = service->session_; + service->session_ = nullptr; + auto ret = service->StartFwkTimer(isFwkStart); + EXPECT_EQ(ret, BError(BError::Codes::SA_INVAL_ARG).GetCode()); + + service->session_ = session_; + EXPECT_CALL(*skeleton, GetCallingTokenID()).WillOnce(Return(0)); + EXPECT_CALL(*token, GetTokenType(_)).WillOnce(Return(Security::AccessToken::ATokenTypeEnum::TOKEN_HAP)); + EXPECT_CALL(*token, GetHapTokenInfo(_, _)).WillOnce(Return(0)); + EXPECT_CALL(*jsonUtil, BuildBundleNameIndexInfo(_, _)).WillOnce(Return("")); + EXPECT_CALL(*session, StopExtTimer(_)).WillOnce(Return(true)); + EXPECT_CALL(*session, StartFwkTimer(_, _)).WillOnce(Return(true)); + ret = service->StartFwkTimer(isFwkStart); + EXPECT_EQ(ret, BError(BError::Codes::OK).GetCode()); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by StartFwkTimer."; + } + GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_StartFwkTimer_0000"; +} + +/** + * @tc.number: SUB_Service_TimeoutRadarReport_0000 + * @tc.name: SUB_Service_TimeoutRadarReport_0000 + * @tc.desc: 测试 TimeoutRadarReport 的正常/异常分支 + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: issueIAKC3I + */ +HWTEST_F(ServiceTest, SUB_Service_TimeoutRadarReport_0000, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "ServiceTest-begin SUB_Service_TimeoutRadarReport_0000"; + try { + string bundleName; + EXPECT_CALL(*param, GetBackupDebugOverrideAccount()) + .WillOnce(Return(make_pair(true, DEBUG_ID + 1))); + service->TimeoutRadarReport(IServiceReverse::Scenario::BACKUP, bundleName); + EXPECT_TRUE(true); + + EXPECT_CALL(*param, GetBackupDebugOverrideAccount()) + .WillOnce(Return(make_pair(true, DEBUG_ID + 1))); + service->TimeoutRadarReport(IServiceReverse::Scenario::RESTORE, bundleName); + EXPECT_TRUE(true); + + service->TimeoutRadarReport(IServiceReverse::Scenario::UNDEFINED, bundleName); + EXPECT_TRUE(true); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "ServiceTest-an exception occurred by TimeoutRadarReport."; + } + GTEST_LOG_(INFO) << "ServiceTest-end SUB_Service_TimeoutRadarReport_0000"; +} \ No newline at end of file -- Gitee