diff --git a/tests/unittests/backup_utils/b_error/b_error_test.cpp b/tests/unittests/backup_utils/b_error/b_error_test.cpp index be2638eae4aa0fd13866339757b1b463a8ded6e7..d48c401d7f3cfe0a1db5e3bb6ca29dcaecad66a0 100644 --- a/tests/unittests/backup_utils/b_error/b_error_test.cpp +++ b/tests/unittests/backup_utils/b_error/b_error_test.cpp @@ -93,6 +93,98 @@ HWTEST_F(BErrorTest, b_error_construction_0500, testing::ext::TestSize.Level0) GTEST_LOG_(INFO) << "BErrorTest-end b_error_construction_0500"; } +/** + * @tc.number: SUB_backup_b_error_construction_0700 + * @tc.name: b_error_construction_0700 + * @tc.desc: Test function of construction interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 0 + * @tc.require: I6F3GV + */ +HWTEST_F(BErrorTest, b_error_construction_0700, testing::ext::TestSize.Level0) +{ + GTEST_LOG_(INFO) << "BErrorTest-begin b_error_construction_0700"; + try { + throw BError(BError::Codes::UTILS_INVAL_FILE_HANDLE); + EXPECT_TRUE(false); + } catch (const BError &e) { + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "BErrorTest-an exception occurred by construction."; + } + GTEST_LOG_(INFO) << "BErrorTest-end b_error_construction_0700"; +} + +/** + * @tc.number: SUB_backup_b_error_construction_0900 + * @tc.name: b_error_construction_0900 + * @tc.desc: Test function of construction interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 0 + * @tc.require: I6F3GV + */ +HWTEST_F(BErrorTest, b_error_construction_0900, testing::ext::TestSize.Level0) +{ + GTEST_LOG_(INFO) << "BErrorTest-begin b_error_construction_0900"; + try { + throw BError(BError::Codes::UTILS_INVAL_TARBALL_ARG); + EXPECT_TRUE(false); + } catch (const BError &e) { + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "BErrorTest-an exception occurred by construction."; + } + GTEST_LOG_(INFO) << "BErrorTest-end b_error_construction_0900"; +} + +/** + * @tc.number: SUB_backup_b_error_construction_0200 + * @tc.name: b_error_construction_0200 + * @tc.desc: Test function of construction interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 0 + * @tc.require: I6F3GV + */ +HWTEST_F(BErrorTest, b_error_construction_0200, testing::ext::TestSize.Level0) +{ + GTEST_LOG_(INFO) << "BErrorTest-begin b_error_construction_0200"; + try { + throw BError(BError::Codes::UTILS_INVAL_PROCESS_ARG); + EXPECT_TRUE(false); + } catch (const BError &e) { + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "BErrorTest-an exception occurred by construction."; + } + GTEST_LOG_(INFO) << "BErrorTest-end b_error_construction_0200"; +} + +/** + * @tc.number: SUB_backup_b_error_construction_0400 + * @tc.name: b_error_construction_0400 + * @tc.desc: Test function of construction interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 0 + * @tc.require: I6F3GV + */ +HWTEST_F(BErrorTest, b_error_construction_0400, testing::ext::TestSize.Level0) +{ + GTEST_LOG_(INFO) << "BErrorTest-begin b_error_construction_0400"; + try { + throw BError(BError::Codes::UTILS_INTERRUPTED_PROCESS); + EXPECT_TRUE(false); + } catch (const BError &e) { + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "BErrorTest-an exception occurred by construction."; + } + GTEST_LOG_(INFO) << "BErrorTest-end b_error_construction_0400"; +} + /** * @tc.number: SUB_backup_b_error_GetCode_0100 * @tc.name: b_error_GetCode_0100 @@ -111,6 +203,96 @@ HWTEST_F(BErrorTest, b_error_GetCode_0100, testing::ext::TestSize.Level0) GTEST_LOG_(INFO) << "BErrorTest-end b_error_GetCode_0100"; } +/** + * @tc.number: SUB_backup_b_error_GetCode_0200 + * @tc.name: b_error_GetCode_0200 + * @tc.desc: Test function of GetCode interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 0 + * @tc.require: I6F3GV + */ +HWTEST_F(BErrorTest, b_error_GetCode_0200, testing::ext::TestSize.Level0) +{ + GTEST_LOG_(INFO) << "BErrorTest-begin b_error_GetCode_0200"; + BError be(BError::Codes::UTILS_INVAL_JSON_ENTITY); + int ret = be.GetCode(); + EXPECT_EQ(ret, BError::BackupErrorCode::E_INVAL); + GTEST_LOG_(INFO) << "BErrorTest-end b_error_GetCode_0200"; +} + +/** + * @tc.number: SUB_backup_b_error_GetCode_0300 + * @tc.name: b_error_GetCode_0300 + * @tc.desc: Test function of GetCode interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 0 + * @tc.require: I6F3GV + */ +HWTEST_F(BErrorTest, b_error_GetCode_0300, testing::ext::TestSize.Level0) +{ + GTEST_LOG_(INFO) << "BErrorTest-begin b_error_GetCode_0300"; + BError be(BError::Codes::UTILS_INVAL_FILE_HANDLE); + int ret = be.GetCode(); + EXPECT_EQ(ret, BError::BackupErrorCode::E_INVAL); + GTEST_LOG_(INFO) << "BErrorTest-end b_error_GetCode_0300"; +} + +/** + * @tc.number: SUB_backup_b_error_GetCode_0400 + * @tc.name: b_error_GetCode_0400 + * @tc.desc: Test function of GetCode interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 0 + * @tc.require: I6F3GV + */ +HWTEST_F(BErrorTest, b_error_GetCode_0400, testing::ext::TestSize.Level0) +{ + GTEST_LOG_(INFO) << "BErrorTest-begin b_error_GetCode_0400"; + BError be(BError::Codes::UTILS_INVAL_TARBALL_ARG); + int ret = be.GetCode(); + EXPECT_EQ(ret, BError::BackupErrorCode::E_UKERR); + GTEST_LOG_(INFO) << "BErrorTest-end b_error_GetCode_0400"; +} + +/** + * @tc.number: SUB_backup_b_error_GetCode_0500 + * @tc.name: b_error_GetCode_0500 + * @tc.desc: Test function of GetCode interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 0 + * @tc.require: I6F3GV + */ +HWTEST_F(BErrorTest, b_error_GetCode_0500, testing::ext::TestSize.Level0) +{ + GTEST_LOG_(INFO) << "BErrorTest-begin b_error_GetCode_0500"; + BError be(BError::Codes::UTILS_INVAL_PROCESS_ARG); + int ret = be.GetCode(); + EXPECT_EQ(ret, BError::BackupErrorCode::E_UKERR); + GTEST_LOG_(INFO) << "BErrorTest-end b_error_GetCode_0500"; +} + +/** + * @tc.number: SUB_backup_b_error_GetCode_0600 + * @tc.name: b_error_GetCode_0600 + * @tc.desc: Test function of GetCode interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 0 + * @tc.require: I6F3GV + */ +HWTEST_F(BErrorTest, b_error_GetCode_0600, testing::ext::TestSize.Level0) +{ + GTEST_LOG_(INFO) << "BErrorTest-begin b_error_GetCode_0600"; + BError be(BError::Codes::UTILS_INTERRUPTED_PROCESS); + int ret = be.GetCode(); + EXPECT_EQ(ret, BError::BackupErrorCode::E_UKERR); + GTEST_LOG_(INFO) << "BErrorTest-end b_error_GetCode_0600"; +} + /** * @tc.number: SUB_backup_b_error_GetRawCode_0100 * @tc.name: b_error_GetRawCode_0100 @@ -129,6 +311,96 @@ HWTEST_F(BErrorTest, b_error_GetRawCode_0100, testing::ext::TestSize.Level0) GTEST_LOG_(INFO) << "BErrorTest-end b_error_GetRawCode_0100"; } +/** + * @tc.number: SUB_backup_b_error_GetRawCode_0200 + * @tc.name: b_error_GetRawCode_0200 + * @tc.desc: Test function of GetRawCode interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 0 + * @tc.require: I6F3GV + */ +HWTEST_F(BErrorTest, b_error_GetRawCode_0200, testing::ext::TestSize.Level0) +{ + GTEST_LOG_(INFO) << "BErrorTest-begin b_error_GetRawCode_0200"; + BError be(BError::Codes::UTILS_INVAL_JSON_ENTITY); + BError::Codes result = be.GetRawCode(); + EXPECT_EQ(result, BError::Codes::UTILS_INVAL_JSON_ENTITY); + GTEST_LOG_(INFO) << "BErrorTest-end b_error_GetRawCode_0200"; +} + +/** + * @tc.number: SUB_backup_b_error_GetRawCode_0300 + * @tc.name: b_error_GetRawCode_0300 + * @tc.desc: Test function of GetRawCode interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 0 + * @tc.require: I6F3GV + */ +HWTEST_F(BErrorTest, b_error_GetRawCode_0300, testing::ext::TestSize.Level0) +{ + GTEST_LOG_(INFO) << "BErrorTest-begin b_error_GetRawCode_0300"; + BError be(BError::Codes::UTILS_INVAL_FILE_HANDLE); + BError::Codes result = be.GetRawCode(); + EXPECT_EQ(result, BError::Codes::UTILS_INVAL_FILE_HANDLE); + GTEST_LOG_(INFO) << "BErrorTest-end b_error_GetRawCode_0300"; +} + +/** + * @tc.number: SUB_backup_b_error_GetRawCode_0400 + * @tc.name: b_error_GetRawCode_0400 + * @tc.desc: Test function of GetRawCode interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 0 + * @tc.require: I6F3GV + */ +HWTEST_F(BErrorTest, b_error_GetRawCode_0400, testing::ext::TestSize.Level0) +{ + GTEST_LOG_(INFO) << "BErrorTest-begin b_error_GetRawCode_0400"; + BError be(BError::Codes::UTILS_INVAL_TARBALL_ARG); + BError::Codes result = be.GetRawCode(); + EXPECT_EQ(result, BError::Codes::UTILS_INVAL_TARBALL_ARG); + GTEST_LOG_(INFO) << "BErrorTest-end b_error_GetRawCode_0400"; +} + +/** + * @tc.number: SUB_backup_b_error_GetRawCode_0500 + * @tc.name: b_error_GetRawCode_0500 + * @tc.desc: Test function of GetRawCode interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 0 + * @tc.require: I6F3GV + */ +HWTEST_F(BErrorTest, b_error_GetRawCode_0500, testing::ext::TestSize.Level0) +{ + GTEST_LOG_(INFO) << "BErrorTest-begin b_error_GetRawCode_0500"; + BError be(BError::Codes::UTILS_INVAL_PROCESS_ARG); + BError::Codes result = be.GetRawCode(); + EXPECT_EQ(result, BError::Codes::UTILS_INVAL_PROCESS_ARG); + GTEST_LOG_(INFO) << "BErrorTest-end b_error_GetRawCode_0500"; +} + +/** + * @tc.number: SUB_backup_b_error_GetRawCode_0600 + * @tc.name: b_error_GetRawCode_0600 + * @tc.desc: Test function of GetRawCode interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 0 + * @tc.require: I6F3GV + */ +HWTEST_F(BErrorTest, b_error_GetRawCode_0600, testing::ext::TestSize.Level0) +{ + GTEST_LOG_(INFO) << "BErrorTest-begin b_error_GetRawCode_0600"; + BError be(BError::Codes::UTILS_INTERRUPTED_PROCESS); + BError::Codes result = be.GetRawCode(); + EXPECT_EQ(result, BError::Codes::UTILS_INTERRUPTED_PROCESS); + GTEST_LOG_(INFO) << "BErrorTest-end b_error_GetRawCode_0600"; +} + /** * @tc.number: SUB_backup_b_error_what_0100 * @tc.name: b_error_what_0100 diff --git a/tests/unittests/backup_utils/b_filesystem/b_dir_test.cpp b/tests/unittests/backup_utils/b_filesystem/b_dir_test.cpp index f89595510d083390afd03c5fb04b736597362cc3..4db35de4204f0dd5aac6940ce228e601230cb5be 100644 --- a/tests/unittests/backup_utils/b_filesystem/b_dir_test.cpp +++ b/tests/unittests/backup_utils/b_filesystem/b_dir_test.cpp @@ -76,6 +76,36 @@ HWTEST_F(BDirTest, b_dir_GetDirFiles_0100, testing::ext::TestSize.Level0) GTEST_LOG_(INFO) << "BDirTest-end b_dir_GetDirFiles_0100"; } +HWTEST_F(BDirTest, b_dir_GetDirFiles_0104, testing::ext::TestSize.Level0) +{ + GTEST_LOG_(INFO) << "BDirTest-begin b_dir_GetDirFiles_0104"; + try { + TestManager tm("b_dir_GetDirFiles_0104"); + + string preparedDir = "/data/app/"; + string touchFilePrefix = string("touch ") + preparedDir; + system(touchFilePrefix.append("a.txt").c_str()); + system(touchFilePrefix.append("b.txt").c_str()); + system(touchFilePrefix.append("c.txt").c_str()); + + bool bSucc; + vector out; + tie(bSucc, out) = BDir::GetDirFiles(preparedDir); + + vector expectedRes = {preparedDir.append("a.txt"), preparedDir.append("b.txt"), + preparedDir.append("c.txt")}; + EXPECT_EQ(out, expectedRes); + + tie(bSucc, out) = BDir::GetDirFiles("dev"); + EXPECT_EQ(bSucc, true); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "BDirTest-an exception occurred."; + } + GTEST_LOG_(INFO) << "BDirTest-end b_dir_GetDirFiles_0104"; +} + + /** * @tc.number: SUB_backup_b_dir_GetBigFiles_0100 * @tc.name: b_dir_GetBigFiles_0100 @@ -139,6 +169,105 @@ HWTEST_F(BDirTest, b_dir_GetBigFiles_0200, testing::ext::TestSize.Level1) GTEST_LOG_(INFO) << "BDirTest-end b_dir_GetBigFiles_0200"; } +/** + * @tc.number: SUB_backup_b_dir_GetBigFiles_0201 + * @tc.name: b_dir_GetBigFiles_0201 + * @tc.desc: 测试GetBigFiles接口 分支逻辑 + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: I6F3GV + */ +HWTEST_F(BDirTest, b_dir_GetBigFiles_0201, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "BDirTest-begin b_dir_GetBigFiles_0201"; + try { + vector includes = {"/data/"}; + vector excludes; + auto [errCode, mpNameToStat, smallFiles] = BDir::GetBigFiles(includes, excludes); + EXPECT_EQ(errCode, ERR_OK); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "BDirTest-an exception occurred."; + } + GTEST_LOG_(INFO) << "BDirTest-end b_dir_GetBigFiles_0201"; +} + +/** + * @tc.number: SUB_backup_b_dir_GetBigFiles_0202 + * @tc.name: b_dir_GetBigFiles_0202 + * @tc.desc: 测试GetBigFiles接口 分支逻辑 + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: I6F3GV + */ +HWTEST_F(BDirTest, b_dir_GetBigFiles_0202, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "BDirTest-begin b_dir_GetBigFiles_0202"; + try { + vector includes = {"/data/app/"}; + vector excludes; + auto [errCode, mpNameToStat, smallFiles] = BDir::GetBigFiles(includes, excludes); + EXPECT_EQ(errCode, ERR_OK); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "BDirTest-an exception occurred."; + } + GTEST_LOG_(INFO) << "BDirTest-end b_dir_GetBigFiles_0202"; +} + +/** + * @tc.number: SUB_backup_b_dir_GetBigFiles_0203 + * @tc.name: b_dir_GetBigFiles_0203 + * @tc.desc: 测试GetBigFiles接口 分支逻辑 + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: I6F3GV + */ +HWTEST_F(BDirTest, b_dir_GetBigFiles_0203, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "BDirTest-begin b_dir_GetBigFiles_0203"; + try { + vector includes; + vector excludes; + const string str = ""; + auto [errCode, mpNameToStat, smallFiles] = BDir::GetBigFiles(includes, excludes); + EXPECT_EQ(errCode, ERR_OK); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "BDirTest-an exception occurred."; + } + GTEST_LOG_(INFO) << "BDirTest-end b_dir_GetBigFiles_0203"; +} + +// /** +// * @tc.number: SUB_backup_b_dir_GetBigFiles_0204 +// * @tc.name: b_dir_GetBigFiles_0204 +// * @tc.desc: 测试GetBigFiles接口 分支逻辑 +// * @tc.size: MEDIUM +// * @tc.type: FUNC +// * @tc.level Level 1 +// * @tc.require: I6F3GV +// */ +// HWTEST_F(BDirTest, b_dir_GetBigFiles_0204, testing::ext::TestSize.Level1) +// { +// GTEST_LOG_(INFO) << "BDirTest-begin b_dir_GetBigFiles_0204"; +// try { +// vector includes; +// vector excludes; +// const string item = "app"; +// const string str = "app"; +// auto [errCode, mpNameToStat, smallFiles] = BDir::GetBigFiles(includes, excludes); +// EXPECT_EQ(errCode, ERR_OK); +// } catch (...) { +// EXPECT_TRUE(false); +// GTEST_LOG_(INFO) << "BDirTest-an exception occurred."; +// } +// GTEST_LOG_(INFO) << "BDirTest-end b_dir_GetBigFiles_0204"; +// } + /** * @tc.number: SUB_backup_b_dir_GetBigFiles_0300 * @tc.name: b_dir_GetBigFiles_0300 @@ -179,4 +308,55 @@ HWTEST_F(BDirTest, b_dir_GetBigFiles_0300, testing::ext::TestSize.Level1) } GTEST_LOG_(INFO) << "BDirTest-end b_dir_GetBigFiles_0300"; } + +/** + * @tc.number: SUB_backup_b_dir_GetDirs_0100 + * @tc.name: b_dir_GetDirs_0100 + * @tc.desc: Test function of GetDirs interface for SUCCESS + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: I6F3GV + */ +HWTEST_F(BDirTest, b_dir_GetDirs_0100, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "BDirTest-begin b_dir_GetDirs_0100"; + try { + TestManager tm("b_dir_GetDirs_0100"); + vector paths; + vector res = BDir::GetDirs(paths); + set inc(paths.begin(), paths.end()); + bool result = equal(inc.begin(), inc.end(), res.begin(), res.end()); + EXPECT_EQ(1, result); + EXPECT_EQ(inc.size(), res.size()); + } catch (...) { + GTEST_LOG_(INFO) << "BDirTest-an exception occurred."; + } + GTEST_LOG_(INFO) << "BDirTest-end b_dir_GetDirs_0100"; +} + +/** + * @tc.number: SUB_backup_b_dir_GetDirs_0200 + * @tc.name: b_dir_GetDirs_0200 + * @tc.desc: Test function of GetDirs interface for SUCCESS + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: I6F3GV + */ +HWTEST_F(BDirTest, b_dir_GetDirs_0200, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "BDirTest-begin b_dir_GetDirs_0200"; + try { + TestManager tm("b_dir_GetDirs_0200"); + vector paths; + const string pattern = "app"; + vector res = BDir::GetDirs(paths); + set inc(paths.begin(), paths.end()); + EXPECT_EQ(inc.size(), res.size()); + } catch (...) { + GTEST_LOG_(INFO) << "BDirTest-an exception occurred."; + } + GTEST_LOG_(INFO) << "BDirTest-end b_dir_GetDirs_0200"; +} } // namespace OHOS::FileManagement::Backup \ No newline at end of file diff --git a/tests/unittests/backup_utils/b_filesystem/b_file_test.cpp b/tests/unittests/backup_utils/b_filesystem/b_file_test.cpp index 813e72c0cb6d86ca7e5dc59893438d0d0f4b8224..5708ff7609b0b37bc75733df4221582e7be14dc4 100644 --- a/tests/unittests/backup_utils/b_filesystem/b_file_test.cpp +++ b/tests/unittests/backup_utils/b_filesystem/b_file_test.cpp @@ -133,4 +133,31 @@ HWTEST_F(BFileTest, b_file_CopyFile_0100, testing::ext::TestSize.Level1) } GTEST_LOG_(INFO) << "BFileTest-end b_file_CopyFile_0100"; } + +/** + * @tc.number: SUB_backup_b_file_Write_0100 + * @tc.name: b_file_Write_0100 + * @tc.desc: 测试Write接口 + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: I6F3GV + */ +HWTEST_F(BFileTest, b_file_Write_0100, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "BFileTest-begin b_file_Write_0100"; + try { + TestManager tm(__func__); + const auto [filePath, content] = GetTestFile(tm); + TestManager tmInFile("b_file_GetFd_0200"); + string fileInPath = tmInFile.GetRootDirCurTest().append("1.txt"); + BFile::Write(UniqueFd(open(filePath.data(), O_RDWR)), fileInPath); + string contentTmp = BFile::ReadFile(UniqueFd(open(fileInPath.c_str(), O_RDONLY))).get(); + EXPECT_EQ(contentTmp, fileInPath); + } catch (const exception &e) { + GTEST_LOG_(INFO) << "BFileTest-an exception occurred by Write."; + e.what(); + } + GTEST_LOG_(INFO) << "BFileTest-end b_file_Write_0100"; +} } // namespace OHOS::FileManagement::Backup \ No newline at end of file diff --git a/tests/unittests/backup_utils/b_json/b_json_cached_entity_test.cpp b/tests/unittests/backup_utils/b_json/b_json_cached_entity_test.cpp index 3aa8898c6f3e1dc0009cf9e95d3f80b7363df16a..90ecf60d604c0f1862650876a6c13b66268a5870 100644 --- a/tests/unittests/backup_utils/b_json/b_json_cached_entity_test.cpp +++ b/tests/unittests/backup_utils/b_json/b_json_cached_entity_test.cpp @@ -59,6 +59,181 @@ HWTEST_F(BJsonCachedEntityTest, b_json_construction_0100, testing::ext::TestSize GTEST_LOG_(INFO) << "BJsonCachedEntityTest-end b_json_construction_0100"; } +/** + * @tc.number: SUB_backup_b_json_construction_0101 + * @tc.name: b_json_construction_0101 + * @tc.desc: Test function of construction interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 0 + * @tc.require: I6F3GV + */ +HWTEST_F(BJsonCachedEntityTest, b_json_construction_0101, testing::ext::TestSize.Level0) +{ + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-begin b_json_construction_0101"; + try { + TestManager tm("b_json_construction_0101"); + + std::string path = tm.GetRootDirCurTest(); + std::string filePath = path + ""; + BJsonCachedEntity jce(UniqueFd(open(filePath.data(), O_RDWR | O_CREAT, 0600))); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-an exception occurred by construction."; + } + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-end b_json_construction_0101"; +} + +/** + * @tc.number: SUB_backup_b_json_construction_0102 + * @tc.name: b_json_construction_0102 + * @tc.desc: Test function of construction interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 0 + * @tc.require: I6F3GV + */ +HWTEST_F(BJsonCachedEntityTest, b_json_construction_0102, testing::ext::TestSize.Level0) +{ + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-begin b_json_construction_0102"; + try { + TestManager tm("b_json_construction_0102"); + + std::string path = tm.GetRootDirCurTest(); + std::string filePath = path + ".json"; + BJsonCachedEntity jce(UniqueFd(open(filePath.data(), O_RDWR | O_CREAT, NULL))); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-an exception occurred by construction."; + } + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-end b_json_construction_0102"; +} + +/** + * @tc.number: SUB_backup_b_json_construction_0103 + * @tc.name: b_json_construction_0103 + * @tc.desc: Test function of construction interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 0 + * @tc.require: I6F3GV + */ +HWTEST_F(BJsonCachedEntityTest, b_json_construction_0103, testing::ext::TestSize.Level0) +{ + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-begin b_json_construction_0103"; + try { + TestManager tm("b_json_construction_0103"); + + std::string path = tm.GetRootDirCurTest(); + std::string filePath = path + ".json"; + BJsonCachedEntity jce(UniqueFd(open(filePath.data(), O_RDWR | O_CREAT, 0600))); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-an exception occurred by construction."; + } + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-end b_json_construction_0103"; +} + +/** + * @tc.number: SUB_backup_b_json_construction_0104 + * @tc.name: b_json_construction_0104 + * @tc.desc: Test function of construction interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 0 + * @tc.require: I6F3GV + */ +HWTEST_F(BJsonCachedEntityTest, b_json_construction_0104, testing::ext::TestSize.Level0) +{ + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-begin b_json_construction_0104"; + try { + TestManager tm("b_json_construction_0104"); + + std::string path = tm.GetRootDirCurTest(); + std::string filePath = path + ".json"; + BJsonCachedEntity jce(UniqueFd(open(filePath.data(), O_RDONLY, NULL))); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-an exception occurred by construction."; + } + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-end b_json_construction_0104"; +} + +/** + * @tc.number: SUB_backup_b_json_construction_0105 + * @tc.name: b_json_construction_0105 + * @tc.desc: Test function of construction interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 0 + * @tc.require: I6F3GV + */ +HWTEST_F(BJsonCachedEntityTest, b_json_construction_0105, testing::ext::TestSize.Level0) +{ + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-begin b_json_construction_0105"; + try { + TestManager tm("b_json_construction_0105"); + + std::string path = tm.GetRootDirCurTest(); + std::string filePath = path + ""; + BJsonCachedEntity jce(UniqueFd(open(filePath.data(), O_RDWR | O_CREAT, NULL))); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-an exception occurred by construction."; + } + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-end b_json_construction_0105"; +} + +/** + * @tc.number: SUB_backup_b_json_construction_0106 + * @tc.name: b_json_construction_0106 + * @tc.desc: Test function of construction interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 0 + * @tc.require: I6F3GV + */ +HWTEST_F(BJsonCachedEntityTest, b_json_construction_0106, testing::ext::TestSize.Level0) +{ + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-begin b_json_construction_0106"; + try { + TestManager tm("b_json_construction_0106"); + + std::string path = tm.GetRootDirCurTest(); + std::string filePath = path + ""; + BJsonCachedEntity jce(UniqueFd(open(filePath.data(), O_RDONLY, 0600))); + } catch (...) { + EXPECT_TRUE(true); + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-an exception occurred by construction."; + } + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-end b_json_construction_0106"; +} + +/** + * @tc.number: SUB_backup_b_json_construction_0107 + * @tc.name: b_json_construction_0107 + * @tc.desc: Test function of construction interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 0 + * @tc.require: I6F3GV + */ +HWTEST_F(BJsonCachedEntityTest, b_json_construction_0107, testing::ext::TestSize.Level0) +{ + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-begin b_json_construction_0107"; + try { + TestManager tm("b_json_construction_0107"); + + std::string path = tm.GetRootDirCurTest(); + std::string filePath = path + ""; + BJsonCachedEntity jce(UniqueFd(open(filePath.data(), O_RDONLY, NULL))); + } catch (...) { + EXPECT_TRUE(true); + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-an exception occurred by construction."; + } + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-end b_json_construction_0107"; +} + /** * @tc.number: SUB_backup_b_json_Structuralize_0100 * @tc.name: b_json_Structuralize_0100 @@ -85,6 +260,188 @@ HWTEST_F(BJsonCachedEntityTest, b_json_Structuralize_0100, testing::ext::TestSiz GTEST_LOG_(INFO) << "BJsonCachedEntityTest-end b_json_Structuralize_0100"; } +/** + * @tc.number: SUB_backup_b_json_Structuralize_0101 + * @tc.name: b_json_Structuralize_0101 + * @tc.desc: Test function of Structuralize interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 0 + * @tc.require: I6F3GV + */ +HWTEST_F(BJsonCachedEntityTest, b_json_Structuralize_0101, testing::ext::TestSize.Level0) +{ + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-begin b_json_Structuralize_0101"; + try { + TestManager tm("b_json_Structuralize_0101"); + + std::string path = tm.GetRootDirCurTest(); + std::string filePath = path + ""; + BJsonCachedEntity jce(UniqueFd(open(filePath.data(), O_RDWR | O_CREAT, 0600))); + jce.Structuralize(); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-an exception occurred."; + } + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-end b_json_Structuralize_0101"; +} + +/** + * @tc.number: SUB_backup_b_json_Structuralize_0102 + * @tc.name: b_json_Structuralize_0102 + * @tc.desc: Test function of Structuralize interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 0 + * @tc.require: I6F3GV + */ +HWTEST_F(BJsonCachedEntityTest, b_json_Structuralize_0102, testing::ext::TestSize.Level0) +{ + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-begin b_json_Structuralize_0102"; + try { + TestManager tm("b_json_Structuralize_0102"); + + std::string path = tm.GetRootDirCurTest(); + std::string filePath = path + ".json"; + BJsonCachedEntity jce(UniqueFd(open(filePath.data(), O_RDWR | O_CREAT, NULL))); + jce.Structuralize(); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-an exception occurred."; + } + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-end b_json_Structuralize_0102"; +} + +/** + * @tc.number: SUB_backup_b_json_Structuralize_0103 + * @tc.name: b_json_Structuralize_0103 + * @tc.desc: Test function of Structuralize interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 0 + * @tc.require: I6F3GV + */ +HWTEST_F(BJsonCachedEntityTest, b_json_Structuralize_0103, testing::ext::TestSize.Level0) +{ + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-begin b_json_Structuralize_0103"; + try { + TestManager tm("b_json_Structuralize_0103"); + + std::string path = tm.GetRootDirCurTest(); + std::string filePath = path + ".json"; + BJsonCachedEntity jce(UniqueFd(open(filePath.data(), O_RDONLY, 0600))); + jce.Structuralize(); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-an exception occurred."; + } + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-end b_json_Structuralize_0103"; +} + +/** + * @tc.number: SUB_backup_b_json_Structuralize_0104 + * @tc.name: b_json_Structuralize_0104 + * @tc.desc: Test function of Structuralize interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 0 + * @tc.require: I6F3GV + */ +HWTEST_F(BJsonCachedEntityTest, b_json_Structuralize_0104, testing::ext::TestSize.Level0) +{ + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-begin b_json_Structuralize_0104"; + try { + TestManager tm("b_json_Structuralize_0104"); + + std::string path = tm.GetRootDirCurTest(); + std::string filePath = path + ""; + BJsonCachedEntity jce(UniqueFd(open(filePath.data(), O_RDWR | O_CREAT, NULL))); + jce.Structuralize(); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-an exception occurred."; + } + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-end b_json_Structuralize_0104"; +} + +/** + * @tc.number: SUB_backup_b_json_Structuralize_0105 + * @tc.name: b_json_Structuralize_0105 + * @tc.desc: Test function of Structuralize interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 0 + * @tc.require: I6F3GV + */ +HWTEST_F(BJsonCachedEntityTest, b_json_Structuralize_0105, testing::ext::TestSize.Level0) +{ + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-begin b_json_Structuralize_0105"; + try { + TestManager tm("b_json_Structuralize_0105"); + + std::string path = tm.GetRootDirCurTest(); + std::string filePath = path + ""; + BJsonCachedEntity jce(UniqueFd(open(filePath.data(), O_RDONLY, 0600))); + jce.Structuralize(); + } catch (...) { + EXPECT_TRUE(true); + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-an exception occurred."; + } + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-end b_json_Structuralize_0105"; +} + +/** + * @tc.number: SUB_backup_b_json_Structuralize_0106 + * @tc.name: b_json_Structuralize_0106 + * @tc.desc: Test function of Structuralize interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 0 + * @tc.require: I6F3GV + */ +HWTEST_F(BJsonCachedEntityTest, b_json_Structuralize_0106, testing::ext::TestSize.Level0) +{ + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-begin b_json_Structuralize_0106"; + try { + TestManager tm("b_json_Structuralize_0106"); + + std::string path = tm.GetRootDirCurTest(); + std::string filePath = path + ".json"; + BJsonCachedEntity jce(UniqueFd(open(filePath.data(), O_RDONLY, NULL))); + jce.Structuralize(); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-an exception occurred."; + } + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-end b_json_Structuralize_0106"; +} + +/** + * @tc.number: SUB_backup_b_json_Structuralize_0107 + * @tc.name: b_json_Structuralize_0107 + * @tc.desc: Test function of Structuralize interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 0 + * @tc.require: I6F3GV + */ +HWTEST_F(BJsonCachedEntityTest, b_json_Structuralize_0107, testing::ext::TestSize.Level0) +{ + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-begin b_json_Structuralize_0107"; + try { + TestManager tm("b_json_Structuralize_0107"); + + std::string path = tm.GetRootDirCurTest(); + std::string filePath = path + ""; + BJsonCachedEntity jce(UniqueFd(open(filePath.data(), O_RDONLY, NULL))); + jce.Structuralize(); + } catch (...) { + EXPECT_TRUE(true); + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-an exception occurred."; + } + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-end b_json_Structuralize_0107"; +} + /** * @tc.number: SUB_backup_b_json_GetFd_0100 * @tc.name: b_json_GetFd_0100 @@ -110,4 +467,819 @@ HWTEST_F(BJsonCachedEntityTest, b_json_GetFd_0100, testing::ext::TestSize.Level0 } GTEST_LOG_(INFO) << "BJsonCachedEntityTest-end b_json_GetFd_0100"; } + +/** + * @tc.number: SUB_backup_b_json_GetFd_0101 + * @tc.name: b_json_GetFd_0101 + * @tc.desc: Test function of GetFd interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 0 + * @tc.require: I6F3GV + */ +HWTEST_F(BJsonCachedEntityTest, b_json_GetFd_0101, testing::ext::TestSize.Level0) +{ + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-begin b_json_GetFd_0101"; + try { + TestManager tm("b_json_GetFd_0101"); + + std::string path = tm.GetRootDirCurTest(); + std::string filePath = path + ""; + BJsonCachedEntity jce(UniqueFd(open(filePath.data(), O_RDWR | O_CREAT, 0600))); + jce.GetFd(); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-an exception occurred."; + } + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-end b_json_GetFd_0101"; +} + +/** + * @tc.number: SUB_backup_b_json_GetFd_0102 + * @tc.name: b_json_GetFd_0102 + * @tc.desc: Test function of GetFd interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 0 + * @tc.require: I6F3GV + */ +HWTEST_F(BJsonCachedEntityTest, b_json_GetFd_0102, testing::ext::TestSize.Level0) +{ + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-begin b_json_GetFd_0102"; + try { + TestManager tm("b_json_GetFd_0102"); + + std::string path = tm.GetRootDirCurTest(); + std::string filePath = path + ".json"; + BJsonCachedEntity jce(UniqueFd(open(filePath.data(), O_RDWR | O_CREAT, NULL))); + jce.GetFd(); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-an exception occurred."; + } + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-end b_json_GetFd_0102"; +} + +/** + * @tc.number: SUB_backup_b_json_GetFd_0103 + * @tc.name: b_json_GetFd_0103 + * @tc.desc: Test function of GetFd interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 0 + * @tc.require: I6F3GV + */ +HWTEST_F(BJsonCachedEntityTest, b_json_GetFd_0103, testing::ext::TestSize.Level0) +{ + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-begin b_json_GetFd_0103"; + try { + TestManager tm("b_json_GetFd_0103"); + + std::string path = tm.GetRootDirCurTest(); + std::string filePath = path + ".json"; + BJsonCachedEntity jce(UniqueFd(open(filePath.data(), O_RDONLY, 0600))); + jce.GetFd(); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-an exception occurred."; + } + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-end b_json_GetFd_0103"; +} + +/** + * @tc.number: SUB_backup_b_json_GetFd_0104 + * @tc.name: b_json_GetFd_0104 + * @tc.desc: Test function of GetFd interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 0 + * @tc.require: I6F3GV + */ +HWTEST_F(BJsonCachedEntityTest, b_json_GetFd_0104, testing::ext::TestSize.Level0) +{ + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-begin b_json_GetFd_0104"; + try { + TestManager tm("b_json_GetFd_0104"); + + std::string path = tm.GetRootDirCurTest(); + std::string filePath = path + ""; + BJsonCachedEntity jce(UniqueFd(open(filePath.data(), O_RDWR | O_CREAT, NULL))); + jce.GetFd(); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-an exception occurred."; + } + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-end b_json_GetFd_0104"; +} + +/** + * @tc.number: SUB_backup_b_json_GetFd_0105 + * @tc.name: b_json_GetFd_0105 + * @tc.desc: Test function of GetFd interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 0 + * @tc.require: I6F3GV + */ +HWTEST_F(BJsonCachedEntityTest, b_json_GetFd_0105, testing::ext::TestSize.Level0) +{ + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-begin b_json_GetFd_0105"; + try { + TestManager tm("b_json_GetFd_0105"); + + std::string path = tm.GetRootDirCurTest(); + std::string filePath = path + ""; + BJsonCachedEntity jce(UniqueFd(open(filePath.data(), O_RDONLY, 0600))); + jce.GetFd(); + } catch (...) { + EXPECT_TRUE(true); + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-an exception occurred."; + } + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-end b_json_GetFd_0105"; +} + +/** + * @tc.number: SUB_backup_b_json_GetFd_0106 + * @tc.name: b_json_GetFd_0106 + * @tc.desc: Test function of GetFd interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 0 + * @tc.require: I6F3GV + */ +HWTEST_F(BJsonCachedEntityTest, b_json_GetFd_0106, testing::ext::TestSize.Level0) +{ + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-begin b_json_GetFd_0106"; + try { + TestManager tm("b_json_GetFd_0106"); + + std::string path = tm.GetRootDirCurTest(); + std::string filePath = path + ".json"; + BJsonCachedEntity jce(UniqueFd(open(filePath.data(), O_RDONLY, NULL))); + jce.GetFd(); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-an exception occurred."; + } + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-end b_json_GetFd_0106"; +} + +/** + * @tc.number: SUB_backup_b_json_GetFd_0107 + * @tc.name: b_json_GetFd_0107 + * @tc.desc: Test function of GetFd interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 0 + * @tc.require: I6F3GV + */ +HWTEST_F(BJsonCachedEntityTest, b_json_GetFd_0107, testing::ext::TestSize.Level0) +{ + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-begin b_json_GetFd_0107"; + try { + TestManager tm("b_json_GetFd_0107"); + + std::string path = tm.GetRootDirCurTest(); + std::string filePath = path + ""; + BJsonCachedEntity jce(UniqueFd(open(filePath.data(), O_RDONLY, NULL))); + jce.GetFd(); + } catch (...) { + EXPECT_TRUE(true); + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-an exception occurred."; + } + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-end b_json_GetFd_0107"; +} + +/** + * @tc.number: SUB_backup_b_json_Persist_0100 + * @tc.name: b_json_Persist_0100 + * @tc.desc: Test function of Persist interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 0 + * @tc.require: I6F3GV + */ +HWTEST_F(BJsonCachedEntityTest, b_json_Persist_0100, testing::ext::TestSize.Level0) +{ + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-begin b_json_Persist_0100"; + try { + TestManager tm("b_json_Persist_0100"); + + std::string path = tm.GetRootDirCurTest(); + std::string filePath = path + ".json"; + BJsonCachedEntity jce(UniqueFd(open(filePath.data(), O_RDWR | O_CREAT, 0600))); + jce.Persist(); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-an exception occurred."; + } + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-end b_json_Persist_0100"; +} + +/** + * @tc.number: SUB_backup_b_json_Persist_0101 + * @tc.name: b_json_Persist_0101 + * @tc.desc: Test function of Persist interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 0 + * @tc.require: I6F3GV + */ +HWTEST_F(BJsonCachedEntityTest, b_json_Persist_0101, testing::ext::TestSize.Level0) +{ + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-begin b_json_Persist_0101"; + try { + TestManager tm("b_json_Persist_0101"); + + std::string path = tm.GetRootDirCurTest(); + std::string filePath = path + ""; + BJsonCachedEntity jce(UniqueFd(open(filePath.data(), O_RDWR | O_CREAT, 0600))); + jce.Persist(); + } catch (...) { + EXPECT_TRUE(true); + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-an exception occurred."; + } + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-end b_json_Persist_0101"; +} + +/** + * @tc.number: SUB_backup_b_json_Persist_0102 + * @tc.name: b_json_Persist_0102 + * @tc.desc: Test function of Persist interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 0 + * @tc.require: I6F3GV + */ +HWTEST_F(BJsonCachedEntityTest, b_json_Persist_0102, testing::ext::TestSize.Level0) +{ + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-begin b_json_Persist_0102"; + try { + TestManager tm("b_json_Persist_0102"); + + std::string path = tm.GetRootDirCurTest(); + std::string filePath = path + ".json"; + BJsonCachedEntity jce(UniqueFd(open(filePath.data(), O_RDWR | O_CREAT, NULL))); + jce.Persist(); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-an exception occurred."; + } + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-end b_json_Persist_0102"; +} + +/** + * @tc.number: SUB_backup_b_json_Persist_0103 + * @tc.name: b_json_Persist_0103 + * @tc.desc: Test function of Persist interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 0 + * @tc.require: I6F3GV + */ +HWTEST_F(BJsonCachedEntityTest, b_json_Persist_0103, testing::ext::TestSize.Level0) +{ + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-begin b_json_Persist_0103"; + try { + TestManager tm("b_json_Persist_0103"); + + std::string path = tm.GetRootDirCurTest(); + std::string filePath = path + ".json"; + BJsonCachedEntity jce(UniqueFd(open(filePath.data(), O_RDONLY, 0600))); + jce.Persist(); + } catch (...) { + EXPECT_TRUE(true); + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-an exception occurred."; + } + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-end b_json_Persist_0103"; +} + +/** + * @tc.number: SUB_backup_b_json_Persist_0104 + * @tc.name: b_json_Persist_0104 + * @tc.desc: Test function of Persist interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 0 + * @tc.require: I6F3GV + */ +HWTEST_F(BJsonCachedEntityTest, b_json_Persist_0104, testing::ext::TestSize.Level0) +{ + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-begin b_json_Persist_0104"; + try { + TestManager tm("b_json_Persist_0104"); + + std::string path = tm.GetRootDirCurTest(); + std::string filePath = path + ""; + BJsonCachedEntity jce(UniqueFd(open(filePath.data(), O_RDWR | O_CREAT, NULL))); + jce.Persist(); + } catch (...) { + EXPECT_TRUE(true); + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-an exception occurred."; + } + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-end b_json_Persist_0104"; +} + +/** + * @tc.number: SUB_backup_b_json_Persist_0105 + * @tc.name: b_json_Persist_0105 + * @tc.desc: Test function of Persist interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 0 + * @tc.require: I6F3GV + */ +HWTEST_F(BJsonCachedEntityTest, b_json_Persist_0105, testing::ext::TestSize.Level0) +{ + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-begin b_json_Persist_0105"; + try { + TestManager tm("b_json_Persist_0105"); + + std::string path = tm.GetRootDirCurTest(); + std::string filePath = path + ""; + BJsonCachedEntity jce(UniqueFd(open(filePath.data(), O_RDONLY, 0600))); + jce.Persist(); + } catch (...) { + EXPECT_TRUE(true); + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-an exception occurred."; + } + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-end b_json_Persist_0105"; +} + +/** + * @tc.number: SUB_backup_b_json_Persist_0106 + * @tc.name: b_json_Persist_0106 + * @tc.desc: Test function of Persist interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 0 + * @tc.require: I6F3GV + */ +HWTEST_F(BJsonCachedEntityTest, b_json_Persist_0106, testing::ext::TestSize.Level0) +{ + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-begin b_json_Persist_0106"; + try { + TestManager tm("b_json_Persist_0106"); + + std::string path = tm.GetRootDirCurTest(); + std::string filePath = path + ".json"; + BJsonCachedEntity jce(UniqueFd(open(filePath.data(), O_RDONLY, NULL))); + jce.Persist(); + } catch (...) { + EXPECT_TRUE(true); + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-an exception occurred."; + } + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-end b_json_Persist_0106"; +} + +/** + * @tc.number: SUB_backup_b_json_Persist_0107 + * @tc.name: b_json_Persist_0107 + * @tc.desc: Test function of Persist interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 0 + * @tc.require: I6F3GV + */ +HWTEST_F(BJsonCachedEntityTest, b_json_Persist_0107, testing::ext::TestSize.Level0) +{ + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-begin b_json_Persist_0107"; + try { + TestManager tm("b_json_Persist_0107"); + + std::string path = tm.GetRootDirCurTest(); + std::string filePath = path + ""; + BJsonCachedEntity jce(UniqueFd(open(filePath.data(), O_RDONLY, NULL))); + jce.Persist(); + } catch (...) { + EXPECT_TRUE(true); + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-an exception occurred."; + } + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-end b_json_Persist_0107"; +} + +/** + * @tc.number: SUB_backup_b_json_ReloadFromFile_0100 + * @tc.name: b_json_ReloadFromFile_0100 + * @tc.desc: Test function of ReloadFromFile interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 0 + * @tc.require: I6F3GV + */ +HWTEST_F(BJsonCachedEntityTest, b_json_ReloadFromFile_0100, testing::ext::TestSize.Level0) +{ + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-begin b_json_ReloadFromFile_0100"; + try { + TestManager tm("b_json_ReloadFromFile_0100"); + + std::string path = tm.GetRootDirCurTest(); + std::string filePath = path + ".json"; + BJsonCachedEntity jce(UniqueFd(open(filePath.data(), O_RDWR | O_CREAT, 0600))); + int ret = jce.ReloadFromFile(); + EXPECT_EQ(ret, 0); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-an exception occurred."; + } + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-end b_json_ReloadFromFile_0100"; +} + +/** + * @tc.number: SUB_backup_b_json_ReloadFromFile_0101 + * @tc.name: b_json_ReloadFromFile_0101 + * @tc.desc: Test function of ReloadFromFile interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 0 + * @tc.require: I6F3GV + */ +HWTEST_F(BJsonCachedEntityTest, b_json_ReloadFromFile_0101, testing::ext::TestSize.Level0) +{ + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-begin b_json_ReloadFromFile_0101"; + try { + TestManager tm("b_json_ReloadFromFile_0101"); + + std::string path = tm.GetRootDirCurTest(); + std::string filePath = path + ""; + BJsonCachedEntity jce(UniqueFd(open(filePath.data(), O_RDWR | O_CREAT, 0600))); + jce.ReloadFromFile(); + } catch (...) { + EXPECT_TRUE(true); + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-an exception occurred."; + } + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-end b_json_ReloadFromFile_0101"; +} + +/** + * @tc.number: SUB_backup_b_json_ReloadFromFile_0102 + * @tc.name: b_json_ReloadFromFile_0102 + * @tc.desc: Test function of ReloadFromFile interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 0 + * @tc.require: I6F3GV + */ +HWTEST_F(BJsonCachedEntityTest, b_json_ReloadFromFile_0102, testing::ext::TestSize.Level0) +{ + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-begin b_json_ReloadFromFile_0102"; + try { + TestManager tm("b_json_ReloadFromFile_0102"); + + std::string path = tm.GetRootDirCurTest(); + std::string filePath = path + ".json"; + BJsonCachedEntity jce(UniqueFd(open(filePath.data(), O_RDWR | O_CREAT, NULL))); + jce.ReloadFromFile(); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-an exception occurred."; + } + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-end b_json_ReloadFromFile_0102"; +} + +/** + * @tc.number: SUB_backup_b_json_ReloadFromFile_0103 + * @tc.name: b_json_ReloadFromFile_0103 + * @tc.desc: Test function of ReloadFromFile interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 0 + * @tc.require: I6F3GV + */ +HWTEST_F(BJsonCachedEntityTest, b_json_ReloadFromFile_0103, testing::ext::TestSize.Level0) +{ + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-begin b_json_ReloadFromFile_0103"; + try { + TestManager tm("b_json_ReloadFromFile_0103"); + + std::string path = tm.GetRootDirCurTest(); + std::string filePath = path + ".json"; + BJsonCachedEntity jce(UniqueFd(open(filePath.data(), O_RDONLY, 0600))); + jce.ReloadFromFile(); + } catch (...) { + EXPECT_TRUE(true); + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-an exception occurred."; + } + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-end b_json_ReloadFromFile_0103"; +} + +/** + * @tc.number: SUB_backup_b_json_ReloadFromFile_0104 + * @tc.name: b_json_ReloadFromFile_0104 + * @tc.desc: Test function of ReloadFromFile interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 0 + * @tc.require: I6F3GV + */ +HWTEST_F(BJsonCachedEntityTest, b_json_ReloadFromFile_0104, testing::ext::TestSize.Level0) +{ + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-begin b_json_ReloadFromFile_0104"; + try { + TestManager tm("b_json_ReloadFromFile_0104"); + + std::string path = tm.GetRootDirCurTest(); + std::string filePath = path + ""; + BJsonCachedEntity jce(UniqueFd(open(filePath.data(), O_RDWR | O_CREAT, NULL))); + jce.ReloadFromFile(); + } catch (...) { + EXPECT_TRUE(true); + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-an exception occurred."; + } + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-end b_json_ReloadFromFile_0104"; +} + +/** + * @tc.number: SUB_backup_b_json_ReloadFromFile_0105 + * @tc.name: b_json_ReloadFromFile_0105 + * @tc.desc: Test function of ReloadFromFile interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 0 + * @tc.require: I6F3GV + */ +HWTEST_F(BJsonCachedEntityTest, b_json_ReloadFromFile_0105, testing::ext::TestSize.Level0) +{ + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-begin b_json_ReloadFromFile_0105"; + try { + TestManager tm("b_json_ReloadFromFile_0105"); + + std::string path = tm.GetRootDirCurTest(); + std::string filePath = path + ""; + BJsonCachedEntity jce(UniqueFd(open(filePath.data(), O_RDONLY, 0600))); + jce.ReloadFromFile(); + } catch (...) { + EXPECT_TRUE(true); + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-an exception occurred."; + } + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-end b_json_ReloadFromFile_0105"; +} + +/** + * @tc.number: SUB_backup_b_json_ReloadFromFile_0106 + * @tc.name: b_json_ReloadFromFile_0106 + * @tc.desc: Test function of ReloadFromFile interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 0 + * @tc.require: I6F3GV + */ +HWTEST_F(BJsonCachedEntityTest, b_json_ReloadFromFile_0106, testing::ext::TestSize.Level0) +{ + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-begin b_json_ReloadFromFile_0106"; + try { + TestManager tm("b_json_ReloadFromFile_0106"); + + std::string path = tm.GetRootDirCurTest(); + std::string filePath = path + ".json"; + BJsonCachedEntity jce(UniqueFd(open(filePath.data(), O_RDONLY, NULL))); + jce.ReloadFromFile(); + } catch (...) { + EXPECT_TRUE(true); + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-an exception occurred."; + } + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-end b_json_ReloadFromFile_0106"; +} + +/** + * @tc.number: SUB_backup_b_json_ReloadFromFile_0107 + * @tc.name: b_json_ReloadFromFile_0107 + * @tc.desc: Test function of ReloadFromFile interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 0 + * @tc.require: I6F3GV + */ +HWTEST_F(BJsonCachedEntityTest, b_json_ReloadFromFile_0107, testing::ext::TestSize.Level0) +{ + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-begin b_json_ReloadFromFile_0107"; + try { + TestManager tm("b_json_ReloadFromFile_0107"); + + std::string path = tm.GetRootDirCurTest(); + std::string filePath = path + ""; + BJsonCachedEntity jce(UniqueFd(open(filePath.data(), O_RDONLY, NULL))); + jce.ReloadFromFile(); + } catch (...) { + EXPECT_TRUE(true); + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-an exception occurred."; + } + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-end b_json_ReloadFromFile_0107"; +} + +/** + * @tc.number: SUB_backup_b_json_ReloadFromString_0100 + * @tc.name: b_json_ReloadFromString_0100 + * @tc.desc: Test function of ReloadFromString interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 0 + * @tc.require: I6F3GV + */ +HWTEST_F(BJsonCachedEntityTest, b_json_ReloadFromString_0100, testing::ext::TestSize.Level0) +{ + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-begin b_json_ReloadFromString_0100"; + try { + TestManager tm("b_json_ReloadFromString_0100"); + + std::string path = tm.GetRootDirCurTest(); + std::string filePath = path + ".json"; + std::string_view sv = ""; + BJsonCachedEntity jce(UniqueFd(open(filePath.data(), O_RDWR | O_CREAT, 0600))); + jce.ReloadFromString(sv); + } catch (...) { + EXPECT_TRUE(true); + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-an exception occurred."; + } + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-end b_json_ReloadFromString_0100"; +} + +/** + * @tc.number: SUB_backup_b_json_ReloadFromString_0101 + * @tc.name: b_json_ReloadFromString_0101 + * @tc.desc: Test function of ReloadFromString interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 0 + * @tc.require: I6F3GV + */ +HWTEST_F(BJsonCachedEntityTest, b_json_ReloadFromString_0101, testing::ext::TestSize.Level0) +{ + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-begin b_json_ReloadFromString_0101"; + try { + TestManager tm("b_json_ReloadFromString_0101"); + + std::string path = tm.GetRootDirCurTest(); + std::string filePath = path + ""; + std::string_view sv; + BJsonCachedEntity jce(UniqueFd(open(filePath.data(), O_RDWR | O_CREAT, 0600))); + jce.ReloadFromString(sv); + } catch (...) { + EXPECT_TRUE(true); + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-an exception occurred."; + } + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-end b_json_ReloadFromString_0101"; +} + +/** + * @tc.number: SUB_backup_b_json_ReloadFromString_0102 + * @tc.name: b_json_ReloadFromString_0102 + * @tc.desc: Test function of ReloadFromString interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 0 + * @tc.require: I6F3GV + */ +HWTEST_F(BJsonCachedEntityTest, b_json_ReloadFromString_0102, testing::ext::TestSize.Level0) +{ + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-begin b_json_ReloadFromString_0102"; + try { + TestManager tm("b_json_ReloadFromString_0102"); + + std::string path = tm.GetRootDirCurTest(); + std::string filePath = path + ".json"; + std::string_view sv; + BJsonCachedEntity jce(UniqueFd(open(filePath.data(), O_RDWR | O_CREAT, NULL))); + jce.ReloadFromString(sv); + } catch (...) { + EXPECT_TRUE(true); + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-an exception occurred."; + } + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-end b_json_ReloadFromString_0102"; +} + +/** + * @tc.number: SUB_backup_b_json_ReloadFromString_0103 + * @tc.name: b_json_ReloadFromString_0103 + * @tc.desc: Test function of ReloadFromString interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 0 + * @tc.require: I6F3GV + */ +HWTEST_F(BJsonCachedEntityTest, b_json_ReloadFromString_0103, testing::ext::TestSize.Level0) +{ + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-begin b_json_ReloadFromString_0103"; + try { + TestManager tm("b_json_ReloadFromString_0103"); + + std::string path = tm.GetRootDirCurTest(); + std::string filePath = path + ".json"; + std::string_view sv; + BJsonCachedEntity jce(UniqueFd(open(filePath.data(), O_RDONLY, NULL))); + jce.ReloadFromString(sv); + } catch (...) { + EXPECT_TRUE(true); + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-an exception occurred."; + } + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-end b_json_ReloadFromString_0103"; +} + +/** + * @tc.number: SUB_backup_b_json_ReloadFromString_0104 + * @tc.name: b_json_ReloadFromString_0104 + * @tc.desc: Test function of ReloadFromString interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 0 + * @tc.require: I6F3GV + */ +HWTEST_F(BJsonCachedEntityTest, b_json_ReloadFromString_0104, testing::ext::TestSize.Level0) +{ + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-begin b_json_ReloadFromString_0104"; + try { + TestManager tm("b_json_ReloadFromString_0104"); + + std::string path = tm.GetRootDirCurTest(); + std::string filePath = path + ""; + std::string_view sv; + BJsonCachedEntity jce(UniqueFd(open(filePath.data(), O_RDWR | O_CREAT, NULL))); + jce.ReloadFromString(sv); + } catch (...) { + EXPECT_TRUE(true); + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-an exception occurred."; + } + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-end b_json_ReloadFromString_0104"; +} + +/** + * @tc.number: SUB_backup_b_json_ReloadFromString_0105 + * @tc.name: b_json_ReloadFromString_0105 + * @tc.desc: Test function of ReloadFromString interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 0 + * @tc.require: I6F3GV + */ +HWTEST_F(BJsonCachedEntityTest, b_json_ReloadFromString_0105, testing::ext::TestSize.Level0) +{ + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-begin b_json_ReloadFromString_0105"; + try { + TestManager tm("b_json_ReloadFromString_0105"); + + std::string path = tm.GetRootDirCurTest(); + std::string filePath = path + ""; + std::string_view sv; + BJsonCachedEntity jce(UniqueFd(open(filePath.data(), O_RDONLY, 0600))); + jce.ReloadFromString(sv); + } catch (...) { + EXPECT_TRUE(true); + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-an exception occurred."; + } + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-end b_json_ReloadFromString_0105"; +} + +/** + * @tc.number: SUB_backup_b_json_ReloadFromString_0106 + * @tc.name: b_json_ReloadFromString_0106 + * @tc.desc: Test function of ReloadFromString interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 0 + * @tc.require: I6F3GV + */ +HWTEST_F(BJsonCachedEntityTest, b_json_ReloadFromString_0106, testing::ext::TestSize.Level0) +{ + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-begin b_json_ReloadFromString_0106"; + try { + TestManager tm("b_json_ReloadFromString_0106"); + + std::string path = tm.GetRootDirCurTest(); + std::string filePath = path + ".json"; + std::string_view sv; + BJsonCachedEntity jce(UniqueFd(open(filePath.data(), O_RDONLY, NULL))); + jce.ReloadFromString(sv); + } catch (...) { + EXPECT_TRUE(true); + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-an exception occurred."; + } + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-end b_json_ReloadFromString_0106"; +} + +/** + * @tc.number: SUB_backup_b_json_ReloadFromString_0107 + * @tc.name: b_json_ReloadFromString_0107 + * @tc.desc: Test function of ReloadFromString interface for SUCCESS. + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 0 + * @tc.require: I6F3GV + */ +HWTEST_F(BJsonCachedEntityTest, b_json_ReloadFromString_0107, testing::ext::TestSize.Level0) +{ + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-begin b_json_ReloadFromString_0107"; + try { + TestManager tm("b_json_ReloadFromString_0107"); + + std::string path = tm.GetRootDirCurTest(); + std::string filePath = path + ""; + std::string_view sv; + BJsonCachedEntity jce(UniqueFd(open(filePath.data(), O_RDONLY, NULL))); + jce.ReloadFromString(sv); + } catch (...) { + EXPECT_TRUE(true); + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-an exception occurred."; + } + GTEST_LOG_(INFO) << "BJsonCachedEntityTest-end b_json_ReloadFromString_0107"; +} } // namespace OHOS::FileManagement::Backup \ No newline at end of file diff --git a/tests/unittests/backup_utils/b_json/b_json_entity_ext_manage_test.cpp b/tests/unittests/backup_utils/b_json/b_json_entity_ext_manage_test.cpp index 8db6c334562168eabf8a7ba97b5c22c2d68cf27b..2e6c0b6145ec0c19e9e3acf5303c782af402ef56 100644 --- a/tests/unittests/backup_utils/b_json/b_json_entity_ext_manage_test.cpp +++ b/tests/unittests/backup_utils/b_json/b_json_entity_ext_manage_test.cpp @@ -517,7 +517,82 @@ HWTEST_F(BJsonEntityExtManageTest, b_json_entity_ext_manage_0800, testing::ext:: } /** - * @tc.number: SUB_backup_b_json_entity_ext_manage_0900 + * @tc.number: SUB_backup_b_json_entity_ext_manage_0801 + * @tc.name: b_json_entity_ext_manage_0801 + * @tc.desc: 测试GetExtManageInfo在Json数据为数组且有一个键为information的对象时能否成功返回空map + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 0 + * @tc.require: I6F3GV + */ +HWTEST_F(BJsonEntityExtManageTest, b_json_entity_ext_manage_0801, testing::ext::TestSize.Level0) +{ + GTEST_LOG_(INFO) << "BJsonEntityExtManageTest-begin b_json_entity_ext_manage_0801"; + try { + string_view sv = R"([{"path":1}])"; + BJsonCachedEntity cachedEntity(sv); + auto cache = cachedEntity.Structuralize(); + auto mp = cache.GetExtManageInfo(); + EXPECT_TRUE(mp.empty()); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "BJsonEntityExtManageTest-an exception occurred."; + } + GTEST_LOG_(INFO) << "BJsonEntityExtManageTest-end b_json_entity_ext_manage_0801"; +} + +/** + * @tc.number: SUB_backup_b_json_entity_ext_manage_0802 + * @tc.name: b_json_entity_ext_manage_0802 + * @tc.desc: 测试GetExtManageInfo在Json数据为数组且有两个键为information的对象时能否成功返回空map + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 0 + * @tc.require: I6F3GV + */ +HWTEST_F(BJsonEntityExtManageTest, b_json_entity_ext_manage_0802, testing::ext::TestSize.Level0) +{ + GTEST_LOG_(INFO) << "BJsonEntityExtManageTest-begin b_json_entity_ext_manage_0802"; + try { + string_view sv = R"([{"path":1}, {"fileName":1}])"; + BJsonCachedEntity cachedEntity(sv); + auto cache = cachedEntity.Structuralize(); + auto mp = cache.GetExtManageInfo(); + EXPECT_TRUE(mp.empty()); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "BJsonEntityExtManageTest-an exception occurred."; + } + GTEST_LOG_(INFO) << "BJsonEntityExtManageTest-end b_json_entity_ext_manage_0802"; +} + +/** + * @tc.number: SUB_backup_b_json_entity_ext_manage_0803 + * @tc.name: b_json_entity_ext_manage_0803 + * @tc.desc: 测试GetExtManageInfo在Json数据为数组且键为空时能否成功返回空map + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 0 + * @tc.require: I6F3GV + */ +HWTEST_F(BJsonEntityExtManageTest, b_json_entity_ext_manage_0803, testing::ext::TestSize.Level0) +{ + GTEST_LOG_(INFO) << "BJsonEntityExtManageTest-begin b_json_entity_ext_manage_0803"; + try { + string_view sv = R"([{"":1}])"; + BJsonCachedEntity cachedEntity(sv); + auto cache = cachedEntity.Structuralize(); + auto mp = cache.GetExtManageInfo(); + EXPECT_TRUE(mp.empty()); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "BJsonEntityExtManageTest-an exception occurred."; + } + GTEST_LOG_(INFO) << "BJsonEntityExtManageTest-end b_json_entity_ext_manage_0803"; +} + +/** + * @tc.number: SUB_backup_bb_json_entity_ext_manage_0900 * @tc.name: b_json_entity_ext_manage_0900 * @tc.desc: 测试SetHardLinkInfo接口和GetHardLinkInfo接口在不符合相关条件时能否成功返回false和空set * @tc.size: MEDIUM @@ -551,4 +626,151 @@ HWTEST_F(BJsonEntityExtManageTest, b_json_entity_ext_manage_0900, testing::ext:: } GTEST_LOG_(INFO) << "BJsonEntityExtManageTest-end b_json_entity_ext_manage_0900"; } + +/** + * @tc.number: SUB_backup_b_json_entity_ext_manage_0901 + * @tc.name: b_json_entity_ext_manage_0901 + * @tc.desc: 测试SetHardLinkInfo接口和GetHardLinkInfo接口在不符合相关条件时能否成功返回false和空set + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 0 + * @tc.require: I6F3GV + */ +HWTEST_F(BJsonEntityExtManageTest, b_json_entity_ext_manage_0901, testing::ext::TestSize.Level0) +{ + GTEST_LOG_(INFO) << "BJsonEntityExtManageTest-begin b_json_entity_ext_manage_0901"; + try { + string_view sv = R"({"key":1})"; + BJsonCachedEntity cachedEntity(sv); + auto cache = cachedEntity.Structuralize(); + EXPECT_FALSE(cache.SetHardLinkInfo("#4$5%", {})); + + Json::Value jv; + BJsonEntityExtManage extMg(jv); + EXPECT_FALSE(extMg.SetHardLinkInfo("1", {})); + + EXPECT_FALSE(cache.SetHardLinkInfo("1", {})); + + EXPECT_EQ(cache.GetHardLinkInfo("#4$5%"), set()); + + EXPECT_EQ(extMg.GetHardLinkInfo("1"), set()); + + EXPECT_EQ(cache.GetHardLinkInfo("1"), set()); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "BJsonEntityExtManageTest-an exception occurred."; + } + GTEST_LOG_(INFO) << "BJsonEntityExtManageTest-end b_json_entity_ext_manage_0901"; +} + +/** + * @tc.number: SUB_backup_b_json_entity_ext_manage_0902 + * @tc.name: b_json_entity_ext_manage_0902 + * @tc.desc: 测试SetHardLinkInfo接口和GetHardLinkInfo接口在不符合相关条件时能否成功返回false和空set + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 0 + * @tc.require: I6F3GV + */ +HWTEST_F(BJsonEntityExtManageTest, b_json_entity_ext_manage_0902, testing::ext::TestSize.Level0) +{ + GTEST_LOG_(INFO) << "BJsonEntityExtManageTest-begin b_json_entity_ext_manage_0902"; + try { + string_view sv = R"({"key":1})"; + BJsonCachedEntity cachedEntity(sv); + auto cache = cachedEntity.Structuralize(); + EXPECT_FALSE(cache.SetHardLinkInfo("测试代码", {})); + + Json::Value jv; + BJsonEntityExtManage extMg(jv); + EXPECT_FALSE(extMg.SetHardLinkInfo("1", {})); + + EXPECT_FALSE(cache.SetHardLinkInfo("1", {})); + + EXPECT_EQ(cache.GetHardLinkInfo("测试代码"), set()); + + EXPECT_EQ(extMg.GetHardLinkInfo("1"), set()); + + EXPECT_EQ(cache.GetHardLinkInfo("1"), set()); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "BJsonEntityExtManageTest-an exception occurred."; + } + GTEST_LOG_(INFO) << "BJsonEntityExtManageTest-end b_json_entity_ext_manage_0902"; +} + +/** + * @tc.number: SUB_backup_b_json_entity_ext_manage_0903 + * @tc.name: b_json_entity_ext_manage_0903 + * @tc.desc: 测试SetHardLinkInfo接口和GetHardLinkInfo接口在不符合相关条件时能否成功返回false和空set + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 0 + * @tc.require: I6F3GV + */ +HWTEST_F(BJsonEntityExtManageTest, b_json_entity_ext_manage_0903, testing::ext::TestSize.Level0) +{ + GTEST_LOG_(INFO) << "BJsonEntityExtManageTest-begin b_json_entity_ext_manage_0903"; + try { + string_view sv = R"({"key":1})"; + BJsonCachedEntity cachedEntity(sv); + auto cache = cachedEntity.Structuralize(); + EXPECT_FALSE(cache.SetHardLinkInfo("ABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDA\ + BCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCD", {})); + + Json::Value jv; + BJsonEntityExtManage extMg(jv); + EXPECT_FALSE(extMg.SetHardLinkInfo("1", {})); + + EXPECT_FALSE(cache.SetHardLinkInfo("1", {})); + + EXPECT_EQ(cache.GetHardLinkInfo("ABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDA\ + BCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCD"), set()); + + EXPECT_EQ(extMg.GetHardLinkInfo("1"), set()); + + EXPECT_EQ(cache.GetHardLinkInfo("1"), set()); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "BJsonEntityExtManageTest-an exception occurred."; + } + GTEST_LOG_(INFO) << "BJsonEntityExtManageTest-end b_json_entity_ext_manage_0903"; +} + +/** + * @tc.number: SUB_backup_b_json_entity_ext_manage_0904 + * @tc.name: b_json_entity_ext_manage_0904 + * @tc.desc: 测试SetHardLinkInfo接口和GetHardLinkInfo接口在不符合相关条件时能否成功返回false和空set + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 0 + * @tc.require: I6F3GV + */ +HWTEST_F(BJsonEntityExtManageTest, b_json_entity_ext_manage_0904, testing::ext::TestSize.Level0) +{ + GTEST_LOG_(INFO) << "BJsonEntityExtManageTest-begin b_json_entity_ext_manage_0904"; + try { + string_view sv = R"({"key":1})"; + BJsonCachedEntity cachedEntity(sv); + auto cache = cachedEntity.Structuralize(); + EXPECT_FALSE(cache.SetHardLinkInfo("", {""""""""""""""""""""""""""""""""""""""""""""""""""})); + + Json::Value jv; + BJsonEntityExtManage extMg(jv); + EXPECT_FALSE(extMg.SetHardLinkInfo("测试代码", {})); + + EXPECT_FALSE(cache.SetHardLinkInfo("#4$5%", {})); + + EXPECT_EQ(cache.GetHardLinkInfo(""), set()); + + EXPECT_EQ(extMg.GetHardLinkInfo("测试代码"), set()); + + EXPECT_EQ(cache.GetHardLinkInfo("#4$5%"), set()); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "BJsonEntityExtManageTest-an exception occurred."; + } + GTEST_LOG_(INFO) << "BJsonEntityExtManageTest-end b_json_entity_ext_manage_0904"; +} + } // namespace OHOS::FileManagement::Backup \ No newline at end of file diff --git a/tests/unittests/backup_utils/b_json/b_json_entity_extension_config_test.cpp b/tests/unittests/backup_utils/b_json/b_json_entity_extension_config_test.cpp index f882bf01c2bd48860af5223dc6f19743670a9cd5..6a2984e4ac73a4838aa5a03a81bf004de7b87f5c 100644 --- a/tests/unittests/backup_utils/b_json/b_json_entity_extension_config_test.cpp +++ b/tests/unittests/backup_utils/b_json/b_json_entity_extension_config_test.cpp @@ -287,39 +287,8 @@ HWTEST_F(BJsonEntityExtensionConfigTest, b_json_entity_extension_config_0700, te GTEST_LOG_(INFO) << "BJsonEntityExtensionConfigTest-end b_json_entity_extension_config_0700"; } -/** - * @tc.number: SUB_backup_b_json_entity_extension_config_0800 - * @tc.name: b_json_entity_extension_config_0800 - * @tc.desc: json文件标签中有异常引号 - * @tc.size: MEDIUM - * @tc.type: FUNC - * @tc.level Level 2 - * @tc.require: I6F3GV - */ -HWTEST_F(BJsonEntityExtensionConfigTest, b_json_entity_extension_config_0800, testing::ext::TestSize.Level2) -{ - GTEST_LOG_(INFO) << "BJsonEntityExtensionConfigTest-begin b_json_entity_extension_config_0800"; - try { - TestManager tm("b_json_entity_extension_config_0800"); - - string root = tm.GetRootDirCurTest(); - string pathConfigFile = root + "config.json"; - SaveStringToFile( - pathConfigFile, - R"({"includes":["", "", ""], "excludes":["", "", ""], """""""""""""""""""""""""""""""""""""""""""""""""":[]})"); - BJsonCachedEntity cachedEntity(UniqueFd(open(pathConfigFile.data(), O_RDONLY, 0))); - auto cache = cachedEntity.Structuralize(); - vector includes = cache.GetIncludes(); - EXPECT_EQ(includes, DEFAULT_INCLUDE_DIR); - vector excludes = cache.GetExcludes(); - EXPECT_EQ(excludes, DEFAULT_EXCLUDE_DIR); - } catch (...) { - EXPECT_TRUE(false); - GTEST_LOG_(INFO) << "BJsonEntityExtensionConfigTest-an exception occurred by construction."; - } - GTEST_LOG_(INFO) << "BJsonEntityExtensionConfigTest-end b_json_entity_extension_config_0800"; -} + /** * @tc.number: SUB_backup_b_json_entity_extension_config_0900 @@ -800,4 +769,204 @@ HWTEST_F(BJsonEntityExtensionConfigTest, b_json_entity_extension_config_2700, te } GTEST_LOG_(INFO) << "BJsonEntityExtensionConfigTest-end b_json_entity_extension_config_2700"; } + + + +/** + * @tc.number: SUB_backup_b_json_entity_extension_config_2800 + * @tc.name: b_json_entity_extension_config_2800 + * @tc.desc: 测试 GetIncludes 接口在Json数据中键为includes的值为数组且数组元素为空时能否成功返回空目录 + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 2 + * @tc.require: I6F3GV + */ +HWTEST_F(BJsonEntityExtensionConfigTest, b_json_entity_extension_config_2800, testing::ext::TestSize.Level2) +{ + GTEST_LOG_(INFO) << "BJsonEntityExtensionConfigTest-begin b_json_entity_extension_config_2800"; + try { + string_view sv = R"({"includes":[]})"; + BJsonCachedEntity cachedEntity(sv); + auto cache = cachedEntity.Structuralize(); + vector vs = cache.GetIncludes(); + EXPECT_EQ(vs, vector({""})); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "BJsonEntityExtensionConfigTest-an exception occurred by GetIncludes."; + } + GTEST_LOG_(INFO) << "BJsonEntityExtensionConfigTest-end b_json_entity_extension_config_2800"; +} + +/** + * @tc.number: SUB_backup_b_json_entity_extension_config_2900 + * @tc.name: b_json_entity_extension_config_2900 + * @tc.desc: 测试GetExcludes接口在Json数据中键为excludes的值为数组且数组元素为空时能否成功返回空vector + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 2 + * @tc.require: I6F3GV + */ +HWTEST_F(BJsonEntityExtensionConfigTest, b_json_entity_extension_config_2900, testing::ext::TestSize.Level2) +{ + GTEST_LOG_(INFO) << "BJsonEntityExtensionConfigTest-begin b_json_entity_extension_config_2900"; + try { + string_view sv = R"({"excludes":[]})"; + BJsonCachedEntity cachedEntity(sv); + auto cache = cachedEntity.Structuralize(); + vector vs = cache.GetExcludes(); + EXPECT_EQ(vs, vector()); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "BJsonEntityExtensionConfigTest-an exception occurred by GetExcludes."; + } + GTEST_LOG_(INFO) << "BJsonEntityExtensionConfigTest-end b_json_entity_extension_config_2900"; +} + + +/** + * @tc.number: SUB_backup_b_json_entity_extension_config_3000 + * @tc.name: b_json_entity_extension_config_3000 + * @tc.desc: 测试GetFullBackupOnly接口在Json数据对象键为fullBackupOnly的值不为布尔值时能否成功返回false + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 2 + * @tc.require: I6F3GV + */ +HWTEST_F(BJsonEntityExtensionConfigTest, b_json_entity_extension_config_3000, testing::ext::TestSize.Level2) +{ + GTEST_LOG_(INFO) << "BJsonEntityExtensionConfigTest-begin b_json_entity_extension_config_3000"; + try { + string_view sv = R"({"fullBackupOnly":1})"; + BJsonCachedEntity cachedEntity(sv); + auto cache = cachedEntity.Structuralize(); + EXPECT_FALSE(cache.GetFullBackupOnly()); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "BJsonEntityExtensionConfigTest-an exception occurred by GetFullBackupOnly."; + } + GTEST_LOG_(INFO) << "BJsonEntityExtensionConfigTest-end b_json_entity_extension_config_3000"; +} + +/** + * @tc.number: SUB_backup_b_json_entity_extension_config_3100 + * @tc.name: b_json_entity_extension_config_3100 + * @tc.desc: 测试GetFullBackupOnly接口在Json数据对象不含fullBackupOnly键时能否成功返回TRUE + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 2 + * @tc.require: I6F3GV + */ +HWTEST_F(BJsonEntityExtensionConfigTest, b_json_entity_extension_config_3100, testing::ext::TestSize.Level2) +{ + GTEST_LOG_(INFO) << "BJsonEntityExtensionConfigTest-begin b_json_entity_extension_config_3100"; + try { + string_view sv = R"({"fullBackupOnly":true})"; + BJsonCachedEntity cachedEntity(sv); + auto cache = cachedEntity.Structuralize(); + EXPECT_TRUE(cache.GetFullBackupOnly()); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "BJsonEntityExtensionConfigTest-an exception occurred by GetAllowToBackupRestore."; + } + GTEST_LOG_(INFO) << "BJsonEntityExtensionConfigTest-end b_json_entity_extension_config_3100"; +} + +/** + * @tc.number: SUB_backup_b_json_entity_extension_config_3200 + * @tc.name: b_json_entity_extension_config_3200 + * @tc.desc: 测试GetFullBackupOnly接口在Json数据对象nullValue时能否成功返回false + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 2 + * @tc.require: I6F3GV + */ +HWTEST_F(BJsonEntityExtensionConfigTest, b_json_entity_extension_config_3200, testing::ext::TestSize.Level2) +{ + GTEST_LOG_(INFO) << "BJsonEntityExtensionConfigTest-begin b_json_entity_extension_config_3200"; + try { + Json::Value jv(Json::nullValue); + BJsonEntityExtensionConfig extCfg(jv); + EXPECT_FALSE(extCfg.GetFullBackupOnly()); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "BJsonEntityExtensionConfigTest-an exception occurred by GetFullBackupOnly."; + } + GTEST_LOG_(INFO) << "BJsonEntityExtensionConfigTest-end b_json_entity_extension_config_3200"; +} + +/** + * @tc.number: SUB_backup_b_json_entity_extension_config_3300 + * @tc.name: b_json_entity_extension_config_3300 + * @tc.desc: 测试GetRestoreDeps接口能否在Json数据对象的键为restoreDeps的值不为字符串值时能否成功返回string + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 2 + * @tc.require: I6F3GV + */ +HWTEST_F(BJsonEntityExtensionConfigTest, b_json_entity_extension_config_3300, testing::ext::TestSize.Level2) +{ + GTEST_LOG_(INFO) << "BJsonEntityExtensionConfigTest-begin b_json_entity_extension_config_3300"; + try { + string_view sv = R"({"restoreDeps":1})"; + BJsonCachedEntity cachedEntity(sv); + auto cache = cachedEntity.Structuralize(); + string depRead = cache.GetRestoreDeps(); + EXPECT_NE(depRead, string(sv)); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "BJsonEntityExtensionConfigTest-an exception occurred by GetRestoreDeps."; + } + GTEST_LOG_(INFO) << "BJsonEntityExtensionConfigTest-end b_json_entity_extension_config_3300"; +} + +/** + * @tc.number: SUB_backup_b_json_entity_extension_config_3400 + * @tc.name: b_json_entity_extension_config_3400 + * @tc.desc: 测试GetRestoreDeps接口能否在Json数据对象不含restoreDeps键时能否成功返回string + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 2 + * @tc.require: I6F3GV + */ +HWTEST_F(BJsonEntityExtensionConfigTest, b_json_entity_extension_config_3400, testing::ext::TestSize.Level2) +{ + GTEST_LOG_(INFO) << "BJsonEntityExtensionConfigTest-begin b_json_entity_extension_config_3400"; + try { + string_view sv = R"({"restoreDeps_":true})"; + BJsonCachedEntity cachedEntity(sv); + auto cache = cachedEntity.Structuralize(); + string depRead = cache.GetRestoreDeps(); + EXPECT_NE(depRead, string(sv)); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "BJsonEntityExtensionConfigTest-an exception occurred by GetRestoreDeps."; + } + GTEST_LOG_(INFO) << "BJsonEntityExtensionConfigTest-end b_json_entity_extension_config_3400"; +} + +/** + * @tc.number: SUB_backup_b_json_entity_extension_config_3500 + * @tc.name: b_json_entity_extension_config_3500 + * @tc.desc: 测试GetRestoreDeps接口能否在Json数据对象不含restoreDeps键时能否成功返回空 + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 2 + * @tc.require: I6F3GV + */ +HWTEST_F(BJsonEntityExtensionConfigTest, b_json_entity_extension_config_3500, testing::ext::TestSize.Level2) +{ + GTEST_LOG_(INFO) << "BJsonEntityExtensionConfigTest-begin b_json_entity_extension_config_3500"; + try { + string_view sv = R"({"":true})"; + BJsonCachedEntity cachedEntity(sv); + auto cache = cachedEntity.Structuralize(); + string depRead = cache.GetRestoreDeps(); + EXPECT_EQ(depRead, ""); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "BJsonEntityExtensionConfigTest-an exception occurred by GetRestoreDeps."; + } + GTEST_LOG_(INFO) << "BJsonEntityExtensionConfigTest-end b_json_entity_extension_config_3500"; +} + } // namespace OHOS::FileManagement::Backup \ No newline at end of file diff --git a/tests/unittests/backup_utils/b_process/b_process_test.cpp b/tests/unittests/backup_utils/b_process/b_process_test.cpp index 54f4b5d7efb75fdec2e7fd1c6ee0c0e7173299a5..1c8534d996f59898e6f58c861e0e5a68300e9a27 100644 --- a/tests/unittests/backup_utils/b_process/b_process_test.cpp +++ b/tests/unittests/backup_utils/b_process/b_process_test.cpp @@ -76,4 +76,245 @@ HWTEST_F(BProcessTest, SUB_backup_tool_BProcess_0100, testing::ext::TestSize.Lev } GTEST_LOG_(INFO) << "BProcessTest-end SUB_backup_tool_BProcess_0100"; } + +/** + * @tc.number: SUB_backup_tool_BProcess_0200 + * @tc.name: SUB_backup_tool_BProcess_0200 + * @tc.desc: 测试ExecuteCmd + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 0 + * @tc.require: I6F3GV + */ +HWTEST_F(BProcessTest, SUB_backup_tool_BProcess_0200, testing::ext::TestSize.Level0) +{ + GTEST_LOG_(INFO) << "BProcessTest-begin SUB_backup_tool_BProcess_0200"; + try { + vector argvCf = { + "", + "-cf", + "/data/backup/", + }; + auto [bFatalError, ret] = BProcess::ExecuteCmd(argvCf, DetectFatalLog); + EXPECT_EQ(ret, 2); + + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "BProcessTest-an exception occurred."; + } + GTEST_LOG_(INFO) << "BProcessTest-end SUB_backup_tool_BProcess_0200"; +} + +/** + * @tc.number: SUB_backup_tool_BProcess_0300 + * @tc.name: SUB_backup_tool_BProcess_0300 + * @tc.desc: 测试ExecuteCmd + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 0 + * @tc.require: I6F3GV + */ +HWTEST_F(BProcessTest, SUB_backup_tool_BProcess_0300, testing::ext::TestSize.Level0) +{ + GTEST_LOG_(INFO) << "BProcessTest-begin SUB_backup_tool_BProcess_0300"; + try { + vector argvCf = { + "/system/bin/tar", + "", + "/data/backup/", + }; + auto [bFatalError, ret] = BProcess::ExecuteCmd(argvCf, DetectFatalLog); + EXPECT_EQ(ret, 1); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "BProcessTest-an exception occurred."; + } + GTEST_LOG_(INFO) << "BProcessTest-end SUB_backup_tool_BProcess_0300"; +} + +/** + * @tc.number: SUB_backup_tool_BProcess_0400 + * @tc.name: SUB_backup_tool_BProcess_0400 + * @tc.desc: 测试ExecuteCmd + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 0 + * @tc.require: I6F3GV + */ +HWTEST_F(BProcessTest, SUB_backup_tool_BProcess_0400, testing::ext::TestSize.Level0) +{ + GTEST_LOG_(INFO) << "BProcessTest-begin SUB_backup_tool_BProcess_0400"; + try { + vector argvCf = { + "/system/bin/tar", + "-cf", + "", + }; + auto [bFatalError, ret] = BProcess::ExecuteCmd(argvCf, DetectFatalLog); + EXPECT_EQ(ret, 1); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "BProcessTest-an exception occurred."; + } + GTEST_LOG_(INFO) << "BProcessTest-end SUB_backup_tool_BProcess_0400"; +} + +/** + * @tc.number: SUB_backup_tool_BProcess_0500 + * @tc.name: SUB_backup_tool_BProcess_0500 + * @tc.desc: 测试ExecuteCmd + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 0 + * @tc.require: I6F3GV + */ +HWTEST_F(BProcessTest, SUB_backup_tool_BProcess_0500, testing::ext::TestSize.Level0) +{ + GTEST_LOG_(INFO) << "BProcessTest-begin SUB_backup_tool_BProcess_0500"; + try { + vector argvCf = { + "", + "", + "/data/backup/", + }; + auto [bFatalError, ret] = BProcess::ExecuteCmd(argvCf, DetectFatalLog); + EXPECT_EQ(ret, 2); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "BProcessTest-an exception occurred."; + } + GTEST_LOG_(INFO) << "BProcessTest-end SUB_backup_tool_BProcess_0500"; +} + +/** + * @tc.number: SUB_backup_tool_BProcess_0600 + * @tc.name: SUB_backup_tool_BProcess_0600 + * @tc.desc: 测试ExecuteCmd + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 0 + * @tc.require: I6F3GV + */ +HWTEST_F(BProcessTest, SUB_backup_tool_BProcess_0600, testing::ext::TestSize.Level0) +{ + GTEST_LOG_(INFO) << "BProcessTest-begin SUB_backup_tool_BProcess_0600"; + try { + vector argvCf = { + "", + "-cf", + "", + }; + auto [bFatalError, ret] = BProcess::ExecuteCmd(argvCf, DetectFatalLog); + EXPECT_EQ(ret, 2); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "BProcessTest-an exception occurred."; + } + GTEST_LOG_(INFO) << "BProcessTest-end SUB_backup_tool_BProcess_0600"; +} + +/** + * @tc.number: SUB_backup_tool_BProcess_0700 + * @tc.name: SUB_backup_tool_BProcess_0700 + * @tc.desc: 测试ExecuteCmd + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 0 + * @tc.require: I6F3GV + */ +HWTEST_F(BProcessTest, SUB_backup_tool_BProcess_0700, testing::ext::TestSize.Level0) +{ + GTEST_LOG_(INFO) << "BProcessTest-begin SUB_backup_tool_BProcess_0700"; + try { + vector argvCf = { + "/system/bin/tar", + "", + "", + }; + auto [bFatalError, ret] = BProcess::ExecuteCmd(argvCf, DetectFatalLog); + EXPECT_EQ(ret, 1); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "BProcessTest-an exception occurred."; + } + GTEST_LOG_(INFO) << "BProcessTest-end SUB_backup_tool_BProcess_0700"; +} + +/** + * @tc.number: SUB_backup_tool_BProcess_0800 + * @tc.name: SUB_backup_tool_BProcess_0800 + * @tc.desc: 测试ExecuteCmd + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 0 + * @tc.require: I6F3GV + */ +HWTEST_F(BProcessTest, SUB_backup_tool_BProcess_0800, testing::ext::TestSize.Level0) +{ + GTEST_LOG_(INFO) << "BProcessTest-begin SUB_backup_tool_BProcess_0800"; + try { + vector argvCf = { + "", + "", + "", + }; + auto [bFatalError, ret] = BProcess::ExecuteCmd(argvCf, DetectFatalLog); + EXPECT_EQ(ret, 2); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "BProcessTest-an exception occurred."; + } + GTEST_LOG_(INFO) << "BProcessTest-end SUB_backup_tool_BProcess_0800"; +} + +/** + * @tc.number: SUB_backup_tool_BProcess_0900 + * @tc.name: SUB_backup_tool_BProcess_0900 + * @tc.desc: 测试ExecuteCmd + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 0 + * @tc.require: I6F3GV + */ +HWTEST_F(BProcessTest, SUB_backup_tool_BProcess_0900, testing::ext::TestSize.Level0) +{ + GTEST_LOG_(INFO) << "BProcessTest-begin SUB_backup_tool_BProcess_0900"; + try { + vector argvCf = { + "/system/bin/tar", + }; + auto [bFatalError, ret] = BProcess::ExecuteCmd(argvCf, DetectFatalLog); + EXPECT_EQ(ret, 1); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "BProcessTest-an exception occurred."; + } + GTEST_LOG_(INFO) << "BProcessTest-end SUB_backup_tool_BProcess_0900"; +} + +/** + * @tc.number: SUB_backup_tool_BProcess_1000 + * @tc.name: SUB_backup_tool_BProcess_1000 + * @tc.desc: 测试ExecuteCmd + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 0 + * @tc.require: I6F3GV + */ +HWTEST_F(BProcessTest, SUB_backup_tool_BProcess_1000, testing::ext::TestSize.Level0) +{ + GTEST_LOG_(INFO) << "BProcessTest-begin SUB_backup_tool_BProcess_1000"; + try { + vector argvCf = { + "/system/bin/tar", + "-cf", + }; + auto [bFatalError, ret] = BProcess::ExecuteCmd(argvCf, DetectFatalLog); + EXPECT_EQ(ret, 1); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "BProcessTest-an exception occurred."; + } + GTEST_LOG_(INFO) << "BProcessTest-end SUB_backup_tool_BProcess_1000"; +} } // namespace OHOS::FileManagement::Backup diff --git a/tests/unittests/backup_utils/b_tarball/b_tarball_cmdline_test.cpp b/tests/unittests/backup_utils/b_tarball/b_tarball_cmdline_test.cpp index 97a5c4899a9544eea99d1127e38fab5d0f383954..e8827aa5827e9d4db649cda43c8a47af6187e028 100644 --- a/tests/unittests/backup_utils/b_tarball/b_tarball_cmdline_test.cpp +++ b/tests/unittests/backup_utils/b_tarball/b_tarball_cmdline_test.cpp @@ -66,6 +66,32 @@ HWTEST_F(BTarballCmdlineTest, b_tarball_cmdline_0100, testing::ext::TestSize.Lev GTEST_LOG_(INFO) << "BTarballCmdlineTest-end b_tarball_cmdline_0100"; } +/** + * @tc.number: SUB_b_tarball_cmdline_0101 + * @tc.name: b_tarball_cmdline_0101 + * @tc.desc: 测试BTarballCmdline类构造函数是否成功 + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: I6F3GV + */ +HWTEST_F(BTarballCmdlineTest, b_tarball_cmdline_0101, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "BTarballCmdlineTest-begin b_tarball_cmdline_0101"; + try { + TestManager tm("b_tarball_cmdline_0101"); + string root = tm.GetRootDirCurTest(); + string_view tarballDir = root; + string_view tarballName = ""; + + BTarballCmdline tarballCmdline(tarballDir, tarballName); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "BTarballCmdlineTest-an exception occurred by BTarballCmdline."; + } + GTEST_LOG_(INFO) << "BTarballCmdlineTest-end b_tarball_cmdline_0101"; +} + /** * @tc.number: SUB_b_tarball_cmdline_0200 * @tc.name: b_tarball_cmdline_0200 @@ -113,6 +139,100 @@ HWTEST_F(BTarballCmdlineTest, b_tarball_cmdline_0200, testing::ext::TestSize.Lev GTEST_LOG_(INFO) << "BTarballCmdlineTest-end b_tarball_cmdline_0200"; } +/** + * @tc.number: SUB_b_tarball_cmdline_0201 + * @tc.name: b_tarball_cmdline_0201 + * @tc.desc: 测试BTarballCmdline类Tar函数是否成功 + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: I6F3GV + */ +HWTEST_F(BTarballCmdlineTest, b_tarball_cmdline_0201, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "BTarballCmdlineTest-begin b_tarball_cmdline_0201"; + try { + // 预置文件和目录 + TestManager tm("b_tarball_cmdline_0201"); + string root = tm.GetRootDirCurTest(); + string_view tarballDir = root; + string_view tarballName = "test.tar"; + string testDir = root + "/testdir"; + if (mkdir(testDir.data(), S_IRWXU) && errno != EEXIST) { + GTEST_LOG_(INFO) << " invoked mkdir failure, errno :" << errno; + throw BError(errno); + } + string strFile = root + tarballName.data(); + UniqueFd fd(open(strFile.data(), O_RDONLY | O_CREAT, S_IRUSR | S_IWUSR)); + if (fd < 0) { + GTEST_LOG_(INFO) << " invoked open failure, errno :" << errno; + throw BError(errno); + } + + string aFile = testDir + ""; + string bFile = testDir + "/b.txt"; + SaveStringToFile(aFile, "hello"); + SaveStringToFile(bFile, "world"); + vector includes {testDir}; + vector excludes {bFile}; + + // 调用tar打包 + BTarballCmdline tarballCmdline(tarballDir, tarballName); + tarballCmdline.Tar(root, includes, excludes); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "BTarballCmdlineTest-an exception occurred by BTarballCmdline."; + } + GTEST_LOG_(INFO) << "BTarballCmdlineTest-end b_tarball_cmdline_0201"; +} + +/** + * @tc.number: SUB_b_tarball_cmdline_0202 + * @tc.name: b_tarball_cmdline_0202 + * @tc.desc: 测试BTarballCmdline类Tar函数是否成功 + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: I6F3GV + */ +HWTEST_F(BTarballCmdlineTest, b_tarball_cmdline_0202, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "BTarballCmdlineTest-begin b_tarball_cmdline_0202"; + try { + // 预置文件和目录 + TestManager tm("b_tarball_cmdline_0202"); + string root = tm.GetRootDirCurTest(); + string_view tarballDir = root; + string_view tarballName = "test.tar"; + string testDir = root + "/testdir"; + if (mkdir(testDir.data(), S_IRWXU) && errno != EEXIST) { + GTEST_LOG_(INFO) << " invoked mkdir failure, errno :" << errno; + throw BError(errno); + } + string strFile = root + tarballName.data(); + UniqueFd fd(open(strFile.data(), O_RDONLY | O_CREAT, S_IRUSR | S_IWUSR)); + if (fd < 0) { + GTEST_LOG_(INFO) << " invoked open failure, errno :" << errno; + throw BError(errno); + } + + string aFile = testDir + "/a.txt"; + string bFile = testDir + ""; + SaveStringToFile(aFile, "hello"); + SaveStringToFile(bFile, "world"); + vector includes {testDir}; + vector excludes {bFile}; + + // 调用tar打包 + BTarballCmdline tarballCmdline(tarballDir, tarballName); + tarballCmdline.Tar(root, includes, excludes); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "BTarballCmdlineTest-an exception occurred by BTarballCmdline."; + } + GTEST_LOG_(INFO) << "BTarballCmdlineTest-end b_tarball_cmdline_0202"; +} + /** * @tc.number: SUB_b_tarball_cmdline_0300 * @tc.name: b_tarball_cmdline_0300 @@ -146,4 +266,38 @@ HWTEST_F(BTarballCmdlineTest, b_tarball_cmdline_0300, testing::ext::TestSize.Lev } GTEST_LOG_(INFO) << "BTarballCmdlineTest-end b_tarball_cmdline_0300"; } + +/** + * @tc.number: SUB_b_tarball_cmdline_0301 + * @tc.name: b_tarball_cmdline_0301 + * @tc.desc: 测试BTarballCmdline类Untar函数是否成功 + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: I6F3GV + */ +HWTEST_F(BTarballCmdlineTest, b_tarball_cmdline_0301, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "BTarballCmdlineTest-begin b_tarball_cmdline_0301"; + try { + // 预置文件和目录 + TestManager tm("b_tarball_cmdline_0301"); + string root = tm.GetRootDirCurTest(); + string_view tarballDir = root; + string_view tarballName = "test.tar"; + string testUntarDir = root + ""; + if (mkdir(testUntarDir.data(), S_IRWXU) && errno != EEXIST) { + GTEST_LOG_(INFO) << " invoked mkdir failure, errno :" << errno; + throw BError(errno); + } + // 调用tar打包 + BTarballCmdline tarballCmdline(tarballDir, tarballName); + tarballCmdline.Untar(testUntarDir); + + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "BTarballCmdlineTest-an exception occurred by BTarballCmdline."; + } + GTEST_LOG_(INFO) << "BTarballCmdlineTest-end b_tarball_cmdline_0301"; +} } // namespace OHOS::FileManagement::Backup \ No newline at end of file diff --git a/tests/unittests/backup_utils/b_tarball/b_tarball_factory_test.cpp b/tests/unittests/backup_utils/b_tarball/b_tarball_factory_test.cpp index d0bd3d78329de770b0f83b39bdc15bb104ab9a93..35ba0d4e92b977dc697819731208bfbd085f23a3 100644 --- a/tests/unittests/backup_utils/b_tarball/b_tarball_factory_test.cpp +++ b/tests/unittests/backup_utils/b_tarball/b_tarball_factory_test.cpp @@ -64,4 +64,100 @@ HWTEST_F(BTarballFactoryTest, b_tarball_factory_0100, testing::ext::TestSize.Lev } GTEST_LOG_(INFO) << "BTarballFactoryTest-end b_tarball_factory_0100"; } + +/** + * @tc.number: SUB_b_tarball_factory_0200 + * @tc.name: b_tarball_factory_0200 + * @tc.desc: 测试BTarballFactory类create函数是否成功 + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: I6F3GV + */ +HWTEST_F(BTarballFactoryTest, b_tarball_factory_0200, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "BTarballFactoryTest-begin b_tarball_factory_0200"; + try { + // 预置路径 + TestManager tm("b_tarball_factory_0200"); + string root = tm.GetRootDirCurTest(); + string implType = ""; + string tarballPath = root + "/test.tar"; + SaveStringToFile(tarballPath, "data/storage/el2/database/"); + // 调用create获取打包解包能力 + auto tarballTar = BTarballFactory::Create(implType, tarballPath); + GTEST_LOG_(INFO) << "BTarballFactoryTest-tar"; + (tarballTar->tar)("/", {}, {"/data/storage/el2/database/", {}}); + GTEST_LOG_(INFO) << "BTarballFactoryTest-untar"; + (tarballTar->untar)("/"); + } catch (...) { + EXPECT_TRUE(true); + GTEST_LOG_(INFO) << "BTarballFactoryTest-an exception occurred by BTarballFactory."; + } + GTEST_LOG_(INFO) << "BTarballFactoryTest-end b_tarball_factory_0200"; +} + +/** + * @tc.number: SUB_b_tarball_factory_0300 + * @tc.name: b_tarball_factory_0300 + * @tc.desc: 测试BTarballFactory类create函数是否成功 + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: I6F3GV + */ +HWTEST_F(BTarballFactoryTest, b_tarball_factory_0300, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "BTarballFactoryTest-begin b_tarball_factory_0300"; + try { + // 预置路径 + TestManager tm("b_tarball_factory_0300"); + string root = tm.GetRootDirCurTest(); + string implType = "cmdline"; + string tarballPath = root + ""; + SaveStringToFile(tarballPath, "data/storage/el2/database/"); + // 调用create获取打包解包能力 + auto tarballTar = BTarballFactory::Create(implType, tarballPath); + GTEST_LOG_(INFO) << "BTarballFactoryTest-tar"; + (tarballTar->tar)("/", {}, {"/data/storage/el2/database/", {}}); + GTEST_LOG_(INFO) << "BTarballFactoryTest-untar"; + (tarballTar->untar)("/"); + } catch (...) { + EXPECT_TRUE(true); + GTEST_LOG_(INFO) << "BTarballFactoryTest-an exception occurred by BTarballFactory."; + } + GTEST_LOG_(INFO) << "BTarballFactoryTest-end b_tarball_factory_0300"; +} + +/** + * @tc.number: SUB_b_tarball_factory_0400 + * @tc.name: b_tarball_factory_0400 + * @tc.desc: 测试BTarballFactory类create函数是否成功 + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: I6F3GV + */ +HWTEST_F(BTarballFactoryTest, b_tarball_factory_0400, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "BTarballFactoryTest-begin b_tarball_factory_0400"; + try { + // 预置路径 + TestManager tm("b_tarball_factory_0400"); + string root = tm.GetRootDirCurTest(); + string implType = ""; + string tarballPath = root + ""; + SaveStringToFile(tarballPath, "data/storage/el2/database/"); + // 调用create获取打包解包能力 + auto tarballTar = BTarballFactory::Create(implType, tarballPath); + GTEST_LOG_(INFO) << "BTarballFactoryTest-tar"; + (tarballTar->tar)("/", {}, {"/data/storage/el2/database/", {}}); + GTEST_LOG_(INFO) << "BTarballFactoryTest-untar"; + (tarballTar->untar)("/"); + } catch (...) { + EXPECT_TRUE(true); + GTEST_LOG_(INFO) << "BTarballFactoryTest-an exception occurred by BTarballFactory."; + } + GTEST_LOG_(INFO) << "BTarballFactoryTest-end b_tarball_factory_0400"; +} } // namespace OHOS::FileManagement::Backup \ No newline at end of file