third_party/zlib/google/zip_reader_unittest.cc

   1 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "third_party/zlib/google/zip_reader.h"
   6
   7 #include <set>
   8 #include <string>
   9
  10 #include "base/bind.h"
  11 #include "base/file_util.h"
  12 #include "base/files/file.h"
  13 #include "base/files/scoped_temp_dir.h"
  14 #include "base/logging.h"
  15 #include "base/md5.h"
  16 #include "base/path_service.h"
  17 #include "base/run_loop.h"
  18 #include "base/strings/stringprintf.h"
  19 #include "base/strings/utf_string_conversions.h"
  20 #include "base/time/time.h"
  21 #include "testing/gtest/include/gtest/gtest.h"
  22 #include "testing/platform_test.h"
  23 #include "third_party/zlib/google/zip_internal.h"
  24
  25 namespace {
  26
  27 const static std::string kQuuxExpectedMD5 = "d1ae4ac8a17a0e09317113ab284b57a6";
  28
  29 class FileWrapper {
  30  public:
  31   typedef enum {
  32     READ_ONLY,
  33     READ_WRITE
  34   } AccessMode;
  35
  36   FileWrapper(const base::FilePath& path, AccessMode mode) {
  37     int flags = base::File::FLAG_READ;
  38     if (mode == READ_ONLY)
  39       flags |= base::File::FLAG_OPEN;
  40     else
  41       flags |= base::File::FLAG_WRITE | base::File::FLAG_CREATE_ALWAYS;
  42
  43     file_.Initialize(path, flags);
  44   }
  45
  46   ~FileWrapper() {}
  47
  48   base::PlatformFile platform_file() { return file_.GetPlatformFile(); }
  49
  50  private:
  51   base::File file_;
  52 };
  53
  54 // A mock that provides methods that can be used as callbacks in asynchronous
  55 // unzip functions.  Tracks the number of calls and number of bytes reported.
  56 // Assumes that progress callbacks will be executed in-order.
  57 class MockUnzipListener : public base::SupportsWeakPtr<MockUnzipListener> {
  58  public:
  59   MockUnzipListener()
  60       : success_calls_(0),
  61         failure_calls_(0),
  62         progress_calls_(0),
  63         current_progress_(0) {
  64   }
  65
  66   // Success callback for async functions.
  67   void OnUnzipSuccess() {
  68     success_calls_++;
  69   }
  70
  71   // Failure callback for async functions.
  72   void OnUnzipFailure() {
  73     failure_calls_++;
  74   }
  75
  76   // Progress callback for async functions.
  77   void OnUnzipProgress(int64 progress) {
  78     DCHECK(progress > current_progress_);
  79     progress_calls_++;
  80     current_progress_ = progress;
  81   }
  82
  83   int success_calls() { return success_calls_; }
  84   int failure_calls() { return failure_calls_; }
  85   int progress_calls() { return progress_calls_; }
  86   int current_progress() { return current_progress_; }
  87
  88  private:
  89   int success_calls_;
  90   int failure_calls_;
  91   int progress_calls_;
  92
  93   int64 current_progress_;
  94 };
  95
  96 }   // namespace
  97
  98 namespace zip {
  99
 100 // Make the test a PlatformTest to setup autorelease pools properly on Mac.
 101 class ZipReaderTest : public PlatformTest {
 102  protected:
 103   virtual void SetUp() {
 104     PlatformTest::SetUp();
 105
 106     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
 107     test_dir_ = temp_dir_.path();
 108
 109     ASSERT_TRUE(GetTestDataDirectory(&test_data_dir_));
 110
 111     test_zip_file_ = test_data_dir_.AppendASCII("test.zip");
 112     evil_zip_file_ = test_data_dir_.AppendASCII("evil.zip");
 113     evil_via_invalid_utf8_zip_file_ = test_data_dir_.AppendASCII(
 114         "evil_via_invalid_utf8.zip");
 115     evil_via_absolute_file_name_zip_file_ = test_data_dir_.AppendASCII(
 116         "evil_via_absolute_file_name.zip");
 117
 118     test_zip_contents_.insert(base::FilePath(FILE_PATH_LITERAL("foo/")));
 119     test_zip_contents_.insert(base::FilePath(FILE_PATH_LITERAL("foo/bar/")));
 120     test_zip_contents_.insert(
 121         base::FilePath(FILE_PATH_LITERAL("foo/bar/baz.txt")));
 122     test_zip_contents_.insert(
 123         base::FilePath(FILE_PATH_LITERAL("foo/bar/quux.txt")));
 124     test_zip_contents_.insert(
 125         base::FilePath(FILE_PATH_LITERAL("foo/bar.txt")));
 126     test_zip_contents_.insert(base::FilePath(FILE_PATH_LITERAL("foo.txt")));
 127     test_zip_contents_.insert(
 128         base::FilePath(FILE_PATH_LITERAL("foo/bar/.hidden")));
 129   }
 130
 131   virtual void TearDown() {
 132     PlatformTest::TearDown();
 133   }
 134
 135   bool GetTestDataDirectory(base::FilePath* path) {
 136     bool success = PathService::Get(base::DIR_SOURCE_ROOT, path);
 137     EXPECT_TRUE(success);
 138     if (!success)
 139       return false;
 140     *path = path->AppendASCII("third_party");
 141     *path = path->AppendASCII("zlib");
 142     *path = path->AppendASCII("google");
 143     *path = path->AppendASCII("test");
 144     *path = path->AppendASCII("data");
 145     return true;
 146   }
 147
 148   bool CompareFileAndMD5(const base::FilePath& path,
 149                          const std::string expected_md5) {
 150     // Read the output file and compute the MD5.
 151     std::string output;
 152     if (!base::ReadFileToString(path, &output))
 153       return false;
 154     const std::string md5 = base::MD5String(output);
 155     return expected_md5 == md5;
 156   }
 157
 158   // The path to temporary directory used to contain the test operations.
 159   base::FilePath test_dir_;
 160   // The path to the test data directory where test.zip etc. are located.
 161   base::FilePath test_data_dir_;
 162   // The path to test.zip in the test data directory.
 163   base::FilePath test_zip_file_;
 164   // The path to evil.zip in the test data directory.
 165   base::FilePath evil_zip_file_;
 166   // The path to evil_via_invalid_utf8.zip in the test data directory.
 167   base::FilePath evil_via_invalid_utf8_zip_file_;
 168   // The path to evil_via_absolute_file_name.zip in the test data directory.
 169   base::FilePath evil_via_absolute_file_name_zip_file_;
 170   std::set<base::FilePath> test_zip_contents_;
 171
 172   base::ScopedTempDir temp_dir_;
 173
 174   base::MessageLoop message_loop_;
 175 };
 176
 177 TEST_F(ZipReaderTest, Open_ValidZipFile) {
 178   ZipReader reader;
 179   ASSERT_TRUE(reader.Open(test_zip_file_));
 180 }
 181
 182 TEST_F(ZipReaderTest, Open_ValidZipPlatformFile) {
 183   ZipReader reader;
 184   FileWrapper zip_fd_wrapper(test_zip_file_, FileWrapper::READ_ONLY);
 185   ASSERT_TRUE(reader.OpenFromPlatformFile(zip_fd_wrapper.platform_file()));
 186 }
 187
 188 TEST_F(ZipReaderTest, Open_NonExistentFile) {
 189   ZipReader reader;
 190   ASSERT_FALSE(reader.Open(test_data_dir_.AppendASCII("nonexistent.zip")));
 191 }
 192
 193 TEST_F(ZipReaderTest, Open_ExistentButNonZipFile) {
 194   ZipReader reader;
 195   ASSERT_FALSE(reader.Open(test_data_dir_.AppendASCII("create_test_zip.sh")));
 196 }
 197
 198 // Iterate through the contents in the test zip file, and compare that the
 199 // contents collected from the zip reader matches the expected contents.
 200 TEST_F(ZipReaderTest, Iteration) {
 201   std::set<base::FilePath> actual_contents;
 202   ZipReader reader;
 203   ASSERT_TRUE(reader.Open(test_zip_file_));
 204   while (reader.HasMore()) {
 205     ASSERT_TRUE(reader.OpenCurrentEntryInZip());
 206     actual_contents.insert(reader.current_entry_info()->file_path());
 207     ASSERT_TRUE(reader.AdvanceToNextEntry());
 208   }
 209   EXPECT_FALSE(reader.AdvanceToNextEntry());  // Shouldn't go further.
 210   EXPECT_EQ(test_zip_contents_.size(),
 211             static_cast<size_t>(reader.num_entries()));
 212   EXPECT_EQ(test_zip_contents_.size(), actual_contents.size());
 213   EXPECT_EQ(test_zip_contents_, actual_contents);
 214 }
 215
 216 // Open the test zip file from a file descriptor, iterate through its contents,
 217 // and compare that they match the expected contents.
 218 TEST_F(ZipReaderTest, PlatformFileIteration) {
 219   std::set<base::FilePath> actual_contents;
 220   ZipReader reader;
 221   FileWrapper zip_fd_wrapper(test_zip_file_, FileWrapper::READ_ONLY);
 222   ASSERT_TRUE(reader.OpenFromPlatformFile(zip_fd_wrapper.platform_file()));
 223   while (reader.HasMore()) {
 224     ASSERT_TRUE(reader.OpenCurrentEntryInZip());
 225     actual_contents.insert(reader.current_entry_info()->file_path());
 226     ASSERT_TRUE(reader.AdvanceToNextEntry());
 227   }
 228   EXPECT_FALSE(reader.AdvanceToNextEntry());  // Shouldn't go further.
 229   EXPECT_EQ(test_zip_contents_.size(),
 230             static_cast<size_t>(reader.num_entries()));
 231   EXPECT_EQ(test_zip_contents_.size(), actual_contents.size());
 232   EXPECT_EQ(test_zip_contents_, actual_contents);
 233 }
 234
 235 TEST_F(ZipReaderTest, LocateAndOpenEntry_ValidFile) {
 236   std::set<base::FilePath> actual_contents;
 237   ZipReader reader;
 238   ASSERT_TRUE(reader.Open(test_zip_file_));
 239   base::FilePath target_path(FILE_PATH_LITERAL("foo/bar/quux.txt"));
 240   ASSERT_TRUE(reader.LocateAndOpenEntry(target_path));
 241   EXPECT_EQ(target_path, reader.current_entry_info()->file_path());
 242 }
 243
 244 TEST_F(ZipReaderTest, LocateAndOpenEntry_NonExistentFile) {
 245   std::set<base::FilePath> actual_contents;
 246   ZipReader reader;
 247   ASSERT_TRUE(reader.Open(test_zip_file_));
 248   base::FilePath target_path(FILE_PATH_LITERAL("nonexistent.txt"));
 249   ASSERT_FALSE(reader.LocateAndOpenEntry(target_path));
 250   EXPECT_EQ(NULL, reader.current_entry_info());
 251 }
 252
 253 TEST_F(ZipReaderTest, ExtractCurrentEntryToFilePath_RegularFile) {
 254   ZipReader reader;
 255   ASSERT_TRUE(reader.Open(test_zip_file_));
 256   base::FilePath target_path(FILE_PATH_LITERAL("foo/bar/quux.txt"));
 257   ASSERT_TRUE(reader.LocateAndOpenEntry(target_path));
 258   ASSERT_TRUE(reader.ExtractCurrentEntryToFilePath(
 259       test_dir_.AppendASCII("quux.txt")));
 260   // Read the output file ans compute the MD5.
 261   std::string output;
 262   ASSERT_TRUE(base::ReadFileToString(test_dir_.AppendASCII("quux.txt"),
 263                                      &output));
 264   const std::string md5 = base::MD5String(output);
 265   EXPECT_EQ(kQuuxExpectedMD5, md5);
 266   // quux.txt should be larger than kZipBufSize so that we can exercise
 267   // the loop in ExtractCurrentEntry().
 268   EXPECT_LT(static_cast<size_t>(internal::kZipBufSize), output.size());
 269 }
 270
 271 TEST_F(ZipReaderTest, PlatformFileExtractCurrentEntryToFilePath_RegularFile) {
 272   ZipReader reader;
 273   FileWrapper zip_fd_wrapper(test_zip_file_, FileWrapper::READ_ONLY);
 274   ASSERT_TRUE(reader.OpenFromPlatformFile(zip_fd_wrapper.platform_file()));
 275   base::FilePath target_path(FILE_PATH_LITERAL("foo/bar/quux.txt"));
 276   ASSERT_TRUE(reader.LocateAndOpenEntry(target_path));
 277   ASSERT_TRUE(reader.ExtractCurrentEntryToFilePath(
 278       test_dir_.AppendASCII("quux.txt")));
 279   // Read the output file and compute the MD5.
 280   std::string output;
 281   ASSERT_TRUE(base::ReadFileToString(test_dir_.AppendASCII("quux.txt"),
 282                                      &output));
 283   const std::string md5 = base::MD5String(output);
 284   EXPECT_EQ(kQuuxExpectedMD5, md5);
 285   // quux.txt should be larger than kZipBufSize so that we can exercise
 286   // the loop in ExtractCurrentEntry().
 287   EXPECT_LT(static_cast<size_t>(internal::kZipBufSize), output.size());
 288 }
 289
 290 #if defined(OS_POSIX)
 291 TEST_F(ZipReaderTest, PlatformFileExtractCurrentEntryToFd_RegularFile) {
 292   ZipReader reader;
 293   FileWrapper zip_fd_wrapper(test_zip_file_, FileWrapper::READ_ONLY);
 294   ASSERT_TRUE(reader.OpenFromPlatformFile(zip_fd_wrapper.platform_file()));
 295   base::FilePath target_path(FILE_PATH_LITERAL("foo/bar/quux.txt"));
 296   base::FilePath out_path = test_dir_.AppendASCII("quux.txt");
 297   FileWrapper out_fd_w(out_path, FileWrapper::READ_WRITE);
 298   ASSERT_TRUE(reader.LocateAndOpenEntry(target_path));
 299   ASSERT_TRUE(reader.ExtractCurrentEntryToFd(out_fd_w.platform_file()));
 300   // Read the output file and compute the MD5.
 301   std::string output;
 302   ASSERT_TRUE(base::ReadFileToString(test_dir_.AppendASCII("quux.txt"),
 303                                      &output));
 304   const std::string md5 = base::MD5String(output);
 305   EXPECT_EQ(kQuuxExpectedMD5, md5);
 306   // quux.txt should be larger than kZipBufSize so that we can exercise
 307   // the loop in ExtractCurrentEntry().
 308   EXPECT_LT(static_cast<size_t>(internal::kZipBufSize), output.size());
 309 }
 310 #endif
 311
 312 TEST_F(ZipReaderTest, ExtractCurrentEntryToFilePath_Directory) {
 313   ZipReader reader;
 314   ASSERT_TRUE(reader.Open(test_zip_file_));
 315   base::FilePath target_path(FILE_PATH_LITERAL("foo/"));
 316   ASSERT_TRUE(reader.LocateAndOpenEntry(target_path));
 317   ASSERT_TRUE(reader.ExtractCurrentEntryToFilePath(
 318       test_dir_.AppendASCII("foo")));
 319   // The directory should be created.
 320   ASSERT_TRUE(base::DirectoryExists(test_dir_.AppendASCII("foo")));
 321 }
 322
 323 TEST_F(ZipReaderTest, ExtractCurrentEntryIntoDirectory_RegularFile) {
 324   ZipReader reader;
 325   ASSERT_TRUE(reader.Open(test_zip_file_));
 326   base::FilePath target_path(FILE_PATH_LITERAL("foo/bar/quux.txt"));
 327   ASSERT_TRUE(reader.LocateAndOpenEntry(target_path));
 328   ASSERT_TRUE(reader.ExtractCurrentEntryIntoDirectory(test_dir_));
 329   // Sub directories should be created.
 330   ASSERT_TRUE(base::DirectoryExists(test_dir_.AppendASCII("foo/bar")));
 331   // And the file should be created.
 332   std::string output;
 333   ASSERT_TRUE(base::ReadFileToString(
 334       test_dir_.AppendASCII("foo/bar/quux.txt"), &output));
 335   const std::string md5 = base::MD5String(output);
 336   EXPECT_EQ(kQuuxExpectedMD5, md5);
 337 }
 338
 339 TEST_F(ZipReaderTest, current_entry_info_RegularFile) {
 340   ZipReader reader;
 341   ASSERT_TRUE(reader.Open(test_zip_file_));
 342   base::FilePath target_path(FILE_PATH_LITERAL("foo/bar/quux.txt"));
 343   ASSERT_TRUE(reader.LocateAndOpenEntry(target_path));
 344   ZipReader::EntryInfo* current_entry_info = reader.current_entry_info();
 345
 346   EXPECT_EQ(target_path, current_entry_info->file_path());
 347   EXPECT_EQ(13527, current_entry_info->original_size());
 348
 349   // The expected time stamp: 2009-05-29 06:22:20
 350   base::Time::Exploded exploded = {};  // Zero-clear.
 351   current_entry_info->last_modified().LocalExplode(&exploded);
 352   EXPECT_EQ(2009, exploded.year);
 353   EXPECT_EQ(5, exploded.month);
 354   EXPECT_EQ(29, exploded.day_of_month);
 355   EXPECT_EQ(6, exploded.hour);
 356   EXPECT_EQ(22, exploded.minute);
 357   EXPECT_EQ(20, exploded.second);
 358   EXPECT_EQ(0, exploded.millisecond);
 359
 360   EXPECT_FALSE(current_entry_info->is_unsafe());
 361   EXPECT_FALSE(current_entry_info->is_directory());
 362 }
 363
 364 TEST_F(ZipReaderTest, current_entry_info_DotDotFile) {
 365   ZipReader reader;
 366   ASSERT_TRUE(reader.Open(evil_zip_file_));
 367   base::FilePath target_path(FILE_PATH_LITERAL(
 368       "../levilevilevilevilevilevilevilevilevilevilevilevil"));
 369   ASSERT_TRUE(reader.LocateAndOpenEntry(target_path));
 370   ZipReader::EntryInfo* current_entry_info = reader.current_entry_info();
 371   EXPECT_EQ(target_path, current_entry_info->file_path());
 372
 373   // This file is unsafe because of ".." in the file name.
 374   EXPECT_TRUE(current_entry_info->is_unsafe());
 375   EXPECT_FALSE(current_entry_info->is_directory());
 376 }
 377
 378 TEST_F(ZipReaderTest, current_entry_info_InvalidUTF8File) {
 379   ZipReader reader;
 380   ASSERT_TRUE(reader.Open(evil_via_invalid_utf8_zip_file_));
 381   // The evil file is the 2nd file in the zip file.
 382   // We cannot locate by the file name ".\x80.\\evil.txt",
 383   // as FilePath may internally convert the string.
 384   ASSERT_TRUE(reader.AdvanceToNextEntry());
 385   ASSERT_TRUE(reader.OpenCurrentEntryInZip());
 386   ZipReader::EntryInfo* current_entry_info = reader.current_entry_info();
 387
 388   // This file is unsafe because of invalid UTF-8 in the file name.
 389   EXPECT_TRUE(current_entry_info->is_unsafe());
 390   EXPECT_FALSE(current_entry_info->is_directory());
 391 }
 392
 393 TEST_F(ZipReaderTest, current_entry_info_AbsoluteFile) {
 394   ZipReader reader;
 395   ASSERT_TRUE(reader.Open(evil_via_absolute_file_name_zip_file_));
 396   base::FilePath target_path(FILE_PATH_LITERAL("/evil.txt"));
 397   ASSERT_TRUE(reader.LocateAndOpenEntry(target_path));
 398   ZipReader::EntryInfo* current_entry_info = reader.current_entry_info();
 399   EXPECT_EQ(target_path, current_entry_info->file_path());
 400
 401   // This file is unsafe because of the absolute file name.
 402   EXPECT_TRUE(current_entry_info->is_unsafe());
 403   EXPECT_FALSE(current_entry_info->is_directory());
 404 }
 405
 406 TEST_F(ZipReaderTest, current_entry_info_Directory) {
 407   ZipReader reader;
 408   ASSERT_TRUE(reader.Open(test_zip_file_));
 409   base::FilePath target_path(FILE_PATH_LITERAL("foo/bar/"));
 410   ASSERT_TRUE(reader.LocateAndOpenEntry(target_path));
 411   ZipReader::EntryInfo* current_entry_info = reader.current_entry_info();
 412
 413   EXPECT_EQ(base::FilePath(FILE_PATH_LITERAL("foo/bar/")),
 414             current_entry_info->file_path());
 415   // The directory size should be zero.
 416   EXPECT_EQ(0, current_entry_info->original_size());
 417
 418   // The expected time stamp: 2009-05-31 15:49:52
 419   base::Time::Exploded exploded = {};  // Zero-clear.
 420   current_entry_info->last_modified().LocalExplode(&exploded);
 421   EXPECT_EQ(2009, exploded.year);
 422   EXPECT_EQ(5, exploded.month);
 423   EXPECT_EQ(31, exploded.day_of_month);
 424   EXPECT_EQ(15, exploded.hour);
 425   EXPECT_EQ(49, exploded.minute);
 426   EXPECT_EQ(52, exploded.second);
 427   EXPECT_EQ(0, exploded.millisecond);
 428
 429   EXPECT_FALSE(current_entry_info->is_unsafe());
 430   EXPECT_TRUE(current_entry_info->is_directory());
 431 }
 432
 433 // Verifies that the ZipReader class can extract a file from a zip archive
 434 // stored in memory. This test opens a zip archive in a std::string object,
 435 // extracts its content, and verifies the content is the same as the expected
 436 // text.
 437 TEST_F(ZipReaderTest, OpenFromString) {
 438   // A zip archive consisting of one file "test.txt", which is a 16-byte text
 439   // file that contains "This is a test.\n".
 440   const char kTestData[] =
 441       "\x50\x4b\x03\x04\x0a\x00\x00\x00\x00\x00\xa4\x66\x24\x41\x13\xe8"
 442       "\xcb\x27\x10\x00\x00\x00\x10\x00\x00\x00\x08\x00\x1c\x00\x74\x65"
 443       "\x73\x74\x2e\x74\x78\x74\x55\x54\x09\x00\x03\x34\x89\x45\x50\x34"
 444       "\x89\x45\x50\x75\x78\x0b\x00\x01\x04\x8e\xf0\x00\x00\x04\x88\x13"
 445       "\x00\x00\x54\x68\x69\x73\x20\x69\x73\x20\x61\x20\x74\x65\x73\x74"
 446       "\x2e\x0a\x50\x4b\x01\x02\x1e\x03\x0a\x00\x00\x00\x00\x00\xa4\x66"
 447       "\x24\x41\x13\xe8\xcb\x27\x10\x00\x00\x00\x10\x00\x00\x00\x08\x00"
 448       "\x18\x00\x00\x00\x00\x00\x01\x00\x00\x00\xa4\x81\x00\x00\x00\x00"
 449       "\x74\x65\x73\x74\x2e\x74\x78\x74\x55\x54\x05\x00\x03\x34\x89\x45"
 450       "\x50\x75\x78\x0b\x00\x01\x04\x8e\xf0\x00\x00\x04\x88\x13\x00\x00"
 451       "\x50\x4b\x05\x06\x00\x00\x00\x00\x01\x00\x01\x00\x4e\x00\x00\x00"
 452       "\x52\x00\x00\x00\x00\x00";
 453   std::string data(kTestData, arraysize(kTestData));
 454   ZipReader reader;
 455   ASSERT_TRUE(reader.OpenFromString(data));
 456   base::FilePath target_path(FILE_PATH_LITERAL("test.txt"));
 457   ASSERT_TRUE(reader.LocateAndOpenEntry(target_path));
 458   ASSERT_TRUE(reader.ExtractCurrentEntryToFilePath(
 459       test_dir_.AppendASCII("test.txt")));
 460
 461   std::string actual;
 462   ASSERT_TRUE(base::ReadFileToString(
 463       test_dir_.AppendASCII("test.txt"), &actual));
 464   EXPECT_EQ(std::string("This is a test.\n"), actual);
 465 }
 466
 467 // Verifies that the asynchronous extraction to a file works.
 468 TEST_F(ZipReaderTest, ExtractToFileAsync_RegularFile) {
 469   MockUnzipListener listener;
 470
 471   ZipReader reader;
 472   base::FilePath target_file = test_dir_.AppendASCII("quux.txt");
 473   base::FilePath target_path(FILE_PATH_LITERAL("foo/bar/quux.txt"));
 474   ASSERT_TRUE(reader.Open(test_zip_file_));
 475   ASSERT_TRUE(reader.LocateAndOpenEntry(target_path));
 476   reader.ExtractCurrentEntryToFilePathAsync(
 477       target_file,
 478       base::Bind(&MockUnzipListener::OnUnzipSuccess,
 479                  listener.AsWeakPtr()),
 480       base::Bind(&MockUnzipListener::OnUnzipFailure,
 481                  listener.AsWeakPtr()),
 482       base::Bind(&MockUnzipListener::OnUnzipProgress,
 483                  listener.AsWeakPtr()));
 484
 485   EXPECT_EQ(0, listener.success_calls());
 486   EXPECT_EQ(0, listener.failure_calls());
 487   EXPECT_EQ(0, listener.progress_calls());
 488
 489   base::RunLoop().RunUntilIdle();
 490
 491   EXPECT_EQ(1, listener.success_calls());
 492   EXPECT_EQ(0, listener.failure_calls());
 493   EXPECT_LE(1, listener.progress_calls());
 494
 495   std::string output;
 496   ASSERT_TRUE(base::ReadFileToString(test_dir_.AppendASCII("quux.txt"),
 497                                      &output));
 498   const std::string md5 = base::MD5String(output);
 499   EXPECT_EQ(kQuuxExpectedMD5, md5);
 500
 501   int64 file_size = 0;
 502   ASSERT_TRUE(base::GetFileSize(target_file, &file_size));
 503
 504   EXPECT_EQ(file_size, listener.current_progress());
 505 }
 506
 507 // Verifies that the asynchronous extraction to a file works.
 508 TEST_F(ZipReaderTest, ExtractToFileAsync_Directory) {
 509   MockUnzipListener listener;
 510
 511   ZipReader reader;
 512   base::FilePath target_file = test_dir_.AppendASCII("foo");
 513   base::FilePath target_path(FILE_PATH_LITERAL("foo/"));
 514   ASSERT_TRUE(reader.Open(test_zip_file_));
 515   ASSERT_TRUE(reader.LocateAndOpenEntry(target_path));
 516   reader.ExtractCurrentEntryToFilePathAsync(
 517       target_file,
 518       base::Bind(&MockUnzipListener::OnUnzipSuccess,
 519                  listener.AsWeakPtr()),
 520       base::Bind(&MockUnzipListener::OnUnzipFailure,
 521                  listener.AsWeakPtr()),
 522       base::Bind(&MockUnzipListener::OnUnzipProgress,
 523                  listener.AsWeakPtr()));
 524
 525   EXPECT_EQ(0, listener.success_calls());
 526   EXPECT_EQ(0, listener.failure_calls());
 527   EXPECT_EQ(0, listener.progress_calls());
 528
 529   base::RunLoop().RunUntilIdle();
 530
 531   EXPECT_EQ(1, listener.success_calls());
 532   EXPECT_EQ(0, listener.failure_calls());
 533   EXPECT_GE(0, listener.progress_calls());
 534
 535   ASSERT_TRUE(base::DirectoryExists(target_file));
 536 }
 537
 538 TEST_F(ZipReaderTest, ExtractCurrentEntryToString) {
 539   // test_mismatch_size.zip contains files with names from 0.txt to 7.txt with
 540   // sizes from 0 to 7 bytes respectively, being the contents of each file a
 541   // substring of "0123456" starting at '0'.
 542   base::FilePath test_zip_file =
 543       test_data_dir_.AppendASCII("test_mismatch_size.zip");
 544
 545   ZipReader reader;
 546   std::string contents;
 547   ASSERT_TRUE(reader.Open(test_zip_file));
 548
 549   for (size_t i = 0; i < 8; i++) {
 550     SCOPED_TRACE(base::StringPrintf("Processing %d.txt", static_cast<int>(i)));
 551
 552     base::FilePath file_name = base::FilePath::FromUTF8Unsafe(
 553         base::StringPrintf("%d.txt", static_cast<int>(i)));
 554     ASSERT_TRUE(reader.LocateAndOpenEntry(file_name));
 555
 556     if (i > 1) {
 557       // Off by one byte read limit: must fail.
 558       EXPECT_FALSE(reader.ExtractCurrentEntryToString(i - 1, &contents));
 559     }
 560
 561     if (i > 0) {
 562       // Exact byte read limit: must pass.
 563       EXPECT_TRUE(reader.ExtractCurrentEntryToString(i, &contents));
 564       EXPECT_EQ(i, contents.size());
 565       EXPECT_EQ(0, memcmp(contents.c_str(), "0123456", i));
 566     }
 567
 568     // More than necessary byte read limit: must pass.
 569     EXPECT_TRUE(reader.ExtractCurrentEntryToString(16, &contents));
 570     EXPECT_EQ(i, contents.size());
 571     EXPECT_EQ(0, memcmp(contents.c_str(), "0123456", i));
 572   }
 573   reader.Close();
 574 }
 575
 576 }  // namespace zip