| // Copyright (c) 2011 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include <stddef.h> |
| #include <stdint.h> |
| |
| #include <iomanip> |
| #include <limits> |
| #include <string> |
| #include <unordered_map> |
| #include <unordered_set> |
| #include <vector> |
| |
| #include "base/bind.h" |
| #include "base/files/file.h" |
| #include "base/files/file_enumerator.h" |
| #include "base/files/file_path.h" |
| #include "base/files/file_util.h" |
| #include "base/files/scoped_temp_dir.h" |
| #include "base/logging.h" |
| #include "base/path_service.h" |
| #include "base/strings/string_util.h" |
| #include "base/strings/stringprintf.h" |
| #include "base/test/bind.h" |
| #include "base/time/time.h" |
| #include "build/build_config.h" |
| #include "testing/gmock/include/gmock/gmock.h" |
| #include "testing/gtest/include/gtest/gtest.h" |
| #include "testing/platform_test.h" |
| #include "third_party/zlib/google/zip.h" |
| #include "third_party/zlib/google/zip_internal.h" |
| #include "third_party/zlib/google/zip_reader.h" |
| |
| // Convenience macro to create a file path from a string literal. |
| #define FP(path) base::FilePath(FILE_PATH_LITERAL(path)) |
| |
| namespace { |
| |
| using testing::UnorderedElementsAre; |
| |
| std::vector<std::string> GetRelativePaths(const base::FilePath& dir, |
| base::FileEnumerator::FileType type) { |
| std::vector<std::string> got_paths; |
| base::FileEnumerator files(dir, true, type); |
| for (base::FilePath path = files.Next(); !path.empty(); path = files.Next()) { |
| base::FilePath relative; |
| EXPECT_TRUE(dir.AppendRelativePath(path, &relative)); |
| got_paths.push_back(relative.AsUTF8Unsafe()); |
| } |
| |
| EXPECT_EQ(base::File::FILE_OK, files.GetError()); |
| return got_paths; |
| } |
| |
| bool CreateFile(const std::string& content, |
| base::FilePath* file_path, |
| base::File* file) { |
| if (!base::CreateTemporaryFile(file_path)) |
| return false; |
| |
| if (base::WriteFile(*file_path, content.data(), content.size()) == -1) |
| return false; |
| |
| *file = base::File( |
| *file_path, base::File::Flags::FLAG_OPEN | base::File::Flags::FLAG_READ); |
| return file->IsValid(); |
| } |
| |
| // A WriterDelegate that logs progress once per second. |
| class ProgressWriterDelegate : public zip::WriterDelegate { |
| public: |
| explicit ProgressWriterDelegate(int64_t expected_size) |
| : expected_size_(expected_size) { |
| CHECK_GT(expected_size_, 0); |
| } |
| |
| bool WriteBytes(const char* data, int num_bytes) override { |
| received_bytes_ += num_bytes; |
| LogProgressIfNecessary(); |
| return true; |
| } |
| |
| void SetTimeModified(const base::Time& time) override { LogProgress(); } |
| |
| int64_t received_bytes() const { return received_bytes_; } |
| |
| private: |
| void LogProgressIfNecessary() { |
| const base::TimeTicks now = base::TimeTicks::Now(); |
| if (next_progress_report_time_ > now) |
| return; |
| |
| next_progress_report_time_ = now + progress_period_; |
| LogProgress(); |
| } |
| |
| void LogProgress() const { |
| LOG(INFO) << "Unzipping... " << std::setw(3) |
| << (100 * received_bytes_ / expected_size_) << "%"; |
| } |
| |
| const base::TimeDelta progress_period_ = base::Seconds(1); |
| base::TimeTicks next_progress_report_time_ = |
| base::TimeTicks::Now() + progress_period_; |
| const uint64_t expected_size_; |
| int64_t received_bytes_ = 0; |
| }; |
| |
| // A virtual file system containing: |
| // /test |
| // /test/foo.txt |
| // /test/bar/bar1.txt |
| // /test/bar/bar2.txt |
| // Used to test providing a custom zip::FileAccessor when unzipping. |
| class VirtualFileSystem : public zip::FileAccessor { |
| public: |
| static constexpr char kFooContent[] = "This is foo."; |
| static constexpr char kBar1Content[] = "This is bar."; |
| static constexpr char kBar2Content[] = "This is bar too."; |
| |
| VirtualFileSystem() { |
| base::FilePath test_dir; |
| base::FilePath foo_txt_path = test_dir.AppendASCII("foo.txt"); |
| |
| base::FilePath file_path; |
| base::File file; |
| bool success = CreateFile(kFooContent, &file_path, &file); |
| DCHECK(success); |
| files_[foo_txt_path] = std::move(file); |
| |
| base::FilePath bar_dir = test_dir.AppendASCII("bar"); |
| base::FilePath bar1_txt_path = bar_dir.AppendASCII("bar1.txt"); |
| success = CreateFile(kBar1Content, &file_path, &file); |
| DCHECK(success); |
| files_[bar1_txt_path] = std::move(file); |
| |
| base::FilePath bar2_txt_path = bar_dir.AppendASCII("bar2.txt"); |
| success = CreateFile(kBar2Content, &file_path, &file); |
| DCHECK(success); |
| files_[bar2_txt_path] = std::move(file); |
| |
| file_tree_[base::FilePath()] = {{foo_txt_path}, {bar_dir}}; |
| file_tree_[bar_dir] = {{bar1_txt_path, bar2_txt_path}}; |
| file_tree_[foo_txt_path] = {}; |
| file_tree_[bar1_txt_path] = {}; |
| file_tree_[bar2_txt_path] = {}; |
| } |
| |
| VirtualFileSystem(const VirtualFileSystem&) = delete; |
| VirtualFileSystem& operator=(const VirtualFileSystem&) = delete; |
| |
| ~VirtualFileSystem() override = default; |
| |
| private: |
| bool Open(const zip::Paths paths, |
| std::vector<base::File>* const files) override { |
| DCHECK(files); |
| files->reserve(files->size() + paths.size()); |
| |
| for (const base::FilePath& path : paths) { |
| const auto it = files_.find(path); |
| if (it == files_.end()) { |
| files->emplace_back(); |
| } else { |
| EXPECT_TRUE(it->second.IsValid()); |
| files->push_back(std::move(it->second)); |
| } |
| } |
| |
| return true; |
| } |
| |
| bool List(const base::FilePath& path, |
| std::vector<base::FilePath>* const files, |
| std::vector<base::FilePath>* const subdirs) override { |
| DCHECK(!path.IsAbsolute()); |
| DCHECK(files); |
| DCHECK(subdirs); |
| |
| const auto it = file_tree_.find(path); |
| if (it == file_tree_.end()) |
| return false; |
| |
| for (const base::FilePath& file : it->second.files) { |
| DCHECK(!file.empty()); |
| files->push_back(file); |
| } |
| |
| for (const base::FilePath& subdir : it->second.subdirs) { |
| DCHECK(!subdir.empty()); |
| subdirs->push_back(subdir); |
| } |
| |
| return true; |
| } |
| |
| bool GetInfo(const base::FilePath& path, Info* const info) override { |
| DCHECK(!path.IsAbsolute()); |
| DCHECK(info); |
| |
| if (!file_tree_.count(path)) |
| return false; |
| |
| info->is_directory = !files_.count(path); |
| info->last_modified = |
| base::Time::FromDoubleT(172097977); // Some random date. |
| |
| return true; |
| } |
| |
| struct DirContents { |
| std::vector<base::FilePath> files, subdirs; |
| }; |
| |
| std::unordered_map<base::FilePath, DirContents> file_tree_; |
| std::unordered_map<base::FilePath, base::File> files_; |
| }; |
| |
| // static |
| constexpr char VirtualFileSystem::kFooContent[]; |
| constexpr char VirtualFileSystem::kBar1Content[]; |
| constexpr char VirtualFileSystem::kBar2Content[]; |
| |
| // Make the test a PlatformTest to setup autorelease pools properly on Mac. |
| class ZipTest : public PlatformTest { |
| protected: |
| enum ValidYearType { VALID_YEAR, INVALID_YEAR }; |
| |
| virtual void SetUp() { |
| PlatformTest::SetUp(); |
| |
| ASSERT_TRUE(temp_dir_.CreateUniqueTempDir()); |
| test_dir_ = temp_dir_.GetPath(); |
| |
| base::FilePath zip_path(test_dir_); |
| zip_contents_.insert(zip_path.AppendASCII("foo.txt")); |
| zip_path = zip_path.AppendASCII("foo"); |
| zip_contents_.insert(zip_path); |
| zip_contents_.insert(zip_path.AppendASCII("bar.txt")); |
| zip_path = zip_path.AppendASCII("bar"); |
| zip_contents_.insert(zip_path); |
| zip_contents_.insert(zip_path.AppendASCII("baz.txt")); |
| zip_contents_.insert(zip_path.AppendASCII("quux.txt")); |
| zip_contents_.insert(zip_path.AppendASCII(".hidden")); |
| |
| // Include a subset of files in |zip_file_list_| to test ZipFiles(). |
| zip_file_list_.push_back(FP("foo.txt")); |
| zip_file_list_.push_back(FP("foo/bar/quux.txt")); |
| zip_file_list_.push_back(FP("foo/bar/.hidden")); |
| } |
| |
| virtual void TearDown() { PlatformTest::TearDown(); } |
| |
| static base::FilePath GetDataDirectory() { |
| base::FilePath path; |
| bool success = base::PathService::Get(base::DIR_SOURCE_ROOT, &path); |
| EXPECT_TRUE(success); |
| return std::move(path) |
| .AppendASCII("third_party") |
| .AppendASCII("zlib") |
| .AppendASCII("google") |
| .AppendASCII("test") |
| .AppendASCII("data"); |
| } |
| |
| void TestUnzipFile(const base::FilePath::StringType& filename, |
| bool expect_hidden_files) { |
| TestUnzipFile(GetDataDirectory().Append(filename), expect_hidden_files); |
| } |
| |
| void TestUnzipFile(const base::FilePath& path, bool expect_hidden_files) { |
| ASSERT_TRUE(base::PathExists(path)) << "no file " << path; |
| ASSERT_TRUE(zip::Unzip(path, test_dir_)); |
| |
| base::FilePath original_dir = GetDataDirectory().AppendASCII("test"); |
| |
| base::FileEnumerator files( |
| test_dir_, true, |
| base::FileEnumerator::FILES | base::FileEnumerator::DIRECTORIES); |
| |
| size_t count = 0; |
| for (base::FilePath unzipped_entry_path = files.Next(); |
| !unzipped_entry_path.empty(); unzipped_entry_path = files.Next()) { |
| EXPECT_EQ(zip_contents_.count(unzipped_entry_path), 1U) |
| << "Couldn't find " << unzipped_entry_path; |
| count++; |
| |
| if (base::PathExists(unzipped_entry_path) && |
| !base::DirectoryExists(unzipped_entry_path)) { |
| // It's a file, check its contents are what we zipped. |
| base::FilePath relative_path; |
| ASSERT_TRUE( |
| test_dir_.AppendRelativePath(unzipped_entry_path, &relative_path)) |
| << "Cannot append relative path failed, params: '" << test_dir_ |
| << "' and '" << unzipped_entry_path << "'"; |
| base::FilePath original_path = original_dir.Append(relative_path); |
| EXPECT_TRUE(base::ContentsEqual(original_path, unzipped_entry_path)) |
| << "Original file '" << original_path << "' and unzipped file '" |
| << unzipped_entry_path << "' have different contents"; |
| } |
| } |
| EXPECT_EQ(base::File::FILE_OK, files.GetError()); |
| |
| size_t expected_count = 0; |
| for (const base::FilePath& path : zip_contents_) { |
| if (expect_hidden_files || path.BaseName().value()[0] != '.') |
| ++expected_count; |
| } |
| |
| EXPECT_EQ(expected_count, count); |
| } |
| |
| // This function does the following: |
| // 1) Creates a test.txt file with the given last modification timestamp |
| // 2) Zips test.txt and extracts it back into a different location. |
| // 3) Confirms that test.txt in the output directory has the specified |
| // last modification timestamp if it is valid (|valid_year| is true). |
| // If the timestamp is not supported by the zip format, the last |
| // modification defaults to the current time. |
| void TestTimeStamp(const char* date_time, ValidYearType valid_year) { |
| SCOPED_TRACE(std::string("TestTimeStamp(") + date_time + ")"); |
| base::ScopedTempDir temp_dir; |
| ASSERT_TRUE(temp_dir.CreateUniqueTempDir()); |
| |
| base::FilePath zip_file = temp_dir.GetPath().AppendASCII("out.zip"); |
| base::FilePath src_dir = temp_dir.GetPath().AppendASCII("input"); |
| base::FilePath out_dir = temp_dir.GetPath().AppendASCII("output"); |
| |
| base::FilePath src_file = src_dir.AppendASCII("test.txt"); |
| base::FilePath out_file = out_dir.AppendASCII("test.txt"); |
| |
| EXPECT_TRUE(base::CreateDirectory(src_dir)); |
| EXPECT_TRUE(base::CreateDirectory(out_dir)); |
| |
| base::Time test_mtime; |
| ASSERT_TRUE(base::Time::FromString(date_time, &test_mtime)); |
| |
| // Adjusting the current timestamp to the resolution that the zip file |
| // supports, which is 2 seconds. Note that between this call to Time::Now() |
| // and zip::Zip() the clock can advance a bit, hence the use of EXPECT_GE. |
| base::Time::Exploded now_parts; |
| base::Time::Now().UTCExplode(&now_parts); |
| now_parts.second = now_parts.second & ~1; |
| now_parts.millisecond = 0; |
| base::Time now_time; |
| EXPECT_TRUE(base::Time::FromUTCExploded(now_parts, &now_time)); |
| |
| EXPECT_EQ(1, base::WriteFile(src_file, "1", 1)); |
| EXPECT_TRUE(base::TouchFile(src_file, base::Time::Now(), test_mtime)); |
| |
| EXPECT_TRUE(zip::Zip(src_dir, zip_file, true)); |
| ASSERT_TRUE(zip::Unzip(zip_file, out_dir)); |
| |
| base::File::Info file_info; |
| EXPECT_TRUE(base::GetFileInfo(out_file, &file_info)); |
| EXPECT_EQ(file_info.size, 1); |
| |
| if (valid_year == VALID_YEAR) { |
| EXPECT_EQ(file_info.last_modified, test_mtime); |
| } else { |
| // Invalid date means the modification time will default to 'now'. |
| EXPECT_GE(file_info.last_modified, now_time); |
| } |
| } |
| |
| // The path to temporary directory used to contain the test operations. |
| base::FilePath test_dir_; |
| |
| base::ScopedTempDir temp_dir_; |
| |
| // Hard-coded contents of a known zip file. |
| std::unordered_set<base::FilePath> zip_contents_; |
| |
| // Hard-coded list of relative paths for a zip file created with ZipFiles. |
| std::vector<base::FilePath> zip_file_list_; |
| }; |
| |
| TEST_F(ZipTest, UnzipNoSuchFile) { |
| EXPECT_FALSE(zip::Unzip(GetDataDirectory().AppendASCII("No Such File.zip"), |
| test_dir_)); |
| EXPECT_THAT( |
| GetRelativePaths(test_dir_, base::FileEnumerator::FileType::FILES), |
| UnorderedElementsAre()); |
| EXPECT_THAT( |
| GetRelativePaths(test_dir_, base::FileEnumerator::FileType::DIRECTORIES), |
| UnorderedElementsAre()); |
| } |
| |
| TEST_F(ZipTest, Unzip) { |
| TestUnzipFile(FILE_PATH_LITERAL("test.zip"), true); |
| } |
| |
| TEST_F(ZipTest, UnzipUncompressed) { |
| TestUnzipFile(FILE_PATH_LITERAL("test_nocompress.zip"), true); |
| } |
| |
| TEST_F(ZipTest, UnzipEvil) { |
| base::FilePath path = GetDataDirectory().AppendASCII("evil.zip"); |
| // Unzip the zip file into a sub directory of test_dir_ so evil.zip |
| // won't create a persistent file outside test_dir_ in case of a |
| // failure. |
| base::FilePath output_dir = test_dir_.AppendASCII("out"); |
| ASSERT_FALSE(zip::Unzip(path, output_dir)); |
| base::FilePath evil_file = output_dir; |
| evil_file = evil_file.AppendASCII( |
| "../levilevilevilevilevilevilevilevilevilevilevilevil"); |
| ASSERT_FALSE(base::PathExists(evil_file)); |
| } |
| |
| TEST_F(ZipTest, UnzipEvil2) { |
| // The ZIP file contains a file with invalid UTF-8 in its file name. |
| base::FilePath path = |
| GetDataDirectory().AppendASCII("evil_via_invalid_utf8.zip"); |
| // See the comment at UnzipEvil() for why we do this. |
| base::FilePath output_dir = test_dir_.AppendASCII("out"); |
| ASSERT_TRUE(zip::Unzip(path, output_dir)); |
| ASSERT_TRUE(base::PathExists( |
| output_dir.Append(base::FilePath::FromUTF8Unsafe(".�.\\evil.txt")))); |
| ASSERT_FALSE(base::PathExists(output_dir.AppendASCII("../evil.txt"))); |
| } |
| |
| TEST_F(ZipTest, UnzipWithFilter) { |
| auto filter = base::BindRepeating([](const base::FilePath& path) { |
| return path.BaseName().MaybeAsASCII() == "foo.txt"; |
| }); |
| ASSERT_TRUE(zip::Unzip(GetDataDirectory().AppendASCII("test.zip"), test_dir_, |
| {.filter = std::move(filter)})); |
| // Only foo.txt should have been extracted. |
| EXPECT_THAT( |
| GetRelativePaths(test_dir_, base::FileEnumerator::FileType::FILES), |
| UnorderedElementsAre("foo.txt")); |
| EXPECT_THAT( |
| GetRelativePaths(test_dir_, base::FileEnumerator::FileType::DIRECTORIES), |
| UnorderedElementsAre()); |
| } |
| |
| TEST_F(ZipTest, UnzipEncryptedWithRightPassword) { |
| // TODO(crbug.com/1296838) Also check the AES-encrypted files. |
| auto filter = base::BindRepeating([](const base::FilePath& path) { |
| return !base::StartsWith(path.MaybeAsASCII(), "Encrypted AES"); |
| }); |
| |
| ASSERT_TRUE(zip::Unzip( |
| GetDataDirectory().AppendASCII("Different Encryptions.zip"), test_dir_, |
| {.filter = std::move(filter), .password = "password"})); |
| |
| std::string contents; |
| ASSERT_TRUE(base::ReadFileToString(test_dir_.AppendASCII("ClearText.txt"), |
| &contents)); |
| EXPECT_EQ("This is not encrypted.\n", contents); |
| |
| ASSERT_TRUE(base::ReadFileToString( |
| test_dir_.AppendASCII("Encrypted ZipCrypto.txt"), &contents)); |
| EXPECT_EQ("This is encrypted with ZipCrypto.\n", contents); |
| } |
| |
| TEST_F(ZipTest, UnzipEncryptedWithWrongPassword) { |
| // TODO(crbug.com/1296838) Also check the AES-encrypted files. |
| auto filter = base::BindRepeating([](const base::FilePath& path) { |
| return !base::StartsWith(path.MaybeAsASCII(), "Encrypted AES"); |
| }); |
| |
| ASSERT_FALSE(zip::Unzip( |
| GetDataDirectory().AppendASCII("Different Encryptions.zip"), test_dir_, |
| {.filter = std::move(filter), .password = "wrong"})); |
| |
| std::string contents; |
| ASSERT_TRUE(base::ReadFileToString(test_dir_.AppendASCII("ClearText.txt"), |
| &contents)); |
| EXPECT_EQ("This is not encrypted.\n", contents); |
| |
| // No rubbish file should be left behind. |
| EXPECT_THAT( |
| GetRelativePaths(test_dir_, base::FileEnumerator::FileType::FILES), |
| UnorderedElementsAre("ClearText.txt")); |
| } |
| |
| TEST_F(ZipTest, UnzipEncryptedWithNoPassword) { |
| // TODO(crbug.com/1296838) Also check the AES-encrypted files. |
| auto filter = base::BindRepeating([](const base::FilePath& path) { |
| return !base::StartsWith(path.MaybeAsASCII(), "Encrypted AES"); |
| }); |
| |
| ASSERT_FALSE( |
| zip::Unzip(GetDataDirectory().AppendASCII("Different Encryptions.zip"), |
| test_dir_, {.filter = std::move(filter)})); |
| |
| std::string contents; |
| ASSERT_TRUE(base::ReadFileToString(test_dir_.AppendASCII("ClearText.txt"), |
| &contents)); |
| EXPECT_EQ("This is not encrypted.\n", contents); |
| |
| // No rubbish file should be left behind. |
| EXPECT_THAT( |
| GetRelativePaths(test_dir_, base::FileEnumerator::FileType::FILES), |
| UnorderedElementsAre("ClearText.txt")); |
| } |
| |
| TEST_F(ZipTest, UnzipEncryptedContinueOnError) { |
| EXPECT_TRUE( |
| zip::Unzip(GetDataDirectory().AppendASCII("Different Encryptions.zip"), |
| test_dir_, {.continue_on_error = true})); |
| |
| std::string contents; |
| EXPECT_TRUE(base::ReadFileToString(test_dir_.AppendASCII("ClearText.txt"), |
| &contents)); |
| EXPECT_EQ("This is not encrypted.\n", contents); |
| |
| // No rubbish file should be left behind. |
| EXPECT_THAT( |
| GetRelativePaths(test_dir_, base::FileEnumerator::FileType::FILES), |
| UnorderedElementsAre("ClearText.txt")); |
| } |
| |
| TEST_F(ZipTest, UnzipWrongCrc) { |
| ASSERT_FALSE( |
| zip::Unzip(GetDataDirectory().AppendASCII("Wrong CRC.zip"), test_dir_)); |
| |
| // No rubbish file should be left behind. |
| EXPECT_THAT( |
| GetRelativePaths(test_dir_, base::FileEnumerator::FileType::FILES), |
| UnorderedElementsAre()); |
| } |
| |
| TEST_F(ZipTest, UnzipRepeatedDirName) { |
| EXPECT_TRUE(zip::Unzip( |
| GetDataDirectory().AppendASCII("Repeated Dir Name.zip"), test_dir_)); |
| |
| EXPECT_THAT( |
| GetRelativePaths(test_dir_, base::FileEnumerator::FileType::FILES), |
| UnorderedElementsAre()); |
| |
| EXPECT_THAT( |
| GetRelativePaths(test_dir_, base::FileEnumerator::FileType::DIRECTORIES), |
| UnorderedElementsAre("repeated")); |
| } |
| |
| TEST_F(ZipTest, UnzipRepeatedFileName) { |
| EXPECT_FALSE(zip::Unzip( |
| GetDataDirectory().AppendASCII("Repeated File Name.zip"), test_dir_)); |
| |
| EXPECT_THAT( |
| GetRelativePaths(test_dir_, base::FileEnumerator::FileType::FILES), |
| UnorderedElementsAre("repeated")); |
| |
| std::string contents; |
| EXPECT_TRUE( |
| base::ReadFileToString(test_dir_.AppendASCII("repeated"), &contents)); |
| EXPECT_EQ("First file", contents); |
| } |
| |
| TEST_F(ZipTest, UnzipCannotCreateEmptyDir) { |
| EXPECT_FALSE(zip::Unzip( |
| GetDataDirectory().AppendASCII("Empty Dir Same Name As File.zip"), |
| test_dir_)); |
| |
| EXPECT_THAT( |
| GetRelativePaths(test_dir_, base::FileEnumerator::FileType::FILES), |
| UnorderedElementsAre("repeated")); |
| |
| EXPECT_THAT( |
| GetRelativePaths(test_dir_, base::FileEnumerator::FileType::DIRECTORIES), |
| UnorderedElementsAre()); |
| |
| std::string contents; |
| EXPECT_TRUE( |
| base::ReadFileToString(test_dir_.AppendASCII("repeated"), &contents)); |
| EXPECT_EQ("First file", contents); |
| } |
| |
| TEST_F(ZipTest, UnzipCannotCreateParentDir) { |
| EXPECT_FALSE(zip::Unzip( |
| GetDataDirectory().AppendASCII("Parent Dir Same Name As File.zip"), |
| test_dir_)); |
| |
| EXPECT_THAT( |
| GetRelativePaths(test_dir_, base::FileEnumerator::FileType::FILES), |
| UnorderedElementsAre("repeated")); |
| |
| EXPECT_THAT( |
| GetRelativePaths(test_dir_, base::FileEnumerator::FileType::DIRECTORIES), |
| UnorderedElementsAre()); |
| |
| std::string contents; |
| EXPECT_TRUE( |
| base::ReadFileToString(test_dir_.AppendASCII("repeated"), &contents)); |
| EXPECT_EQ("First file", contents); |
| } |
| |
| TEST_F(ZipTest, UnzipWindowsSpecialNames) { |
| EXPECT_TRUE(zip::Unzip( |
| GetDataDirectory().AppendASCII("Windows Special Names.zip"), test_dir_)); |
| |
| std::string contents; |
| EXPECT_TRUE(base::ReadFileToString(test_dir_.AppendASCII("Last"), &contents)); |
| EXPECT_EQ("Last file", contents); |
| |
| #ifdef OS_WIN |
| // On Windows, the NUL* files are simply missing. No error is reported. Not |
| // even an error message in the logs. |
| EXPECT_THAT( |
| GetRelativePaths(test_dir_, base::FileEnumerator::FileType::FILES), |
| UnorderedElementsAre("First", "Last")); |
| #else |
| EXPECT_THAT( |
| GetRelativePaths(test_dir_, base::FileEnumerator::FileType::FILES), |
| UnorderedElementsAre("First", "Last", "NUL", "Nul.txt", |
| "nul.very long extension")); |
| |
| EXPECT_TRUE(base::ReadFileToString(test_dir_.AppendASCII("NUL"), &contents)); |
| EXPECT_EQ("This is: NUL", contents); |
| |
| EXPECT_TRUE( |
| base::ReadFileToString(test_dir_.AppendASCII("Nul.txt"), &contents)); |
| EXPECT_EQ("This is: Nul.txt", contents); |
| |
| EXPECT_TRUE(base::ReadFileToString( |
| test_dir_.AppendASCII("nul.very long extension"), &contents)); |
| EXPECT_EQ("This is: nul.very long extension", contents); |
| #endif |
| } |
| |
| TEST_F(ZipTest, UnzipDifferentCases) { |
| #if defined(OS_WIN) || defined(OS_MAC) |
| // Only the first file (with mixed case) is extracted. |
| EXPECT_FALSE(zip::Unzip(GetDataDirectory().AppendASCII( |
| "Repeated File Name With Different Cases.zip"), |
| test_dir_)); |
| |
| EXPECT_THAT( |
| GetRelativePaths(test_dir_, base::FileEnumerator::FileType::FILES), |
| UnorderedElementsAre("Case")); |
| |
| std::string contents; |
| EXPECT_TRUE(base::ReadFileToString(test_dir_.AppendASCII("Case"), &contents)); |
| EXPECT_EQ("Mixed case 111", contents); |
| #else |
| // All the files are extracted. |
| EXPECT_TRUE(zip::Unzip(GetDataDirectory().AppendASCII( |
| "Repeated File Name With Different Cases.zip"), |
| test_dir_)); |
| |
| EXPECT_THAT( |
| GetRelativePaths(test_dir_, base::FileEnumerator::FileType::FILES), |
| UnorderedElementsAre("Case", "case", "CASE")); |
| |
| std::string contents; |
| EXPECT_TRUE(base::ReadFileToString(test_dir_.AppendASCII("Case"), &contents)); |
| EXPECT_EQ("Mixed case 111", contents); |
| |
| EXPECT_TRUE(base::ReadFileToString(test_dir_.AppendASCII("case"), &contents)); |
| EXPECT_EQ("Lower case 22", contents); |
| |
| EXPECT_TRUE(base::ReadFileToString(test_dir_.AppendASCII("CASE"), &contents)); |
| EXPECT_EQ("Upper case 3", contents); |
| #endif |
| } |
| |
| TEST_F(ZipTest, UnzipDifferentCasesContinueOnError) { |
| EXPECT_TRUE(zip::Unzip(GetDataDirectory().AppendASCII( |
| "Repeated File Name With Different Cases.zip"), |
| test_dir_, {.continue_on_error = true})); |
| |
| std::string contents; |
| |
| #if defined(OS_WIN) || defined(OS_MAC) |
| // Only the first file (with mixed case) has been extracted. |
| EXPECT_THAT( |
| GetRelativePaths(test_dir_, base::FileEnumerator::FileType::FILES), |
| UnorderedElementsAre("Case")); |
| |
| EXPECT_TRUE(base::ReadFileToString(test_dir_.AppendASCII("Case"), &contents)); |
| EXPECT_EQ("Mixed case 111", contents); |
| #else |
| // All the files have been extracted. |
| EXPECT_THAT( |
| GetRelativePaths(test_dir_, base::FileEnumerator::FileType::FILES), |
| UnorderedElementsAre("Case", "case", "CASE")); |
| |
| EXPECT_TRUE(base::ReadFileToString(test_dir_.AppendASCII("Case"), &contents)); |
| EXPECT_EQ("Mixed case 111", contents); |
| |
| EXPECT_TRUE(base::ReadFileToString(test_dir_.AppendASCII("case"), &contents)); |
| EXPECT_EQ("Lower case 22", contents); |
| |
| EXPECT_TRUE(base::ReadFileToString(test_dir_.AppendASCII("CASE"), &contents)); |
| EXPECT_EQ("Upper case 3", contents); |
| #endif |
| } |
| |
| TEST_F(ZipTest, UnzipMixedPaths) { |
| EXPECT_TRUE(zip::Unzip(GetDataDirectory().AppendASCII("Mixed Paths.zip"), |
| test_dir_, {.continue_on_error = true})); |
| |
| std::unordered_set<std::string> want_paths = { |
| #ifdef OS_WIN |
| "Dot", // |
| "Space→", // |
| "a\\b", // |
| "u\\v\\w\\x\\y\\z", // |
| "←Backslash2", // |
| #else |
| " ", // Invalid on Windows |
| "Angle <>", // Invalid on Windows |
| "Backslash1→\\", // |
| "Backspace \x08", // Invalid on Windows |
| "Bell \a", // Invalid on Windows |
| "C:", // Invalid on Windows |
| "C:\\", // Absolute path on Windows |
| "C:\\Temp", // Absolute path on Windows |
| "C:\\Temp\\", // Absolute path on Windows |
| "C:\\Temp\\File", // Absolute path on Windows |
| "Carriage Return \r", // Invalid on Windows |
| "Colon :", // Invalid on Windows |
| "Dot .", // Becomes "Dot" on Windows |
| "Double quote \"", // Invalid on Windows |
| "Escape \x1B", // Invalid on Windows |
| "Line Feed \n", // Invalid on Windows |
| "NUL .txt", // Disappears on Windows |
| "NUL", // Disappears on Windows |
| "NUL..txt", // Disappears on Windows |
| "NUL.tar.gz", // Disappears on Windows |
| "NUL.txt", // Disappears on Windows |
| "Pipe |", // Invalid on Windows |
| "Question ?", // Invalid on Windows |
| "Space→ ", // Becomes "Space→" on Windows |
| "Star *", // Invalid on Windows |
| "Tab \t", // Invalid on Windows |
| "\\\\server\\share\\file", // Absolute path on Windows |
| "\\←Backslash2", // Becomes "←Backslash2" on Windows |
| "a/b", // |
| "u/v/w/x/y/z", // |
| #ifndef OS_MAC |
| "CASE", // |
| "Case", // |
| #endif |
| #endif |
| " NUL.txt", // |
| " ←Space", // |
| "$HOME", // |
| "%TMP", // |
| "-", // |
| "...Tree", // |
| "..Two", // |
| ".One", // |
| "Ampersand &", // |
| "At @", // |
| "Backslash3→\\←Backslash4", // |
| "Backtick `", // |
| "Caret ^", // |
| "Comma ,", // |
| "Curly {}", // |
| "Dash -", // |
| "Delete \x7F", // |
| "Dollar $", // |
| "Equal =", // |
| "Euro €", // |
| "Exclamation !", // |
| "FileOrDir", // |
| "First", // |
| "Hash #", // |
| "Last", // |
| "Percent %", // |
| "Plus +", // |
| "Quote '", // |
| "Round ()", // |
| "Semicolon ;", // |
| "Smile \U0001F642", // |
| "Square []", // |
| "String Terminator \u009C", // |
| "Tilde ~", // |
| "Underscore _", // |
| "case", // |
| "~", // |
| }; |
| |
| const std::vector<std::string> got_paths = |
| GetRelativePaths(test_dir_, base::FileEnumerator::FileType::FILES); |
| |
| for (const std::string& path : got_paths) { |
| EXPECT_TRUE(want_paths.erase(path)) |
| << "Found unexpected file: " << std::quoted(path); |
| } |
| |
| for (const std::string& path : want_paths) { |
| EXPECT_TRUE(false) << "Cannot find expected file: " << std::quoted(path); |
| } |
| |
| EXPECT_THAT( |
| GetRelativePaths(test_dir_, base::FileEnumerator::FileType::DIRECTORIES), |
| UnorderedElementsAre( |
| #ifdef OS_WIN |
| "Backslash3→", "Empty", "a", "u", "u\\v", "u\\v\\w", "u\\v\\w\\x", |
| "u\\v\\w\\x\\y" |
| #else |
| "Empty", "a", "u", "u/v", "u/v/w", "u/v/w/x", "u/v/w/x/y" |
| #endif |
| )); |
| } |
| |
| TEST_F(ZipTest, UnzipWithDelegates) { |
| auto dir_creator = |
| base::BindLambdaForTesting([this](const base::FilePath& entry_path) { |
| return base::CreateDirectory(test_dir_.Append(entry_path)); |
| }); |
| auto writer = |
| base::BindLambdaForTesting([this](const base::FilePath& entry_path) |
| -> std::unique_ptr<zip::WriterDelegate> { |
| return std::make_unique<zip::FilePathWriterDelegate>( |
| test_dir_.Append(entry_path)); |
| }); |
| |
| base::File file(GetDataDirectory().AppendASCII("test.zip"), |
| base::File::Flags::FLAG_OPEN | base::File::Flags::FLAG_READ); |
| EXPECT_TRUE(zip::Unzip(file.GetPlatformFile(), writer, dir_creator)); |
| base::FilePath dir = test_dir_; |
| base::FilePath dir_foo = dir.AppendASCII("foo"); |
| base::FilePath dir_foo_bar = dir_foo.AppendASCII("bar"); |
| EXPECT_TRUE(base::PathExists(dir.AppendASCII("foo.txt"))); |
| EXPECT_TRUE(base::DirectoryExists(dir_foo)); |
| EXPECT_TRUE(base::PathExists(dir_foo.AppendASCII("bar.txt"))); |
| EXPECT_TRUE(base::DirectoryExists(dir_foo_bar)); |
| EXPECT_TRUE(base::PathExists(dir_foo_bar.AppendASCII(".hidden"))); |
| EXPECT_TRUE(base::PathExists(dir_foo_bar.AppendASCII("baz.txt"))); |
| EXPECT_TRUE(base::PathExists(dir_foo_bar.AppendASCII("quux.txt"))); |
| } |
| |
| TEST_F(ZipTest, UnzipOnlyDirectories) { |
| auto dir_creator = |
| base::BindLambdaForTesting([this](const base::FilePath& entry_path) { |
| return base::CreateDirectory(test_dir_.Append(entry_path)); |
| }); |
| |
| // Always return a null WriterDelegate. |
| auto writer = |
| base::BindLambdaForTesting([](const base::FilePath& entry_path) { |
| return std::unique_ptr<zip::WriterDelegate>(); |
| }); |
| |
| base::File file(GetDataDirectory().AppendASCII("test.zip"), |
| base::File::Flags::FLAG_OPEN | base::File::Flags::FLAG_READ); |
| EXPECT_TRUE(zip::Unzip(file.GetPlatformFile(), writer, dir_creator, |
| {.continue_on_error = true})); |
| base::FilePath dir = test_dir_; |
| base::FilePath dir_foo = dir.AppendASCII("foo"); |
| base::FilePath dir_foo_bar = dir_foo.AppendASCII("bar"); |
| EXPECT_FALSE(base::PathExists(dir.AppendASCII("foo.txt"))); |
| EXPECT_TRUE(base::DirectoryExists(dir_foo)); |
| EXPECT_FALSE(base::PathExists(dir_foo.AppendASCII("bar.txt"))); |
| EXPECT_TRUE(base::DirectoryExists(dir_foo_bar)); |
| EXPECT_FALSE(base::PathExists(dir_foo_bar.AppendASCII(".hidden"))); |
| EXPECT_FALSE(base::PathExists(dir_foo_bar.AppendASCII("baz.txt"))); |
| EXPECT_FALSE(base::PathExists(dir_foo_bar.AppendASCII("quux.txt"))); |
| } |
| |
| // Tests that a ZIP archive containing SJIS-encoded file names can be correctly |
| // extracted if the encoding is specified. |
| TEST_F(ZipTest, UnzipSjis) { |
| ASSERT_TRUE(zip::Unzip(GetDataDirectory().AppendASCII("SJIS Bug 846195.zip"), |
| test_dir_, {.encoding = "Shift_JIS"})); |
| |
| const base::FilePath dir = |
| test_dir_.Append(base::FilePath::FromUTF8Unsafe("新しいフォルダ")); |
| EXPECT_TRUE(base::DirectoryExists(dir)); |
| |
| std::string contents; |
| ASSERT_TRUE(base::ReadFileToString( |
| dir.Append(base::FilePath::FromUTF8Unsafe("SJIS_835C_ソ.txt")), |
| &contents)); |
| EXPECT_EQ( |
| "This file's name contains 0x5c (backslash) as the 2nd byte of Japanese " |
| "characater \"\x83\x5c\" when encoded in Shift JIS.", |
| contents); |
| |
| ASSERT_TRUE(base::ReadFileToString(dir.Append(base::FilePath::FromUTF8Unsafe( |
| "新しいテキスト ドキュメント.txt")), |
| &contents)); |
| EXPECT_EQ("This file name is coded in Shift JIS in the archive.", contents); |
| } |
| |
| // Tests that a ZIP archive containing SJIS-encoded file names can be extracted |
| // even if the encoding is not specified. In this case, file names are |
| // interpreted as UTF-8, which leads to garbled names where invalid UTF-8 |
| // sequences are replaced with the character �. Nevertheless, the files are |
| // safely extracted and readable. |
| TEST_F(ZipTest, UnzipSjisAsUtf8) { |
| ASSERT_TRUE(zip::Unzip(GetDataDirectory().AppendASCII("SJIS Bug 846195.zip"), |
| test_dir_)); |
| |
| EXPECT_FALSE(base::DirectoryExists( |
| test_dir_.Append(base::FilePath::FromUTF8Unsafe("新しいフォルダ")))); |
| |
| const base::FilePath dir = |
| test_dir_.Append(base::FilePath::FromUTF8Unsafe("�V�����t�H���_")); |
| EXPECT_TRUE(base::DirectoryExists(dir)); |
| |
| std::string contents; |
| ASSERT_TRUE(base::ReadFileToString( |
| dir.Append(base::FilePath::FromUTF8Unsafe("SJIS_835C_�\\.txt")), |
| &contents)); |
| EXPECT_EQ( |
| "This file's name contains 0x5c (backslash) as the 2nd byte of Japanese " |
| "characater \"\x83\x5c\" when encoded in Shift JIS.", |
| contents); |
| |
| ASSERT_TRUE(base::ReadFileToString(dir.Append(base::FilePath::FromUTF8Unsafe( |
| "�V�����e�L�X�g �h�L�������g.txt")), |
| &contents)); |
| EXPECT_EQ("This file name is coded in Shift JIS in the archive.", contents); |
| } |
| |
| TEST_F(ZipTest, Zip) { |
| base::FilePath src_dir = GetDataDirectory().AppendASCII("test"); |
| |
| base::ScopedTempDir temp_dir; |
| ASSERT_TRUE(temp_dir.CreateUniqueTempDir()); |
| base::FilePath zip_file = temp_dir.GetPath().AppendASCII("out.zip"); |
| |
| EXPECT_TRUE(zip::Zip(src_dir, zip_file, /*include_hidden_files=*/true)); |
| TestUnzipFile(zip_file, true); |
| } |
| |
| TEST_F(ZipTest, ZipIgnoreHidden) { |
| base::FilePath src_dir = GetDataDirectory().AppendASCII("test"); |
| |
| base::ScopedTempDir temp_dir; |
| ASSERT_TRUE(temp_dir.CreateUniqueTempDir()); |
| base::FilePath zip_file = temp_dir.GetPath().AppendASCII("out.zip"); |
| |
| EXPECT_TRUE(zip::Zip(src_dir, zip_file, /*include_hidden_files=*/false)); |
| TestUnzipFile(zip_file, false); |
| } |
| |
| TEST_F(ZipTest, ZipNonASCIIDir) { |
| base::FilePath src_dir = GetDataDirectory().AppendASCII("test"); |
| |
| base::ScopedTempDir temp_dir; |
| ASSERT_TRUE(temp_dir.CreateUniqueTempDir()); |
| // Append 'Тест' (in cyrillic). |
| base::FilePath src_dir_russian = temp_dir.GetPath().Append( |
| base::FilePath::FromUTF8Unsafe("\xD0\xA2\xD0\xB5\xD1\x81\xD1\x82")); |
| base::CopyDirectory(src_dir, src_dir_russian, true); |
| base::FilePath zip_file = temp_dir.GetPath().AppendASCII("out_russian.zip"); |
| |
| EXPECT_TRUE(zip::Zip(src_dir_russian, zip_file, true)); |
| TestUnzipFile(zip_file, true); |
| } |
| |
| TEST_F(ZipTest, ZipTimeStamp) { |
| // The dates tested are arbitrary, with some constraints. The zip format can |
| // only store years from 1980 to 2107 and an even number of seconds, due to it |
| // using the ms dos date format. |
| |
| // Valid arbitrary date. |
| TestTimeStamp("23 Oct 1997 23:22:20", VALID_YEAR); |
| |
| // Date before 1980, zip format limitation, must default to unix epoch. |
| TestTimeStamp("29 Dec 1979 21:00:10", INVALID_YEAR); |
| |
| // Despite the minizip headers telling the maximum year should be 2044, it |
| // can actually go up to 2107. Beyond that, the dos date format cannot store |
| // the year (2107-1980=127). To test that limit, the input file needs to be |
| // touched, but the code that modifies the file access and modification times |
| // relies on time_t which is defined as long, therefore being in many |
| // platforms just a 4-byte integer, like 32-bit Mac OSX or linux. As such, it |
| // suffers from the year-2038 bug. Therefore 2038 is the highest we can test |
| // in all platforms reliably. |
| TestTimeStamp("02 Jan 2038 23:59:58", VALID_YEAR); |
| } |
| |
| #if defined(OS_POSIX) || defined(OS_FUCHSIA) |
| TEST_F(ZipTest, ZipFiles) { |
| base::FilePath src_dir = GetDataDirectory().AppendASCII("test"); |
| |
| base::ScopedTempDir temp_dir; |
| ASSERT_TRUE(temp_dir.CreateUniqueTempDir()); |
| base::FilePath zip_name = temp_dir.GetPath().AppendASCII("out.zip"); |
| |
| base::File zip_file(zip_name, |
| base::File::FLAG_CREATE | base::File::FLAG_WRITE); |
| ASSERT_TRUE(zip_file.IsValid()); |
| EXPECT_TRUE( |
| zip::ZipFiles(src_dir, zip_file_list_, zip_file.GetPlatformFile())); |
| zip_file.Close(); |
| |
| zip::ZipReader reader; |
| EXPECT_TRUE(reader.Open(zip_name)); |
| EXPECT_EQ(zip_file_list_.size(), static_cast<size_t>(reader.num_entries())); |
| for (size_t i = 0; i < zip_file_list_.size(); ++i) { |
| const zip::ZipReader::Entry* const entry = reader.Next(); |
| ASSERT_TRUE(entry); |
| EXPECT_EQ(entry->path, zip_file_list_[i]); |
| } |
| } |
| #endif // defined(OS_POSIX) || defined(OS_FUCHSIA) |
| |
| TEST_F(ZipTest, UnzipFilesWithIncorrectSize) { |
| // test_mismatch_size.zip contains files with names from 0.txt to 7.txt with |
| // sizes from 0 to 7 bytes respectively, but the metadata in the zip file says |
| // the uncompressed size is 3 bytes. The ZipReader and minizip code needs to |
| // be clever enough to get all the data out. |
| base::FilePath test_zip_file = |
| GetDataDirectory().AppendASCII("test_mismatch_size.zip"); |
| |
| base::ScopedTempDir scoped_temp_dir; |
| ASSERT_TRUE(scoped_temp_dir.CreateUniqueTempDir()); |
| const base::FilePath& temp_dir = scoped_temp_dir.GetPath(); |
| |
| ASSERT_TRUE(zip::Unzip(test_zip_file, temp_dir)); |
| EXPECT_TRUE(base::DirectoryExists(temp_dir.AppendASCII("d"))); |
| |
| for (int i = 0; i < 8; i++) { |
| SCOPED_TRACE(base::StringPrintf("Processing %d.txt", i)); |
| base::FilePath file_path = |
| temp_dir.AppendASCII(base::StringPrintf("%d.txt", i)); |
| int64_t file_size = -1; |
| EXPECT_TRUE(base::GetFileSize(file_path, &file_size)); |
| EXPECT_EQ(static_cast<int64_t>(i), file_size); |
| } |
| } |
| |
| TEST_F(ZipTest, ZipWithFileAccessor) { |
| base::FilePath zip_file; |
| ASSERT_TRUE(base::CreateTemporaryFile(&zip_file)); |
| VirtualFileSystem file_accessor; |
| const zip::ZipParams params{.file_accessor = &file_accessor, |
| .dest_file = zip_file}; |
| ASSERT_TRUE(zip::Zip(params)); |
| |
| base::ScopedTempDir scoped_temp_dir; |
| ASSERT_TRUE(scoped_temp_dir.CreateUniqueTempDir()); |
| const base::FilePath& temp_dir = scoped_temp_dir.GetPath(); |
| ASSERT_TRUE(zip::Unzip(zip_file, temp_dir)); |
| base::FilePath bar_dir = temp_dir.AppendASCII("bar"); |
| EXPECT_TRUE(base::DirectoryExists(bar_dir)); |
| std::string file_content; |
| EXPECT_TRUE( |
| base::ReadFileToString(temp_dir.AppendASCII("foo.txt"), &file_content)); |
| EXPECT_EQ(VirtualFileSystem::kFooContent, file_content); |
| EXPECT_TRUE( |
| base::ReadFileToString(bar_dir.AppendASCII("bar1.txt"), &file_content)); |
| EXPECT_EQ(VirtualFileSystem::kBar1Content, file_content); |
| EXPECT_TRUE( |
| base::ReadFileToString(bar_dir.AppendASCII("bar2.txt"), &file_content)); |
| EXPECT_EQ(VirtualFileSystem::kBar2Content, file_content); |
| } |
| |
| // Tests progress reporting while zipping files. |
| TEST_F(ZipTest, ZipProgress) { |
| base::FilePath src_dir = GetDataDirectory().AppendASCII("test"); |
| |
| base::ScopedTempDir temp_dir; |
| ASSERT_TRUE(temp_dir.CreateUniqueTempDir()); |
| base::FilePath zip_file = temp_dir.GetPath().AppendASCII("out.zip"); |
| |
| int progress_count = 0; |
| zip::Progress last_progress; |
| |
| zip::ProgressCallback progress_callback = |
| base::BindLambdaForTesting([&](const zip::Progress& progress) { |
| progress_count++; |
| LOG(INFO) << "Progress #" << progress_count << ": " << progress; |
| |
| // Progress should only go forwards. |
| EXPECT_GE(progress.bytes, last_progress.bytes); |
| EXPECT_GE(progress.files, last_progress.files); |
| EXPECT_GE(progress.directories, last_progress.directories); |
| |
| last_progress = progress; |
| return true; |
| }); |
| |
| EXPECT_TRUE(zip::Zip({.src_dir = src_dir, |
| .dest_file = zip_file, |
| .progress_callback = std::move(progress_callback)})); |
| |
| EXPECT_EQ(progress_count, 14); |
| EXPECT_EQ(last_progress.bytes, 13546); |
| EXPECT_EQ(last_progress.files, 5); |
| EXPECT_EQ(last_progress.directories, 2); |
| |
| TestUnzipFile(zip_file, true); |
| } |
| |
| // Tests throttling of progress reporting while zipping files. |
| TEST_F(ZipTest, ZipProgressPeriod) { |
| base::FilePath src_dir = GetDataDirectory().AppendASCII("test"); |
| |
| base::ScopedTempDir temp_dir; |
| ASSERT_TRUE(temp_dir.CreateUniqueTempDir()); |
| base::FilePath zip_file = temp_dir.GetPath().AppendASCII("out.zip"); |
| |
| int progress_count = 0; |
| zip::Progress last_progress; |
| |
| zip::ProgressCallback progress_callback = |
| base::BindLambdaForTesting([&](const zip::Progress& progress) { |
| progress_count++; |
| LOG(INFO) << "Progress #" << progress_count << ": " << progress; |
| |
| // Progress should only go forwards. |
| EXPECT_GE(progress.bytes, last_progress.bytes); |
| EXPECT_GE(progress.files, last_progress.files); |
| EXPECT_GE(progress.directories, last_progress.directories); |
| |
| last_progress = progress; |
| return true; |
| }); |
| |
| EXPECT_TRUE(zip::Zip({.src_dir = src_dir, |
| .dest_file = zip_file, |
| .progress_callback = std::move(progress_callback), |
| .progress_period = base::Hours(1)})); |
| |
| // We expect only 2 progress reports: the first one, and the last one. |
| EXPECT_EQ(progress_count, 2); |
| EXPECT_EQ(last_progress.bytes, 13546); |
| EXPECT_EQ(last_progress.files, 5); |
| EXPECT_EQ(last_progress.directories, 2); |
| |
| TestUnzipFile(zip_file, true); |
| } |
| |
| // Tests cancellation while zipping files. |
| TEST_F(ZipTest, ZipCancel) { |
| base::FilePath src_dir = GetDataDirectory().AppendASCII("test"); |
| |
| base::ScopedTempDir temp_dir; |
| ASSERT_TRUE(temp_dir.CreateUniqueTempDir()); |
| base::FilePath zip_file = temp_dir.GetPath().AppendASCII("out.zip"); |
| |
| // First: establish the number of possible interruption points. |
| int progress_count = 0; |
| |
| EXPECT_TRUE(zip::Zip({.src_dir = src_dir, |
| .dest_file = zip_file, |
| .progress_callback = base::BindLambdaForTesting( |
| [&progress_count](const zip::Progress&) { |
| progress_count++; |
| return true; |
| })})); |
| |
| EXPECT_EQ(progress_count, 14); |
| |
| // Second: exercise each and every interruption point. |
| for (int i = progress_count; i > 0; i--) { |
| int j = 0; |
| EXPECT_FALSE(zip::Zip({.src_dir = src_dir, |
| .dest_file = zip_file, |
| .progress_callback = base::BindLambdaForTesting( |
| [i, &j](const zip::Progress&) { |
| j++; |
| // Callback shouldn't be called again after |
| // having returned false once. |
| EXPECT_LE(j, i); |
| return j < i; |
| })})); |
| |
| EXPECT_EQ(j, i); |
| } |
| } |
| |
| // Tests zip::internal::GetCompressionMethod() |
| TEST_F(ZipTest, GetCompressionMethod) { |
| using zip::internal::GetCompressionMethod; |
| using zip::internal::kDeflated; |
| using zip::internal::kStored; |
| |
| EXPECT_EQ(GetCompressionMethod(FP("")), kDeflated); |
| EXPECT_EQ(GetCompressionMethod(FP("NoExtension")), kDeflated); |
| EXPECT_EQ(GetCompressionMethod(FP("Folder.zip").Append(FP("NoExtension"))), |
| kDeflated); |
| EXPECT_EQ(GetCompressionMethod(FP("Name.txt")), kDeflated); |
| EXPECT_EQ(GetCompressionMethod(FP("Name.zip")), kStored); |
| EXPECT_EQ(GetCompressionMethod(FP("Name....zip")), kStored); |
| EXPECT_EQ(GetCompressionMethod(FP("Name.zip")), kStored); |
| EXPECT_EQ(GetCompressionMethod(FP("NAME.ZIP")), kStored); |
| EXPECT_EQ(GetCompressionMethod(FP("Name.gz")), kStored); |
| EXPECT_EQ(GetCompressionMethod(FP("Name.tar.gz")), kStored); |
| EXPECT_EQ(GetCompressionMethod(FP("Name.tar")), kDeflated); |
| |
| // This one is controversial. |
| EXPECT_EQ(GetCompressionMethod(FP(".zip")), kStored); |
| } |
| |
| // Tests that files put inside a ZIP are effectively compressed. |
| TEST_F(ZipTest, Compressed) { |
| base::ScopedTempDir temp_dir; |
| ASSERT_TRUE(temp_dir.CreateUniqueTempDir()); |
| |
| const base::FilePath src_dir = temp_dir.GetPath().AppendASCII("input"); |
| EXPECT_TRUE(base::CreateDirectory(src_dir)); |
| |
| // Create some dummy source files. |
| for (const base::StringPiece s : {"foo", "bar.txt", ".hidden"}) { |
| base::File f(src_dir.AppendASCII(s), |
| base::File::FLAG_CREATE | base::File::FLAG_WRITE); |
| ASSERT_TRUE(f.SetLength(5000)); |
| } |
| |
| // Zip the source files. |
| const base::FilePath dest_file = temp_dir.GetPath().AppendASCII("dest.zip"); |
| EXPECT_TRUE(zip::Zip({.src_dir = src_dir, |
| .dest_file = dest_file, |
| .include_hidden_files = true})); |
| |
| // Since the source files compress well, the destination ZIP file should be |
| // smaller than the source files. |
| int64_t dest_file_size; |
| ASSERT_TRUE(base::GetFileSize(dest_file, &dest_file_size)); |
| EXPECT_GT(dest_file_size, 300); |
| EXPECT_LT(dest_file_size, 1000); |
| } |
| |
| // Tests that a ZIP put inside a ZIP is simply stored instead of being |
| // compressed. |
| TEST_F(ZipTest, NestedZip) { |
| base::ScopedTempDir temp_dir; |
| ASSERT_TRUE(temp_dir.CreateUniqueTempDir()); |
| |
| const base::FilePath src_dir = temp_dir.GetPath().AppendASCII("input"); |
| EXPECT_TRUE(base::CreateDirectory(src_dir)); |
| |
| // Create a dummy ZIP file. This is not a valid ZIP file, but for the purpose |
| // of this test, it doesn't really matter. |
| const int64_t src_size = 5000; |
| |
| { |
| base::File f(src_dir.AppendASCII("src.zip"), |
| base::File::FLAG_CREATE | base::File::FLAG_WRITE); |
| ASSERT_TRUE(f.SetLength(src_size)); |
| } |
| |
| // Zip the dummy ZIP file. |
| const base::FilePath dest_file = temp_dir.GetPath().AppendASCII("dest.zip"); |
| EXPECT_TRUE(zip::Zip({.src_dir = src_dir, .dest_file = dest_file})); |
| |
| // Since the dummy source (inner) ZIP file should simply be stored in the |
| // destination (outer) ZIP file, the destination file should be bigger than |
| // the source file, but not much bigger. |
| int64_t dest_file_size; |
| ASSERT_TRUE(base::GetFileSize(dest_file, &dest_file_size)); |
| EXPECT_GT(dest_file_size, src_size + 100); |
| EXPECT_LT(dest_file_size, src_size + 300); |
| } |
| |
| // Tests that there is no 2GB or 4GB limits. Tests that big files can be zipped |
| // (crbug.com/1207737) and that big ZIP files can be created |
| // (crbug.com/1221447). Tests that the big ZIP can be opened, that its entries |
| // are correctly enumerated (crbug.com/1298347), and that the big file can be |
| // extracted. |
| // |
| // Because this test is dealing with big files, it tends to take a lot of disk |
| // space and time (crbug.com/1299736). Therefore, it only gets run on a few bots |
| // (ChromeOS and Windows). |
| // |
| // This test is too slow with TSAN. |
| // OS Fuchsia does not seem to support large files. |
| // Some 32-bit Android waterfall and CQ try bots are running out of space when |
| // performing this test (android-asan, android-11-x86-rel, |
| // android-marshmallow-x86-rel-non-cq). |
| // Some Mac, Linux and Debug (dbg) bots tend to time out when performing this |
| // test (crbug.com/1299736, crbug.com/1300448). |
| #if defined(THREAD_SANITIZER) || BUILDFLAG(IS_FUCHSIA) || \ |
| BUILDFLAG(IS_ANDROID) || BUILDFLAG(IS_MAC) || BUILDFLAG(IS_LINUX) || \ |
| BUILDFLAG(IS_CHROMEOS_LACROS) || !defined(NDEBUG) |
| TEST_F(ZipTest, DISABLED_BigFile) { |
| #else |
| TEST_F(ZipTest, BigFile) { |
| #endif |
| base::ScopedTempDir temp_dir; |
| ASSERT_TRUE(temp_dir.CreateUniqueTempDir()); |
| |
| const base::FilePath src_dir = temp_dir.GetPath().AppendASCII("input"); |
| EXPECT_TRUE(base::CreateDirectory(src_dir)); |
| |
| // Create a big dummy ZIP file. This is not a valid ZIP file, but for the |
| // purpose of this test, it doesn't really matter. |
| const int64_t src_size = 5'000'000'000; |
| |
| const base::FilePath src_file = src_dir.AppendASCII("src.zip"); |
| LOG(INFO) << "Creating big file " << src_file; |
| { |
| base::File f(src_file, base::File::FLAG_CREATE | base::File::FLAG_WRITE); |
| ASSERT_TRUE(f.SetLength(src_size)); |
| } |
| |
| // Zip the dummy ZIP file. |
| const base::FilePath dest_file = temp_dir.GetPath().AppendASCII("dest.zip"); |
| LOG(INFO) << "Zipping big file into " << dest_file; |
| zip::ProgressCallback progress_callback = |
| base::BindLambdaForTesting([&](const zip::Progress& progress) { |
| LOG(INFO) << "Zipping... " << std::setw(3) |
| << (100 * progress.bytes / src_size) << "%"; |
| return true; |
| }); |
| EXPECT_TRUE(zip::Zip({.src_dir = src_dir, |
| .dest_file = dest_file, |
| .progress_callback = std::move(progress_callback), |
| .progress_period = base::Seconds(1)})); |
| |
| // Since the dummy source (inner) ZIP file should simply be stored in the |
| // destination (outer) ZIP file, the destination file should be bigger than |
| // the source file, but not much bigger. |
| int64_t dest_file_size; |
| ASSERT_TRUE(base::GetFileSize(dest_file, &dest_file_size)); |
| EXPECT_GT(dest_file_size, src_size + 100); |
| EXPECT_LT(dest_file_size, src_size + 300); |
| |
| LOG(INFO) << "Reading big ZIP " << dest_file; |
| zip::ZipReader reader; |
| ASSERT_TRUE(reader.Open(dest_file)); |
| |
| const zip::ZipReader::Entry* const entry = reader.Next(); |
| ASSERT_TRUE(entry); |
| EXPECT_EQ(FP("src.zip"), entry->path); |
| EXPECT_EQ(src_size, entry->original_size); |
| EXPECT_FALSE(entry->is_directory); |
| EXPECT_FALSE(entry->is_encrypted); |
| |
| ProgressWriterDelegate writer(src_size); |
| EXPECT_TRUE(reader.ExtractCurrentEntry(&writer, |
| std::numeric_limits<uint64_t>::max())); |
| EXPECT_EQ(src_size, writer.received_bytes()); |
| |
| EXPECT_FALSE(reader.Next()); |
| EXPECT_TRUE(reader.ok()); |
| } |
| |
| } // namespace |