Index: chrome/common/zip_reader_unittest.cc |
diff --git a/chrome/common/zip_reader_unittest.cc b/chrome/common/zip_reader_unittest.cc |
new file mode 100644 |
index 0000000000000000000000000000000000000000..82f0b14f727040feb3a435cbb028890b9990db33 |
--- /dev/null |
+++ b/chrome/common/zip_reader_unittest.cc |
@@ -0,0 +1,265 @@ |
+// 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 "chrome/common/zip_reader.h" |
+ |
+#include <set> |
+#include <string> |
+ |
+#include "base/file_util.h" |
+#include "base/md5.h" |
+#include "base/path_service.h" |
+#include "base/scoped_temp_dir.h" |
+#include "base/time.h" |
+#include "base/utf_string_conversions.h" |
+#include "chrome/common/chrome_paths.h" |
+#include "chrome/common/zip_internal.h" |
+#include "testing/gtest/include/gtest/gtest.h" |
+#include "testing/platform_test.h" |
+ |
+namespace zip { |
+ |
+// Make the test a PlatformTest to setup autorelease pools properly on Mac. |
+class ZipReaderTest : public PlatformTest { |
+ protected: |
+ virtual void SetUp() { |
+ PlatformTest::SetUp(); |
+ |
+ ASSERT_TRUE(temp_dir_.CreateUniqueTempDir()); |
+ test_dir_ = temp_dir_.path(); |
+ |
+ ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &test_data_dir_)); |
+ test_data_dir_ = test_data_dir_.AppendASCII("zip"); |
+ |
+ test_zip_file_ = test_data_dir_.AppendASCII("test.zip"); |
+ evil_zip_file_ = test_data_dir_.AppendASCII("evil.zip"); |
+ evil_via_invalid_utf8_zip_file_ = test_data_dir_.AppendASCII( |
+ "evil_via_invalid_utf8.zip"); |
+ evil_via_absolute_file_name_zip_file_ = test_data_dir_.AppendASCII( |
+ "evil_via_absolute_file_name.zip"); |
+ |
+ test_zip_contents_.insert(FilePath(FILE_PATH_LITERAL("foo/"))); |
+ test_zip_contents_.insert(FilePath(FILE_PATH_LITERAL("foo/bar/"))); |
+ test_zip_contents_.insert(FilePath(FILE_PATH_LITERAL("foo/bar/baz.txt"))); |
+ test_zip_contents_.insert(FilePath(FILE_PATH_LITERAL("foo/bar/quux.txt"))); |
+ test_zip_contents_.insert(FilePath(FILE_PATH_LITERAL("foo/bar.txt"))); |
+ test_zip_contents_.insert(FilePath(FILE_PATH_LITERAL("foo.txt"))); |
+ test_zip_contents_.insert(FilePath(FILE_PATH_LITERAL("foo/bar/.hidden"))); |
+ } |
+ |
+ virtual void TearDown() { |
+ PlatformTest::TearDown(); |
+ } |
+ |
+ // The path to temporary directory used to contain the test operations. |
+ FilePath test_dir_; |
+ // The path to the test data directory where test.zip etc. are located. |
+ FilePath test_data_dir_; |
+ // The path to test.zip in the test data directory. |
+ FilePath test_zip_file_; |
+ // The path to evil.zip in the test data directory. |
+ FilePath evil_zip_file_; |
+ // The path to evil_via_invalid_utf8.zip in the test data directory. |
+ FilePath evil_via_invalid_utf8_zip_file_; |
+ // The path to evil_via_absolute_file_name.zip in the test data directory. |
+ FilePath evil_via_absolute_file_name_zip_file_; |
+ std::set<FilePath> test_zip_contents_; |
+ |
+ ScopedTempDir temp_dir_; |
+}; |
+ |
+TEST_F(ZipReaderTest, Open_ValidZipFile) { |
+ ZipReader reader; |
+ ASSERT_TRUE(reader.Open(test_zip_file_)); |
+} |
+ |
+TEST_F(ZipReaderTest, Open_NonExistentFile) { |
+ ZipReader reader; |
+ ASSERT_FALSE(reader.Open(test_data_dir_.AppendASCII("nonexistent.zip"))); |
+} |
+ |
+TEST_F(ZipReaderTest, Open_ExistentButNonZipFile) { |
+ ZipReader reader; |
+ ASSERT_FALSE(reader.Open(test_data_dir_.AppendASCII("create_test_zip.sh"))); |
+} |
+ |
+// Iterate through the contents in the test zip file, and compare that the |
+// contents collected from the zip reader matches the expected contents. |
+TEST_F(ZipReaderTest, Iteration) { |
+ std::set<FilePath> actual_contents; |
+ ZipReader reader; |
+ ASSERT_TRUE(reader.Open(test_zip_file_)); |
+ while (reader.HasMore()) { |
+ ASSERT_TRUE(reader.OpenCurrentEntryInZip()); |
+ actual_contents.insert(reader.current_entry_info()->file_path()); |
+ ASSERT_TRUE(reader.AdvanceToNextEntry()); |
+ } |
+ EXPECT_FALSE(reader.AdvanceToNextEntry()); // Shouldn't go further. |
+ EXPECT_EQ(test_zip_contents_.size(), |
+ static_cast<size_t>(reader.num_entries())); |
+ EXPECT_EQ(test_zip_contents_.size(), actual_contents.size()); |
+ EXPECT_EQ(test_zip_contents_, actual_contents); |
+} |
+ |
+ |
+TEST_F(ZipReaderTest, LocateAndOpenEntry_ValidFile) { |
+ std::set<FilePath> actual_contents; |
+ ZipReader reader; |
+ ASSERT_TRUE(reader.Open(test_zip_file_)); |
+ FilePath target_path(FILE_PATH_LITERAL("foo/bar/quux.txt")); |
+ ASSERT_TRUE(reader.LocateAndOpenEntry(target_path)); |
+ EXPECT_EQ(target_path, reader.current_entry_info()->file_path()); |
+} |
+ |
+TEST_F(ZipReaderTest, LocateAndOpenEntry_NonExistentFile) { |
+ std::set<FilePath> actual_contents; |
+ ZipReader reader; |
+ ASSERT_TRUE(reader.Open(test_zip_file_)); |
+ FilePath target_path(FILE_PATH_LITERAL("nonexistent.txt")); |
+ ASSERT_FALSE(reader.LocateAndOpenEntry(target_path)); |
+ EXPECT_EQ(NULL, reader.current_entry_info()); |
+} |
+ |
+TEST_F(ZipReaderTest, ExtractCurrentEntryToFilePath_RegularFile) { |
+ ZipReader reader; |
+ ASSERT_TRUE(reader.Open(test_zip_file_)); |
+ FilePath target_path(FILE_PATH_LITERAL("foo/bar/quux.txt")); |
+ ASSERT_TRUE(reader.LocateAndOpenEntry(target_path)); |
+ ASSERT_TRUE(reader.ExtractCurrentEntryToFilePath( |
+ test_dir_.AppendASCII("quux.txt"))); |
+ // Read the output file ans compute the MD5. |
+ std::string output; |
+ ASSERT_TRUE(file_util::ReadFileToString(test_dir_.AppendASCII("quux.txt"), |
+ &output)); |
+ const std::string md5 = base::MD5String(output); |
+ const std::string kExpectedMD5 = "d1ae4ac8a17a0e09317113ab284b57a6"; |
+ EXPECT_EQ(kExpectedMD5, md5); |
+ // quux.txt should be larger than kZipBufSize so that we can exercise |
+ // the loop in ExtractCurrentEntry(). |
+ EXPECT_LT(static_cast<size_t>(internal::kZipBufSize), output.size()); |
+} |
+ |
+TEST_F(ZipReaderTest, ExtractCurrentEntryToFilePath_Directory) { |
+ ZipReader reader; |
+ ASSERT_TRUE(reader.Open(test_zip_file_)); |
+ FilePath target_path(FILE_PATH_LITERAL("foo/")); |
+ ASSERT_TRUE(reader.LocateAndOpenEntry(target_path)); |
+ ASSERT_TRUE(reader.ExtractCurrentEntryToFilePath( |
+ test_dir_.AppendASCII("foo"))); |
+ // The directory should be created. |
+ ASSERT_TRUE(file_util::DirectoryExists(test_dir_.AppendASCII("foo"))); |
+} |
+ |
+TEST_F(ZipReaderTest, ExtractCurrentEntryIntoDirectory_RegularFile) { |
+ ZipReader reader; |
+ ASSERT_TRUE(reader.Open(test_zip_file_)); |
+ FilePath target_path(FILE_PATH_LITERAL("foo/bar/quux.txt")); |
+ ASSERT_TRUE(reader.LocateAndOpenEntry(target_path)); |
+ ASSERT_TRUE(reader.ExtractCurrentEntryIntoDirectory(test_dir_)); |
+ // Sub directories should be created. |
+ ASSERT_TRUE(file_util::DirectoryExists(test_dir_.AppendASCII("foo/bar"))); |
+ // And the file should be created. |
+ std::string output; |
+ ASSERT_TRUE(file_util::ReadFileToString( |
+ test_dir_.AppendASCII("foo/bar/quux.txt"), &output)); |
+ const std::string md5 = base::MD5String(output); |
+ const std::string kExpectedMD5 = "d1ae4ac8a17a0e09317113ab284b57a6"; |
+ EXPECT_EQ(kExpectedMD5, md5); |
+} |
+ |
+TEST_F(ZipReaderTest, current_entry_info_RegularFile) { |
+ ZipReader reader; |
+ ASSERT_TRUE(reader.Open(test_zip_file_)); |
+ FilePath target_path(FILE_PATH_LITERAL("foo/bar/quux.txt")); |
+ ASSERT_TRUE(reader.LocateAndOpenEntry(target_path)); |
+ ZipReader::EntryInfo* current_entry_info = reader.current_entry_info(); |
+ |
+ EXPECT_EQ(target_path, current_entry_info->file_path()); |
+ EXPECT_EQ(13527, current_entry_info->original_size()); |
+ |
+ // The expected time stamp: 2009-05-29 06:22:20 |
+ base::Time::Exploded exploded = {}; // Zero-clear. |
+ current_entry_info->last_modified().LocalExplode(&exploded); |
+ EXPECT_EQ(2009, exploded.year); |
+ EXPECT_EQ(5, exploded.month); |
+ EXPECT_EQ(29, exploded.day_of_month); |
+ EXPECT_EQ(6, exploded.hour); |
+ EXPECT_EQ(22, exploded.minute); |
+ EXPECT_EQ(20, exploded.second); |
+ EXPECT_EQ(0, exploded.millisecond); |
+ |
+ EXPECT_FALSE(current_entry_info->is_unsafe()); |
+ EXPECT_FALSE(current_entry_info->is_directory()); |
+} |
+ |
+TEST_F(ZipReaderTest, current_entry_info_DotDotFile) { |
+ ZipReader reader; |
+ ASSERT_TRUE(reader.Open(evil_zip_file_)); |
+ FilePath target_path(FILE_PATH_LITERAL( |
+ "../levilevilevilevilevilevilevilevilevilevilevilevil")); |
+ ASSERT_TRUE(reader.LocateAndOpenEntry(target_path)); |
+ ZipReader::EntryInfo* current_entry_info = reader.current_entry_info(); |
+ EXPECT_EQ(target_path, current_entry_info->file_path()); |
+ |
+ // This file is unsafe because of ".." in the file name. |
+ EXPECT_TRUE(current_entry_info->is_unsafe()); |
+ EXPECT_FALSE(current_entry_info->is_directory()); |
+} |
+ |
+TEST_F(ZipReaderTest, current_entry_info_InvalidUTF8File) { |
+ ZipReader reader; |
+ ASSERT_TRUE(reader.Open(evil_via_invalid_utf8_zip_file_)); |
+ // The evil file is the 2nd file in the zip file. |
+ // We cannot locate by the file name ".\x80.\\evil.txt", |
+ // as FilePath may internally convert the string. |
+ ASSERT_TRUE(reader.AdvanceToNextEntry()); |
+ ASSERT_TRUE(reader.OpenCurrentEntryInZip()); |
+ ZipReader::EntryInfo* current_entry_info = reader.current_entry_info(); |
+ |
+ // This file is unsafe because of invalid UTF-8 in the file name. |
+ EXPECT_TRUE(current_entry_info->is_unsafe()); |
+ EXPECT_FALSE(current_entry_info->is_directory()); |
+} |
+ |
+TEST_F(ZipReaderTest, current_entry_info_AbsoluteFile) { |
+ ZipReader reader; |
+ ASSERT_TRUE(reader.Open(evil_via_absolute_file_name_zip_file_)); |
+ FilePath target_path(FILE_PATH_LITERAL("/evil.txt")); |
+ ASSERT_TRUE(reader.LocateAndOpenEntry(target_path)); |
+ ZipReader::EntryInfo* current_entry_info = reader.current_entry_info(); |
+ EXPECT_EQ(target_path, current_entry_info->file_path()); |
+ |
+ // This file is unsafe because of the absolute file name. |
+ EXPECT_TRUE(current_entry_info->is_unsafe()); |
+ EXPECT_FALSE(current_entry_info->is_directory()); |
+} |
+ |
+TEST_F(ZipReaderTest, current_entry_info_Directory) { |
+ ZipReader reader; |
+ ASSERT_TRUE(reader.Open(test_zip_file_)); |
+ FilePath target_path(FILE_PATH_LITERAL("foo/bar/")); |
+ ASSERT_TRUE(reader.LocateAndOpenEntry(target_path)); |
+ ZipReader::EntryInfo* current_entry_info = reader.current_entry_info(); |
+ |
+ EXPECT_EQ(FilePath(FILE_PATH_LITERAL("foo/bar/")), |
+ current_entry_info->file_path()); |
+ // The directory size should be zero. |
+ EXPECT_EQ(0, current_entry_info->original_size()); |
+ |
+ // The expected time stamp: 2009-05-31 15:49:52 |
+ base::Time::Exploded exploded = {}; // Zero-clear. |
+ current_entry_info->last_modified().LocalExplode(&exploded); |
+ EXPECT_EQ(2009, exploded.year); |
+ EXPECT_EQ(5, exploded.month); |
+ EXPECT_EQ(31, exploded.day_of_month); |
+ EXPECT_EQ(15, exploded.hour); |
+ EXPECT_EQ(49, exploded.minute); |
+ EXPECT_EQ(52, exploded.second); |
+ EXPECT_EQ(0, exploded.millisecond); |
+ |
+ EXPECT_FALSE(current_entry_info->is_unsafe()); |
+ EXPECT_TRUE(current_entry_info->is_directory()); |
+} |
+ |
+} // namespace zip |