diff --git a/test/unittest/file_permission_native/BUILD.gn b/test/unittest/file_permission_native/BUILD.gn index 9e89815258792cecd86332dc75d14e1d9761de0a..bef7bfa9ca859c5012ef43d178284001561694f6 100644 --- a/test/unittest/file_permission_native/BUILD.gn +++ b/test/unittest/file_permission_native/BUILD.gn @@ -34,7 +34,6 @@ ohos_unittest("file_permission_test") { sources = [ "${app_file_service_path}/tests/mock/file_permission_native/src/sandbox_mock.cpp", "${app_file_service_path}/tests/mock/file_permission_native/src/upms_mock.cpp", - "${app_file_service_path}/tests/mock/library_func_mock/library_func_mock.cpp", "src/file_permission_test.cpp", ] diff --git a/test/unittest/file_permission_native/src/file_permission_test.cpp b/test/unittest/file_permission_native/src/file_permission_test.cpp index 3f3c2e4e8cbb37016c87aab69b8090978c413c26..c64d9b922b61af53b74b67fce92ed802d158678a 100644 --- a/test/unittest/file_permission_native/src/file_permission_test.cpp +++ b/test/unittest/file_permission_native/src/file_permission_test.cpp @@ -36,6 +36,22 @@ #include "permission_state_full.h" #include "token_setproc.h" +int fseeko(FILE *stream, off_t offset, int whence) +{ + if (OHOS::AppFileService::LibraryFunc::libraryFunc_ == nullptr) { + return -1; + } + return OHOS::AppFileService::LibraryFunc::libraryFunc_->fseeko(stream, offset, whence); +} + +int access(const char *pathname, int mode) +{ + if (OHOS::AppFileService::LibraryFunc::libraryFunc_ == nullptr) { + return -1; + } + return OHOS::AppFileService::LibraryFunc::libraryFunc_->access(pathname, mode); +} + using namespace testing; using namespace testing::ext; namespace OHOS { diff --git a/tests/mock/library_func_mock/library_func_define.h b/tests/mock/library_func_mock/library_func_define.h index c86f0582364d3a281894e98db4b7762aa043e902..dbe53e08f324578e10a470a208b62a325a017c83 100644 --- a/tests/mock/library_func_mock/library_func_define.h +++ b/tests/mock/library_func_mock/library_func_define.h @@ -28,5 +28,14 @@ #define chmod Chmod #define utime Utime #define stat(pathname, statbuf) Stat(pathname, statbuf) +#define ferror Ferror +#define fflush Fflush +#define remove Remove +#define getpwuid Getpwuid +#define getgrgid Getgrgid +#define open Open +#define read Read +#define write Write +#define close Close #endif // FILEMANAGEMENT_APP_FILE_SERVICE_LIBRARY_FUNC_DEFINE_H \ No newline at end of file diff --git a/tests/mock/library_func_mock/library_func_mock.cpp b/tests/mock/library_func_mock/library_func_mock.cpp index 8779d92dd68de475b48af1cb2f45ddc5ee463998..99645bac91a17eca9c0f16482558b670268a4ae0 100644 --- a/tests/mock/library_func_mock/library_func_mock.cpp +++ b/tests/mock/library_func_mock/library_func_mock.cpp @@ -51,7 +51,7 @@ char *Realpath(const char *path, char *resolved_path) return LibraryFunc::libraryFunc_->realpath(path, resolved_path); } -FILE* Fopen(const char *pathname, const char *mode) +FILE *Fopen(const char *pathname, const char *mode) { return LibraryFunc::libraryFunc_->fopen(pathname, mode); } @@ -74,4 +74,49 @@ int Stat(const char *pathname, struct stat *statbuf) int Utime(const char *filename, const struct utimbuf *times) { return LibraryFunc::libraryFunc_->utime(filename, times); +} + +int Ferror(FILE *f) +{ + return LibraryFunc::libraryFunc_->ferror(f); +} + +int Fflush(FILE *f) +{ + return LibraryFunc::libraryFunc_->fflush(f); +} + +int Remove(const char *path) +{ + return LibraryFunc::libraryFunc_->remove(path); +} + +struct passwd *Getpwuid(uid_t uid) +{ + return LibraryFunc::libraryFunc_->getpwuid(uid); +} + +struct group *Getgrgid(gid_t gid) +{ + return LibraryFunc::libraryFunc_->getgrgid(gid); +} + +int Open(const char *filename, int flags, ...) +{ + return LibraryFunc::libraryFunc_->open(filename, flags); +} + +ssize_t Read(int fd, void *buf, size_t count) +{ + return LibraryFunc::libraryFunc_->read(fd, buf, count); +} + +ssize_t Write(int fd, const void *buf, size_t count) +{ + return LibraryFunc::libraryFunc_->write(fd, buf, count); +} + +int Close(int fd) +{ + return LibraryFunc::libraryFunc_->close(fd); } \ No newline at end of file diff --git a/tests/mock/library_func_mock/library_func_mock.h b/tests/mock/library_func_mock/library_func_mock.h index 61e6edf124f928442382b55b54133bcd7179293e..9905a5674b65bbdb702ab6fdba487d8e31394e02 100644 --- a/tests/mock/library_func_mock/library_func_mock.h +++ b/tests/mock/library_func_mock/library_func_mock.h @@ -18,13 +18,17 @@ #include +#include #include +#include #include -#include +#include #include #include #include +#include "securec.h" + int Fseeko(FILE*, off_t, int); off_t Ftello(FILE*); int Access(const char*, int); @@ -37,6 +41,15 @@ int Fclose(FILE*); int Chmod(const char*, mode_t); int Stat(const char*, struct stat*); int Utime(const char*, const struct utimbuf*); +int Ferror(FILE*); +int Fflush(FILE*); +int Remove(const char*); +struct passwd* Getpwuid(uid_t); +struct group* Getgrgid(gid_t); +int Open(const char*, int, ...); +ssize_t Read(int, void*, size_t); +ssize_t Write(int, const void*, size_t); +int Close(int); namespace OHOS { namespace AppFileService { @@ -55,6 +68,15 @@ public: virtual int chmod(const char*, mode_t) = 0; virtual int stat(const char*, struct stat*) = 0; virtual int utime(const char*, const struct utimbuf*) = 0; + virtual int ferror(FILE*) = 0; + virtual int fflush(FILE*) = 0; + virtual int remove(const char*) = 0; + virtual struct passwd* getpwuid(uid_t) = 0; + virtual struct group *getgrgid(gid_t) = 0; + virtual int open(const char *, int) = 0; + virtual ssize_t read(int, void*, size_t) = 0; + virtual ssize_t write(int, const void*, size_t) = 0; + virtual int close(int) = 0; public: static inline std::shared_ptr libraryFunc_ = nullptr; }; @@ -73,7 +95,17 @@ public: MOCK_METHOD(int, chmod, (const char*, mode_t)); MOCK_METHOD(int, stat, (const char*, struct stat*)); MOCK_METHOD(int, utime, (const char*, const struct utimbuf*)); + MOCK_METHOD(int, ferror, (FILE*)); + MOCK_METHOD(int, fflush, (FILE*)); + MOCK_METHOD(int, remove, (const char*)); + MOCK_METHOD(passwd*, getpwuid, (uid_t)); + MOCK_METHOD(group*, getgrgid, (gid_t)); + MOCK_METHOD(int, open, (const char*, int)); + MOCK_METHOD(ssize_t, read, (int, void*, size_t)); + MOCK_METHOD(ssize_t, write, (int, const void*, size_t)); + MOCK_METHOD(int, close, (int)); }; } // namespace AppFileService } // namespace OHOS + #endif // FILEMANAGEMENT_APP_FILE_SERVICE_LIBRARY_FUNC_MOCK_H \ No newline at end of file diff --git a/tests/mock/library_func_mock/library_func_undef.h b/tests/mock/library_func_mock/library_func_undef.h index e2f0f9ae95d01a911485873511573dc28df96958..e488abecc348bc77c041a7a78212ebb3cd981505 100644 --- a/tests/mock/library_func_mock/library_func_undef.h +++ b/tests/mock/library_func_mock/library_func_undef.h @@ -28,5 +28,14 @@ #define Chmod chmod #define Utime utime #define Stat(pathname, statbuf) stat(pathname, statbuf) +#define Ferror ferror +#define Fflush fflush +#define Remove remove +#define Getpwuid getpwuid +#define Getgrgid getgrgid +#define Open open +#define Read read +#define Write write +#define Close close #endif // FILEMANAGEMENT_APP_FILE_SERVICE_LIBRARY_FUNC_UNDEF_H \ No newline at end of file diff --git a/tests/unittests/backup_ext/BUILD.gn b/tests/unittests/backup_ext/BUILD.gn index 849943f247ed548a33f3bb94ee35e90ac2cec557..20195587ee7b84bb3bd5fb0a3d0e5428b6154c88 100644 --- a/tests/unittests/backup_ext/BUILD.gn +++ b/tests/unittests/backup_ext/BUILD.gn @@ -401,6 +401,40 @@ ohos_unittest("ext_backup_js_test") { use_exceptions = true } +ohos_unittest("tar_file_sub_test") { + module_out_path = path_module_out_tests + + sources = [ + "${path_backup}/tests/mock/library_func_mock/library_func_mock.cpp", + "tar_file_sub_test.cpp", + ] + + include_dirs = [ + "${path_backup}/frameworks/native/backup_ext/include", + "${path_backup}/frameworks/native/backup_ext/src", + "${path_backup}/tests/mock/library_func_mock", + "${path_backup}/utils/include", + "${path_backup}/utils/include/b_hilog", + ] + + cflags = [ "--coverage" ] + ldflags = [ "--coverage" ] + cflags_cc = [ "--coverage" ] + + deps = [ "${path_backup}/utils:backup_utils" ] + + external_deps = [ + "c_utils:utils", + "googletest:gmock_main", + "googletest:gtest_main", + "hilog:libhilog", + ] + + defines = [ "private=public" ] + + use_exceptions = true +} + group("backup_ext_test") { testonly = true if (!use_libfuzzer) { @@ -408,6 +442,7 @@ group("backup_ext_test") { ":ext_backup_js_test", ":ext_extension_stub_test", ":ext_extension_test", + ":tar_file_sub_test", ":tar_file_test", ":untar_file_sup_test", ":untar_file_test", diff --git a/tests/unittests/backup_ext/tar_file_sub_test.cpp b/tests/unittests/backup_ext/tar_file_sub_test.cpp index 864bb2a9deee4ad70766291e1b65fa2339fe3691..433d43175aad22d1462f3c5b244a5a8ff1f333cd 100644 --- a/tests/unittests/backup_ext/tar_file_sub_test.cpp +++ b/tests/unittests/backup_ext/tar_file_sub_test.cpp @@ -67,49 +67,209 @@ void TarFileSubTest::TearDownTestCase() } /** - * @tc.number: SUB_Tar_File_CopyData_0100 - * @tc.name: SUB_Tar_File_CopyData_0100 - * @tc.desc: 测试 CopyData 接口 + * @tc.number: SUB_Tar_File_SplitWriteAll_0100 + * @tc.name: SUB_Tar_File_SplitWriteAll_0100 + * @tc.desc: 测试 SplitWriteAll 接口 * @tc.size: MEDIUM * @tc.type: FUNC * @tc.level Level 1 * @tc.require: I6F3GV */ -HWTEST_F(TarFileSubTest, SUB_Tar_File_CopyData_0100, testing::ext::TestSize.Level1) +HWTEST_F(TarFileSubTest, SUB_Tar_File_SplitWriteAll_0100, testing::ext::TestSize.Level1) { - GTEST_LOG_(INFO) << "TarFileSubTest-begin SUB_Tar_File_CopyData_0100"; + GTEST_LOG_(INFO) << "TarFileSubTest-begin SUB_Tar_File_SplitWriteAll_0100"; try { - TarHeader hdr; - string mode; - string uid; - string gid; - string size; - - EXPECT_CALL(*funcMock, memcpy_s(_, _, _, _)).WillOnce(Return(-1)); - auto ret = CopyData(hdr, mode, uid, gid, size); - EXPECT_FALSE(ret); - - EXPECT_CALL(*funcMock, memcpy_s(_, _, _, _)).WillOnce(Return(EOK)).WillOnce(Return(-1)); - ret = CopyData(hdr, mode, uid, gid, size); - EXPECT_FALSE(ret); - - EXPECT_CALL(*funcMock, memcpy_s(_, _, _, _)).WillOnce(Return(EOK)).WillOnce(Return(EOK)).WillOnce(Return(-1)); - ret = CopyData(hdr, mode, uid, gid, size); - EXPECT_FALSE(ret); - - EXPECT_CALL(*funcMock, memcpy_s(_, _, _, _)).WillOnce(Return(EOK)).WillOnce(Return(EOK)).WillOnce(Return(EOK)) - .WillOnce(Return(-1)); - ret = CopyData(hdr, mode, uid, gid, size); - EXPECT_FALSE(ret); - - EXPECT_CALL(*funcMock, memcpy_s(_, _, _, _)).WillOnce(Return(EOK)).WillOnce(Return(EOK)).WillOnce(Return(EOK)) - .WillOnce(Return(0)); - ret = CopyData(hdr, mode, uid, gid, size); - EXPECT_TRUE(ret); + vector ioBuffer {0, 0, 0, 0, 0}; + EXPECT_CALL(*funcMock, fwrite(_, _, _, _)).WillOnce(Return(ioBuffer.size())); + auto ret = TarFile::GetInstance().SplitWriteAll(ioBuffer, 5); + EXPECT_EQ(ret, ioBuffer.size()); + + EXPECT_CALL(*funcMock, fwrite(_, _, _, _)).WillOnce(Return(0)).WillOnce(Return(ioBuffer.size())); + ret = TarFile::GetInstance().SplitWriteAll(ioBuffer, 5); + EXPECT_EQ(ret, ioBuffer.size()); + + EXPECT_CALL(*funcMock, fwrite(_, _, _, _)).WillOnce(Return(0)).WillOnce(Return(0)); + ret = TarFile::GetInstance().SplitWriteAll(ioBuffer, 5); + EXPECT_EQ(ret, 0); + + EXPECT_CALL(*funcMock, fwrite(_, _, _, _)).WillOnce(Return(4)); + ret = TarFile::GetInstance().SplitWriteAll(ioBuffer, 4); + EXPECT_EQ(ret, 4); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "TarFileSubTest-an exception occurred by TarFile."; + } + GTEST_LOG_(INFO) << "TarFileSubTest-end SUB_Tar_File_SplitWriteAll_0100"; +} + +/** + * @tc.number: SUB_Tar_File_CreateSplitTarFile_0100 + * @tc.name: SUB_Tar_File_CreateSplitTarFile_0100 + * @tc.desc: 测试 CreateSplitTarFile 接口 + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: I6F3GV + */ +HWTEST_F(TarFileSubTest, SUB_Tar_File_CreateSplitTarFile_0100, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "TarFileSubTest-begin SUB_Tar_File_CreateSplitTarFile_0100"; + try { + TarFile::GetInstance().currentTarFile_ = nullptr; + EXPECT_CALL(*funcMock, fopen(_, _)).WillOnce(Return(nullptr)); + EXPECT_THROW(TarFile::GetInstance().CreateSplitTarFile(), BError); + + int n = 0; + TarFile::GetInstance().currentTarFile_ = reinterpret_cast(&n); + EXPECT_CALL(*funcMock, fclose(_)).WillOnce(Return(0)); + EXPECT_CALL(*funcMock, fopen(_, _)).WillOnce(Return(reinterpret_cast(&n))); + EXPECT_TRUE(TarFile::GetInstance().CreateSplitTarFile()); + TarFile::GetInstance().currentTarFile_ = nullptr; + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "TarFileSubTest-an exception occurred by TarFile."; + } + GTEST_LOG_(INFO) << "TarFileSubTest-end SUB_Tar_File_CreateSplitTarFile_0100"; +} + +/** + * @tc.number: SUB_Tar_File_FillSplitTailBlocks_0100 + * @tc.name: SUB_Tar_File_FillSplitTailBlocks_0100 + * @tc.desc: 测试 FillSplitTailBlocks 接口 + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: I6F3GV + */ +HWTEST_F(TarFileSubTest, SUB_Tar_File_FillSplitTailBlocks_0100, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "TarFileSubTest-begin SUB_Tar_File_FillSplitTailBlocks_0100"; + try { + TarFile::GetInstance().currentTarFile_ = nullptr; + EXPECT_THROW(TarFile::GetInstance().FillSplitTailBlocks(), BError); + + int n = 0; + const int END_BLOCK_SIZE = 1024; + TarFile::GetInstance().currentTarFile_ = reinterpret_cast(&n); + EXPECT_CALL(*funcMock, fwrite(_, _, _, _)).WillOnce(Return(END_BLOCK_SIZE)); + EXPECT_CALL(*funcMock, ferror(_)).WillOnce(Return(0)); + EXPECT_CALL(*funcMock, fflush(_)).WillOnce(Return(0)); + EXPECT_CALL(*funcMock, stat(_, _)).WillOnce(Return(-1)); + EXPECT_THROW(TarFile::GetInstance().FillSplitTailBlocks(), BError); + + TarFile::GetInstance().tarFileCount_ = 1; + TarFile::GetInstance().fileCount_ = 0; + TarFile::GetInstance().currentTarFile_ = reinterpret_cast(&n); + EXPECT_CALL(*funcMock, fwrite(_, _, _, _)).WillOnce(Return(END_BLOCK_SIZE)); + EXPECT_CALL(*funcMock, ferror(_)).WillOnce(Return(0)); + EXPECT_CALL(*funcMock, fflush(_)).WillOnce(Return(0)); + EXPECT_CALL(*funcMock, stat(_, _)).WillOnce(Return(0)); + EXPECT_CALL(*funcMock, fclose(_)).WillOnce(Return(0)); + EXPECT_CALL(*funcMock, remove(_)).WillOnce(Return(0)); + EXPECT_TRUE(TarFile::GetInstance().FillSplitTailBlocks()); + + TarFile::GetInstance().fileCount_ = 1; + TarFile::GetInstance().isReset_ = true; + TarFile::GetInstance().currentTarFile_ = reinterpret_cast(&n); + EXPECT_CALL(*funcMock, fwrite(_, _, _, _)).WillOnce(Return(END_BLOCK_SIZE)); + EXPECT_CALL(*funcMock, ferror(_)).WillOnce(Return(0)); + EXPECT_CALL(*funcMock, fflush(_)).WillOnce(Return(0)); + EXPECT_CALL(*funcMock, stat(_, _)).WillOnce(Return(0)); + EXPECT_CALL(*funcMock, fclose(_)).WillOnce(Return(0)); + EXPECT_TRUE(TarFile::GetInstance().FillSplitTailBlocks()); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "TarFileSubTest-an exception occurred by TarFile."; + } + GTEST_LOG_(INFO) << "TarFileSubTest-end SUB_Tar_File_FillSplitTailBlocks_0100"; +} + +/** + * @tc.number: SUB_Tar_File_FillSplitTailBlocks_0200 + * @tc.name: SUB_Tar_File_FillSplitTailBlocks_0200 + * @tc.desc: 测试 FillSplitTailBlocks 接口 + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: I6F3GV + */ +HWTEST_F(TarFileSubTest, SUB_Tar_File_FillSplitTailBlocks_0200, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "TarFileSubTest-begin SUB_Tar_File_FillSplitTailBlocks_0200"; + try { + TarFile::GetInstance().currentTarFile_ = nullptr; + EXPECT_THROW(TarFile::GetInstance().FillSplitTailBlocks(), BError); + + int n = 0; + const int END_BLOCK_SIZE = 1024; + TarFile::GetInstance().fileCount_ = 0; + TarFile::GetInstance().tarFileCount_ = 0; + TarFile::GetInstance().isReset_ = false; + TarFile::GetInstance().currentTarFile_ = reinterpret_cast(&n); + EXPECT_CALL(*funcMock, fwrite(_, _, _, _)).WillOnce(Return(END_BLOCK_SIZE)); + EXPECT_CALL(*funcMock, ferror(_)).WillOnce(Return(0)); + EXPECT_CALL(*funcMock, fflush(_)).WillOnce(Return(0)); + EXPECT_CALL(*funcMock, stat(_, _)).WillOnce(Return(0)); + EXPECT_CALL(*funcMock, fclose(_)).WillOnce(Return(0)); + EXPECT_TRUE(TarFile::GetInstance().FillSplitTailBlocks()); + + struct stat sta { .st_size = 1 }; + TarFile::GetInstance().currentTarFile_ = reinterpret_cast(&n); + EXPECT_CALL(*funcMock, fwrite(_, _, _, _)).WillOnce(Return(END_BLOCK_SIZE)); + EXPECT_CALL(*funcMock, ferror(_)).WillOnce(Return(0)); + EXPECT_CALL(*funcMock, fflush(_)).WillOnce(Return(0)); + EXPECT_CALL(*funcMock, stat(_, _)).WillOnce(DoAll(SetArgPointee<1>(sta), Return(0))); + EXPECT_CALL(*funcMock, fclose(_)).WillOnce(Return(0)); + EXPECT_TRUE(TarFile::GetInstance().FillSplitTailBlocks()); + } catch (...) { + EXPECT_TRUE(false); + GTEST_LOG_(INFO) << "TarFileSubTest-an exception occurred by TarFile."; + } + GTEST_LOG_(INFO) << "TarFileSubTest-end SUB_Tar_File_FillSplitTailBlocks_0200"; +} + +/** + * @tc.number: SUB_Tar_File_WriteFileContent_0100 + * @tc.name: SUB_Tar_File_WriteFileContent_0100 + * @tc.desc: 测试 WriteFileContent 接口 + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + * @tc.require: I6F3GV + */ +HWTEST_F(TarFileSubTest, SUB_Tar_File_WriteFileContent_0100, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "TarFileSubTest-begin SUB_Tar_File_WriteFileContent_0100"; + try { + string fileName = "fileName"; + off_t size = 0; + int err = 0; + EXPECT_CALL(*funcMock, open(_, _)).WillOnce(Return(-1)); + EXPECT_FALSE(TarFile::GetInstance().WriteFileContent(fileName, size, err)); + + TarFile::GetInstance().ioBuffer_.resize(BLOCK_SIZE); + EXPECT_CALL(*funcMock, open(_, _)).WillOnce(Return(0)); + EXPECT_CALL(*funcMock, read(_, _, _)).WillOnce(Return(BLOCK_SIZE)); + EXPECT_CALL(*funcMock, close(_)).WillOnce(Return(0)); + EXPECT_FALSE(TarFile::GetInstance().WriteFileContent(fileName, 1, err)); + + TarFile::GetInstance().ioBuffer_.resize(BLOCK_SIZE); + EXPECT_CALL(*funcMock, open(_, _)).WillOnce(Return(0)); + EXPECT_CALL(*funcMock, read(_, _, _)).WillOnce(Return(BLOCK_SIZE)); + EXPECT_CALL(*funcMock, fwrite(_, _, _, _)).WillOnce(Return(BLOCK_SIZE + 1)); + EXPECT_CALL(*funcMock, close(_)).WillOnce(Return(0)); + EXPECT_FALSE(TarFile::GetInstance().WriteFileContent(fileName, BLOCK_SIZE, err)); + + TarFile::GetInstance().ioBuffer_.resize(BLOCK_SIZE); + EXPECT_CALL(*funcMock, open(_, _)).WillOnce(Return(0)); + EXPECT_CALL(*funcMock, read(_, _, _)).WillOnce(Return(BLOCK_SIZE)); + EXPECT_CALL(*funcMock, fwrite(_, _, _, _)).WillOnce(Return(BLOCK_SIZE)); + EXPECT_CALL(*funcMock, close(_)).WillOnce(Return(0)); + EXPECT_TRUE(TarFile::GetInstance().WriteFileContent(fileName, BLOCK_SIZE, err)); } catch (...) { EXPECT_TRUE(false); GTEST_LOG_(INFO) << "TarFileSubTest-an exception occurred by TarFile."; } - GTEST_LOG_(INFO) << "TarFileSubTest-end SUB_Tar_File_CopyData_0100"; + GTEST_LOG_(INFO) << "TarFileSubTest-end SUB_Tar_File_WriteFileContent_0100"; } } // namespace OHOS::FileManagement::Backup \ No newline at end of file diff --git a/utils/src/b_hiaudit/zip_util.cpp b/utils/src/b_hiaudit/zip_util.cpp index 41994b82afac645a86baa82535551cb9560e75b5..321e916c663bb35c0ecf9d1811b4954c45eb7480 100644 --- a/utils/src/b_hiaudit/zip_util.cpp +++ b/utils/src/b_hiaudit/zip_util.cpp @@ -57,6 +57,8 @@ int ZipUtil::AddFileInZip(zipFile &zipfile, const std::string &srcFile, int keep Z_DEFLATED, Z_DEFAULT_COMPRESSION); if (errcode != Z_OK) { HILOGE("zipOpenNewFileInZip failed:%{public}s, errno: %{public}d.", srcFile.c_str(), errcode); + (void)fclose(srcFp); + zipCloseFileInZip(zipfile); return errcode; }