From f38c8600b288ae588e1b324d89054f869fc94b53 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=88=98=E6=B8=8A?= Date: Thu, 28 Aug 2025 10:28:46 +0800 Subject: [PATCH 01/17] use decompress for full restore MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 刘渊 --- frameworks/native/backup_ext/src/ext_extension.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/frameworks/native/backup_ext/src/ext_extension.cpp b/frameworks/native/backup_ext/src/ext_extension.cpp index 3f1964279..e2cfbd9fb 100644 --- a/frameworks/native/backup_ext/src/ext_extension.cpp +++ b/frameworks/native/backup_ext/src/ext_extension.cpp @@ -912,6 +912,7 @@ int BackupExtExtension::DoRestore(const string &fileName, const off_t fileSize) if (!extension_->SpecialVersionForCloneAndCloud() && !extension_->UseFullBackupOnly()) { path = "/"; } + tarName = TarFile::GetInstance().DecompressTar(tarName); auto [ret, fileInfos, errInfos] = UntarFile::GetInstance().UnPacket(tarName, path); if (isDebug_) { if (ret != 0) { -- Gitee From d16c667dfa48ce9ac4661c0bbce81f96131c62a3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=88=98=E6=B8=8A?= Date: Mon, 1 Sep 2025 16:40:10 +0800 Subject: [PATCH 02/17] USE COMPRESS ONLY WHEN tar is over 10M MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 刘渊 --- frameworks/native/backup_ext/src/tar_file.cpp | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/frameworks/native/backup_ext/src/tar_file.cpp b/frameworks/native/backup_ext/src/tar_file.cpp index 5b5d718b0..c54d2dc9c 100644 --- a/frameworks/native/backup_ext/src/tar_file.cpp +++ b/frameworks/native/backup_ext/src/tar_file.cpp @@ -53,9 +53,10 @@ const string VERSION = "1.0"; const string LONG_LINK_SYMBOL = "longLinkSymbol"; const string COMPRESS_FILE_SUFFIX = "__A"; const string TAR_EXTENSION = ".tar"; +constexpr int64_t COMPRESS_BOUND = 10 * 1024 * 1024; #ifdef BROTLI_ENABLED constexpr int MEGA_BYTE = 1024 * 1024; -constexpr int BROTLI_QUALITY = 3; +constexpr int BROTLI_QUALITY = 1; constexpr bool USE_COMPRESS = false; // 默认关闭 #else constexpr bool USE_COMPRESS = false; @@ -514,10 +515,10 @@ bool TarFile::FillSplitTailBlocks() HILOGI("tarFileName:%{public}s, currentTarName:%{public}s, newTarPath:%{public}s", GetAnonyPath(tarFileName_).c_str(), GetAnonyPath(currentTarName_).c_str(), GetAnonyPath(newTarPath).c_str()); - if (!CompressFile(fullTarPath, newTarPath)) { - tarMap_.emplace(tarFileName_, make_tuple(currentTarName_, staTar, false)); - } else { + if (staTar.st_size > COMPRESS_BOUND && CompressFile(fullTarPath, newTarPath)) { tarMap_.emplace(tarNewName, make_tuple(newTarPath, staTar, false)); + } else { + tarMap_.emplace(tarFileName_, make_tuple(currentTarName_, staTar, false)); } } else { tarMap_.emplace(tarFileName_, make_tuple(currentTarName_, staTar, false)); -- Gitee From b8f64252b57bc6905e8ad9c130bb8f7b0494872d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=88=98=E6=B8=8A?= Date: Thu, 4 Sep 2025 21:13:07 +0800 Subject: [PATCH 03/17] use lz4 for compress MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 刘渊 --- backup.gni | 13 +- bundle.json | 1 + frameworks/native/backup_ext/BUILD.gn | 4 + .../native/backup_ext/include/tar_file.h | 48 ++++- frameworks/native/backup_ext/src/tar_file.cpp | 183 +++++++++++++----- 5 files changed, 192 insertions(+), 57 deletions(-) diff --git a/backup.gni b/backup.gni index d6149f38f..f06ea7dbb 100644 --- a/backup.gni +++ b/backup.gni @@ -43,10 +43,15 @@ backup_mock_proxy_src = [ ] declare_args() { - brotli_enabled = true - if (defined(global_parts_info) && - (!defined(global_parts_info.thirdparty_brotli) || !global_parts_info.thirdparty_brotli)) { - brotli_enabled = false + brotli_enabled = false + if (defined(global_parts_info) && defined(global_parts_info.thirdparty_brotli) && + global_parts_info.thirdparty_brotli) { + brotli_enabled = true + } + lz4_enabled = false + if (defined(global_parts_info) && defined(global_parts_info.thirdparty_lz4) && + global_parts_info.thirdparty_lz4) { + lz4_enabled = true } if (current_cpu == "arm" || current_cpu == "x86") { system_bit = 32 diff --git a/bundle.json b/bundle.json index e1b4b64ac..9eb9d7c51 100644 --- a/bundle.json +++ b/bundle.json @@ -40,6 +40,7 @@ "init", "json", "jsoncpp", + "lz4", "napi", "runtime_core", "openssl", diff --git a/frameworks/native/backup_ext/BUILD.gn b/frameworks/native/backup_ext/BUILD.gn index 27a36aae5..8faa5313f 100644 --- a/frameworks/native/backup_ext/BUILD.gn +++ b/frameworks/native/backup_ext/BUILD.gn @@ -83,6 +83,10 @@ ohos_shared_library("backup_extension_ability_native") { external_deps += ["brotli:brotli_shared"] defines += ["BROTLI_ENABLED"] } + if (lz4_enabled) { + external_deps += ["lz4:liblz4_static"] + defines += ["LZ4_ENABLED"] + } if (system_bit == 32) { defines += ["SYSTEM_BIT_32"] } else { diff --git a/frameworks/native/backup_ext/include/tar_file.h b/frameworks/native/backup_ext/include/tar_file.h index bed12aacd..be1b6a701 100644 --- a/frameworks/native/backup_ext/include/tar_file.h +++ b/frameworks/native/backup_ext/include/tar_file.h @@ -99,17 +99,53 @@ public: FILE* file_ = nullptr; }; -template class Buffer { public: Buffer(size_t size); Buffer(const Buffer&) = delete; Buffer& operator=(const Buffer&) = delete; ~Buffer(); - T* data_ = nullptr; + char* data_ = nullptr; size_t size_ = 0; }; +class ICompressStrategy { +public: + size_t GetMaxCompressedSize(size_t inputSize); + virtual bool CompressBuffer(Buffer input, Buffer &output) = 0; + virtual bool DecompressBuffer(Buffer compressed, Buffer origin) = 0; + virtual std::string GetFileSuffix() = 0; +protected: + virtual size_t GetMaxCompressedSizeInner(size_t inputSize) = 0; + std::map maxSizeCache_; +} + +class BrotilCompress : public ICompressStrategy { +public: + bool CompressBuffer(Buffer input, Buffer &output) override; + bool DecompressBuffer(Buffer compressed, Buffer origin) override; + std::string GetFileSuffix() override + { + return COMPRESS_FILE_SUFFIX; + } +protected: + size_t GetMaxCompressedSizeInner(size_t inputSize) override; + const string COMPRESS_FILE_SUFFIX = "__BRO"; +} + +class Lz4Compress : public ICompressStrategy { +public: + bool CompressBuffer(Buffer input, Buffer &output) override; + bool DecompressBuffer(Buffer compressed, Buffer origin) override; + std::string GetFileSuffix() override + { + return COMPRESS_FILE_SUFFIX; + } +protected: + size_t GetMaxCompressedSizeInner(size_t inputSize) override; + const string COMPRESS_FILE_SUFFIX = "__LZ4"; +} + class TarFile { public: static TarFile &GetInstance(); @@ -135,10 +171,10 @@ public: bool DecompressFile(const std::string &compFile, const std::string &srcFile); std::string DecompressTar(const std::string &tarPath); private: - bool WriteCompressData(Buffer& compressBuffer, const Buffer& ori, UniqueFile& fout); - bool WriteDecompressData(const Buffer& compressBuffer, Buffer& decompressBuffer, + bool WriteCompressData(Buffer& compressBuffer, const Buffer& ori, UniqueFile& fout); + bool WriteDecompressData(const Buffer& compressBuffer, Buffer& decompressBuffer, UniqueFile& fout, std::chrono::duration& decompSpan); - TarFile() {} + TarFile(); ~TarFile() = default; TarFile(const TarFile &instance) = delete; TarFile &operator=(const TarFile &instance) = delete; @@ -276,6 +312,8 @@ private: std::string currentFileName_ {}; bool isReset_ = false; + + std::shared_ptr compressTool_; }; } // namespace OHOS::FileManagement::Backup diff --git a/frameworks/native/backup_ext/src/tar_file.cpp b/frameworks/native/backup_ext/src/tar_file.cpp index c54d2dc9c..04a4d0bd9 100644 --- a/frameworks/native/backup_ext/src/tar_file.cpp +++ b/frameworks/native/backup_ext/src/tar_file.cpp @@ -34,10 +34,18 @@ #include "securec.h" #ifdef BROTLI_ENABLED +#define USE_COMPRESS true #include "brotli/encode.h" #include "brotli/decode.h" #endif +#ifdef LZ4_ENABLED +#ifndef USE_COMPRESS +#define USE_COMPRESS true +#endif +#include "lz4" +#endif + namespace OHOS::FileManagement::Backup { using namespace std; namespace { @@ -51,16 +59,18 @@ const uint32_t WAIT_INDEX = 100000; const uint32_t WAIT_TIME = 5; const string VERSION = "1.0"; const string LONG_LINK_SYMBOL = "longLinkSymbol"; -const string COMPRESS_FILE_SUFFIX = "__A"; const string TAR_EXTENSION = ".tar"; constexpr int64_t COMPRESS_BOUND = 10 * 1024 * 1024; -#ifdef BROTLI_ENABLED +#ifdef USE_COMPRESS constexpr int MEGA_BYTE = 1024 * 1024; -constexpr int BROTLI_QUALITY = 1; constexpr bool USE_COMPRESS = false; // 默认关闭 #else constexpr bool USE_COMPRESS = false; #endif + +#ifdef BROTIL_ENABLED +constexpr int BROTLI_QUALITY = 1; +#endif } // namespace UniqueFile::UniqueFile(const char* filePath, const char* mode) @@ -81,13 +91,12 @@ UniqueFile::~UniqueFile() file_ = nullptr; } -template -Buffer::Buffer(size_t size) +Buffer::Buffer(size_t size) { if (size <= 0 || size > MAX_BUFFER_SIZE) { return; } - data_ = new (std::nothrow) T[size]; + data_ = new (std::nothrow) char[size]; if (data_ == nullptr) { HILOGE("new fail, size=%{public}zu", size); return; @@ -95,20 +104,124 @@ Buffer::Buffer(size_t size) size_ = size; } -template -Buffer::~Buffer() +Buffer::~Buffer() { if (data_ != nullptr) { delete[] data_; } } +size_t ICompressStrategy::GetMaxCompressedSize(size_t inputSize) +{ + if (maxSizeCache_.count(inputSize) > 0) { + return maxSizeCache_[inputSize]; + } + size_t maxSize = GetMaxCompressedSizeInner(inputSize); + maxSizeCache_[inputSize] = maxSize; + return maxSize; +} + +bool BrotilCompress::CompressBuffer(Buffer input, Buffer &output) +{ +#ifdef BROTLI_ENABLED + int ret = BrotliEncoderCompress(BROTLI_QUALITY, BROTLI_MAX_WINDOW_BITS, BROTLI_DEFAULT_MODE, + input.size_, (const uint8_t*)input.data_, output.size_, output.data_); + if (ret != BROTLI_TRUE) { + HILOGE("compress fail, error: %{public}d", ret); + return false; + } + return true; +#else + return false; +#endif +} + +bool BrotilCompress::DecompressBuffer(Buffer compressed, Buffer origin) +{ +#ifdef BROTLI_ENABLED + int ret = BrotliDecoderDecompress(compressed.size_, (const uint8_t*)compressed.data_, origin.size_, origin.data_); + if (ret != BROTLI_TRUE) { + HILOGE("decompress fail, error: %{public}d", ret); + return false; + } + return true; +#else + return false; +#endif +} + +size_t BrotilCompress::GetMaxCompressedSizeInner(size_t inputSize) +{ +#ifdef BROTLI_ENABLED + return BrotliEncoderMaxCompressedSize(inputSize); +#else + return 0; +#endif +} + +bool Lz4Compress::CompressBuffer(Buffer input, Buffer &output) +{ +#ifdef LZ4_ENABLED + int compressedSize = LZ4_compress_default(input.data_, output.data_, input.size_, + GetMaxCompressedSizeInner(input.size_)); + if (compressedSize <= 0) { + HILOGE("compress fail, error: %{public}d", compressedSize); + return false; + } + output.size_ = compressedSize; + return true; +#else + return false; +#endif +} + +bool Lz4Compress::DecompressBuffer(Buffer compressed, Buffer origin) +{ +#ifdef LZ4_ENABLED + int decompressedSize = LZ4_decompress_safe(compressed.data_, origin.data_, compressed.size_, origin.size_); + if (decompressedSize <= 0) { + HILOGE("decompress fail, error: %{public}d", decompressedSize); + return false; + } + if (decompressedSize != origin.size_) { + HILOGE("decompress size(%{public}d) != origin size(%{public}d).", decompressedSize, origin.size_); + return false; + } + return true; +#else + return false; +#endif +} + +size_t Lz4Compress::GetMaxCompressedSizeInner(size_t inputSize) +{ +#ifdef LZ4_ENABLED + if (inputSize > LZ4_MAX_INPUT_SIZE) { + HILOGE("input size is over max size"); + return 0; + } + int maxSize = LZ4_compressBound(inputSize); + if (maxSize <= 0) { + HILOGE("maxSize is invalid:%{public}d", maxSize); + return 0; + } + return maxSize; +#else + return 0; +#endif +} + TarFile &TarFile::GetInstance() { static TarFile instance; return instance; } +TarFile::TarFile() +{ + compressTool_ = std::make_shared(); +} + bool TarFile::Packet(const vector &srcFiles, const string &tarFileName, const string &pkPath, TarMap &tarMap, std::function reportCb) { @@ -510,7 +623,7 @@ bool TarFile::FillSplitTailBlocks() std::filesystem::path fullTarPath = currentTarName_; // 全量路径 std::filesystem::path parentPath = fullTarPath.parent_path(); std::filesystem::path fileNameWithoutExtension = fullTarPath.stem(); // 文件名前缀 - std::string tarNewName = fileNameWithoutExtension.string() + COMPRESS_FILE_SUFFIX + TAR_EXTENSION; + std::string tarNewName = fileNameWithoutExtension.string() + compressTool_->GetFileSuffix() + TAR_EXTENSION; string newTarPath = parentPath.string() + "/" + tarNewName; HILOGI("tarFileName:%{public}s, currentTarName:%{public}s, newTarPath:%{public}s", GetAnonyPath(tarFileName_).c_str(), GetAnonyPath(currentTarName_).c_str(), @@ -720,32 +833,7 @@ void TarFile::SetPacketMode(bool isReset) isReset_ = isReset; } -bool TarFile::Compress(const uint8_t* inputBuffer, size_t inputSize, uint8_t* outputBuffer, size_t* outputSize) -{ -#ifdef BROTLI_ENABLED - int ret = BrotliEncoderCompress(BROTLI_QUALITY, BROTLI_MAX_WINDOW_BITS, BROTLI_DEFAULT_MODE, - inputSize, inputBuffer, outputSize, outputBuffer); - if (ret != BROTLI_TRUE) { - HILOGE("compress fail, error: %{public}d", ret); - return false; - } -#endif - return true; -} - -bool TarFile::Decompress(const uint8_t* inputBuffer, size_t inputSize, uint8_t* outputBuffer, size_t* outputSize) -{ -#ifdef BROTLI_ENABLED - int ret = BrotliDecoderDecompress(inputSize, inputBuffer, outputSize, outputBuffer); - if (ret != BROTLI_TRUE) { - HILOGE("decompress fail, error: %{public}d", ret); - return false; - } -#endif - return true; -} - -bool TarFile::WriteCompressData(Buffer& compressBuffer, const Buffer& ori, UniqueFile& fout) +bool TarFile::WriteCompressData(Buffer& compressBuffer, const Buffer& ori, UniqueFile& fout) { size_t sizeCount = 1; char* writeData = (char *)compressBuffer.data_; @@ -772,7 +860,7 @@ bool TarFile::WriteCompressData(Buffer& compressBuffer, const Buffer ori(BLOCK_SIZE); + Buffer ori(BLOCK_SIZE); if (ori.data_ == nullptr) { HILOGE("new ori buffer fail!"); return false; } - size_t maxSize = BrotliEncoderMaxCompressedSize(BLOCK_SIZE); - Buffer compressBuffer(maxSize); - if (compressBuffer.data_ == nullptr) { + size_t maxSize = compressTool_->GetMaxCompressedSize(BLOCK_SIZE); + Buffer compressBuffer(maxSize); + if (maxSize == 0 || compressBuffer.data_ == nullptr) { HILOGE("new compress buffer fail!"); return false; } @@ -797,7 +885,7 @@ bool TarFile::CompressFile(const std::string &srcFile, const std::string &compFi while ((ori.size_ = fread(ori.data_, 1, BLOCK_SIZE, fin.file_)) > 0) { compressBuffer.size_ = maxSize; auto startTime = std::chrono::high_resolution_clock::now(); - if (!Compress((const uint8_t*)(ori.data_), ori.size_, compressBuffer.data_, &compressBuffer.size_)) { + if (!compressTool_->CompressBuffer(ori, compressBuffer)) { return false; } compSpan += (std::chrono::high_resolution_clock::now() - startTime); @@ -814,7 +902,7 @@ bool TarFile::CompressFile(const std::string &srcFile, const std::string &compFi return true; } -bool TarFile::WriteDecompressData(const Buffer& compressBuffer, Buffer& decompressBuffer, +bool TarFile::WriteDecompressData(const Buffer& compressBuffer, Buffer& decompressBuffer, UniqueFile& fout, std::chrono::duration& decompSpan) { size_t written = 0; @@ -822,8 +910,7 @@ bool TarFile::WriteDecompressData(const Buffer& compressBuffer, BufferDecompressBuffer(compressBuffer, decompressBuffer)) { return false; } decompSpan += (std::chrono::high_resolution_clock::now() - startTime); @@ -838,7 +925,7 @@ bool TarFile::WriteDecompressData(const Buffer& compressBuffer, Buffer decompressBuffer(BLOCK_SIZE); - Buffer compressBuffer(BLOCK_SIZE); + Buffer decompressBuffer(BLOCK_SIZE); + Buffer compressBuffer(BLOCK_SIZE); if (decompressBuffer.data_ == nullptr || compressBuffer.data_ == nullptr) { HILOGE("new buffer fail!"); return false; @@ -890,7 +977,7 @@ std::string TarFile::DecompressTar(const std::string &tarPath) std::filesystem::path filePath = tarPath; std::filesystem::path parentPath = filePath.parent_path(); std::filesystem::path fileNameWithoutExtension = filePath.stem(); - size_t pos = fileNameWithoutExtension.string().rfind(COMPRESS_FILE_SUFFIX); + size_t pos = fileNameWithoutExtension.string().rfind(compressTool_->GetFileSuffix()); if (pos == std::string::npos) { return tarPath; } -- Gitee From e46d4c82e7620d051ae185fd0f0c0825399b5f93 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=88=98=E6=B8=8A?= Date: Thu, 4 Sep 2025 21:47:34 +0800 Subject: [PATCH 04/17] fix compile bug MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 刘渊 --- .../native/backup_ext/include/tar_file.h | 22 +++++++++---------- frameworks/native/backup_ext/src/tar_file.cpp | 21 +++++++++--------- 2 files changed, 22 insertions(+), 21 deletions(-) diff --git a/frameworks/native/backup_ext/include/tar_file.h b/frameworks/native/backup_ext/include/tar_file.h index be1b6a701..a034e62d8 100644 --- a/frameworks/native/backup_ext/include/tar_file.h +++ b/frameworks/native/backup_ext/include/tar_file.h @@ -112,39 +112,39 @@ public: class ICompressStrategy { public: size_t GetMaxCompressedSize(size_t inputSize); - virtual bool CompressBuffer(Buffer input, Buffer &output) = 0; - virtual bool DecompressBuffer(Buffer compressed, Buffer origin) = 0; + virtual bool CompressBuffer(Buffer& input, Buffer& output) = 0; + virtual bool DecompressBuffer(Buffer& compressed, Buffer& origin) = 0; virtual std::string GetFileSuffix() = 0; protected: virtual size_t GetMaxCompressedSizeInner(size_t inputSize) = 0; std::map maxSizeCache_; -} +}; class BrotilCompress : public ICompressStrategy { public: - bool CompressBuffer(Buffer input, Buffer &output) override; - bool DecompressBuffer(Buffer compressed, Buffer origin) override; + bool CompressBuffer(Buffer& input, Buffer& output) override; + bool DecompressBuffer(Buffer& compressed, Buffer& origin) override; std::string GetFileSuffix() override { return COMPRESS_FILE_SUFFIX; } protected: size_t GetMaxCompressedSizeInner(size_t inputSize) override; - const string COMPRESS_FILE_SUFFIX = "__BRO"; -} + const std::string COMPRESS_FILE_SUFFIX = "__BRO"; +}; class Lz4Compress : public ICompressStrategy { public: - bool CompressBuffer(Buffer input, Buffer &output) override; - bool DecompressBuffer(Buffer compressed, Buffer origin) override; + bool CompressBuffer(Buffer& input, Buffer& output) override; + bool DecompressBuffer(Buffer& compressed, Buffer& origin) override; std::string GetFileSuffix() override { return COMPRESS_FILE_SUFFIX; } protected: size_t GetMaxCompressedSizeInner(size_t inputSize) override; - const string COMPRESS_FILE_SUFFIX = "__LZ4"; -} + const std::string COMPRESS_FILE_SUFFIX = "__LZ4"; +}; class TarFile { public: diff --git a/frameworks/native/backup_ext/src/tar_file.cpp b/frameworks/native/backup_ext/src/tar_file.cpp index 04a4d0bd9..d6f28dce5 100644 --- a/frameworks/native/backup_ext/src/tar_file.cpp +++ b/frameworks/native/backup_ext/src/tar_file.cpp @@ -43,7 +43,7 @@ #ifndef USE_COMPRESS #define USE_COMPRESS true #endif -#include "lz4" +#include "lz4.h" #endif namespace OHOS::FileManagement::Backup { @@ -68,7 +68,7 @@ constexpr bool USE_COMPRESS = false; // 默认关闭 constexpr bool USE_COMPRESS = false; #endif -#ifdef BROTIL_ENABLED +#ifdef BROTLI_ENABLED constexpr int BROTLI_QUALITY = 1; #endif } // namespace @@ -121,11 +121,11 @@ size_t ICompressStrategy::GetMaxCompressedSize(size_t inputSize) return maxSize; } -bool BrotilCompress::CompressBuffer(Buffer input, Buffer &output) +bool BrotilCompress::CompressBuffer(Buffer& input, Buffer& output) { #ifdef BROTLI_ENABLED int ret = BrotliEncoderCompress(BROTLI_QUALITY, BROTLI_MAX_WINDOW_BITS, BROTLI_DEFAULT_MODE, - input.size_, (const uint8_t*)input.data_, output.size_, output.data_); + input.size_, (const uint8_t*)input.data_, &output.size_, (uint8_t*)output.data_); if (ret != BROTLI_TRUE) { HILOGE("compress fail, error: %{public}d", ret); return false; @@ -136,10 +136,11 @@ bool BrotilCompress::CompressBuffer(Buffer input, Buffer &output) #endif } -bool BrotilCompress::DecompressBuffer(Buffer compressed, Buffer origin) +bool BrotilCompress::DecompressBuffer(Buffer& compressed, Buffer& origin) { #ifdef BROTLI_ENABLED - int ret = BrotliDecoderDecompress(compressed.size_, (const uint8_t*)compressed.data_, origin.size_, origin.data_); + int ret = BrotliDecoderDecompress(compressed.size_, (const uint8_t*)compressed.data_, origin.size_, + (uint8_t*)origin.data_); if (ret != BROTLI_TRUE) { HILOGE("decompress fail, error: %{public}d", ret); return false; @@ -159,7 +160,7 @@ size_t BrotilCompress::GetMaxCompressedSizeInner(size_t inputSize) #endif } -bool Lz4Compress::CompressBuffer(Buffer input, Buffer &output) +bool Lz4Compress::CompressBuffer(Buffer& input, Buffer& output) { #ifdef LZ4_ENABLED int compressedSize = LZ4_compress_default(input.data_, output.data_, input.size_, @@ -175,7 +176,7 @@ bool Lz4Compress::CompressBuffer(Buffer input, Buffer &output) #endif } -bool Lz4Compress::DecompressBuffer(Buffer compressed, Buffer origin) +bool Lz4Compress::DecompressBuffer(Buffer& compressed, Buffer& origin) { #ifdef LZ4_ENABLED int decompressedSize = LZ4_decompress_safe(compressed.data_, origin.data_, compressed.size_, origin.size_); @@ -183,8 +184,8 @@ bool Lz4Compress::DecompressBuffer(Buffer compressed, Buffer origin) HILOGE("decompress fail, error: %{public}d", decompressedSize); return false; } - if (decompressedSize != origin.size_) { - HILOGE("decompress size(%{public}d) != origin size(%{public}d).", decompressedSize, origin.size_); + if ((size_t)decompressedSize != origin.size_) { + HILOGE("decompress size(%{public}d) != origin size(%{public}zu).", decompressedSize, origin.size_); return false; } return true; -- Gitee From fbe1b244f2a0d64e10f53b64ad092f37a80d9d5d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=88=98=E6=B8=8A?= Date: Thu, 4 Sep 2025 22:25:08 +0800 Subject: [PATCH 05/17] fix compile bug 2 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 刘渊 --- .../native/backup_ext/include/tar_file.h | 7 +++--- frameworks/native/backup_ext/src/tar_file.cpp | 24 +++++++++---------- 2 files changed, 16 insertions(+), 15 deletions(-) diff --git a/frameworks/native/backup_ext/include/tar_file.h b/frameworks/native/backup_ext/include/tar_file.h index a034e62d8..155cff2d1 100644 --- a/frameworks/native/backup_ext/include/tar_file.h +++ b/frameworks/native/backup_ext/include/tar_file.h @@ -111,6 +111,7 @@ public: class ICompressStrategy { public: + virtual ~ICompressStrategy() {}; size_t GetMaxCompressedSize(size_t inputSize); virtual bool CompressBuffer(Buffer& input, Buffer& output) = 0; virtual bool DecompressBuffer(Buffer& compressed, Buffer& origin) = 0; @@ -120,7 +121,7 @@ protected: std::map maxSizeCache_; }; -class BrotilCompress : public ICompressStrategy { +class BrotliCompress : public ICompressStrategy { public: bool CompressBuffer(Buffer& input, Buffer& output) override; bool DecompressBuffer(Buffer& compressed, Buffer& origin) override; @@ -171,8 +172,8 @@ public: bool DecompressFile(const std::string &compFile, const std::string &srcFile); std::string DecompressTar(const std::string &tarPath); private: - bool WriteCompressData(Buffer& compressBuffer, const Buffer& ori, UniqueFile& fout); - bool WriteDecompressData(const Buffer& compressBuffer, Buffer& decompressBuffer, + bool WriteCompressData(Buffer& compressBuffer, Buffer& ori, UniqueFile& fout); + bool WriteDecompressData(Buffer& compressBuffer, Buffer& decompressBuffer, UniqueFile& fout, std::chrono::duration& decompSpan); TarFile(); ~TarFile() = default; diff --git a/frameworks/native/backup_ext/src/tar_file.cpp b/frameworks/native/backup_ext/src/tar_file.cpp index d6f28dce5..cad351262 100644 --- a/frameworks/native/backup_ext/src/tar_file.cpp +++ b/frameworks/native/backup_ext/src/tar_file.cpp @@ -34,14 +34,14 @@ #include "securec.h" #ifdef BROTLI_ENABLED -#define USE_COMPRESS true +#define COMPRESS_ENABLED true #include "brotli/encode.h" #include "brotli/decode.h" #endif #ifdef LZ4_ENABLED -#ifndef USE_COMPRESS -#define USE_COMPRESS true +#ifndef COMPRESS_ENABLED +#define COMPRESS_ENABLED true #endif #include "lz4.h" #endif @@ -61,7 +61,7 @@ const string VERSION = "1.0"; const string LONG_LINK_SYMBOL = "longLinkSymbol"; const string TAR_EXTENSION = ".tar"; constexpr int64_t COMPRESS_BOUND = 10 * 1024 * 1024; -#ifdef USE_COMPRESS +#ifdef COMPRESS_ENABLED constexpr int MEGA_BYTE = 1024 * 1024; constexpr bool USE_COMPRESS = false; // 默认关闭 #else @@ -121,7 +121,7 @@ size_t ICompressStrategy::GetMaxCompressedSize(size_t inputSize) return maxSize; } -bool BrotilCompress::CompressBuffer(Buffer& input, Buffer& output) +bool BrotliCompress::CompressBuffer(Buffer& input, Buffer& output) { #ifdef BROTLI_ENABLED int ret = BrotliEncoderCompress(BROTLI_QUALITY, BROTLI_MAX_WINDOW_BITS, BROTLI_DEFAULT_MODE, @@ -136,10 +136,10 @@ bool BrotilCompress::CompressBuffer(Buffer& input, Buffer& output) #endif } -bool BrotilCompress::DecompressBuffer(Buffer& compressed, Buffer& origin) +bool BrotliCompress::DecompressBuffer(Buffer& compressed, Buffer& origin) { #ifdef BROTLI_ENABLED - int ret = BrotliDecoderDecompress(compressed.size_, (const uint8_t*)compressed.data_, origin.size_, + int ret = BrotliDecoderDecompress(compressed.size_, (const uint8_t*)compressed.data_, &origin.size_, (uint8_t*)origin.data_); if (ret != BROTLI_TRUE) { HILOGE("decompress fail, error: %{public}d", ret); @@ -151,7 +151,7 @@ bool BrotilCompress::DecompressBuffer(Buffer& compressed, Buffer& origin) #endif } -size_t BrotilCompress::GetMaxCompressedSizeInner(size_t inputSize) +size_t BrotliCompress::GetMaxCompressedSizeInner(size_t inputSize) { #ifdef BROTLI_ENABLED return BrotliEncoderMaxCompressedSize(inputSize); @@ -834,7 +834,7 @@ void TarFile::SetPacketMode(bool isReset) isReset_ = isReset; } -bool TarFile::WriteCompressData(Buffer& compressBuffer, const Buffer& ori, UniqueFile& fout) +bool TarFile::WriteCompressData(Buffer& compressBuffer, Buffer& ori, UniqueFile& fout) { size_t sizeCount = 1; char* writeData = (char *)compressBuffer.data_; @@ -861,7 +861,7 @@ bool TarFile::WriteCompressData(Buffer& compressBuffer, const Buffer& ori, Uniqu bool TarFile::CompressFile(const std::string &srcFile, const std::string &compFile) { -#ifdef USE_COMPRESS +#ifdef COMPRESS_ENABLED HILOGI("BEGIN strF: %{public}s, compF: %{public}s", GetAnonyPath(srcFile).c_str(), GetAnonyPath(compFile).c_str()); UniqueFile fin(srcFile.c_str(), "rb"); UniqueFile fout(compFile.c_str(), "wb"); @@ -903,7 +903,7 @@ bool TarFile::CompressFile(const std::string &srcFile, const std::string &compFi return true; } -bool TarFile::WriteDecompressData(const Buffer& compressBuffer, Buffer& decompressBuffer, +bool TarFile::WriteDecompressData(Buffer& compressBuffer, Buffer& decompressBuffer, UniqueFile& fout, std::chrono::duration& decompSpan) { size_t written = 0; @@ -926,7 +926,7 @@ bool TarFile::WriteDecompressData(const Buffer& compressBuffer, Buffer& decompre bool TarFile::DecompressFile(const std::string &compFile, const std::string &srcFile) { -#ifdef USE_COMPRESS +#ifdef COMPRESS_ENABLED HILOGI("BEGIN, compF:%{public}s, srcF:%{public}s", GetAnonyPath(compFile).c_str(), GetAnonyPath(srcFile).c_str()); UniqueFile fin(compFile.c_str(), "rb"); UniqueFile fout(srcFile.c_str(), "wb"); -- Gitee From 5b4c9970d184147f279dd8466c4744667163e07f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=88=98=E6=B8=8A?= Date: Sat, 6 Sep 2025 11:52:55 +0800 Subject: [PATCH 06/17] add ut MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 刘渊 --- .../native/backup_ext/include/tar_file.h | 2 - .../include/compress_strategy_mock.h | 33 ++++++++ tests/unittests/backup_ext/BUILD.gn | 41 ++++++++++ tests/unittests/backup_ext/tar_file_test.cpp | 79 ++++++++++++++++++- 4 files changed, 152 insertions(+), 3 deletions(-) create mode 100644 tests/mock/backup_ext/include/compress_strategy_mock.h diff --git a/frameworks/native/backup_ext/include/tar_file.h b/frameworks/native/backup_ext/include/tar_file.h index 155cff2d1..1682f2959 100644 --- a/frameworks/native/backup_ext/include/tar_file.h +++ b/frameworks/native/backup_ext/include/tar_file.h @@ -166,8 +166,6 @@ public: uint64_t GetTarFileSize() { return static_cast(currentTarFileSize_); } - bool Compress(const uint8_t* inputBuffer, size_t inputSize, uint8_t* outputBuffer, size_t* outputSize); - bool Decompress(const uint8_t* inputBuffer, size_t inputSize, uint8_t* outputBuffer, size_t* outputSize); bool CompressFile(const std::string &srcFile, const std::string &compFile); bool DecompressFile(const std::string &compFile, const std::string &srcFile); std::string DecompressTar(const std::string &tarPath); diff --git a/tests/mock/backup_ext/include/compress_strategy_mock.h b/tests/mock/backup_ext/include/compress_strategy_mock.h new file mode 100644 index 000000000..9edb24b92 --- /dev/null +++ b/tests/mock/backup_ext/include/compress_strategy_mock.h @@ -0,0 +1,33 @@ +/* + * Copyright (c) 2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef OHOS_FILEMGMT_BACKUP_COMPRESS_STRATEGY_MOCK_H +#define OHOS_FILEMGMT_BACKUP_COMPRESS_STRATEGY_MOCK_H + +#include + +#include "tar_file.h" + +namespace OHOS::FileManagement::Backup { +class CompressMock : public ICompressStrategy { +public: + MOCK_METHOD(bool, CompressBuffer, (Buffer& input, Buffer& output)); + MOCK_METHOD(bool, DecompressBuffer, (Buffer& compressed, Buffer& origin)); + MOCK_METHOD(std::string, GetFileSuffix, ()); +protected: + MOCK_METHOD(size_t, GetMaxCompressedSizeInner, (size_t inputSize)); +}; +} // namespace OHOS::FileManagement::Backup +#endif // OHOS_FILEMGMT_BACKUP_COMPRESS_STRATEGY_MOCK_H diff --git a/tests/unittests/backup_ext/BUILD.gn b/tests/unittests/backup_ext/BUILD.gn index b350117a4..5cd4cada4 100644 --- a/tests/unittests/backup_ext/BUILD.gn +++ b/tests/unittests/backup_ext/BUILD.gn @@ -150,6 +150,7 @@ ohos_unittest("tar_file_test") { "${path_backup}/interfaces/inner_api/native/backup_kit_inner/impl", "${path_backup}/frameworks/native/backup_kit_inner/include", "${path_backup}/utils/include", + "${path_backup}/tests/mock/backup_ext/include", ] include_dirs += backup_mock_utils_include @@ -188,6 +189,14 @@ ohos_unittest("tar_file_test") { ] defines = [ "private=public" ] + if (brotli_enabled) { + external_deps += ["brotli:brotli_shared"] + defines += ["BROTLI_ENABLED"] + } + if (lz4_enabled) { + external_deps += ["lz4:liblz4_static"] + defines += ["LZ4_ENABLED"] + } if (system_bit == 32) { defines += ["SYSTEM_BIT_32"] } else { @@ -274,6 +283,14 @@ ohos_unittest("untar_file_sup_test") { ] defines = [ "private=public" ] + if (brotli_enabled) { + external_deps += ["brotli:brotli_shared"] + defines += ["BROTLI_ENABLED"] + } + if (lz4_enabled) { + external_deps += ["lz4:liblz4_static"] + defines += ["LZ4_ENABLED"] + } if (system_bit == 32) { defines += ["SYSTEM_BIT_32"] } else { @@ -353,6 +370,14 @@ ohos_unittest("untar_file_test") { ] defines = [ "private=public" ] + if (brotli_enabled) { + external_deps += ["brotli:brotli_shared"] + defines += ["BROTLI_ENABLED"] + } + if (lz4_enabled) { + external_deps += ["lz4:liblz4_static"] + defines += ["LZ4_ENABLED"] + } if (system_bit == 32) { defines += ["SYSTEM_BIT_32"] } else { @@ -463,6 +488,14 @@ ohos_unittest("tar_file_sub_test") { ] defines = [ "private=public" ] + if (brotli_enabled) { + external_deps += ["brotli:brotli_shared"] + defines += ["BROTLI_ENABLED"] + } + if (lz4_enabled) { + external_deps += ["lz4:liblz4_static"] + defines += ["LZ4_ENABLED"] + } if (system_bit == 32) { defines += ["SYSTEM_BIT_32"] } else { @@ -502,6 +535,14 @@ ohos_unittest("installd_un_tar_file_test") { ] defines = [ "private=public" ] + if (brotli_enabled) { + external_deps += ["brotli:brotli_shared"] + defines += ["BROTLI_ENABLED"] + } + if (lz4_enabled) { + external_deps += ["lz4:liblz4_static"] + defines += ["LZ4_ENABLED"] + } if (system_bit == 32) { defines += ["SYSTEM_BIT_32"] } else { diff --git a/tests/unittests/backup_ext/tar_file_test.cpp b/tests/unittests/backup_ext/tar_file_test.cpp index b1848785f..e4e229f18 100644 --- a/tests/unittests/backup_ext/tar_file_test.cpp +++ b/tests/unittests/backup_ext/tar_file_test.cpp @@ -15,12 +15,18 @@ #include #include +#include #include "b_error/b_error.h" +#include "compress_strategy_mock.h" #include "file_ex.h" #include "tar_file.h" #include "test_manager.h" +#if defined(BROTLI_ENABLED) || defined(LZ4_ENABLED) +#define COMPRESS_ENABLED true +#endif + namespace OHOS::FileManagement::Backup { using namespace std; using namespace testing; @@ -29,8 +35,13 @@ class TarFileTest : public testing::Test { public: static void SetUpTestCase(void); static void TearDownTestCase(); - void SetUp() override {}; + void SetUp() override + { + compressMock_ = std::make_shared(); + } void TearDown() override {}; +protected: + std::shared_ptr compressMock_ = nullptr; }; void TarFileTest::SetUpTestCase() @@ -370,4 +381,70 @@ HWTEST_F(TarFileTest, SUB_Tar_File_Packet_0700, testing::ext::TestSize.Level1) } GTEST_LOG_(INFO) << "TarFileTest-end SUB_Tar_File_Packet_0700"; } + + +HWTEST_F(TarFileTest, WRITE_COMPRESS_DATA_TEST_001, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "TarFileTest-begin WRITE_COMPRESS_DATA_TEST_001"; + UniqueFile fout("/tmp/test.txt", "wb"); + GTEST_LOG_(INFO) << "Test1. compressed bigger"; + Buffer origin(10); + Buffer compress1(20); + bool rs = TarFile::GetInstance().WriteCompressData(compress1, origin, fout); + EXPECT_FALSE(rs); + + GTEST_LOG_(INFO) << "Test2. compressed smaller"; + Buffer compress2(9); + rs = TarFile::GetInstance().WriteCompressData(compress2, origin, fout); + EXPECT_FALSE(rs); + GTEST_LOG_(INFO) << "TarFileTest-end WRITE_COMPRESS_DATA_TEST_001"; +} + + +HWTEST_F(TarFileTest, WRITE_DECOMPRESS_DATA_TEST_001, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "TarFileTest-begin WRITE_DECOMPRESS_DATA_TEST_001"; + TarFile::GetInstance().compressTool_ = compressMock_; + EXPECT_CALL(*compressMock_, DecompressBuffer(_, _)).WillOnce(Return(true)) + .WillOnce(Return(false)); + UniqueFile fout("/tmp/test.txt", "wb"); + auto decompSpan = std::chrono::duration(std::chrono::seconds(0)); + GTEST_LOG_(INFO) << "Test1. compressed equal origin"; + Buffer origin(10); + Buffer compress1(10); + bool rs = TarFile::GetInstance().WriteDecompressData(compress1, origin, fout, decompSpan); + EXPECT_FALSE(rs); + + GTEST_LOG_(INFO) << "Test2. compressed smaller , decompress success"; + Buffer compress2(8); + rs = TarFile::GetInstance().WriteDecompressData(compress2, origin, fout, decompSpan); + EXPECT_FALSE(rs); + GTEST_LOG_(INFO) << "Test3. compressed smaller , decompress fail"; + rs = TarFile::GetInstance().WriteDecompressData(compress2, origin, fout, decompSpan); + EXPECT_FALSE(rs); + GTEST_LOG_(INFO) << "TarFileTest-end WRITE_DECOMPRESS_DATA_TEST_001"; +} + +HWTEST_F(TarFileTest, COMPRESS_FILE_TEST_001, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "TarFileTest-begin COMPRESS_FILE_TEST_001"; + std::string srcFile = "/tmp/in.txt"; + std::string compressFile = "/tmp/out.txt"; +#ifdef COMPRESS_ENABLED + TarFile::GetInstance().compressTool_ = compressMock_; + EXPECT_CALL(*compressMock_, GetMaxCompressedSize(_)).WillOnce(Return(0)).WillRepeatedly(Return(10)); + EXPECT_CALL(*compressMock_, CompressBuffer(_, _)).WillOnce(Return(false)).WillRepeatedly(Return(true)); + GTEST_LOG_(INFO) << "Test1. compressed file"; + bool rs = TarFile::GetInstance().CompressFile(srcFile, compressFile); + EXPECT_FALSE(rs); + + GTEST_LOG_(INFO) << "Test2. compressed file2"; + Buffer compress2(8); + rs = TarFile::GetInstance().WriteDecompressData(compress2, origin, fout, decompSpan); + EXPECT_FALSE(rs); +#else + EXPECT_TRUE(TarFile::GetInstance().CompressFile(srcFile, compressFile)); +#endif + GTEST_LOG_(INFO) << "TarFileTest-end COMPRESS_FILE_TEST_001"; +} } // namespace OHOS::FileManagement::Backup \ No newline at end of file -- Gitee From 0bc3f961e5050c6802998939a4c5c98b547ff08d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=88=98=E6=B8=8A?= Date: Sat, 6 Sep 2025 14:44:10 +0800 Subject: [PATCH 07/17] fix compile bug MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 刘渊 --- frameworks/native/backup_ext/src/tar_file.cpp | 8 ++++++++ tests/mock/backup_ext/include/compress_strategy_mock.h | 1 - tests/unittests/backup_ext/tar_file_test.cpp | 5 +---- 3 files changed, 9 insertions(+), 5 deletions(-) diff --git a/frameworks/native/backup_ext/src/tar_file.cpp b/frameworks/native/backup_ext/src/tar_file.cpp index cad351262..50ff2cba2 100644 --- a/frameworks/native/backup_ext/src/tar_file.cpp +++ b/frameworks/native/backup_ext/src/tar_file.cpp @@ -836,6 +836,10 @@ void TarFile::SetPacketMode(bool isReset) bool TarFile::WriteCompressData(Buffer& compressBuffer, Buffer& ori, UniqueFile& fout) { + if (compressBuffer.data_ == nullptr || ori.data_ == nullptr || fout.file_ == nullptr) { + HILOGE("param invalid"); + return false; + } size_t sizeCount = 1; char* writeData = (char *)compressBuffer.data_; size_t writeDataSize = compressBuffer.size_; @@ -906,6 +910,10 @@ bool TarFile::CompressFile(const std::string &srcFile, const std::string &compFi bool TarFile::WriteDecompressData(Buffer& compressBuffer, Buffer& decompressBuffer, UniqueFile& fout, std::chrono::duration& decompSpan) { + if (compressBuffer.data_ == nullptr || decompressBuffer.data_ == nullptr || fout.file_ == nullptr) { + HILOGE("param invalid"); + return false; + } size_t written = 0; if (compressBuffer.size_ == decompressBuffer.size_) { written += fwrite(compressBuffer.data_, 1, compressBuffer.size_, fout.file_); diff --git a/tests/mock/backup_ext/include/compress_strategy_mock.h b/tests/mock/backup_ext/include/compress_strategy_mock.h index 9edb24b92..eed43bc43 100644 --- a/tests/mock/backup_ext/include/compress_strategy_mock.h +++ b/tests/mock/backup_ext/include/compress_strategy_mock.h @@ -26,7 +26,6 @@ public: MOCK_METHOD(bool, CompressBuffer, (Buffer& input, Buffer& output)); MOCK_METHOD(bool, DecompressBuffer, (Buffer& compressed, Buffer& origin)); MOCK_METHOD(std::string, GetFileSuffix, ()); -protected: MOCK_METHOD(size_t, GetMaxCompressedSizeInner, (size_t inputSize)); }; } // namespace OHOS::FileManagement::Backup diff --git a/tests/unittests/backup_ext/tar_file_test.cpp b/tests/unittests/backup_ext/tar_file_test.cpp index e4e229f18..e7fcfa0bf 100644 --- a/tests/unittests/backup_ext/tar_file_test.cpp +++ b/tests/unittests/backup_ext/tar_file_test.cpp @@ -432,16 +432,13 @@ HWTEST_F(TarFileTest, COMPRESS_FILE_TEST_001, testing::ext::TestSize.Level1) std::string compressFile = "/tmp/out.txt"; #ifdef COMPRESS_ENABLED TarFile::GetInstance().compressTool_ = compressMock_; - EXPECT_CALL(*compressMock_, GetMaxCompressedSize(_)).WillOnce(Return(0)).WillRepeatedly(Return(10)); + EXPECT_CALL(*compressMock_, GetMaxCompressedSizeInner(_)).WillOnce(Return(0)).WillRepeatedly(Return(10)); EXPECT_CALL(*compressMock_, CompressBuffer(_, _)).WillOnce(Return(false)).WillRepeatedly(Return(true)); GTEST_LOG_(INFO) << "Test1. compressed file"; bool rs = TarFile::GetInstance().CompressFile(srcFile, compressFile); EXPECT_FALSE(rs); GTEST_LOG_(INFO) << "Test2. compressed file2"; - Buffer compress2(8); - rs = TarFile::GetInstance().WriteDecompressData(compress2, origin, fout, decompSpan); - EXPECT_FALSE(rs); #else EXPECT_TRUE(TarFile::GetInstance().CompressFile(srcFile, compressFile)); #endif -- Gitee From 6d6ec65dd26c30211c9fb367fc374a7f59880073 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=88=98=E6=B8=8A?= Date: Sat, 6 Sep 2025 16:14:27 +0800 Subject: [PATCH 08/17] fix ut bug MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 刘渊 --- frameworks/native/backup_ext/src/tar_file.cpp | 1 + .../backup_ext/tar_file_sub_test.cpp | 134 +++++++++++++++++- tests/unittests/backup_ext/tar_file_test.cpp | 76 +--------- 3 files changed, 135 insertions(+), 76 deletions(-) diff --git a/frameworks/native/backup_ext/src/tar_file.cpp b/frameworks/native/backup_ext/src/tar_file.cpp index 50ff2cba2..467488f5e 100644 --- a/frameworks/native/backup_ext/src/tar_file.cpp +++ b/frameworks/native/backup_ext/src/tar_file.cpp @@ -94,6 +94,7 @@ UniqueFile::~UniqueFile() Buffer::Buffer(size_t size) { if (size <= 0 || size > MAX_BUFFER_SIZE) { + HILOGE("size invalid:%{public}zu", size); return; } data_ = new (std::nothrow) char[size]; diff --git a/tests/unittests/backup_ext/tar_file_sub_test.cpp b/tests/unittests/backup_ext/tar_file_sub_test.cpp index 78bfcb152..94fe88940 100644 --- a/tests/unittests/backup_ext/tar_file_sub_test.cpp +++ b/tests/unittests/backup_ext/tar_file_sub_test.cpp @@ -15,6 +15,7 @@ #include #include +#include #include #include @@ -34,10 +35,15 @@ #include "securec.h" #include "tar_file.h" +#include "compress_strategy_mock.h" #include "library_func_define.h" #include "tar_file.cpp" #include "library_func_undef.h" +#if defined(BROTLI_ENABLED) || defined(LZ4_ENABLED) +#define COMPRESS_ENABLED true +#endif + namespace OHOS::FileManagement::Backup { using namespace std; using namespace testing; @@ -47,9 +53,13 @@ class TarFileSubTest : public testing::Test { public: static void SetUpTestCase(void); static void TearDownTestCase(); - void SetUp() override {}; + void SetUp() override + { + compressMock_ = std::make_shared(); + } void TearDown() override {}; static inline shared_ptr funcMock = nullptr; + std::shared_ptr compressMock_ = nullptr; }; void TarFileSubTest::SetUpTestCase() @@ -273,4 +283,126 @@ HWTEST_F(TarFileSubTest, SUB_Tar_File_WriteFileContent_0100, testing::ext::TestS } GTEST_LOG_(INFO) << "TarFileSubTest-end SUB_Tar_File_WriteFileContent_0100"; } + +HWTEST_F(TarFileTest, WRITE_COMPRESS_DATA_TEST_001, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "TarFileTest-begin WRITE_COMPRESS_DATA_TEST_001"; + int n = 0; + EXPECT_CALL(*funcMock, fopen(_, _)).WillOnce(Return(nullptr)).WillOnce(Return(reinterpret_cast(&n))); + UniqueFile fout("/tmp/test.txt", "wb"); + UniqueFile fout2("/tmp/test.txt", "wb"); + + GTEST_LOG_(INFO) << "Test1. file null"; + Buffer origin(10); + Buffer compress1(20); + bool rs = TarFile::GetInstance().WriteCompressData(compress1, origin, fout); + EXPECT_FALSE(rs); + + GTEST_LOG_(INFO) << "Test2. compressed bigger, write fail"; + Buffer origin(10); + Buffer compress1(20); + EXPECT_CALL(*funcMock, fwrite(_, _, _, _)).WillOnce(Return(0)); + rs = TarFile::GetInstance().WriteCompressData(compress1, origin, fout2); + EXPECT_FALSE(rs); + + GTEST_LOG_(INFO) << "Test3. compressed bigger, write success"; + Buffer origin(10); + Buffer compress1(20); + size_t sizeCount = 1; + EXPECT_CALL(*funcMock, fwrite(_, _, _, _)).WillOnce(Return(sizeCount)).WillOnce(Return(sizeCount)) + .WillOnce(Return(10)); + rs = TarFile::GetInstance().WriteCompressData(compress1, origin, fout2); + EXPECT_TRUE(rs); + + GTEST_LOG_(INFO) << "Test4. compressed smaller, write success"; + Buffer compress2(9); + EXPECT_CALL(*funcMock, fwrite(_, _, _, _)).WillOnce(Return(sizeCount)).WillOnce(Return(sizeCount)) + .WillOnce(Return(9)); + rs = TarFile::GetInstance().WriteCompressData(compress2, origin, fout2); + EXPECT_TRUE(rs); + GTEST_LOG_(INFO) << "TarFileTest-end WRITE_COMPRESS_DATA_TEST_001"; +} + + +HWTEST_F(TarFileTest, WRITE_DECOMPRESS_DATA_TEST_001, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "TarFileTest-begin WRITE_DECOMPRESS_DATA_TEST_001"; + int n = 0; + EXPECT_CALL(*funcMock, fopen(_, _)).WillOnce(Return(nullptr)).WillOnce(Return(reinterpret_cast(&n))); + UniqueFile fout("/tmp/test.txt", "wb"); + UniqueFile fout2("/tmp/test.txt", "wb"); + auto decompSpan = std::chrono::duration(std::chrono::seconds(0)); + + GTEST_LOG_(INFO) << "Test1. file null"; + Buffer origin(10); + Buffer compress1(10); + bool rs = TarFile::GetInstance().WriteDecompressData(compress1, origin, fout, decompSpan); + EXPECT_FALSE(rs); + + GTEST_LOG_(INFO) << "Test2. compressed equal origin, write fail"; + EXPECT_CALL(*funcMock, fwrite(_, _, _, _)).WillOnce(Return(0)); + rs = TarFile::GetInstance().WriteDecompressData(compress1, origin, fout2, decompSpan); + EXPECT_FALSE(rs); + + GTEST_LOG_(INFO) << "Test3. compressed equal origin, write success"; + EXPECT_CALL(*funcMock, fwrite(_, _, _, _)).WillOnce(Return(10)); + rs = TarFile::GetInstance().WriteDecompressData(compress1, origin, fout2, decompSpan); + EXPECT_TRUE(rs); + + GTEST_LOG_(INFO) << "Test4. compressed smaller , decompress success"; + TarFile::GetInstance().compressTool_ = compressMock_; + EXPECT_CALL(*compressMock_, DecompressBuffer(_, _)).WillOnce(Return(true)).WillOnce(Return(false)); + EXPECT_CALL(*funcMock, fwrite(_, _, _, _)).WillRepeatedly(Return(8)); + Buffer compress2(8); + rs = TarFile::GetInstance().WriteDecompressData(compress2, origin, fout2, decompSpan); + EXPECT_TRUE(rs); + + GTEST_LOG_(INFO) << "Test5. compressed smaller , decompress fail"; + rs = TarFile::GetInstance().WriteDecompressData(compress2, origin, fout2, decompSpan); + EXPECT_FALSE(rs); + GTEST_LOG_(INFO) << "TarFileTest-end WRITE_DECOMPRESS_DATA_TEST_001"; +} + +HWTEST_F(TarFileTest, COMPRESS_FILE_TEST_001, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "TarFileTest-begin COMPRESS_FILE_TEST_001"; + std::string srcFile = "/tmp/in.txt"; + std::string compressFile = "/tmp/out.txt"; +#ifdef COMPRESS_ENABLED + TarFile::GetInstance().compressTool_ = compressMock_; + int n = 0; + EXPECT_CALL(*funcMock, fopen(_, _))..WillOnce(Return(nullptr)).WillOnce(Return(nullptr)) + .WillOnce(Return(reinterpret_cast(&n))); + GTEST_LOG_(INFO) << "Test1. file null"; + bool rs = TarFile::GetInstance().CompressFile(srcFile, compressFile); + EXPECT_FALSE(rs); + + EXPECT_CALL(*compressMock_, GetMaxCompressedSizeInner(_)).WillOnce(Return(0)).WillRepeatedly(Return(BLOCK_SIZE)); + GTEST_LOG_(INFO) << "Test2. get max size fail"; + rs = TarFile::GetInstance().CompressFile(srcFile, compressFile); + EXPECT_FALSE(rs); + + GTEST_LOG_(INFO) << "Test3. fread fail"; + EXPECT_CALL(*funcMock, fread(_, _, _, _)).WillOnce(Return(0)); + rs = TarFile::GetInstance().CompressFile(srcFile, compressFile); + EXPECT_FALSE(rs); + + GTEST_LOG_(INFO) << "Test4. compress fail"; + EXPECT_CALL(*compressMock_, CompressBuffer(_, _)).WillOnce(Return(false)).WillRepeatedly(Return(true)); + EXPECT_CALL(*funcMock, fread(_, _, _, _)).WillOnce(Return(BLOCK_SIZE)); + rs = TarFile::GetInstance().CompressFile(srcFile, compressFile); + EXPECT_FALSE(rs); + + GTEST_LOG_(INFO) << "Test5. compress success"; + EXPECT_CALL(*funcMock, fread(_, _, _, _)).WillOnce(Return(BLOCK_SIZE)).WillOnce(Return(0)); + size_t sizeCount = 1; + EXPECT_CALL(*funcMock, fwrite(_, _, _, _)).WillOnce(Return(sizeCount)).WillOnce(Return(sizeCount)) + .WillOnce(Return(BLOCK_SIZE)); + rs = TarFile::GetInstance().CompressFile(srcFile, compressFile); + EXPECT_TRUE(rs); +#else + EXPECT_TRUE(TarFile::GetInstance().CompressFile(srcFile, compressFile)); +#endif + GTEST_LOG_(INFO) << "TarFileTest-end COMPRESS_FILE_TEST_001"; +} } // namespace OHOS::FileManagement::Backup \ No newline at end of file diff --git a/tests/unittests/backup_ext/tar_file_test.cpp b/tests/unittests/backup_ext/tar_file_test.cpp index e7fcfa0bf..b1848785f 100644 --- a/tests/unittests/backup_ext/tar_file_test.cpp +++ b/tests/unittests/backup_ext/tar_file_test.cpp @@ -15,18 +15,12 @@ #include #include -#include #include "b_error/b_error.h" -#include "compress_strategy_mock.h" #include "file_ex.h" #include "tar_file.h" #include "test_manager.h" -#if defined(BROTLI_ENABLED) || defined(LZ4_ENABLED) -#define COMPRESS_ENABLED true -#endif - namespace OHOS::FileManagement::Backup { using namespace std; using namespace testing; @@ -35,13 +29,8 @@ class TarFileTest : public testing::Test { public: static void SetUpTestCase(void); static void TearDownTestCase(); - void SetUp() override - { - compressMock_ = std::make_shared(); - } + void SetUp() override {}; void TearDown() override {}; -protected: - std::shared_ptr compressMock_ = nullptr; }; void TarFileTest::SetUpTestCase() @@ -381,67 +370,4 @@ HWTEST_F(TarFileTest, SUB_Tar_File_Packet_0700, testing::ext::TestSize.Level1) } GTEST_LOG_(INFO) << "TarFileTest-end SUB_Tar_File_Packet_0700"; } - - -HWTEST_F(TarFileTest, WRITE_COMPRESS_DATA_TEST_001, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "TarFileTest-begin WRITE_COMPRESS_DATA_TEST_001"; - UniqueFile fout("/tmp/test.txt", "wb"); - GTEST_LOG_(INFO) << "Test1. compressed bigger"; - Buffer origin(10); - Buffer compress1(20); - bool rs = TarFile::GetInstance().WriteCompressData(compress1, origin, fout); - EXPECT_FALSE(rs); - - GTEST_LOG_(INFO) << "Test2. compressed smaller"; - Buffer compress2(9); - rs = TarFile::GetInstance().WriteCompressData(compress2, origin, fout); - EXPECT_FALSE(rs); - GTEST_LOG_(INFO) << "TarFileTest-end WRITE_COMPRESS_DATA_TEST_001"; -} - - -HWTEST_F(TarFileTest, WRITE_DECOMPRESS_DATA_TEST_001, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "TarFileTest-begin WRITE_DECOMPRESS_DATA_TEST_001"; - TarFile::GetInstance().compressTool_ = compressMock_; - EXPECT_CALL(*compressMock_, DecompressBuffer(_, _)).WillOnce(Return(true)) - .WillOnce(Return(false)); - UniqueFile fout("/tmp/test.txt", "wb"); - auto decompSpan = std::chrono::duration(std::chrono::seconds(0)); - GTEST_LOG_(INFO) << "Test1. compressed equal origin"; - Buffer origin(10); - Buffer compress1(10); - bool rs = TarFile::GetInstance().WriteDecompressData(compress1, origin, fout, decompSpan); - EXPECT_FALSE(rs); - - GTEST_LOG_(INFO) << "Test2. compressed smaller , decompress success"; - Buffer compress2(8); - rs = TarFile::GetInstance().WriteDecompressData(compress2, origin, fout, decompSpan); - EXPECT_FALSE(rs); - GTEST_LOG_(INFO) << "Test3. compressed smaller , decompress fail"; - rs = TarFile::GetInstance().WriteDecompressData(compress2, origin, fout, decompSpan); - EXPECT_FALSE(rs); - GTEST_LOG_(INFO) << "TarFileTest-end WRITE_DECOMPRESS_DATA_TEST_001"; -} - -HWTEST_F(TarFileTest, COMPRESS_FILE_TEST_001, testing::ext::TestSize.Level1) -{ - GTEST_LOG_(INFO) << "TarFileTest-begin COMPRESS_FILE_TEST_001"; - std::string srcFile = "/tmp/in.txt"; - std::string compressFile = "/tmp/out.txt"; -#ifdef COMPRESS_ENABLED - TarFile::GetInstance().compressTool_ = compressMock_; - EXPECT_CALL(*compressMock_, GetMaxCompressedSizeInner(_)).WillOnce(Return(0)).WillRepeatedly(Return(10)); - EXPECT_CALL(*compressMock_, CompressBuffer(_, _)).WillOnce(Return(false)).WillRepeatedly(Return(true)); - GTEST_LOG_(INFO) << "Test1. compressed file"; - bool rs = TarFile::GetInstance().CompressFile(srcFile, compressFile); - EXPECT_FALSE(rs); - - GTEST_LOG_(INFO) << "Test2. compressed file2"; -#else - EXPECT_TRUE(TarFile::GetInstance().CompressFile(srcFile, compressFile)); -#endif - GTEST_LOG_(INFO) << "TarFileTest-end COMPRESS_FILE_TEST_001"; -} } // namespace OHOS::FileManagement::Backup \ No newline at end of file -- Gitee From ea779af3056a6b3a99e9bd8f0ea173df7c27102b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=88=98=E6=B8=8A?= Date: Sat, 6 Sep 2025 17:05:55 +0800 Subject: [PATCH 09/17] add ut MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 刘渊 --- tests/unittests/backup_ext/BUILD.gn | 2 +- .../backup_ext/tar_file_sub_test.cpp | 71 ++++++++++++++++--- 2 files changed, 62 insertions(+), 11 deletions(-) diff --git a/tests/unittests/backup_ext/BUILD.gn b/tests/unittests/backup_ext/BUILD.gn index 5cd4cada4..4b001b904 100644 --- a/tests/unittests/backup_ext/BUILD.gn +++ b/tests/unittests/backup_ext/BUILD.gn @@ -150,7 +150,6 @@ ohos_unittest("tar_file_test") { "${path_backup}/interfaces/inner_api/native/backup_kit_inner/impl", "${path_backup}/frameworks/native/backup_kit_inner/include", "${path_backup}/utils/include", - "${path_backup}/tests/mock/backup_ext/include", ] include_dirs += backup_mock_utils_include @@ -472,6 +471,7 @@ ohos_unittest("tar_file_sub_test") { "${path_backup}/tests/mock/library_func_mock", "${path_backup}/utils/include", "${path_backup}/utils/include/b_hilog", + "${path_backup}/tests/mock/backup_ext/include", ] cflags = [ "--coverage" ] diff --git a/tests/unittests/backup_ext/tar_file_sub_test.cpp b/tests/unittests/backup_ext/tar_file_sub_test.cpp index 94fe88940..e076ac14b 100644 --- a/tests/unittests/backup_ext/tar_file_sub_test.cpp +++ b/tests/unittests/backup_ext/tar_file_sub_test.cpp @@ -284,11 +284,12 @@ HWTEST_F(TarFileSubTest, SUB_Tar_File_WriteFileContent_0100, testing::ext::TestS GTEST_LOG_(INFO) << "TarFileSubTest-end SUB_Tar_File_WriteFileContent_0100"; } -HWTEST_F(TarFileTest, WRITE_COMPRESS_DATA_TEST_001, testing::ext::TestSize.Level1) +HWTEST_F(TarFileSubTest, WRITE_COMPRESS_DATA_TEST_001, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "TarFileTest-begin WRITE_COMPRESS_DATA_TEST_001"; int n = 0; EXPECT_CALL(*funcMock, fopen(_, _)).WillOnce(Return(nullptr)).WillOnce(Return(reinterpret_cast(&n))); + EXPECT_CALL(*funcMock, fclose(_)).WillRepeatedly(Return(0)); UniqueFile fout("/tmp/test.txt", "wb"); UniqueFile fout2("/tmp/test.txt", "wb"); @@ -299,15 +300,11 @@ HWTEST_F(TarFileTest, WRITE_COMPRESS_DATA_TEST_001, testing::ext::TestSize.Level EXPECT_FALSE(rs); GTEST_LOG_(INFO) << "Test2. compressed bigger, write fail"; - Buffer origin(10); - Buffer compress1(20); EXPECT_CALL(*funcMock, fwrite(_, _, _, _)).WillOnce(Return(0)); rs = TarFile::GetInstance().WriteCompressData(compress1, origin, fout2); EXPECT_FALSE(rs); GTEST_LOG_(INFO) << "Test3. compressed bigger, write success"; - Buffer origin(10); - Buffer compress1(20); size_t sizeCount = 1; EXPECT_CALL(*funcMock, fwrite(_, _, _, _)).WillOnce(Return(sizeCount)).WillOnce(Return(sizeCount)) .WillOnce(Return(10)); @@ -324,11 +321,12 @@ HWTEST_F(TarFileTest, WRITE_COMPRESS_DATA_TEST_001, testing::ext::TestSize.Level } -HWTEST_F(TarFileTest, WRITE_DECOMPRESS_DATA_TEST_001, testing::ext::TestSize.Level1) +HWTEST_F(TarFileSubTest, WRITE_DECOMPRESS_DATA_TEST_001, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "TarFileTest-begin WRITE_DECOMPRESS_DATA_TEST_001"; int n = 0; EXPECT_CALL(*funcMock, fopen(_, _)).WillOnce(Return(nullptr)).WillOnce(Return(reinterpret_cast(&n))); + EXPECT_CALL(*funcMock, fclose(_)).WillRepeatedly(Return(0)); UniqueFile fout("/tmp/test.txt", "wb"); UniqueFile fout2("/tmp/test.txt", "wb"); auto decompSpan = std::chrono::duration(std::chrono::seconds(0)); @@ -352,7 +350,7 @@ HWTEST_F(TarFileTest, WRITE_DECOMPRESS_DATA_TEST_001, testing::ext::TestSize.Lev GTEST_LOG_(INFO) << "Test4. compressed smaller , decompress success"; TarFile::GetInstance().compressTool_ = compressMock_; EXPECT_CALL(*compressMock_, DecompressBuffer(_, _)).WillOnce(Return(true)).WillOnce(Return(false)); - EXPECT_CALL(*funcMock, fwrite(_, _, _, _)).WillRepeatedly(Return(8)); + EXPECT_CALL(*funcMock, fwrite(_, _, _, _)).WillRepeatedly(Return(10)); Buffer compress2(8); rs = TarFile::GetInstance().WriteDecompressData(compress2, origin, fout2, decompSpan); EXPECT_TRUE(rs); @@ -363,7 +361,7 @@ HWTEST_F(TarFileTest, WRITE_DECOMPRESS_DATA_TEST_001, testing::ext::TestSize.Lev GTEST_LOG_(INFO) << "TarFileTest-end WRITE_DECOMPRESS_DATA_TEST_001"; } -HWTEST_F(TarFileTest, COMPRESS_FILE_TEST_001, testing::ext::TestSize.Level1) +HWTEST_F(TarFileSubTest, COMPRESS_FILE_TEST_001, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "TarFileTest-begin COMPRESS_FILE_TEST_001"; std::string srcFile = "/tmp/in.txt"; @@ -371,8 +369,9 @@ HWTEST_F(TarFileTest, COMPRESS_FILE_TEST_001, testing::ext::TestSize.Level1) #ifdef COMPRESS_ENABLED TarFile::GetInstance().compressTool_ = compressMock_; int n = 0; - EXPECT_CALL(*funcMock, fopen(_, _))..WillOnce(Return(nullptr)).WillOnce(Return(nullptr)) - .WillOnce(Return(reinterpret_cast(&n))); + EXPECT_CALL(*funcMock, fopen(_, _)).WillOnce(Return(nullptr)).WillOnce(Return(nullptr)) + .WillRepeatedly(Return(reinterpret_cast(&n))); + EXPECT_CALL(*funcMock, fclose(_)).WillRepeatedly(Return(0)); GTEST_LOG_(INFO) << "Test1. file null"; bool rs = TarFile::GetInstance().CompressFile(srcFile, compressFile); EXPECT_FALSE(rs); @@ -405,4 +404,56 @@ HWTEST_F(TarFileTest, COMPRESS_FILE_TEST_001, testing::ext::TestSize.Level1) #endif GTEST_LOG_(INFO) << "TarFileTest-end COMPRESS_FILE_TEST_001"; } + +HWTEST_F(TarFileSubTest, DECOMPRESS_FILE_TEST_001, testing::ext::TestSize.Level1) +{ + GTEST_LOG_(INFO) << "TarFileTest-begin DECOMPRESS_FILE_TEST_001"; + std::string srcFile = "/tmp/in.txt"; + std::string compressFile = "/tmp/out.txt"; +#ifdef COMPRESS_ENABLED + TarFile::GetInstance().compressTool_ = compressMock_; + int n = 0; + EXPECT_CALL(*funcMock, fopen(_, _)).WillOnce(Return(nullptr)).WillOnce(Return(nullptr)) + .WillRepeatedly(Return(reinterpret_cast(&n))); + EXPECT_CALL(*funcMock, fclose(_)).WillRepeatedly(Return(0)); + GTEST_LOG_(INFO) << "Test1. file null"; + bool rs = TarFile::GetInstance().DecompressFile(compressFile, srcFile); + EXPECT_FALSE(rs); + + GTEST_LOG_(INFO) << "Test2. fread fail"; + EXPECT_CALL(*funcMock, fread(_, _, _, _)).WillOnce(Return(0)); + rs = TarFile::GetInstance().DecompressFile(compressFile, srcFile); + EXPECT_FALSE(rs); + + GTEST_LOG_(INFO) << "Test3. fread size wrong"; + EXPECT_CALL(*funcMock, fread(_, _, _, _)).WillOnce(Return(2)); + rs = TarFile::GetInstance().DecompressFile(compressFile, srcFile); + EXPECT_FALSE(rs); + + GTEST_LOG_(INFO) << "Test4. fread fail2"; + size_t sizeCount = 1; + EXPECT_CALL(*funcMock, fread(_, _, _, _)).WillOnce(Return(sizeCount)).WillOnce(Return(0)); + rs = TarFile::GetInstance().DecompressFile(compressFile, srcFile); + EXPECT_FALSE(rs); + + GTEST_LOG_(INFO) << "Test5. decompress fail"; + size_t sizeCount = 1; + EXPECT_CALL(*compressMock_, DecompressBuffer(_, _)).WillOnce(Return(false)).WillRepeatedly(Return(true)); + EXPECT_CALL(*funcMock, fread(_, _, _, _)).WillOnce(Return(sizeCount)).WillOnce(Return(sizeCount)) + .WillOnce(Return(BLOCK_SIZE)); + EXPECT_CALL(*funcMock, fwrite(_, _, _, _)).WillOnce(Return(BLOCK_SIZE)); + rs = TarFile::GetInstance().DecompressFile(compressFile, srcFile); + EXPECT_FALSE(rs); + + GTEST_LOG_(INFO) << "Test5. decompress success"; + EXPECT_CALL(*funcMock, fread(_, _, _, _)).WillOnce(Return(sizeCount)).WillOnce(Return(sizeCount)) + .WillOnce(Return(BLOCK_SIZE)); + EXPECT_CALL(*funcMock, fwrite(_, _, _, _)).WillOnce(Return(BLOCK_SIZE)); + rs = TarFile::GetInstance().DecompressFile(compressFile, srcFile); + EXPECT_TRUE(rs); +#else + EXPECT_TRUE(TarFile::GetInstance().DecompressFile(compressFile, srcFile)); +#endif + GTEST_LOG_(INFO) << "TarFileTest-end DECOMPRESS_FILE_TEST_001"; +} } // namespace OHOS::FileManagement::Backup \ No newline at end of file -- Gitee From 53b0b8df49e3570b49503cdbd4829d0f48266336 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=88=98=E6=B8=8A?= Date: Sat, 6 Sep 2025 17:53:06 +0800 Subject: [PATCH 10/17] fix ut bug MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 刘渊 --- frameworks/native/backup_ext/src/tar_file.cpp | 8 ++++++++ tests/unittests/backup_ext/BUILD.gn | 5 ++++- tests/unittests/backup_ext/tar_file_sub_test.cpp | 6 +++--- 3 files changed, 15 insertions(+), 4 deletions(-) diff --git a/frameworks/native/backup_ext/src/tar_file.cpp b/frameworks/native/backup_ext/src/tar_file.cpp index 467488f5e..bb1b3f4dc 100644 --- a/frameworks/native/backup_ext/src/tar_file.cpp +++ b/frameworks/native/backup_ext/src/tar_file.cpp @@ -901,6 +901,10 @@ bool TarFile::CompressFile(const std::string &srcFile, const std::string &compFi inTotal += ori.size_; outTotal += compressBuffer.size_; } + if (outTotal == 0) { + HILOGE("read fail"); + return false; + } HILOGI("END srcSize:%{public}zu, destSize:%{public}zu, rate:%{public}f, time:%{public}f ms, speed:%{public}f MB/s", inTotal, outTotal, (outTotal == 0) ? 0 : (inTotal * 1.0f / outTotal), compSpan.count(), (compSpan.count() == 0) ? 0 : inTotal * 1000.0f / MEGA_BYTE / compSpan.count()); @@ -973,6 +977,10 @@ bool TarFile::DecompressFile(const std::string &compFile, const std::string &src inTotal += compressBuffer.size_; outTotal += decompressBuffer.size_; } + if (outTotal == 0) { + HILOGE("read fail"); + return false; + } HILOGI("srcSize:%{public}zu, destSize:%{public}zu, time:%{public}f ms, speed:%{public}f MB/s", inTotal, outTotal, decompSpan.count(), (decompSpan.count() == 0) ? 0 : outTotal * 1000.0f / MEGA_BYTE / decompSpan.count()); #endif diff --git a/tests/unittests/backup_ext/BUILD.gn b/tests/unittests/backup_ext/BUILD.gn index 4b001b904..a424bf348 100644 --- a/tests/unittests/backup_ext/BUILD.gn +++ b/tests/unittests/backup_ext/BUILD.gn @@ -487,7 +487,10 @@ ohos_unittest("tar_file_sub_test") { "hilog:libhilog", ] - defines = [ "private=public" ] + defines = [ + "private=public", + "protected=public" + ] if (brotli_enabled) { external_deps += ["brotli:brotli_shared"] defines += ["BROTLI_ENABLED"] diff --git a/tests/unittests/backup_ext/tar_file_sub_test.cpp b/tests/unittests/backup_ext/tar_file_sub_test.cpp index e076ac14b..fe2901090 100644 --- a/tests/unittests/backup_ext/tar_file_sub_test.cpp +++ b/tests/unittests/backup_ext/tar_file_sub_test.cpp @@ -376,12 +376,13 @@ HWTEST_F(TarFileSubTest, COMPRESS_FILE_TEST_001, testing::ext::TestSize.Level1) bool rs = TarFile::GetInstance().CompressFile(srcFile, compressFile); EXPECT_FALSE(rs); - EXPECT_CALL(*compressMock_, GetMaxCompressedSizeInner(_)).WillOnce(Return(0)).WillRepeatedly(Return(BLOCK_SIZE)); + EXPECT_CALL(*compressMock_, GetMaxCompressedSizeInner(_)).WillOnce(Return(0)); GTEST_LOG_(INFO) << "Test2. get max size fail"; rs = TarFile::GetInstance().CompressFile(srcFile, compressFile); EXPECT_FALSE(rs); GTEST_LOG_(INFO) << "Test3. fread fail"; + compressMock_->maxSizeCache_[BLOCK_SIZE] = BLOCK_SIZE; EXPECT_CALL(*funcMock, fread(_, _, _, _)).WillOnce(Return(0)); rs = TarFile::GetInstance().CompressFile(srcFile, compressFile); EXPECT_FALSE(rs); @@ -437,8 +438,7 @@ HWTEST_F(TarFileSubTest, DECOMPRESS_FILE_TEST_001, testing::ext::TestSize.Level1 EXPECT_FALSE(rs); GTEST_LOG_(INFO) << "Test5. decompress fail"; - size_t sizeCount = 1; - EXPECT_CALL(*compressMock_, DecompressBuffer(_, _)).WillOnce(Return(false)).WillRepeatedly(Return(true)); + EXPECT_CALL(*compressMock_, DecompressBuffer(_, _)).WillOnce(Return(false)).WillOnce(Return(true)); EXPECT_CALL(*funcMock, fread(_, _, _, _)).WillOnce(Return(sizeCount)).WillOnce(Return(sizeCount)) .WillOnce(Return(BLOCK_SIZE)); EXPECT_CALL(*funcMock, fwrite(_, _, _, _)).WillOnce(Return(BLOCK_SIZE)); -- Gitee From 1f58ad817fb4cd0740d7cabe14fef19ece11a27b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=88=98=E6=B8=8A?= Date: Mon, 8 Sep 2025 11:04:55 +0800 Subject: [PATCH 11/17] optimize ut MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 刘渊 --- .../backup_ext/tar_file_sub_test.cpp | 47 ++++++++++--------- 1 file changed, 26 insertions(+), 21 deletions(-) diff --git a/tests/unittests/backup_ext/tar_file_sub_test.cpp b/tests/unittests/backup_ext/tar_file_sub_test.cpp index fe2901090..b3ae86c41 100644 --- a/tests/unittests/backup_ext/tar_file_sub_test.cpp +++ b/tests/unittests/backup_ext/tar_file_sub_test.cpp @@ -56,10 +56,15 @@ public: void SetUp() override { compressMock_ = std::make_shared(); + TarFile::GetInstance().compressTool_ = compressMock_; + } + void TearDown() override + { + TarFile::GetInstance().compressTool_ = nullptr; } - void TearDown() override {}; static inline shared_ptr funcMock = nullptr; std::shared_ptr compressMock_ = nullptr; + const char* tmpFilePath_ = "test.txt"; }; void TarFileSubTest::SetUpTestCase() @@ -287,11 +292,11 @@ HWTEST_F(TarFileSubTest, SUB_Tar_File_WriteFileContent_0100, testing::ext::TestS HWTEST_F(TarFileSubTest, WRITE_COMPRESS_DATA_TEST_001, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "TarFileTest-begin WRITE_COMPRESS_DATA_TEST_001"; - int n = 0; - EXPECT_CALL(*funcMock, fopen(_, _)).WillOnce(Return(nullptr)).WillOnce(Return(reinterpret_cast(&n))); + UniqueFile testFile(tmpFilePath_, "w"); + EXPECT_CALL(*funcMock, fopen(_, _)).WillOnce(Return(nullptr)).WillOnce(Return(testFile.file_)); EXPECT_CALL(*funcMock, fclose(_)).WillRepeatedly(Return(0)); - UniqueFile fout("/tmp/test.txt", "wb"); - UniqueFile fout2("/tmp/test.txt", "wb"); + UniqueFile fout("/tmp/test1.txt", "wb"); + UniqueFile fout2("/tmp/test2.txt", "wb"); GTEST_LOG_(INFO) << "Test1. file null"; Buffer origin(10); @@ -317,6 +322,7 @@ HWTEST_F(TarFileSubTest, WRITE_COMPRESS_DATA_TEST_001, testing::ext::TestSize.Le .WillOnce(Return(9)); rs = TarFile::GetInstance().WriteCompressData(compress2, origin, fout2); EXPECT_TRUE(rs); + remove(tmpFilePath_); GTEST_LOG_(INFO) << "TarFileTest-end WRITE_COMPRESS_DATA_TEST_001"; } @@ -324,11 +330,11 @@ HWTEST_F(TarFileSubTest, WRITE_COMPRESS_DATA_TEST_001, testing::ext::TestSize.Le HWTEST_F(TarFileSubTest, WRITE_DECOMPRESS_DATA_TEST_001, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "TarFileTest-begin WRITE_DECOMPRESS_DATA_TEST_001"; - int n = 0; - EXPECT_CALL(*funcMock, fopen(_, _)).WillOnce(Return(nullptr)).WillOnce(Return(reinterpret_cast(&n))); + UniqueFile testFile(tmpFilePath_, "w"); + EXPECT_CALL(*funcMock, fopen(_, _)).WillOnce(Return(nullptr)).WillOnce(Return(testFile.file_)); EXPECT_CALL(*funcMock, fclose(_)).WillRepeatedly(Return(0)); - UniqueFile fout("/tmp/test.txt", "wb"); - UniqueFile fout2("/tmp/test.txt", "wb"); + UniqueFile fout("/tmp/test1.txt", "wb"); + UniqueFile fout2("/tmp/test2.txt", "wb"); auto decompSpan = std::chrono::duration(std::chrono::seconds(0)); GTEST_LOG_(INFO) << "Test1. file null"; @@ -348,7 +354,6 @@ HWTEST_F(TarFileSubTest, WRITE_DECOMPRESS_DATA_TEST_001, testing::ext::TestSize. EXPECT_TRUE(rs); GTEST_LOG_(INFO) << "Test4. compressed smaller , decompress success"; - TarFile::GetInstance().compressTool_ = compressMock_; EXPECT_CALL(*compressMock_, DecompressBuffer(_, _)).WillOnce(Return(true)).WillOnce(Return(false)); EXPECT_CALL(*funcMock, fwrite(_, _, _, _)).WillRepeatedly(Return(10)); Buffer compress2(8); @@ -358,6 +363,7 @@ HWTEST_F(TarFileSubTest, WRITE_DECOMPRESS_DATA_TEST_001, testing::ext::TestSize. GTEST_LOG_(INFO) << "Test5. compressed smaller , decompress fail"; rs = TarFile::GetInstance().WriteDecompressData(compress2, origin, fout2, decompSpan); EXPECT_FALSE(rs); + remove(tmpFilePath_); GTEST_LOG_(INFO) << "TarFileTest-end WRITE_DECOMPRESS_DATA_TEST_001"; } @@ -367,10 +373,8 @@ HWTEST_F(TarFileSubTest, COMPRESS_FILE_TEST_001, testing::ext::TestSize.Level1) std::string srcFile = "/tmp/in.txt"; std::string compressFile = "/tmp/out.txt"; #ifdef COMPRESS_ENABLED - TarFile::GetInstance().compressTool_ = compressMock_; - int n = 0; - EXPECT_CALL(*funcMock, fopen(_, _)).WillOnce(Return(nullptr)).WillOnce(Return(nullptr)) - .WillRepeatedly(Return(reinterpret_cast(&n))); + UniqueFile testFile(tmpFilePath_, "w"); + EXPECT_CALL(*funcMock, fopen(_, _)).WillOnce(Return(nullptr)).WillOnce(Return(nullptr)); EXPECT_CALL(*funcMock, fclose(_)).WillRepeatedly(Return(0)); GTEST_LOG_(INFO) << "Test1. file null"; bool rs = TarFile::GetInstance().CompressFile(srcFile, compressFile); @@ -378,6 +382,7 @@ HWTEST_F(TarFileSubTest, COMPRESS_FILE_TEST_001, testing::ext::TestSize.Level1) EXPECT_CALL(*compressMock_, GetMaxCompressedSizeInner(_)).WillOnce(Return(0)); GTEST_LOG_(INFO) << "Test2. get max size fail"; + EXPECT_CALL(*funcMock, fopen(_, _)).WillRepeatedly(Return(testFile.file_)); rs = TarFile::GetInstance().CompressFile(srcFile, compressFile); EXPECT_FALSE(rs); @@ -400,6 +405,7 @@ HWTEST_F(TarFileSubTest, COMPRESS_FILE_TEST_001, testing::ext::TestSize.Level1) .WillOnce(Return(BLOCK_SIZE)); rs = TarFile::GetInstance().CompressFile(srcFile, compressFile); EXPECT_TRUE(rs); + remove(tmpFilePath_); #else EXPECT_TRUE(TarFile::GetInstance().CompressFile(srcFile, compressFile)); #endif @@ -412,10 +418,9 @@ HWTEST_F(TarFileSubTest, DECOMPRESS_FILE_TEST_001, testing::ext::TestSize.Level1 std::string srcFile = "/tmp/in.txt"; std::string compressFile = "/tmp/out.txt"; #ifdef COMPRESS_ENABLED - TarFile::GetInstance().compressTool_ = compressMock_; - int n = 0; + UniqueFile testFile(tmpFilePath_, "w"); EXPECT_CALL(*funcMock, fopen(_, _)).WillOnce(Return(nullptr)).WillOnce(Return(nullptr)) - .WillRepeatedly(Return(reinterpret_cast(&n))); + .WillRepeatedly(Return(testFile.file_); EXPECT_CALL(*funcMock, fclose(_)).WillRepeatedly(Return(0)); GTEST_LOG_(INFO) << "Test1. file null"; bool rs = TarFile::GetInstance().DecompressFile(compressFile, srcFile); @@ -438,19 +443,19 @@ HWTEST_F(TarFileSubTest, DECOMPRESS_FILE_TEST_001, testing::ext::TestSize.Level1 EXPECT_FALSE(rs); GTEST_LOG_(INFO) << "Test5. decompress fail"; - EXPECT_CALL(*compressMock_, DecompressBuffer(_, _)).WillOnce(Return(false)).WillOnce(Return(true)); EXPECT_CALL(*funcMock, fread(_, _, _, _)).WillOnce(Return(sizeCount)).WillOnce(Return(sizeCount)) - .WillOnce(Return(BLOCK_SIZE)); - EXPECT_CALL(*funcMock, fwrite(_, _, _, _)).WillOnce(Return(BLOCK_SIZE)); + .WillOnce(Return(BLOCK_SIZE)).WillOnce(Return(0)); + EXPECT_CALL(*funcMock, fwrite(_, _, _, _)).WillOnce(Return(0)); rs = TarFile::GetInstance().DecompressFile(compressFile, srcFile); EXPECT_FALSE(rs); GTEST_LOG_(INFO) << "Test5. decompress success"; EXPECT_CALL(*funcMock, fread(_, _, _, _)).WillOnce(Return(sizeCount)).WillOnce(Return(sizeCount)) - .WillOnce(Return(BLOCK_SIZE)); + .WillOnce(Return(BLOCK_SIZE)).WillOnce(Return(0)); EXPECT_CALL(*funcMock, fwrite(_, _, _, _)).WillOnce(Return(BLOCK_SIZE)); rs = TarFile::GetInstance().DecompressFile(compressFile, srcFile); EXPECT_TRUE(rs); + remove(tmpFilePath_); #else EXPECT_TRUE(TarFile::GetInstance().DecompressFile(compressFile, srcFile)); #endif -- Gitee From 2e7ebec568f86ecf0cf21bd513fed9e0d87191d1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=88=98=E6=B8=8A?= Date: Mon, 8 Sep 2025 14:11:23 +0800 Subject: [PATCH 12/17] optimize ut2 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 刘渊 --- .../backup_ext/tar_file_sub_test.cpp | 23 ++++++++----------- 1 file changed, 10 insertions(+), 13 deletions(-) diff --git a/tests/unittests/backup_ext/tar_file_sub_test.cpp b/tests/unittests/backup_ext/tar_file_sub_test.cpp index b3ae86c41..379a5dba3 100644 --- a/tests/unittests/backup_ext/tar_file_sub_test.cpp +++ b/tests/unittests/backup_ext/tar_file_sub_test.cpp @@ -64,7 +64,7 @@ public: } static inline shared_ptr funcMock = nullptr; std::shared_ptr compressMock_ = nullptr; - const char* tmpFilePath_ = "test.txt"; + File* testFilePtr_ = nullptr; }; void TarFileSubTest::SetUpTestCase() @@ -72,6 +72,7 @@ void TarFileSubTest::SetUpTestCase() GTEST_LOG_(INFO) << "SetUpTestCase enter"; funcMock = make_shared(); LibraryFuncMock::libraryFunc_ = funcMock; + testFilePtr_ = fopen("test.txt", "w"); } void TarFileSubTest::TearDownTestCase() @@ -79,6 +80,10 @@ void TarFileSubTest::TearDownTestCase() GTEST_LOG_(INFO) << "TearDownTestCase enter"; LibraryFuncMock::libraryFunc_ = nullptr; funcMock = nullptr; + if (testFilePtr_ != nullptr) { + fclose(testFilePtr_); + } + remove("test.txt"); } /** @@ -292,8 +297,7 @@ HWTEST_F(TarFileSubTest, SUB_Tar_File_WriteFileContent_0100, testing::ext::TestS HWTEST_F(TarFileSubTest, WRITE_COMPRESS_DATA_TEST_001, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "TarFileTest-begin WRITE_COMPRESS_DATA_TEST_001"; - UniqueFile testFile(tmpFilePath_, "w"); - EXPECT_CALL(*funcMock, fopen(_, _)).WillOnce(Return(nullptr)).WillOnce(Return(testFile.file_)); + EXPECT_CALL(*funcMock, fopen(_, _)).WillOnce(Return(nullptr)).WillOnce(Return(testFilePtr_)); EXPECT_CALL(*funcMock, fclose(_)).WillRepeatedly(Return(0)); UniqueFile fout("/tmp/test1.txt", "wb"); UniqueFile fout2("/tmp/test2.txt", "wb"); @@ -322,7 +326,6 @@ HWTEST_F(TarFileSubTest, WRITE_COMPRESS_DATA_TEST_001, testing::ext::TestSize.Le .WillOnce(Return(9)); rs = TarFile::GetInstance().WriteCompressData(compress2, origin, fout2); EXPECT_TRUE(rs); - remove(tmpFilePath_); GTEST_LOG_(INFO) << "TarFileTest-end WRITE_COMPRESS_DATA_TEST_001"; } @@ -330,8 +333,7 @@ HWTEST_F(TarFileSubTest, WRITE_COMPRESS_DATA_TEST_001, testing::ext::TestSize.Le HWTEST_F(TarFileSubTest, WRITE_DECOMPRESS_DATA_TEST_001, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "TarFileTest-begin WRITE_DECOMPRESS_DATA_TEST_001"; - UniqueFile testFile(tmpFilePath_, "w"); - EXPECT_CALL(*funcMock, fopen(_, _)).WillOnce(Return(nullptr)).WillOnce(Return(testFile.file_)); + EXPECT_CALL(*funcMock, fopen(_, _)).WillOnce(Return(nullptr)).WillOnce(Return(testFilePtr_)); EXPECT_CALL(*funcMock, fclose(_)).WillRepeatedly(Return(0)); UniqueFile fout("/tmp/test1.txt", "wb"); UniqueFile fout2("/tmp/test2.txt", "wb"); @@ -363,7 +365,6 @@ HWTEST_F(TarFileSubTest, WRITE_DECOMPRESS_DATA_TEST_001, testing::ext::TestSize. GTEST_LOG_(INFO) << "Test5. compressed smaller , decompress fail"; rs = TarFile::GetInstance().WriteDecompressData(compress2, origin, fout2, decompSpan); EXPECT_FALSE(rs); - remove(tmpFilePath_); GTEST_LOG_(INFO) << "TarFileTest-end WRITE_DECOMPRESS_DATA_TEST_001"; } @@ -373,7 +374,6 @@ HWTEST_F(TarFileSubTest, COMPRESS_FILE_TEST_001, testing::ext::TestSize.Level1) std::string srcFile = "/tmp/in.txt"; std::string compressFile = "/tmp/out.txt"; #ifdef COMPRESS_ENABLED - UniqueFile testFile(tmpFilePath_, "w"); EXPECT_CALL(*funcMock, fopen(_, _)).WillOnce(Return(nullptr)).WillOnce(Return(nullptr)); EXPECT_CALL(*funcMock, fclose(_)).WillRepeatedly(Return(0)); GTEST_LOG_(INFO) << "Test1. file null"; @@ -382,7 +382,7 @@ HWTEST_F(TarFileSubTest, COMPRESS_FILE_TEST_001, testing::ext::TestSize.Level1) EXPECT_CALL(*compressMock_, GetMaxCompressedSizeInner(_)).WillOnce(Return(0)); GTEST_LOG_(INFO) << "Test2. get max size fail"; - EXPECT_CALL(*funcMock, fopen(_, _)).WillRepeatedly(Return(testFile.file_)); + EXPECT_CALL(*funcMock, fopen(_, _)).WillRepeatedly(Return(testFilePtr_)); rs = TarFile::GetInstance().CompressFile(srcFile, compressFile); EXPECT_FALSE(rs); @@ -405,7 +405,6 @@ HWTEST_F(TarFileSubTest, COMPRESS_FILE_TEST_001, testing::ext::TestSize.Level1) .WillOnce(Return(BLOCK_SIZE)); rs = TarFile::GetInstance().CompressFile(srcFile, compressFile); EXPECT_TRUE(rs); - remove(tmpFilePath_); #else EXPECT_TRUE(TarFile::GetInstance().CompressFile(srcFile, compressFile)); #endif @@ -418,9 +417,8 @@ HWTEST_F(TarFileSubTest, DECOMPRESS_FILE_TEST_001, testing::ext::TestSize.Level1 std::string srcFile = "/tmp/in.txt"; std::string compressFile = "/tmp/out.txt"; #ifdef COMPRESS_ENABLED - UniqueFile testFile(tmpFilePath_, "w"); EXPECT_CALL(*funcMock, fopen(_, _)).WillOnce(Return(nullptr)).WillOnce(Return(nullptr)) - .WillRepeatedly(Return(testFile.file_); + .WillRepeatedly(Return(testFilePtr_)); EXPECT_CALL(*funcMock, fclose(_)).WillRepeatedly(Return(0)); GTEST_LOG_(INFO) << "Test1. file null"; bool rs = TarFile::GetInstance().DecompressFile(compressFile, srcFile); @@ -455,7 +453,6 @@ HWTEST_F(TarFileSubTest, DECOMPRESS_FILE_TEST_001, testing::ext::TestSize.Level1 EXPECT_CALL(*funcMock, fwrite(_, _, _, _)).WillOnce(Return(BLOCK_SIZE)); rs = TarFile::GetInstance().DecompressFile(compressFile, srcFile); EXPECT_TRUE(rs); - remove(tmpFilePath_); #else EXPECT_TRUE(TarFile::GetInstance().DecompressFile(compressFile, srcFile)); #endif -- Gitee From 9997c39bcdabbc36420b993570dcc91bb03c7db6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=88=98=E6=B8=8A?= Date: Mon, 8 Sep 2025 16:16:26 +0800 Subject: [PATCH 13/17] fix ut bug MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 刘渊 --- tests/unittests/backup_ext/tar_file_sub_test.cpp | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/tests/unittests/backup_ext/tar_file_sub_test.cpp b/tests/unittests/backup_ext/tar_file_sub_test.cpp index 379a5dba3..d69bc800e 100644 --- a/tests/unittests/backup_ext/tar_file_sub_test.cpp +++ b/tests/unittests/backup_ext/tar_file_sub_test.cpp @@ -57,14 +57,19 @@ public: { compressMock_ = std::make_shared(); TarFile::GetInstance().compressTool_ = compressMock_; + testFilePtr_ = fopen("test.txt", "w"); } void TearDown() override { TarFile::GetInstance().compressTool_ = nullptr; + if (testFilePtr_ != nullptr) { + fclose(testFilePtr_); + } + remove("test.txt"); } static inline shared_ptr funcMock = nullptr; std::shared_ptr compressMock_ = nullptr; - File* testFilePtr_ = nullptr; + FILE* testFilePtr_ = nullptr; }; void TarFileSubTest::SetUpTestCase() @@ -72,7 +77,6 @@ void TarFileSubTest::SetUpTestCase() GTEST_LOG_(INFO) << "SetUpTestCase enter"; funcMock = make_shared(); LibraryFuncMock::libraryFunc_ = funcMock; - testFilePtr_ = fopen("test.txt", "w"); } void TarFileSubTest::TearDownTestCase() @@ -80,10 +84,6 @@ void TarFileSubTest::TearDownTestCase() GTEST_LOG_(INFO) << "TearDownTestCase enter"; LibraryFuncMock::libraryFunc_ = nullptr; funcMock = nullptr; - if (testFilePtr_ != nullptr) { - fclose(testFilePtr_); - } - remove("test.txt"); } /** -- Gitee From 23c035c0dd1152e39d52810243033615d618b0c6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=88=98=E6=B8=8A?= Date: Mon, 8 Sep 2025 16:35:16 +0800 Subject: [PATCH 14/17] fix code sytle problem MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 刘渊 --- tests/mock/backup_ext/include/compress_strategy_mock.h | 3 +-- tests/unittests/backup_ext/tar_file_sub_test.cpp | 7 +++++-- 2 files changed, 6 insertions(+), 4 deletions(-) diff --git a/tests/mock/backup_ext/include/compress_strategy_mock.h b/tests/mock/backup_ext/include/compress_strategy_mock.h index eed43bc43..3b3ae8924 100644 --- a/tests/mock/backup_ext/include/compress_strategy_mock.h +++ b/tests/mock/backup_ext/include/compress_strategy_mock.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2024 Huawei Device Co., Ltd. + * Copyright (c) Huawei Technologies Co., Ltd. 2025. All rights reserved. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -17,7 +17,6 @@ #define OHOS_FILEMGMT_BACKUP_COMPRESS_STRATEGY_MOCK_H #include - #include "tar_file.h" namespace OHOS::FileManagement::Backup { diff --git a/tests/unittests/backup_ext/tar_file_sub_test.cpp b/tests/unittests/backup_ext/tar_file_sub_test.cpp index d69bc800e..e39f96593 100644 --- a/tests/unittests/backup_ext/tar_file_sub_test.cpp +++ b/tests/unittests/backup_ext/tar_file_sub_test.cpp @@ -64,8 +64,11 @@ public: TarFile::GetInstance().compressTool_ = nullptr; if (testFilePtr_ != nullptr) { fclose(testFilePtr_); + testFilePtr_ = nullptr; + } + if (remove("test.txt") != 0) { + GTEST_LOG_(ERROR) << "remove test.txt fail"; } - remove("test.txt"); } static inline shared_ptr funcMock = nullptr; std::shared_ptr compressMock_ = nullptr; @@ -447,7 +450,7 @@ HWTEST_F(TarFileSubTest, DECOMPRESS_FILE_TEST_001, testing::ext::TestSize.Level1 rs = TarFile::GetInstance().DecompressFile(compressFile, srcFile); EXPECT_FALSE(rs); - GTEST_LOG_(INFO) << "Test5. decompress success"; + GTEST_LOG_(INFO) << "Test6. decompress success"; EXPECT_CALL(*funcMock, fread(_, _, _, _)).WillOnce(Return(sizeCount)).WillOnce(Return(sizeCount)) .WillOnce(Return(BLOCK_SIZE)).WillOnce(Return(0)); EXPECT_CALL(*funcMock, fwrite(_, _, _, _)).WillOnce(Return(BLOCK_SIZE)); -- Gitee From 0cb2e5b1122419bc6fb3c5bacd2258c87cd0a4c9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=88=98=E6=B8=8A?= Date: Mon, 8 Sep 2025 17:30:20 +0800 Subject: [PATCH 15/17] update copyright MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 刘渊 --- tests/mock/backup_ext/include/compress_strategy_mock.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tests/mock/backup_ext/include/compress_strategy_mock.h b/tests/mock/backup_ext/include/compress_strategy_mock.h index 3b3ae8924..79bf079de 100644 --- a/tests/mock/backup_ext/include/compress_strategy_mock.h +++ b/tests/mock/backup_ext/include/compress_strategy_mock.h @@ -1,5 +1,5 @@ /* - * Copyright (c) Huawei Technologies Co., Ltd. 2025. All rights reserved. + * Copyright (c) Huawei Device Co., Ltd. 2025-2025. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -28,4 +28,4 @@ public: MOCK_METHOD(size_t, GetMaxCompressedSizeInner, (size_t inputSize)); }; } // namespace OHOS::FileManagement::Backup -#endif // OHOS_FILEMGMT_BACKUP_COMPRESS_STRATEGY_MOCK_H +#endif // OHOS_FILEMGMT_BACKUP_COMPRESS_STRATEGY_MOCK_H \ No newline at end of file -- Gitee From 5e428d048d7df2434ff6d2f1fbd9a139416fbe8e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=88=98=E6=B8=8A?= Date: Mon, 8 Sep 2025 21:14:50 +0800 Subject: [PATCH 16/17] remove mock file MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 刘渊 --- .../include/compress_strategy_mock.h | 31 ------------------- tests/unittests/backup_ext/BUILD.gn | 1 - .../backup_ext/tar_file_sub_test.cpp | 9 +++++- 3 files changed, 8 insertions(+), 33 deletions(-) delete mode 100644 tests/mock/backup_ext/include/compress_strategy_mock.h diff --git a/tests/mock/backup_ext/include/compress_strategy_mock.h b/tests/mock/backup_ext/include/compress_strategy_mock.h deleted file mode 100644 index 79bf079de..000000000 --- a/tests/mock/backup_ext/include/compress_strategy_mock.h +++ /dev/null @@ -1,31 +0,0 @@ -/* - * Copyright (c) Huawei Device Co., Ltd. 2025-2025. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#ifndef OHOS_FILEMGMT_BACKUP_COMPRESS_STRATEGY_MOCK_H -#define OHOS_FILEMGMT_BACKUP_COMPRESS_STRATEGY_MOCK_H - -#include -#include "tar_file.h" - -namespace OHOS::FileManagement::Backup { -class CompressMock : public ICompressStrategy { -public: - MOCK_METHOD(bool, CompressBuffer, (Buffer& input, Buffer& output)); - MOCK_METHOD(bool, DecompressBuffer, (Buffer& compressed, Buffer& origin)); - MOCK_METHOD(std::string, GetFileSuffix, ()); - MOCK_METHOD(size_t, GetMaxCompressedSizeInner, (size_t inputSize)); -}; -} // namespace OHOS::FileManagement::Backup -#endif // OHOS_FILEMGMT_BACKUP_COMPRESS_STRATEGY_MOCK_H \ No newline at end of file diff --git a/tests/unittests/backup_ext/BUILD.gn b/tests/unittests/backup_ext/BUILD.gn index a424bf348..f9c518e29 100644 --- a/tests/unittests/backup_ext/BUILD.gn +++ b/tests/unittests/backup_ext/BUILD.gn @@ -471,7 +471,6 @@ ohos_unittest("tar_file_sub_test") { "${path_backup}/tests/mock/library_func_mock", "${path_backup}/utils/include", "${path_backup}/utils/include/b_hilog", - "${path_backup}/tests/mock/backup_ext/include", ] cflags = [ "--coverage" ] diff --git a/tests/unittests/backup_ext/tar_file_sub_test.cpp b/tests/unittests/backup_ext/tar_file_sub_test.cpp index e39f96593..32fda2d22 100644 --- a/tests/unittests/backup_ext/tar_file_sub_test.cpp +++ b/tests/unittests/backup_ext/tar_file_sub_test.cpp @@ -35,7 +35,6 @@ #include "securec.h" #include "tar_file.h" -#include "compress_strategy_mock.h" #include "library_func_define.h" #include "tar_file.cpp" #include "library_func_undef.h" @@ -49,6 +48,14 @@ using namespace std; using namespace testing; using namespace OHOS::AppFileService; +class CompressMock : public ICompressStrategy { +public: + MOCK_METHOD(bool, CompressBuffer, (Buffer& input, Buffer& output)); + MOCK_METHOD(bool, DecompressBuffer, (Buffer& compressed, Buffer& origin)); + MOCK_METHOD(std::string, GetFileSuffix, ()); + MOCK_METHOD(size_t, GetMaxCompressedSizeInner, (size_t inputSize)); +}; + class TarFileSubTest : public testing::Test { public: static void SetUpTestCase(void); -- Gitee From db240aa5649d45f060e06b0c41ba1808298ca500 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=88=98=E6=B8=8A?= Date: Tue, 9 Sep 2025 15:15:15 +0800 Subject: [PATCH 17/17] add comment for ut MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 刘渊 --- .../backup_ext/tar_file_sub_test.cpp | 33 ++++++++++++++++++- 1 file changed, 32 insertions(+), 1 deletion(-) diff --git a/tests/unittests/backup_ext/tar_file_sub_test.cpp b/tests/unittests/backup_ext/tar_file_sub_test.cpp index 32fda2d22..e93d81373 100644 --- a/tests/unittests/backup_ext/tar_file_sub_test.cpp +++ b/tests/unittests/backup_ext/tar_file_sub_test.cpp @@ -304,6 +304,14 @@ HWTEST_F(TarFileSubTest, SUB_Tar_File_WriteFileContent_0100, testing::ext::TestS GTEST_LOG_(INFO) << "TarFileSubTest-end SUB_Tar_File_WriteFileContent_0100"; } +/** + * @tc.number: WRITE_COMPRESS_DATA_TEST_001 + * @tc.name: WRITE_COMPRESS_DATA_TEST_001 + * @tc.desc: 测试 WriteCompressData 接口 + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + */ HWTEST_F(TarFileSubTest, WRITE_COMPRESS_DATA_TEST_001, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "TarFileTest-begin WRITE_COMPRESS_DATA_TEST_001"; @@ -339,7 +347,14 @@ HWTEST_F(TarFileSubTest, WRITE_COMPRESS_DATA_TEST_001, testing::ext::TestSize.Le GTEST_LOG_(INFO) << "TarFileTest-end WRITE_COMPRESS_DATA_TEST_001"; } - +/** + * @tc.number: WRITE_DECOMPRESS_DATA_TEST_001 + * @tc.name: WRITE_DECOMPRESS_DATA_TEST_001 + * @tc.desc: 测试 WriteDecompressData 接口 + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + */ HWTEST_F(TarFileSubTest, WRITE_DECOMPRESS_DATA_TEST_001, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "TarFileTest-begin WRITE_DECOMPRESS_DATA_TEST_001"; @@ -378,6 +393,14 @@ HWTEST_F(TarFileSubTest, WRITE_DECOMPRESS_DATA_TEST_001, testing::ext::TestSize. GTEST_LOG_(INFO) << "TarFileTest-end WRITE_DECOMPRESS_DATA_TEST_001"; } +/** + * @tc.number: COMPRESS_FILE_TEST_001 + * @tc.name: COMPRESS_FILE_TEST_001 + * @tc.desc: 测试 CompressFile 接口 + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + */ HWTEST_F(TarFileSubTest, COMPRESS_FILE_TEST_001, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "TarFileTest-begin COMPRESS_FILE_TEST_001"; @@ -421,6 +444,14 @@ HWTEST_F(TarFileSubTest, COMPRESS_FILE_TEST_001, testing::ext::TestSize.Level1) GTEST_LOG_(INFO) << "TarFileTest-end COMPRESS_FILE_TEST_001"; } +/** + * @tc.number: DECOMPRESS_FILE_TEST_001 + * @tc.name: DECOMPRESS_FILE_TEST_001 + * @tc.desc: 测试 DecompressFile 接口 + * @tc.size: MEDIUM + * @tc.type: FUNC + * @tc.level Level 1 + */ HWTEST_F(TarFileSubTest, DECOMPRESS_FILE_TEST_001, testing::ext::TestSize.Level1) { GTEST_LOG_(INFO) << "TarFileTest-begin DECOMPRESS_FILE_TEST_001"; -- Gitee